9 #include "osdep/timer.h"
10 #include "input/input.h"
12 #include "libmpdemux/demuxer.h"
13 #include <dvdnav/dvdnav.h>
14 #include "stream_dvdnav.h"
15 #include "libvo/video_out.h"
16 #include "libavutil/common.h"
21 #include "stream_dvd_common.h"
25 NAV_FLAG_EOF
= 1 << 0, /* end of stream has been reached */
26 NAV_FLAG_WAIT
= 1 << 1, /* wait event */
27 NAV_FLAG_WAIT_SKIP
= 1 << 2, /* wait skip disable */
28 NAV_FLAG_CELL_CHANGE
= 1 << 3, /* cell change event */
29 NAV_FLAG_WAIT_READ_AUTO
= 1 << 4, /* wait read auto mode */
30 NAV_FLAG_WAIT_READ
= 1 << 5, /* suspend read from stream */
31 NAV_FLAG_VTS_DOMAIN
= 1 << 6, /* vts domain */
32 NAV_FLAG_SPU_SET
= 1 << 7, /* spu_clut is valid */
33 NAV_FLAG_STREAM_CHANGE
= 1 << 8, /* title, chapter, audio or SPU */
34 NAV_FLAG_AUDIO_CHANGE
= 1 << 9, /* audio stream change event */
35 NAV_FLAG_SPU_CHANGE
= 1 << 10, /* spu stream change event */
39 dvdnav_t
* dvdnav
; /* handle to libdvdnav stuff */
40 char * filename
; /* path */
41 unsigned int duration
; /* in milliseconds */
44 unsigned int spu_clut
[16];
45 dvdnav_highlight_event_t hlev
;
46 int still_length
; /* still frame duration */
50 static struct stream_priv_s
{
53 } stream_priv_dflts
= {
58 #define ST_OFF(f) M_ST_OFF(struct stream_priv_s,f)
60 static const m_option_t stream_opts_fields
[] = {
61 {"filename", ST_OFF(device
), CONF_TYPE_STRING
, 0, 0, 0, NULL
},
62 {"hostname", ST_OFF(track
), CONF_TYPE_INT
, M_OPT_RANGE
, 1, 99, NULL
},
63 { NULL
, NULL
, 0, 0, 0, 0, NULL
}
65 static const struct m_struct_st stream_opts
= {
67 sizeof(struct stream_priv_s
),
72 static int seek(stream_t
*s
, off_t newpos
);
73 static void show_audio_subs_languages(dvdnav_t
*nav
);
75 static dvdnav_priv_t
* new_dvdnav_stream(char * filename
) {
76 const char * title_str
;
82 if (!(priv
=calloc(1,sizeof(dvdnav_priv_t
))))
85 if (!(priv
->filename
=strdup(filename
))) {
90 dvd_set_speed(priv
->filename
, dvd_speed
);
92 if(dvdnav_open(&(priv
->dvdnav
),priv
->filename
)!=DVDNAV_STATUS_OK
)
104 if(1) //from vlc: if not used dvdnav from cvs will fail
109 dvdnav_get_next_block(priv
->dvdnav
,buf
,&event
,&len
);
110 dvdnav_sector_search(priv
->dvdnav
, 0, SEEK_SET
);
113 /* turn off dvdnav caching */
114 dvdnav_set_readahead_flag(priv
->dvdnav
, 0);
115 if(dvdnav_set_PGC_positioning_flag(priv
->dvdnav
, 1) != DVDNAV_STATUS_OK
)
116 mp_msg(MSGT_OPEN
,MSGL_ERR
,"stream_dvdnav, failed to set PGC positioning\n");
118 /* report the title?! */
119 if (dvdnav_get_title_string(priv
->dvdnav
,&title_str
)==DVDNAV_STATUS_OK
) {
120 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
,"Title: '%s'\n",title_str
);
124 //dvdnav_event_clear(priv);
129 static void dvdnav_get_highlight (dvdnav_priv_t
*priv
, int display_mode
) {
130 pci_t
*pnavpci
= NULL
;
131 dvdnav_highlight_event_t
*hlev
= &(priv
->hlev
);
134 if (!priv
|| !priv
->dvdnav
)
137 pnavpci
= dvdnav_get_current_nav_pci (priv
->dvdnav
);
141 dvdnav_get_current_highlight (priv
->dvdnav
, &(hlev
->buttonN
));
142 hlev
->display
= display_mode
; /* show */
144 if (hlev
->buttonN
> 0 && pnavpci
->hli
.hl_gi
.btn_ns
> 0 && hlev
->display
) {
145 for (btnum
= 0; btnum
< pnavpci
->hli
.hl_gi
.btn_ns
; btnum
++) {
146 btni_t
*btni
= &(pnavpci
->hli
.btnit
[btnum
]);
148 if (hlev
->buttonN
== btnum
+ 1) {
149 hlev
->sx
= FFMIN (btni
->x_start
, btni
->x_end
);
150 hlev
->ex
= FFMAX (btni
->x_start
, btni
->x_end
);
151 hlev
->sy
= FFMIN (btni
->y_start
, btni
->y_end
);
152 hlev
->ey
= FFMAX (btni
->y_start
, btni
->y_end
);
154 hlev
->palette
= (btni
->btn_coln
== 0) ? 0 :
155 pnavpci
->hli
.btn_colit
.btn_coli
[btni
->btn_coln
- 1][0];
159 } else { /* hide button or no button */
160 hlev
->sx
= hlev
->ex
= 0;
161 hlev
->sy
= hlev
->ey
= 0;
162 hlev
->palette
= hlev
->buttonN
= 0;
166 static inline int dvdnav_get_duration (int length
) {
167 return (length
== 255) ? 0 : length
* 1000;
170 static int dvdnav_stream_read(dvdnav_priv_t
* priv
, unsigned char *buf
, int *len
) {
171 int event
= DVDNAV_NOP
;
174 if (dvdnav_get_next_block(priv
->dvdnav
,buf
,&event
,len
)!=DVDNAV_STATUS_OK
) {
175 mp_msg(MSGT_OPEN
,MSGL_V
, "Error getting next block from DVD %d (%s)\n",event
, dvdnav_err_to_string(priv
->dvdnav
) );
178 else if (event
!=DVDNAV_BLOCK_OK
) {
179 // need to handle certain events internally (like skipping stills)
181 case DVDNAV_NAV_PACKET
:
183 case DVDNAV_STILL_FRAME
: {
184 dvdnav_still_event_t
*still_event
= (dvdnav_still_event_t
*) buf
;
185 priv
->still_length
= still_event
->length
;
186 /* set still frame duration */
187 priv
->duration
= dvdnav_get_duration (priv
->still_length
);
188 if (priv
->still_length
<= 1) {
189 pci_t
*pnavpci
= dvdnav_get_current_nav_pci (priv
->dvdnav
);
190 priv
->duration
= mp_dvdtimetomsec (&pnavpci
->pci_gi
.e_eltm
);
194 case DVDNAV_HIGHLIGHT
: {
195 dvdnav_get_highlight (priv
, 1);
198 case DVDNAV_CELL_CHANGE
: {
199 dvdnav_cell_change_event_t
*ev
= (dvdnav_cell_change_event_t
*)buf
;
202 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
203 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
205 priv
->duration
= ev
->pgc_length
/90;
207 if (dvdnav_is_domain_vts(priv
->dvdnav
)) {
208 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "DVDNAV_TITLE_IS_MOVIE\n");
209 priv
->state
&= ~NAV_FLAG_VTS_DOMAIN
;
211 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "DVDNAV_TITLE_IS_MENU\n");
212 priv
->state
|= NAV_FLAG_VTS_DOMAIN
;
215 nextstill
= dvdnav_get_next_still_flag (priv
->dvdnav
);
217 priv
->duration
= dvdnav_get_duration (nextstill
);
218 priv
->still_length
= nextstill
;
219 if (priv
->still_length
<= 1) {
220 pci_t
*pnavpci
= dvdnav_get_current_nav_pci (priv
->dvdnav
);
221 priv
->duration
= mp_dvdtimetomsec (&pnavpci
->pci_gi
.e_eltm
);
227 case DVDNAV_SPU_CLUT_CHANGE
: {
228 memcpy(priv
->spu_clut
, buf
, 16*sizeof(unsigned int));
229 priv
->state
|= NAV_FLAG_SPU_SET
;
233 if ((priv
->state
& NAV_FLAG_WAIT_SKIP
) &&
234 !(priv
->state
& NAV_FLAG_WAIT
))
235 dvdnav_wait_skip (priv
->dvdnav
);
237 priv
->state
|= NAV_FLAG_WAIT
;
240 case DVDNAV_VTS_CHANGE
: {
241 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
242 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
245 case DVDNAV_SPU_STREAM_CHANGE
: {
246 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
256 static void update_title_len(stream_t
*stream
) {
257 dvdnav_priv_t
*priv
= stream
->priv
;
258 dvdnav_status_t status
;
259 uint32_t pos
= 0, len
= 0;
261 status
= dvdnav_get_position(priv
->dvdnav
, &pos
, &len
);
262 if(status
== DVDNAV_STATUS_OK
&& len
) {
263 stream
->end_pos
= (off_t
) len
* 2048;
272 static int seek(stream_t
*s
, off_t newpos
) {
274 dvdnav_priv_t
*priv
= s
->priv
;
276 if(s
->end_pos
&& newpos
> s
->end_pos
)
278 sector
= newpos
/ 2048ULL;
279 if(dvdnav_sector_search(priv
->dvdnav
, (uint64_t) sector
, SEEK_SET
) != DVDNAV_STATUS_OK
)
287 mp_msg(MSGT_STREAM
,MSGL_INFO
,"dvdnav_stream, seeking to %"PRIu64
" failed: %s\n", newpos
, dvdnav_err_to_string(priv
->dvdnav
));
292 static void stream_dvdnav_close(stream_t
*s
) {
293 dvdnav_priv_t
*priv
= s
->priv
;
294 dvdnav_close(priv
->dvdnav
);
296 dvd_set_speed(priv
->filename
, -1);
301 static int fill_buffer(stream_t
*s
, char *but
, int len
)
305 dvdnav_priv_t
* priv
=s
->priv
;
306 if (priv
->state
& NAV_FLAG_WAIT_READ
) /* read is suspended */
311 while(!len
) /* grab all event until DVDNAV_BLOCK_OK (len=2048), DVDNAV_STOP or DVDNAV_STILL_FRAME */
313 event
=dvdnav_stream_read(priv
, s
->buffer
, &len
);
314 if(event
==-1 || len
==-1)
316 mp_msg(MSGT_CPLAYER
,MSGL_ERR
, "DVDNAV stream read error!\n");
319 if (event
!= DVDNAV_BLOCK_OK
)
320 dvdnav_get_highlight (priv
, 1);
323 priv
->state
|= NAV_FLAG_EOF
;
326 case DVDNAV_BLOCK_OK
:
327 case DVDNAV_NAV_PACKET
:
328 case DVDNAV_STILL_FRAME
:
331 if (priv
->state
& NAV_FLAG_WAIT
)
335 case DVDNAV_VTS_CHANGE
: {
336 int tit
= 0, part
= 0;
337 dvdnav_vts_change_event_t
*vts_event
= (dvdnav_vts_change_event_t
*)s
->buffer
;
338 mp_msg(MSGT_CPLAYER
,MSGL_INFO
, "DVDNAV, switched to title: %d\r\n", vts_event
->new_vtsN
);
339 priv
->state
|= NAV_FLAG_CELL_CHANGE
;
340 priv
->state
|= NAV_FLAG_AUDIO_CHANGE
;
341 priv
->state
|= NAV_FLAG_SPU_CHANGE
;
342 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
343 priv
->state
&= ~NAV_FLAG_WAIT
;
346 show_audio_subs_languages(priv
->dvdnav
);
347 if (priv
->state
& NAV_FLAG_WAIT_READ_AUTO
)
348 priv
->state
|= NAV_FLAG_WAIT_READ
;
349 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) == DVDNAV_STATUS_OK
) {
350 mp_msg(MSGT_CPLAYER
,MSGL_V
, "\r\nDVDNAV, NEW TITLE %d\r\n", tit
);
351 dvdnav_get_highlight (priv
, 0);
352 if(priv
->title
> 0 && tit
!= priv
->title
) {
353 priv
->state
|= NAV_FLAG_EOF
;
359 case DVDNAV_CELL_CHANGE
: {
360 priv
->state
|= NAV_FLAG_CELL_CHANGE
;
361 priv
->state
|= NAV_FLAG_AUDIO_CHANGE
;
362 priv
->state
|= NAV_FLAG_SPU_CHANGE
;
363 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
364 priv
->state
&= ~NAV_FLAG_WAIT
;
365 if (priv
->state
& NAV_FLAG_WAIT_READ_AUTO
)
366 priv
->state
|= NAV_FLAG_WAIT_READ
;
367 if(priv
->title
> 0 && dvd_last_chapter
> 0) {
369 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) == DVDNAV_STATUS_OK
&& part
> dvd_last_chapter
) {
370 priv
->state
|= NAV_FLAG_EOF
;
374 dvdnav_get_highlight (priv
, 1);
377 case DVDNAV_AUDIO_STREAM_CHANGE
:
378 priv
->state
|= NAV_FLAG_AUDIO_CHANGE
;
380 case DVDNAV_SPU_STREAM_CHANGE
:
381 priv
->state
|= NAV_FLAG_SPU_CHANGE
;
385 mp_msg(MSGT_STREAM
,MSGL_DBG2
,"DVDNAV fill_buffer len: %d\n",len
);
389 static int control(stream_t
*stream
, int cmd
, void* arg
) {
390 dvdnav_priv_t
* priv
=stream
->priv
;
395 case STREAM_CTRL_SEEK_TO_CHAPTER
:
397 int chap
= *((unsigned int *)arg
)+1;
399 if(chap
< 1 || dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) != DVDNAV_STATUS_OK
)
401 if(dvdnav_part_play(priv
->dvdnav
, tit
, chap
) != DVDNAV_STATUS_OK
)
405 case STREAM_CTRL_GET_NUM_CHAPTERS
:
407 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) != DVDNAV_STATUS_OK
)
409 if(dvdnav_get_number_of_parts(priv
->dvdnav
, tit
, &part
) != DVDNAV_STATUS_OK
)
413 *((unsigned int *)arg
) = part
;
416 case STREAM_CTRL_GET_CURRENT_CHAPTER
:
418 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) != DVDNAV_STATUS_OK
)
420 *((unsigned int *)arg
) = part
- 1;
423 case STREAM_CTRL_GET_TIME_LENGTH
:
425 if(priv
->duration
|| priv
->still_length
)
427 *((double *)arg
) = (double)priv
->duration
/ 1000.0;
432 case STREAM_CTRL_GET_ASPECT_RATIO
:
434 uint8_t ar
= dvdnav_get_video_aspect(priv
->dvdnav
);
435 *((double *)arg
) = !ar
? 4.0/3.0 : 16.0/9.0;
438 case STREAM_CTRL_GET_CURRENT_TIME
:
441 tm
= dvdnav_get_current_time(priv
->dvdnav
)/90000.0f
;
444 *((double *)arg
) = tm
;
449 case STREAM_CTRL_SEEK_TO_TIME
:
451 uint64_t tm
= (uint64_t) (*((double*)arg
) * 90000);
452 if(dvdnav_time_search(priv
->dvdnav
, tm
) == DVDNAV_STATUS_OK
)
456 case STREAM_CTRL_GET_NUM_ANGLES
:
458 uint32_t curr
, angles
;
459 if(dvdnav_get_angle_info(priv
->dvdnav
, &curr
, &angles
) != DVDNAV_STATUS_OK
)
461 *((int *)arg
) = angles
;
464 case STREAM_CTRL_GET_ANGLE
:
466 uint32_t curr
, angles
;
467 if(dvdnav_get_angle_info(priv
->dvdnav
, &curr
, &angles
) != DVDNAV_STATUS_OK
)
469 *((int *)arg
) = curr
;
472 case STREAM_CTRL_SET_ANGLE
:
474 uint32_t curr
, angles
;
475 int new_angle
= *((int *)arg
);
476 if(dvdnav_get_angle_info(priv
->dvdnav
, &curr
, &angles
) != DVDNAV_STATUS_OK
)
478 if(new_angle
>angles
|| new_angle
<1)
480 if(dvdnav_angle_change(priv
->dvdnav
, new_angle
) != DVDNAV_STATUS_OK
)
485 return STREAM_UNSUPPORTED
;
488 static void identify_chapters(dvdnav_t
*nav
, uint32_t title
)
490 uint64_t *parts
=NULL
, duration
=0;
492 n
= dvdnav_describe_title_chapters(nav
, title
, &parts
, &duration
);
495 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "ID_DVD_TITLE_%d_LENGTH=%d.%03d\n", title
, t
/ 1000, t
% 1000);
496 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "TITLE %u, CHAPTERS: ", title
);
498 t
= parts
[i
] / 90000;
499 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "%02d:%02d:%02d,", t
/3600, (t
/60)%60, t
%60);
502 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "\n");
506 static void identify(dvdnav_priv_t
*priv
, struct stream_priv_s
*p
)
508 uint32_t titles
=0, i
;
510 dvdnav_get_number_of_titles(priv
->dvdnav
, &titles
);
511 for(i
=0; i
<titles
; i
++)
512 identify_chapters(priv
->dvdnav
, i
);
515 identify_chapters(priv
->dvdnav
, p
->track
);
518 static void show_audio_subs_languages(dvdnav_t
*nav
)
521 uint16_t i
, lang
, format
, id
, channels
;
522 int base
[7] = {128, 0, 0, 0, 160, 136, 0};
525 char tmp
[] = "unknown";
526 lg
= dvdnav_get_audio_logical_stream(nav
, i
);
527 if(lg
== 0xff) continue;
528 channels
= dvdnav_audio_stream_channels(nav
, lg
);
529 if(channels
== 0xFFFF)
530 channels
= 2; //unknown
533 lang
= dvdnav_audio_stream_to_lang(nav
, lg
);
537 tmp
[1] = lang
& 0xFF;
540 format
= dvdnav_audio_stream_format(nav
, lg
);
541 if(format
== 0xFFFF || format
> 6)
542 format
= 1; //unknown
543 id
= i
+ base
[format
];
544 mp_msg(MSGT_OPEN
,MSGL_STATUS
,MSGTR_DVDaudioStreamInfo
, i
,
545 dvd_audio_stream_types
[format
], dvd_audio_stream_channels
[channels
], tmp
, id
);
546 if (lang
!= 0xFFFF && lang
&& tmp
[0])
547 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", id
, tmp
);
552 char tmp
[] = "unknown";
553 lg
= dvdnav_get_spu_logical_stream(nav
, i
);
554 if(lg
== 0xff) continue;
555 lang
= dvdnav_spu_stream_to_lang(nav
, i
);
559 tmp
[1] = lang
& 0xFF;
562 mp_msg(MSGT_OPEN
,MSGL_STATUS
,MSGTR_DVDsubtitleLanguage
, lg
, tmp
);
563 if (lang
!= 0xFFFF && lang
&& tmp
[0])
564 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", lg
, tmp
);
568 static int open_s(stream_t
*stream
,int mode
, void* opts
, int* file_format
) {
569 struct stream_priv_s
* p
= (struct stream_priv_s
*)opts
;
573 if(p
->device
) filename
= p
->device
;
574 else if(dvd_device
) filename
= dvd_device
;
575 else filename
= DEFAULT_DVD_DEVICE
;
576 if(!(priv
=new_dvdnav_stream(filename
))) {
577 mp_msg(MSGT_OPEN
,MSGL_ERR
,MSGTR_CantOpenDVD
,filename
, strerror(errno
));
578 return STREAM_UNSUPPORTED
;
582 priv
->title
= p
->track
;
583 if(dvdnav_title_play(priv
->dvdnav
, p
->track
) != DVDNAV_STATUS_OK
) {
584 mp_msg(MSGT_OPEN
,MSGL_FATAL
,"dvdnav_stream, couldn't select title %d, error '%s'\n", p
->track
, dvdnav_err_to_string(priv
->dvdnav
));
585 return STREAM_UNSUPPORTED
;
587 } else if (p
->track
== 0) {
588 if(dvdnav_menu_call(priv
->dvdnav
, DVD_MENU_Root
) != DVDNAV_STATUS_OK
)
589 dvdnav_menu_call(priv
->dvdnav
, DVD_MENU_Title
);
591 if(mp_msg_test(MSGT_IDENTIFY
, MSGL_INFO
))
594 show_audio_subs_languages(priv
->dvdnav
);
596 dvdnav_angle_change(priv
->dvdnav
, dvd_angle
);
598 stream
->sector_size
= 2048;
599 stream
->flags
= STREAM_READ
| STREAM_SEEK
;
600 stream
->fill_buffer
= fill_buffer
;
602 stream
->control
= control
;
603 stream
->close
= stream_dvdnav_close
;
604 stream
->type
= STREAMTYPE_DVDNAV
;
605 stream
->priv
=(void*)priv
;
606 *file_format
= DEMUXER_TYPE_MPEG_PS
;
608 update_title_len(stream
);
609 if(!stream
->pos
&& p
->track
> 0)
610 mp_msg(MSGT_OPEN
,MSGL_ERR
, "INIT ERROR: couldn't get init pos %s\r\n", dvdnav_err_to_string(priv
->dvdnav
));
612 mp_msg(MSGT_OPEN
,MSGL_INFO
, "Remember to disable MPlayer's cache when playing dvdnav:// streams (adding -nocache to your command line)\r\n");
618 void mp_dvdnav_handle_input(stream_t
*stream
, int cmd
, int *button
) {
619 dvdnav_priv_t
* priv
= stream
->priv
;
620 dvdnav_t
*nav
= priv
->dvdnav
;
621 dvdnav_status_t status
=DVDNAV_STATUS_ERR
;
622 pci_t
*pci
= dvdnav_get_current_nav_pci(nav
);
624 if(cmd
!= MP_CMD_DVDNAV_SELECT
&& !pci
)
628 case MP_CMD_DVDNAV_UP
:
629 status
= dvdnav_upper_button_select(nav
, pci
);
631 case MP_CMD_DVDNAV_DOWN
:
632 status
= dvdnav_lower_button_select(nav
, pci
);
634 case MP_CMD_DVDNAV_LEFT
:
635 status
= dvdnav_left_button_select(nav
, pci
);
637 case MP_CMD_DVDNAV_RIGHT
:
638 status
= dvdnav_right_button_select(nav
, pci
);
640 case MP_CMD_DVDNAV_MENU
:
641 status
= dvdnav_menu_call(nav
,DVD_MENU_Root
);
643 case MP_CMD_DVDNAV_PREVMENU
: {
646 dvdnav_current_title_info(nav
, &title
, &part
);
648 if((status
=dvdnav_menu_call(nav
, DVD_MENU_Part
)) == DVDNAV_STATUS_OK
)
651 if((status
=dvdnav_menu_call(nav
, DVD_MENU_Title
)) == DVDNAV_STATUS_OK
)
653 status
=dvdnav_menu_call(nav
, DVD_MENU_Root
);
656 case MP_CMD_DVDNAV_SELECT
:
657 status
= dvdnav_button_activate(nav
, pci
);
659 case MP_CMD_DVDNAV_MOUSECLICK
:
661 this is a workaround: in theory the simple dvdnav_lower_button_select()+dvdnav_button_activate()
662 should be enough (and generally it is), but there are cases when the calls to dvdnav_lower_button_select()
663 and friends fail! Hence we have to call dvdnav_mouse_activate(priv->mousex, priv->mousey) with
664 the coodinates saved by mp_dvdnav_update_mouse_pos().
665 This last call always works well
667 status
= dvdnav_mouse_activate(nav
, pci
, priv
->mousex
, priv
->mousey
);
670 mp_msg(MSGT_CPLAYER
, MSGL_V
, "Unknown DVDNAV cmd %d\n", cmd
);
674 if(status
== DVDNAV_STATUS_OK
)
675 dvdnav_get_current_highlight(nav
, button
);
678 void mp_dvdnav_update_mouse_pos(stream_t
*stream
, int32_t x
, int32_t y
, int* button
) {
679 dvdnav_priv_t
* priv
= stream
->priv
;
680 dvdnav_t
*nav
= priv
->dvdnav
;
681 dvdnav_status_t status
;
682 pci_t
*pci
= dvdnav_get_current_nav_pci(nav
);
686 status
= dvdnav_mouse_select(nav
, pci
, x
, y
);
687 if(status
== DVDNAV_STATUS_OK
) dvdnav_get_current_highlight(nav
, button
);
693 static int mp_dvdnav_get_aid_from_format (stream_t
*stream
, int index
, uint8_t lg
) {
694 dvdnav_priv_t
* priv
= stream
->priv
;
697 format
= dvdnav_audio_stream_format(priv
->dvdnav
, lg
);
699 case DVDNAV_FORMAT_AC3
:
701 case DVDNAV_FORMAT_DTS
:
703 case DVDNAV_FORMAT_LPCM
:
705 case DVDNAV_FORMAT_MPEGAUDIO
:
715 * \brief mp_dvdnav_aid_from_lang() returns the audio id corresponding to the language code 'lang'
716 * \param stream: - stream pointer
717 * \param lang: 2-characters language code[s], eventually separated by spaces of commas
718 * \return -1 on error, current subtitle id if successful
720 int mp_dvdnav_aid_from_lang(stream_t
*stream
, unsigned char *language
) {
721 dvdnav_priv_t
* priv
= stream
->priv
;
724 uint16_t lang
, lcode
;
726 while(language
&& strlen(language
)>=2) {
727 lcode
= (language
[0] << 8) | (language
[1]);
728 for(k
=0; k
<32; k
++) {
729 lg
= dvdnav_get_audio_logical_stream(priv
->dvdnav
, k
);
730 if(lg
== 0xff) continue;
731 lang
= dvdnav_audio_stream_to_lang(priv
->dvdnav
, lg
);
732 if(lang
!= 0xFFFF && lang
== lcode
)
733 return mp_dvdnav_get_aid_from_format (stream
, k
, lg
);
736 while(language
[0]==',' || language
[0]==' ') ++language
;
742 * \brief mp_dvdnav_lang_from_aid() assigns to buf the language corresponding to audio id 'aid'
743 * \param stream: - stream pointer
744 * \param sid: physical subtitle id
745 * \param buf: buffer to contain the 2-chars language string
746 * \return 0 on error, 1 if successful
748 int mp_dvdnav_lang_from_aid(stream_t
*stream
, int aid
, unsigned char *buf
) {
751 dvdnav_priv_t
* priv
= stream
->priv
;
755 lg
= dvdnav_get_audio_logical_stream(priv
->dvdnav
, aid
& 0x7);
756 if(lg
== 0xff) return 0;
757 lang
= dvdnav_audio_stream_to_lang(priv
->dvdnav
, lg
);
758 if(lang
== 0xffff) return 0;
760 buf
[1] = lang
& 0xFF;
767 * \brief mp_dvdnav_sid_from_lang() returns the subtitle id corresponding to the language code 'lang'
768 * \param stream: - stream pointer
769 * \param lang: 2-characters language code[s], eventually separated by spaces of commas
770 * \return -1 on error, current subtitle id if successful
772 int mp_dvdnav_sid_from_lang(stream_t
*stream
, unsigned char *language
) {
773 dvdnav_priv_t
* priv
= stream
->priv
;
775 uint16_t lang
, lcode
;
777 while(language
&& strlen(language
)>=2) {
778 lcode
= (language
[0] << 8) | (language
[1]);
779 for(k
=0; k
<32; k
++) {
780 lg
= dvdnav_get_spu_logical_stream(priv
->dvdnav
, k
);
781 if(lg
== 0xff) continue;
782 lang
= dvdnav_spu_stream_to_lang(priv
->dvdnav
, k
);
783 if(lang
!= 0xFFFF && lang
== lcode
) {
788 while(language
[0]==',' || language
[0]==' ') ++language
;
794 * \brief mp_dvdnav_lang_from_sid() assigns to buf the language corresponding to subtitle id 'sid'
795 * \param stream: - stream pointer
796 * \param sid: physical subtitle id
797 * \param buf: buffer to contain the 2-chars language string
798 * \return 0 on error, 1 if successful
800 int mp_dvdnav_lang_from_sid(stream_t
*stream
, int sid
, unsigned char *buf
) {
803 dvdnav_priv_t
*priv
= stream
->priv
;
804 if(sid
< 0) return 0;
806 if (dvdnav_get_spu_logical_stream(priv
->dvdnav
, k
) == sid
)
810 lang
= dvdnav_spu_stream_to_lang(priv
->dvdnav
, k
);
811 if(lang
== 0xffff) return 0;
813 buf
[1] = lang
& 0xFF;
819 * \brief mp_dvdnav_number_of_subs() returns the count of available subtitles
820 * \param stream: - stream pointer
821 * \return 0 on error, something meaningful otherwise
823 int mp_dvdnav_number_of_subs(stream_t
*stream
) {
824 dvdnav_priv_t
* priv
= stream
->priv
;
827 if (priv
->state
& NAV_FLAG_VTS_DOMAIN
) return 0;
828 for(k
=0; k
<32; k
++) {
829 lg
= dvdnav_get_spu_logical_stream(priv
->dvdnav
, k
);
830 if(lg
== 0xff) continue;
831 if(lg
>= n
) n
= lg
+ 1;
837 * \brief mp_dvdnav_get_spu_clut() returns the spu clut
838 * \param stream: - stream pointer
839 * \return spu clut pointer
841 unsigned int *mp_dvdnav_get_spu_clut(stream_t
*stream
) {
842 dvdnav_priv_t
*priv
= stream
->priv
;
843 return (priv
->state
& NAV_FLAG_SPU_SET
) ? priv
->spu_clut
: NULL
;
847 * \brief mp_dvdnav_get_highlight() get dvdnav highlight struct
848 * \param stream: - stream pointer
849 * \param hl : - highlight struct pointer
851 void mp_dvdnav_get_highlight (stream_t
*stream
, nav_highlight_t
*hl
) {
852 dvdnav_priv_t
*priv
= stream
->priv
;
853 dvdnav_highlight_event_t hlev
= priv
->hlev
;
859 hl
->palette
= hlev
.palette
;
862 void mp_dvdnav_switch_title (stream_t
*stream
, int title
) {
863 dvdnav_priv_t
*priv
= stream
->priv
;
866 dvdnav_get_number_of_titles (priv
->dvdnav
, &titles
);
867 if (title
> 0 && title
<= titles
)
868 dvdnav_title_play (priv
->dvdnav
, title
);
872 * \brief Check if end of stream has been reached
873 * \param stream: - stream pointer
874 * \return 1 on really eof
876 int mp_dvdnav_is_eof (stream_t
*stream
) {
877 return ((dvdnav_priv_t
*) stream
->priv
)->state
& NAV_FLAG_EOF
;
881 * \brief Skip still frame
882 * \param stream: - stream pointer
883 * \return 0 on success
885 int mp_dvdnav_skip_still (stream_t
*stream
) {
886 dvdnav_priv_t
*priv
= stream
->priv
;
887 if (priv
->still_length
== 0xff)
889 dvdnav_still_skip(priv
->dvdnav
);
894 * \brief Skip wait event
895 * \param stream: - stream pointer
896 * \return 0 on success
898 int mp_dvdnav_skip_wait (stream_t
*stream
) {
899 dvdnav_priv_t
*priv
= stream
->priv
;
900 if (!(priv
->state
& NAV_FLAG_WAIT
))
902 priv
->state
&= ~NAV_FLAG_WAIT
;
903 dvdnav_wait_skip(priv
->dvdnav
);
908 * \brief Set wait mode
909 * \param stream : - stream pointer
910 * \param mode : - if true, then suspend block read
911 * \param automode: - if true, then VTS or cell change set wait mode
913 void mp_dvdnav_read_wait (stream_t
*stream
, int mode
, int automode
) {
914 dvdnav_priv_t
*priv
= stream
->priv
;
916 priv
->state
&= ~NAV_FLAG_WAIT_READ
;
918 priv
->state
|= NAV_FLAG_WAIT_READ
;
920 priv
->state
&= ~NAV_FLAG_WAIT_READ_AUTO
;
922 priv
->state
|= NAV_FLAG_WAIT_READ_AUTO
;
926 * \brief Check if cell has changed
927 * \param stream: - stream pointer
928 * \param clear : - if true, then clear cell change flag
929 * \return 1 if cell has changed
931 int mp_dvdnav_cell_has_changed (stream_t
*stream
, int clear
) {
932 dvdnav_priv_t
*priv
= stream
->priv
;
933 if (!(priv
->state
& NAV_FLAG_CELL_CHANGE
))
936 priv
->state
&= ~NAV_FLAG_CELL_CHANGE
;
937 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
943 * \brief Check if audio has changed
944 * \param stream: - stream pointer
945 * \param clear : - if true, then clear audio change flag
946 * \return 1 if audio has changed
948 int mp_dvdnav_audio_has_changed (stream_t
*stream
, int clear
) {
949 dvdnav_priv_t
*priv
= stream
->priv
;
951 if (!(priv
->state
& NAV_FLAG_AUDIO_CHANGE
))
955 priv
->state
&= ~NAV_FLAG_AUDIO_CHANGE
;
961 * \brief Check if SPU has changed
962 * \param stream: - stream pointer
963 * \param clear : - if true, then clear spu change flag
964 * \return 1 if spu has changed
966 int mp_dvdnav_spu_has_changed (stream_t
*stream
, int clear
) {
967 dvdnav_priv_t
*priv
= stream
->priv
;
969 if (!(priv
->state
& NAV_FLAG_SPU_CHANGE
))
973 priv
->state
&= ~NAV_FLAG_SPU_CHANGE
;
978 /* Notify if something has changed in stream
979 * Can be related to title, chapter, audio or SPU
981 int mp_dvdnav_stream_has_changed (stream_t
*stream
) {
982 dvdnav_priv_t
*priv
= stream
->priv
;
984 if (!(priv
->state
& NAV_FLAG_STREAM_CHANGE
))
987 priv
->state
&= ~NAV_FLAG_STREAM_CHANGE
;
991 const stream_info_t stream_info_dvdnav
= {
999 1 // Urls are an option string