summaryrefslogtreecommitdiffstats
path: root/stream
diff options
context:
space:
mode:
Diffstat (limited to 'stream')
-rw-r--r--stream/stream.c2
-rw-r--r--stream/stream_bluray.c501
-rw-r--r--stream/stream_dvdnav.h6
3 files changed, 447 insertions, 62 deletions
diff --git a/stream/stream.c b/stream/stream.c
index 1caf6e718c..a7990595d2 100644
--- a/stream/stream.c
+++ b/stream/stream.c
@@ -77,6 +77,7 @@ extern const stream_info_t stream_info_ifo;
extern const stream_info_t stream_info_dvd;
extern const stream_info_t stream_info_dvdnav;
extern const stream_info_t stream_info_bluray;
+extern const stream_info_t stream_info_bdnav;
extern const stream_info_t stream_info_rar_filter;
extern const stream_info_t stream_info_rar_entry;
extern const stream_info_t stream_info_edl;
@@ -114,6 +115,7 @@ static const stream_info_t *const stream_list[] = {
#endif
#if HAVE_LIBBLURAY
&stream_info_bluray,
+ &stream_info_bdnav,
#endif
&stream_info_memory,
diff --git a/stream/stream_bluray.c b/stream/stream_bluray.c
index a30cdd603b..524854396c 100644
--- a/stream/stream_bluray.c
+++ b/stream/stream_bluray.c
@@ -23,7 +23,6 @@
* Use 'git clone git://git.videolan.org/libbluray' to get it.
*
* TODO:
- * - Add libbdnav support for menus navigation
* - Add AACS/BD+ protection detection
* - Add descrambled keys database support (KEYDB.cfg)
*
@@ -34,6 +33,9 @@
#include <libbluray/bluray.h>
#include <libbluray/meta_data.h>
+#include <libbluray/overlay.h>
+#include <libbluray/keys.h>
+#include <libbluray/bluray-version.h>
#include <libavutil/common.h>
#include "config.h"
@@ -43,12 +45,18 @@
#include "options/m_option.h"
#include "stream.h"
#include "osdep/timer.h"
+#include "stream_dvdnav.h"
+#include "sub/osd.h"
+#include "sub/img_convert.h"
+#include "video/mp_image.h"
+#include "video/mp_image_pool.h"
#define BLURAY_SECTOR_SIZE 6144
#define BLURAY_DEFAULT_ANGLE 0
#define BLURAY_DEFAULT_CHAPTER 0
-#define BLURAY_DEFAULT_TITLE -1
+#define BLURAY_DEFAULT_TITLE -2
+#define BLURAY_MENU_TITLE -1
// 90khz ticks
#define BD_TIMEBASE (90000)
@@ -58,6 +66,12 @@
char *bluray_device = NULL;
int bluray_angle = 0;
+struct bluray_overlay {
+ struct sub_bitmap *image;
+ bool clean, hidden;
+ int x, y, w, h;
+};
+
struct bluray_priv_s {
BLURAY *bd;
BLURAY_TITLE_INFO *title_info;
@@ -68,10 +82,25 @@ struct bluray_priv_s {
int cfg_title;
char *cfg_device;
+
+ // overlay stuffs
+ struct bluray_overlay overlays[2], ol_flushed[2];
+ struct mp_image_pool *pool;
+
+ // navigation stuffs
+ uint64_t next_event;
+ uint32_t still_length;
+ int mousex, mousey;
+ bool in_menu, use_nav, nav_enabled, popup_enabled;
};
static struct bluray_priv_s bluray_stream_priv_dflts = {
- .cfg_title = BLURAY_DEFAULT_TITLE
+ .cfg_title = BLURAY_DEFAULT_TITLE,
+};
+
+static struct bluray_priv_s bdnav_stream_priv_dflts = {
+ .cfg_title = BLURAY_DEFAULT_TITLE,
+ .use_nav = true,
};
#define OPT_BASE_STRUCT struct bluray_priv_s
@@ -82,42 +111,251 @@ static const m_option_t bluray_stream_opts_fields[] = {
{0}
};
-static void bluray_stream_close(stream_t *s)
+static const m_option_t bdnav_stream_opts_fields[] = {
+ OPT_CHOICE_OR_INT("title", cfg_title, 0, 0, 99999,
+ ({"menu", BLURAY_MENU_TITLE},
+ {"first", BLURAY_DEFAULT_TITLE})),
+ OPT_STRING("device", cfg_device, 0),
+ {0}
+};
+
+static void destruct(struct bluray_priv_s *priv)
{
- struct bluray_priv_s *b = s->priv;
+ if (priv->title_info)
+ bd_free_title_info(priv->title_info);
+ bd_close(priv->bd);
+ talloc_free(priv->pool);
+}
- if (b->title_info)
- bd_free_title_info(b->title_info);
- bd_close(b->bd);
+inline static int play_title(struct bluray_priv_s *priv, int title)
+{
+ if (priv->use_nav) {
+ if (title == priv->num_titles - 1)
+ title = BLURAY_TITLE_FIRST_PLAY;
+ return bd_play_title(priv->bd, title);
+ } else
+ return bd_select_title(priv->bd, title);
}
-static int bluray_stream_seek(stream_t *s, int64_t pos)
+static void overlay_release(struct bluray_overlay *overlay)
{
- struct bluray_priv_s *b = s->priv;
- int64_t p;
+ if (overlay->image)
+ talloc_free(overlay->image);
+ *overlay = (struct bluray_overlay) { .clean = true };
+}
+
+static void overlay_alloc(struct bluray_priv_s *priv,
+ struct bluray_overlay *overlay,
+ int x, int y, int w, int h)
+{
+ assert(overlay->image == NULL);
+ struct sub_bitmap *image = talloc_zero(NULL, struct sub_bitmap);
+ overlay->w = image->w = image->dw = w;
+ overlay->h = image->h = image->dh = h;
+ overlay->x = image->x = x;
+ overlay->y = image->y = y;
+ struct mp_image *mpi = mp_image_pool_get(priv->pool, IMGFMT_RGBA, w, h);
+ mpi = talloc_steal(image, mpi);
+ assert(image->w > 0 && image->h > 0 && mpi != NULL);
+ image->stride = mpi->stride[0];
+ image->bitmap = mpi->planes[0];
+ overlay->image = image;
+ overlay->clean = true;
+ overlay->hidden = false;
+}
+
+static void overlay_close_all(struct bluray_priv_s *priv)
+{
+ for (int i = 0; i < 2; i++)
+ overlay_release(&priv->overlays[i]);
+}
+
+static void overlay_close(struct bluray_priv_s *priv,
+ const BD_OVERLAY *const bo)
+{
+ overlay_release(&priv->overlays[bo->plane]);
+}
+
+static inline uint32_t conv_rgba(const BD_PG_PALETTE_ENTRY *p)
+{
+ uint32_t rgba;
+ uint8_t *out = (uint8_t*)&rgba;
+ const int y = p->Y, cb = (int)p->Cb - 128, cr = (int)p->Cr - 128;
+ // CAUTION: inaccurate but fast, broken in big endian
+#define CONV(a) (MPCLAMP((a), 0, 255)*p->T >> 8)
+ out[0] = CONV(y + cb + (cb >> 1) + (cb >> 2) + (cb >> 6));
+ out[1] = CONV(y - ((cb >> 2) + (cb >> 4) + (cb >> 5))
+ - ((cr >> 3) + (cr >> 4) + (cr >> 5)));
+ out[2] = CONV(y + cr + (cr >> 2) + (cr >> 3) + (cr >> 5));
+ out[3] = p->T;
+#undef CONV
+ return rgba;
+}
+
+static void overlay_process(void *data, const BD_OVERLAY *const bo)
+{
+ stream_t *s = data;
+ struct bluray_priv_s *priv = s->priv;
+ if (!bo) {
+ overlay_close_all(priv);
+ return;
+ }
+ struct bluray_overlay *overlay = &priv->overlays[bo->plane];
+ switch (bo->cmd) {
+ case BD_OVERLAY_INIT:
+ overlay_alloc(priv, overlay, bo->x, bo->y, bo->w, bo->h);
+ break;
+ case BD_OVERLAY_CLOSE:
+ overlay_close(priv, bo);
+ break;
+ case BD_OVERLAY_CLEAR:
+ if (!overlay->clean) {
+ memset(overlay->image->bitmap, 0,
+ overlay->image->stride*overlay->h);
+ overlay->clean = true;
+ }
+ break;
+ case BD_OVERLAY_DRAW: {
+ if (!bo->img)
+ break;
+ overlay->hidden = false;
+ overlay->clean = false;
+ struct sub_bitmap *img = overlay->image;
+ uint32_t *const origin = img->bitmap;
+ const BD_PG_RLE_ELEM *in = bo->img;
+ for (int y = 0; y < bo->h; y++) {
+ uint32_t *out = origin + (img->stride/4) * (y + bo->y) + bo->x;
+ for (int x = 0; x < bo->w; ) {
+ uint32_t c = 0;
+ if (bo->palette[in->color].T) {
+ c = conv_rgba(&bo->palette[in->color]);
+ for (int i = 0; i < in->len; i++)
+ *out++ = c;
+ } else {
+ memset(out, 0, in->len*4);
+ out += in->len;
+ }
+ x += in->len;
+ ++in;
+ }
+ }
+ break;
+ } case BD_OVERLAY_WIPE: {
+ uint32_t *const origin = overlay->image->bitmap;
+ for (int y = 0; y < bo->h; y++)
+ memset(origin + overlay->w * (y + bo->y) + bo->x, 0, 4 * bo->w);
+ break;
+ } case BD_OVERLAY_HIDE:
+ priv->overlays[bo->plane].hidden = true;
+ break;
+ case BD_OVERLAY_FLUSH: {
+ struct bluray_overlay *in = overlay;
+ struct bluray_overlay *out = &priv->ol_flushed[bo->plane];
+ if (out->image && (out->image->stride != in->image->stride ||
+ out->image->h != in->image->h))
+ overlay_release(out);
+ if (!out->image)
+ overlay_alloc(priv, out, in->x, in->y, in->w, in->h);
+ const int len = in->image->stride*in->image->h;
+ memcpy(out->image->bitmap, in->image->bitmap, len);
+ out->clean = in->clean;
+ out->hidden = in->hidden;
+ priv->next_event |= 1 << MP_NAV_EVENT_OVERLAY;
+ break;
+ } default:
+ break;
+ }
+}
+
+static inline bool set_event_type(struct bluray_priv_s *priv, int type,
+ struct mp_nav_event *event)
+{
+ if (!(priv->next_event & (1 << type)))
+ return false;
+ priv->next_event &= ~(1 << type);
+ event->event = type;
+ return true;
+}
- p = bd_seek(b->bd, pos);
- if (p == -1)
- return 0;
+static void fill_next_event(stream_t *s, struct mp_nav_event **ret)
+{
+ struct bluray_priv_s *priv = s->priv;
+ struct mp_nav_event e = {0};
+ // this should be checked before any other events
+ if (!set_event_type(priv, MP_NAV_EVENT_RESET_ALL, &e))
+ for (int n = 0; n < 30 && !set_event_type(priv, n, &e); n++) ;
+ switch (e.event) {
+ case MP_NAV_EVENT_NONE:
+ return;
+ case MP_NAV_EVENT_OVERLAY: {
+ for (int i = 0; i < 2; i++) {
+ struct bluray_overlay *o = &priv->ol_flushed[i];
+ e.u.overlay.images[i] = NULL;
+ if (!o->clean && !o->hidden) {
+ e.u.overlay.images[i] = o->image;
+ o->image = NULL;
+ }
+ }
+ break;
+ } case MP_NAV_EVENT_MENU_MODE:
+ e.u.menu_mode.enable = priv->in_menu;
+ break;
+ case MP_NAV_EVENT_STILL_FRAME:
+ e.u.still_frame.seconds = priv->still_length;
+ break;
+ }
+ *ret = talloc(NULL, struct mp_nav_event);
+ **ret = e;
+}
- return 1;
+static void bluray_stream_close(stream_t *s)
+{
+ destruct(s->priv);
}
static void handle_event(stream_t *s, const BD_EVENT *ev)
{
+ static const int reset_flags = (1 << MP_NAV_EVENT_RESET_ALL)
+ | (1 << MP_NAV_EVENT_RESET);
struct bluray_priv_s *b = s->priv;
switch (ev->event) {
+ case BD_EVENT_MENU:
+ b->in_menu = ev->param;
+ b->next_event |= 1 << MP_NAV_EVENT_MENU_MODE;
+ break;
+ case BD_EVENT_STILL:
+ b->still_length = ev->param ? -1 : 0;
+ if (b->nav_enabled)
+ b->next_event |= 1 << MP_NAV_EVENT_STILL_FRAME;
+ break;
+ case BD_EVENT_STILL_TIME:
+ b->still_length = ev->param ? -1 : ev->param*1000;
+ if (b->nav_enabled)
+ b->next_event |= 1 << MP_NAV_EVENT_STILL_FRAME;
+ else
+ bd_read_skip_still(b->bd);
+ break;
+ case BD_EVENT_END_OF_TITLE:
+ overlay_close_all(b);
+ break;
case BD_EVENT_PLAYLIST:
+ b->next_event = reset_flags;
b->current_playlist = ev->param;
+ if (!b->use_nav)
+ b->current_title = bd_get_current_title(b->bd);
if (b->title_info)
bd_free_title_info(b->title_info);
b->title_info = bd_get_playlist_info(b->bd, b->current_playlist,
b->current_angle);
break;
case BD_EVENT_TITLE:
- if (ev->param == BLURAY_TITLE_FIRST_PLAY)
- b->current_title = bd_get_current_title(b->bd);
- else
+ b->next_event = reset_flags;
+ if (ev->param == BLURAY_TITLE_FIRST_PLAY) {
+ if (b->use_nav)
+ b->current_title = b->num_titles - 1;
+ else
+ b->current_title = bd_get_current_title(b->bd);
+ } else
b->current_title = ev->param;
if (b->title_info) {
bd_free_title_info(b->title_info);
@@ -132,6 +370,14 @@ static void handle_event(stream_t *s, const BD_EVENT *ev)
b->current_angle);
}
break;
+ case BD_EVENT_POPUP:
+ b->popup_enabled = ev->param;
+ break;
+#if BLURAY_VERSION >= BLURAY_VERSION_CODE(0, 5, 0)
+ case BD_EVENT_DISCONTINUITY:
+ b->next_event = reset_flags;
+ break;
+#endif
default:
MP_TRACE(s, "Unhandled event: %d %d\n", ev->event, ev->param);
break;
@@ -141,13 +387,83 @@ static void handle_event(stream_t *s, const BD_EVENT *ev)
static int bluray_stream_fill_buffer(stream_t *s, char *buf, int len)
{
struct bluray_priv_s *b = s->priv;
-
+ assert(!b->use_nav);
BD_EVENT event;
while (bd_get_event(b->bd, &event))
handle_event(s, &event);
return bd_read(b->bd, buf, len);
}
+static int bdnav_stream_fill_buffer(stream_t *s, char *buf, int len)
+{
+ struct bluray_priv_s *b = s->priv;
+ assert(b->use_nav);
+ BD_EVENT event;
+ int read = -1;
+ for (;;) {
+ read = bd_read_ext(b->bd, buf, len, &event);
+ if (read < 0)
+ return read;
+ if (read == 0) {
+ if (event.event == BD_EVENT_NONE)
+ return 0; // end of stream
+ handle_event(s, &event);
+ } else
+ break;
+ }
+ return read;
+}
+
+static bd_vk_key_e translate_nav_menu_action(const char *cmd)
+{
+ if (strcmp(cmd, "mouse") == 0)
+ return BD_VK_MOUSE_ACTIVATE;
+ if (strcmp(cmd, "up") == 0)
+ return BD_VK_UP;
+ if (strcmp(cmd, "down") == 0)
+ return BD_VK_DOWN;
+ if (strcmp(cmd, "left") == 0)
+ return BD_VK_LEFT;
+ if (strcmp(cmd, "right") == 0)
+ return BD_VK_RIGHT;
+ if (strcmp(cmd, "select") == 0)
+ return BD_VK_ENTER;
+ return BD_VK_NONE;
+}
+
+static void handle_nav_command(stream_t *s, struct mp_nav_cmd *ev)
+{
+ struct bluray_priv_s *priv = s->priv;
+ switch (ev->event) {
+ case MP_NAV_CMD_ENABLE:
+ priv->nav_enabled = true;
+ break;
+ case MP_NAV_CMD_MENU: {
+ const int64_t pts = mp_time_us();
+ const char *action = ev->u.menu.action;
+ bd_vk_key_e key = translate_nav_menu_action(action);
+ if (key != BD_VK_NONE) {
+ if (key == BD_VK_MOUSE_ACTIVATE)
+ bd_mouse_select(priv->bd, pts, priv->mousex, priv->mousey);
+ bd_user_input(priv->bd, pts, key);
+ } else if (strcmp(action, "menu") == 0) {
+ if (priv->popup_enabled)
+ bd_user_input(priv->bd, pts, BD_VK_POPUP);
+ else
+ bd_menu_call(priv->bd, pts);
+ }
+ break;
+ } case MP_NAV_CMD_MOUSE_POS:
+ priv->mousex = ev->u.mouse_pos.x;
+ priv->mousey = ev->u.mouse_pos.y;
+ bd_mouse_select(priv->bd, mp_time_us(), priv->mousex, priv->mousey);
+ break;
+ case MP_NAV_CMD_SKIP_STILL:
+ bd_read_skip_still(priv->bd);
+ break;
+ }
+}
+
static int bluray_stream_control(stream_t *s, int cmd, void *arg)
{
struct bluray_priv_s *b = s->priv;
@@ -156,7 +472,6 @@ static int bluray_stream_control(stream_t *s, int cmd, void *arg)
case STREAM_CTRL_GET_NUM_CHAPTERS: {
const BLURAY_TITLE_INFO *ti = b->title_info;
-
if (!ti)
return STREAM_UNSUPPORTED;
@@ -185,7 +500,7 @@ static int bluray_stream_control(stream_t *s, int cmd, void *arg)
}
case STREAM_CTRL_SET_CURRENT_TITLE: {
const uint32_t title = *((unsigned int*)arg);
- if (title < b->num_titles && bd_select_title(b->bd, title)) {
+ if (title < b->num_titles && play_title(b, title)) {
b->current_title = title;
return STREAM_OK;
}
@@ -218,15 +533,13 @@ static int bluray_stream_control(stream_t *s, int cmd, void *arg)
case STREAM_CTRL_SEEK_TO_TIME: {
double pts = *((double *) arg);
bd_seek_time(b->bd, BD_TIME_FROM_MP(pts));
- // Reset mpv internal stream position.
- stream_seek(s, bd_tell(b->bd));
+ stream_drop_buffers(s);
// API makes it hard to determine seeking success
return STREAM_OK;
}
case STREAM_CTRL_GET_NUM_ANGLES: {
const BLURAY_TITLE_INFO *ti = b->title_info;
-
if (!ti)
return STREAM_UNSUPPORTED;
@@ -298,6 +611,17 @@ static int bluray_stream_control(stream_t *s, int cmd, void *arg)
*(char**)arg = talloc_strdup(NULL, meta->di_name);
return STREAM_OK;
}
+ case STREAM_CTRL_NAV_CMD:
+ if (!b->use_nav)
+ return STREAM_UNSUPPORTED;
+ handle_nav_command(s, arg);
+ return STREAM_OK;
+ case STREAM_CTRL_GET_NAV_EVENT: {
+ struct mp_nav_event **ev = arg;
+ if (ev)
+ fill_next_event(s, ev);
+ return STREAM_OK;
+ }
default:
break;
}
@@ -312,7 +636,7 @@ static int bluray_stream_open(stream_t *s, int mode)
BLURAY_TITLE_INFO *info = NULL;
BLURAY *bd;
- int title, title_guess;
+ int title, title_guess = BLURAY_DEFAULT_TITLE;
uint64_t title_size;
unsigned int angle = 0;
@@ -340,57 +664,99 @@ static int bluray_stream_open(stream_t *s, int mode)
return STREAM_UNSUPPORTED;
}
- /* check for available titles on disc */
- b->num_titles = bd_get_titles(bd, TITLES_RELEVANT, angle);
- MP_SMODE(s, "ID_BLURAY_TITLES=%d\n", b->num_titles);
- if (!b->num_titles) {
- MP_ERR(s, "Can't find any Blu-ray-compatible title here.\n");
- bd_close(bd);
+ const BLURAY_DISC_INFO *disc_info = bd_get_disc_info(bd);
+ if (!disc_info->bluray_detected) {
+ MP_ERR(s, "Given stream is not a Blu-ray.\n");
+ destruct(b);
return STREAM_UNSUPPORTED;
}
- /* parse titles information */
- title_guess = BLURAY_DEFAULT_TITLE;
- for (i = 0; i < b->num_titles; i++) {
- BLURAY_TITLE_INFO *ti;
- int sec, msec;
+ if (b->use_nav) {
+ b->num_titles = disc_info->num_hdmv_titles + disc_info->num_bdj_titles;
+ ++b->num_titles; // for BLURAY_TITLE_TOP_MENU
+ ++b->num_titles; // for BLURAY_TITLE_FIRST_PLAY
+ MP_SMODE(s, "ID_BLURAY_TITLES=%d\n", b->num_titles);
+ } else {
+ /* check for available titles on disc */
+ b->num_titles = bd_get_titles(bd, TITLES_RELEVANT, angle);
+ MP_SMODE(s, "ID_BLURAY_TITLES=%d\n", b->num_titles);
+ if (!b->num_titles) {
+ MP_ERR(s, "Can't find any Blu-ray-compatible title here.\n");
+ destruct(b);
+ return STREAM_UNSUPPORTED;
+ }
- ti = bd_get_title_info(bd, i, angle);
- if (!ti)
- continue;
+ /* parse titles information */
- sec = ti->duration / 90000;
- msec = (ti->duration - sec) % 1000;
+ for (i = 0; i < b->num_titles; i++) {
+ BLURAY_TITLE_INFO *ti;
+ int sec, msec;
- MP_SMODE(s, "ID_BLURAY_TITLE_%d_CHAPTERS=%d\n", i, ti->chapter_count);
- MP_SMODE(s, "ID_BLURAY_TITLE_%d_ANGLE=%d\n", i, ti->angle_count);
- MP_SMODE(s, "ID_BLURAY_TITLE_%d_LENGTH=%d.%03d\n", i, sec, msec);
+ ti = bd_get_title_info(bd, i, angle);
+ if (!ti)
+ continue;
- /* try to guess which title may contain the main movie */
- if (ti->duration > max_duration) {
- max_duration = ti->duration;
- title_guess = i;
- }
+ sec = ti->duration / 90000;
+ msec = (ti->duration - sec) % 1000;
+
+ MP_SMODE(s, "ID_BLURAY_TITLE_%d_CHAPTERS=%d\n", i, ti->chapter_count);
+ MP_SMODE(s, "ID_BLURAY_TITLE_%d_ANGLE=%d\n", i, ti->angle_count);
+ MP_SMODE(s, "ID_BLURAY_TITLE_%d_LENGTH=%d.%03d\n", i, sec, msec);
+
+ /* try to guess which title may contain the main movie */
+ if (ti->duration > max_duration) {
+ max_duration = ti->duration;
+ title_guess = i;
+ }
- bd_free_title_info(ti);
+ bd_free_title_info(ti);
+ }
}
+ // these should be set before any callback
+ b->pool = mp_image_pool_new(6);
+ b->bd = bd;
+ b->current_angle = -1;
+ b->current_title = -1;
+
// initialize libbluray event queue
bd_get_event(bd, NULL);
+ if (b->use_nav) {
+ if (!bd_play(bd)) {
+ destruct(b);
+ return STREAM_ERROR;
+ }
+ bd_register_overlay_proc(bd, s, overlay_process);
+ }
+
/* Select current title */
- if (b->cfg_title != BLURAY_DEFAULT_TITLE)
- title = b->cfg_title;
- else
- title = title_guess;
+ if (b->use_nav) {
+ if (b->cfg_title == BLURAY_MENU_TITLE)
+ title = 0; // BLURAY_TITLE_TOP_MENU
+ else if (b->cfg_title == BLURAY_DEFAULT_TITLE)
+ title = b->num_titles - 1;
+ else
+ title = b->cfg_title;
+ } else {
+ if (b->cfg_title != BLURAY_DEFAULT_TITLE )
+ title = b->cfg_title;
+ else
+ title = title_guess;
+ }
title = FFMIN(title, b->num_titles - 1);
- bd_select_title(bd, title);
+ if (title >= 0) {
+ if (!play_title(b, title))
+ MP_WARN(s, "Couldn't start title '%d'.\n", title);
+ }
title_size = bd_get_title_size(bd);
MP_SMODE(s, "ID_BLURAY_CURRENT_TITLE=%d\n", title);
/* Get current title information */
+ if (b->cfg_title == BLURAY_MENU_TITLE || b->use_nav)
+ goto err_no_info;
info = bd_get_title_info(bd, title, angle);
if (!info)
goto err_no_info;
@@ -407,15 +773,12 @@ static int bluray_stream_open(stream_t *s, int mode)
bd_free_title_info(info);
err_no_info:
- s->fill_buffer = bluray_stream_fill_buffer;
- s->seek = bluray_stream_seek;
+ if (b->use_nav)
+ s->fill_buffer = bdnav_stream_fill_buffer;
+ else
+ s->fill_buffer = bluray_stream_fill_buffer;
s->close = bluray_stream_close;
s->control = bluray_stream_control;
-
- b->bd = bd;
- b->current_angle = angle;
- b->current_title = title;
-
s->type = STREAMTYPE_BLURAY;
s->end_pos = title_size;
s->sector_size = BLURAY_SECTOR_SIZE;
@@ -440,3 +803,17 @@ const stream_info_t stream_info_bluray = {
NULL
},
};
+
+const stream_info_t stream_info_bdnav = {
+ .name = "bdnav",
+ .open = bluray_stream_open,
+ .protocols = (const char*[]){ "bdnav", "brnav", "bluraynav", NULL },
+ .priv_defaults = &bdnav_stream_priv_dflts,
+ .priv_size = sizeof(struct bluray_priv_s),
+ .options = bdnav_stream_opts_fields,
+ .url_options = (const char*[]){
+ "hostname=title",
+ "filename=device",
+ NULL
+ },
+};
diff --git a/stream/stream_dvdnav.h b/stream/stream_dvdnav.h
index e27af6eb1e..9accf0c87a 100644
--- a/stream/stream_dvdnav.h
+++ b/stream/stream_dvdnav.h
@@ -35,8 +35,11 @@ enum mp_nav_event_type {
MP_NAV_EVENT_HIGHLIGHT, // highlight changed
MP_NAV_EVENT_MENU_MODE, // menu mode on/off
MP_NAV_EVENT_EOF, // it's over
+ MP_NAV_EVENT_OVERLAY, // overlay changed
};
+struct sub_bitmap;
+
struct mp_nav_event {
enum mp_nav_event_type event;
union {
@@ -51,6 +54,9 @@ struct mp_nav_event {
struct {
bool enable;
} menu_mode;
+ struct {
+ struct sub_bitmap *images[2];
+ } overlay;
} u;
};