2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27 #include "osdep/timer.h"
28 #include "input/input.h"
30 #include "libmpdemux/demuxer.h"
31 #include <dvdnav/dvdnav.h>
32 #include "stream_dvdnav.h"
33 #include "libvo/video_out.h"
34 #include "libavutil/common.h"
38 #include "stream_dvd_common.h"
42 NAV_FLAG_EOF
= 1 << 0, /* end of stream has been reached */
43 NAV_FLAG_WAIT
= 1 << 1, /* wait event */
44 NAV_FLAG_WAIT_SKIP
= 1 << 2, /* wait skip disable */
45 NAV_FLAG_CELL_CHANGE
= 1 << 3, /* cell change event */
46 NAV_FLAG_WAIT_READ_AUTO
= 1 << 4, /* wait read auto mode */
47 NAV_FLAG_WAIT_READ
= 1 << 5, /* suspend read from stream */
48 NAV_FLAG_VTS_DOMAIN
= 1 << 6, /* vts domain */
49 NAV_FLAG_SPU_SET
= 1 << 7, /* spu_clut is valid */
50 NAV_FLAG_STREAM_CHANGE
= 1 << 8, /* title, chapter, audio or SPU */
51 NAV_FLAG_AUDIO_CHANGE
= 1 << 9, /* audio stream change event */
52 NAV_FLAG_SPU_CHANGE
= 1 << 10, /* spu stream change event */
56 dvdnav_t
* dvdnav
; /* handle to libdvdnav stuff */
57 char * filename
; /* path */
58 unsigned int duration
; /* in milliseconds */
61 unsigned int spu_clut
[16];
62 dvdnav_highlight_event_t hlev
;
63 int still_length
; /* still frame duration */
67 static struct stream_priv_s
{
70 } stream_priv_dflts
= {
75 #define ST_OFF(f) M_ST_OFF(struct stream_priv_s,f)
77 static const m_option_t stream_opts_fields
[] = {
78 {"filename", ST_OFF(device
), CONF_TYPE_STRING
, 0, 0, 0, NULL
},
79 {"hostname", ST_OFF(track
), CONF_TYPE_INT
, M_OPT_RANGE
, 1, 99, NULL
},
80 { NULL
, NULL
, 0, 0, 0, 0, NULL
}
82 static const struct m_struct_st stream_opts
= {
84 sizeof(struct stream_priv_s
),
89 static int seek(stream_t
*s
, off_t newpos
);
90 static void show_audio_subs_languages(dvdnav_t
*nav
);
92 static dvdnav_priv_t
* new_dvdnav_stream(char * filename
) {
93 const char * title_str
;
99 if (!(priv
=calloc(1,sizeof(dvdnav_priv_t
))))
102 if (!(priv
->filename
=strdup(filename
))) {
107 dvd_set_speed(priv
->filename
, dvd_speed
);
109 if(dvdnav_open(&(priv
->dvdnav
),priv
->filename
)!=DVDNAV_STATUS_OK
)
111 free(priv
->filename
);
121 if(1) //from vlc: if not used dvdnav from cvs will fail
126 dvdnav_get_next_block(priv
->dvdnav
,buf
,&event
,&len
);
127 dvdnav_sector_search(priv
->dvdnav
, 0, SEEK_SET
);
130 /* turn off dvdnav caching */
131 dvdnav_set_readahead_flag(priv
->dvdnav
, 0);
132 if(dvdnav_set_PGC_positioning_flag(priv
->dvdnav
, 1) != DVDNAV_STATUS_OK
)
133 mp_msg(MSGT_OPEN
,MSGL_ERR
,"stream_dvdnav, failed to set PGC positioning\n");
134 /* report the title?! */
135 if (dvdnav_get_title_string(priv
->dvdnav
,&title_str
)==DVDNAV_STATUS_OK
) {
136 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
,"Title: '%s'\n",title_str
);
139 //dvdnav_event_clear(priv);
144 static void dvdnav_get_highlight (dvdnav_priv_t
*priv
, int display_mode
) {
145 pci_t
*pnavpci
= NULL
;
146 dvdnav_highlight_event_t
*hlev
= &(priv
->hlev
);
149 if (!priv
|| !priv
->dvdnav
)
152 pnavpci
= dvdnav_get_current_nav_pci (priv
->dvdnav
);
156 dvdnav_get_current_highlight (priv
->dvdnav
, &(hlev
->buttonN
));
157 hlev
->display
= display_mode
; /* show */
159 if (hlev
->buttonN
> 0 && pnavpci
->hli
.hl_gi
.btn_ns
> 0 && hlev
->display
) {
160 for (btnum
= 0; btnum
< pnavpci
->hli
.hl_gi
.btn_ns
; btnum
++) {
161 btni_t
*btni
= &(pnavpci
->hli
.btnit
[btnum
]);
163 if (hlev
->buttonN
== btnum
+ 1) {
164 hlev
->sx
= FFMIN (btni
->x_start
, btni
->x_end
);
165 hlev
->ex
= FFMAX (btni
->x_start
, btni
->x_end
);
166 hlev
->sy
= FFMIN (btni
->y_start
, btni
->y_end
);
167 hlev
->ey
= FFMAX (btni
->y_start
, btni
->y_end
);
169 hlev
->palette
= (btni
->btn_coln
== 0) ? 0 :
170 pnavpci
->hli
.btn_colit
.btn_coli
[btni
->btn_coln
- 1][0];
174 } else { /* hide button or no button */
175 hlev
->sx
= hlev
->ex
= 0;
176 hlev
->sy
= hlev
->ey
= 0;
177 hlev
->palette
= hlev
->buttonN
= 0;
181 static inline int dvdnav_get_duration (int length
) {
182 return (length
== 255) ? 0 : length
* 1000;
185 static int dvdnav_stream_read(dvdnav_priv_t
* priv
, unsigned char *buf
, int *len
) {
186 int event
= DVDNAV_NOP
;
189 if (dvdnav_get_next_block(priv
->dvdnav
,buf
,&event
,len
)!=DVDNAV_STATUS_OK
) {
190 mp_msg(MSGT_OPEN
,MSGL_V
, "Error getting next block from DVD %d (%s)\n",event
, dvdnav_err_to_string(priv
->dvdnav
) );
193 else if (event
!=DVDNAV_BLOCK_OK
) {
194 // need to handle certain events internally (like skipping stills)
196 case DVDNAV_NAV_PACKET
:
198 case DVDNAV_STILL_FRAME
: {
199 dvdnav_still_event_t
*still_event
= (dvdnav_still_event_t
*) buf
;
200 priv
->still_length
= still_event
->length
;
201 /* set still frame duration */
202 priv
->duration
= dvdnav_get_duration (priv
->still_length
);
203 if (priv
->still_length
<= 1) {
204 pci_t
*pnavpci
= dvdnav_get_current_nav_pci (priv
->dvdnav
);
205 priv
->duration
= mp_dvdtimetomsec (&pnavpci
->pci_gi
.e_eltm
);
209 case DVDNAV_HIGHLIGHT
: {
210 dvdnav_get_highlight (priv
, 1);
213 case DVDNAV_CELL_CHANGE
: {
214 dvdnav_cell_change_event_t
*ev
= (dvdnav_cell_change_event_t
*)buf
;
217 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
218 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
220 priv
->duration
= ev
->pgc_length
/90;
222 if (dvdnav_is_domain_vts(priv
->dvdnav
)) {
223 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "DVDNAV_TITLE_IS_MOVIE\n");
224 priv
->state
&= ~NAV_FLAG_VTS_DOMAIN
;
226 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "DVDNAV_TITLE_IS_MENU\n");
227 priv
->state
|= NAV_FLAG_VTS_DOMAIN
;
230 nextstill
= dvdnav_get_next_still_flag (priv
->dvdnav
);
232 priv
->duration
= dvdnav_get_duration (nextstill
);
233 priv
->still_length
= nextstill
;
234 if (priv
->still_length
<= 1) {
235 pci_t
*pnavpci
= dvdnav_get_current_nav_pci (priv
->dvdnav
);
236 priv
->duration
= mp_dvdtimetomsec (&pnavpci
->pci_gi
.e_eltm
);
242 case DVDNAV_SPU_CLUT_CHANGE
: {
243 memcpy(priv
->spu_clut
, buf
, 16*sizeof(unsigned int));
244 priv
->state
|= NAV_FLAG_SPU_SET
;
248 if ((priv
->state
& NAV_FLAG_WAIT_SKIP
) &&
249 !(priv
->state
& NAV_FLAG_WAIT
))
250 dvdnav_wait_skip (priv
->dvdnav
);
252 priv
->state
|= NAV_FLAG_WAIT
;
255 case DVDNAV_VTS_CHANGE
: {
256 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
257 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
260 case DVDNAV_SPU_STREAM_CHANGE
: {
261 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
271 static void update_title_len(stream_t
*stream
) {
272 dvdnav_priv_t
*priv
= stream
->priv
;
273 dvdnav_status_t status
;
274 uint32_t pos
= 0, len
= 0;
276 status
= dvdnav_get_position(priv
->dvdnav
, &pos
, &len
);
277 if(status
== DVDNAV_STATUS_OK
&& len
) {
278 stream
->end_pos
= (off_t
) len
* 2048;
287 static int seek(stream_t
*s
, off_t newpos
) {
289 dvdnav_priv_t
*priv
= s
->priv
;
291 if(s
->end_pos
&& newpos
> s
->end_pos
)
293 sector
= newpos
/ 2048ULL;
294 if(dvdnav_sector_search(priv
->dvdnav
, (uint64_t) sector
, SEEK_SET
) != DVDNAV_STATUS_OK
)
302 mp_msg(MSGT_STREAM
,MSGL_INFO
,"dvdnav_stream, seeking to %"PRIu64
" failed: %s\n", newpos
, dvdnav_err_to_string(priv
->dvdnav
));
307 static void stream_dvdnav_close(stream_t
*s
) {
308 dvdnav_priv_t
*priv
= s
->priv
;
309 dvdnav_close(priv
->dvdnav
);
311 dvd_set_speed(priv
->filename
, -1);
316 static int fill_buffer(stream_t
*s
, char *but
, int len
)
320 dvdnav_priv_t
* priv
=s
->priv
;
321 if (priv
->state
& NAV_FLAG_WAIT_READ
) /* read is suspended */
326 while(!len
) /* grab all event until DVDNAV_BLOCK_OK (len=2048), DVDNAV_STOP or DVDNAV_STILL_FRAME */
328 event
=dvdnav_stream_read(priv
, s
->buffer
, &len
);
329 if(event
==-1 || len
==-1)
331 mp_msg(MSGT_CPLAYER
,MSGL_ERR
, "DVDNAV stream read error!\n");
334 if (event
!= DVDNAV_BLOCK_OK
)
335 dvdnav_get_highlight (priv
, 1);
338 priv
->state
|= NAV_FLAG_EOF
;
341 case DVDNAV_BLOCK_OK
:
342 case DVDNAV_NAV_PACKET
:
343 case DVDNAV_STILL_FRAME
:
346 if (priv
->state
& NAV_FLAG_WAIT
)
350 case DVDNAV_VTS_CHANGE
: {
351 int tit
= 0, part
= 0;
352 dvdnav_vts_change_event_t
*vts_event
= (dvdnav_vts_change_event_t
*)s
->buffer
;
353 mp_msg(MSGT_CPLAYER
,MSGL_INFO
, "DVDNAV, switched to title: %d\r\n", vts_event
->new_vtsN
);
354 priv
->state
|= NAV_FLAG_CELL_CHANGE
;
355 priv
->state
|= NAV_FLAG_AUDIO_CHANGE
;
356 priv
->state
|= NAV_FLAG_SPU_CHANGE
;
357 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
358 priv
->state
&= ~NAV_FLAG_WAIT
;
361 show_audio_subs_languages(priv
->dvdnav
);
362 if (priv
->state
& NAV_FLAG_WAIT_READ_AUTO
)
363 priv
->state
|= NAV_FLAG_WAIT_READ
;
364 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) == DVDNAV_STATUS_OK
) {
365 mp_msg(MSGT_CPLAYER
,MSGL_V
, "\r\nDVDNAV, NEW TITLE %d\r\n", tit
);
366 dvdnav_get_highlight (priv
, 0);
367 if(priv
->title
> 0 && tit
!= priv
->title
) {
368 priv
->state
|= NAV_FLAG_EOF
;
374 case DVDNAV_CELL_CHANGE
: {
375 priv
->state
|= NAV_FLAG_CELL_CHANGE
;
376 priv
->state
|= NAV_FLAG_AUDIO_CHANGE
;
377 priv
->state
|= NAV_FLAG_SPU_CHANGE
;
378 priv
->state
&= ~NAV_FLAG_WAIT_SKIP
;
379 priv
->state
&= ~NAV_FLAG_WAIT
;
380 if (priv
->state
& NAV_FLAG_WAIT_READ_AUTO
)
381 priv
->state
|= NAV_FLAG_WAIT_READ
;
382 if(priv
->title
> 0 && dvd_last_chapter
> 0) {
384 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) == DVDNAV_STATUS_OK
&& part
> dvd_last_chapter
) {
385 priv
->state
|= NAV_FLAG_EOF
;
389 dvdnav_get_highlight (priv
, 1);
392 case DVDNAV_AUDIO_STREAM_CHANGE
:
393 priv
->state
|= NAV_FLAG_AUDIO_CHANGE
;
395 case DVDNAV_SPU_STREAM_CHANGE
:
396 priv
->state
|= NAV_FLAG_SPU_CHANGE
;
400 mp_msg(MSGT_STREAM
,MSGL_DBG2
,"DVDNAV fill_buffer len: %d\n",len
);
404 static int control(stream_t
*stream
, int cmd
, void* arg
) {
405 dvdnav_priv_t
* priv
=stream
->priv
;
410 case STREAM_CTRL_SEEK_TO_CHAPTER
:
412 int chap
= *((unsigned int *)arg
)+1;
414 if(chap
< 1 || dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) != DVDNAV_STATUS_OK
)
416 if(dvdnav_part_play(priv
->dvdnav
, tit
, chap
) != DVDNAV_STATUS_OK
)
420 case STREAM_CTRL_GET_NUM_CHAPTERS
:
422 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) != DVDNAV_STATUS_OK
)
424 if(dvdnav_get_number_of_parts(priv
->dvdnav
, tit
, &part
) != DVDNAV_STATUS_OK
)
428 *((unsigned int *)arg
) = part
;
431 case STREAM_CTRL_GET_CURRENT_CHAPTER
:
433 if(dvdnav_current_title_info(priv
->dvdnav
, &tit
, &part
) != DVDNAV_STATUS_OK
)
435 *((unsigned int *)arg
) = part
- 1;
438 case STREAM_CTRL_GET_TIME_LENGTH
:
440 if(priv
->duration
|| priv
->still_length
)
442 *((double *)arg
) = (double)priv
->duration
/ 1000.0;
447 case STREAM_CTRL_GET_ASPECT_RATIO
:
449 uint8_t ar
= dvdnav_get_video_aspect(priv
->dvdnav
);
450 *((double *)arg
) = !ar
? 4.0/3.0 : 16.0/9.0;
453 case STREAM_CTRL_GET_CURRENT_TIME
:
456 tm
= dvdnav_get_current_time(priv
->dvdnav
)/90000.0f
;
459 *((double *)arg
) = tm
;
464 case STREAM_CTRL_SEEK_TO_TIME
:
466 uint64_t tm
= (uint64_t) (*((double*)arg
) * 90000);
467 if(dvdnav_time_search(priv
->dvdnav
, tm
) == DVDNAV_STATUS_OK
)
471 case STREAM_CTRL_GET_NUM_ANGLES
:
473 uint32_t curr
, angles
;
474 if(dvdnav_get_angle_info(priv
->dvdnav
, &curr
, &angles
) != DVDNAV_STATUS_OK
)
476 *((int *)arg
) = angles
;
479 case STREAM_CTRL_GET_ANGLE
:
481 uint32_t curr
, angles
;
482 if(dvdnav_get_angle_info(priv
->dvdnav
, &curr
, &angles
) != DVDNAV_STATUS_OK
)
484 *((int *)arg
) = curr
;
487 case STREAM_CTRL_SET_ANGLE
:
489 uint32_t curr
, angles
;
490 int new_angle
= *((int *)arg
);
491 if(dvdnav_get_angle_info(priv
->dvdnav
, &curr
, &angles
) != DVDNAV_STATUS_OK
)
493 if(new_angle
>angles
|| new_angle
<1)
495 if(dvdnav_angle_change(priv
->dvdnav
, new_angle
) != DVDNAV_STATUS_OK
)
500 return STREAM_UNSUPPORTED
;
503 static void identify_chapters(dvdnav_t
*nav
, uint32_t title
)
505 uint64_t *parts
=NULL
, duration
=0;
507 n
= dvdnav_describe_title_chapters(nav
, title
, &parts
, &duration
);
510 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "ID_DVD_TITLE_%d_LENGTH=%d.%03d\n", title
, t
/ 1000, t
% 1000);
511 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "TITLE %u, CHAPTERS: ", title
);
513 t
= parts
[i
] / 90000;
514 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "%02d:%02d:%02d,", t
/3600, (t
/60)%60, t
%60);
517 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "\n");
521 static void identify(dvdnav_priv_t
*priv
, struct stream_priv_s
*p
)
523 uint32_t titles
=0, i
;
525 dvdnav_get_number_of_titles(priv
->dvdnav
, &titles
);
526 for(i
=0; i
<titles
; i
++)
527 identify_chapters(priv
->dvdnav
, i
);
530 identify_chapters(priv
->dvdnav
, p
->track
);
533 static void show_audio_subs_languages(dvdnav_t
*nav
)
536 uint16_t i
, lang
, format
, id
, channels
;
537 int base
[7] = {128, 0, 0, 0, 160, 136, 0};
540 char tmp
[] = "unknown";
541 lg
= dvdnav_get_audio_logical_stream(nav
, i
);
542 if(lg
== 0xff) continue;
543 channels
= dvdnav_audio_stream_channels(nav
, lg
);
544 if(channels
== 0xFFFF)
545 channels
= 2; //unknown
548 lang
= dvdnav_audio_stream_to_lang(nav
, lg
);
552 tmp
[1] = lang
& 0xFF;
555 format
= dvdnav_audio_stream_format(nav
, lg
);
556 if(format
== 0xFFFF || format
> 6)
557 format
= 1; //unknown
558 id
= i
+ base
[format
];
559 mp_tmsg(MSGT_OPEN
,MSGL_STATUS
,"audio stream: %d format: %s (%s) language: %s aid: %d.\n", i
,
560 dvd_audio_stream_types
[format
], dvd_audio_stream_channels
[channels
], tmp
, id
);
561 if (lang
!= 0xFFFF && lang
&& tmp
[0])
562 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", id
, tmp
);
567 char tmp
[] = "unknown";
568 lg
= dvdnav_get_spu_logical_stream(nav
, i
);
569 if(lg
== 0xff) continue;
570 lang
= dvdnav_spu_stream_to_lang(nav
, i
);
574 tmp
[1] = lang
& 0xFF;
577 mp_msg(MSGT_OPEN
,MSGL_STATUS
,"subtitle ( sid ): %d language: %s\n", lg
, tmp
);
578 if (lang
!= 0xFFFF && lang
&& tmp
[0])
579 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", lg
, tmp
);
583 static int open_s(stream_t
*stream
,int mode
, void* opts
, int* file_format
) {
584 struct stream_priv_s
* p
= (struct stream_priv_s
*)opts
;
588 if(p
->device
) filename
= p
->device
;
589 else if(dvd_device
) filename
= dvd_device
;
590 else filename
= DEFAULT_DVD_DEVICE
;
591 if(!(priv
=new_dvdnav_stream(filename
))) {
592 mp_tmsg(MSGT_OPEN
,MSGL_ERR
,"Couldn't open DVD device: %s (%s)\n",filename
, strerror(errno
));
593 return STREAM_UNSUPPORTED
;
597 priv
->title
= p
->track
;
598 if(dvdnav_title_play(priv
->dvdnav
, p
->track
) != DVDNAV_STATUS_OK
) {
599 mp_msg(MSGT_OPEN
,MSGL_FATAL
,"dvdnav_stream, couldn't select title %d, error '%s'\n", p
->track
, dvdnav_err_to_string(priv
->dvdnav
));
600 return STREAM_UNSUPPORTED
;
602 } else if (p
->track
== 0) {
603 if(dvdnav_menu_call(priv
->dvdnav
, DVD_MENU_Root
) != DVDNAV_STATUS_OK
)
604 dvdnav_menu_call(priv
->dvdnav
, DVD_MENU_Title
);
606 if(mp_msg_test(MSGT_IDENTIFY
, MSGL_INFO
))
609 show_audio_subs_languages(priv
->dvdnav
);
611 dvdnav_angle_change(priv
->dvdnav
, dvd_angle
);
613 stream
->sector_size
= 2048;
614 stream
->flags
= STREAM_READ
| MP_STREAM_SEEK
;
615 stream
->fill_buffer
= fill_buffer
;
617 stream
->control
= control
;
618 stream
->close
= stream_dvdnav_close
;
619 stream
->type
= STREAMTYPE_DVDNAV
;
620 stream
->priv
=(void*)priv
;
621 *file_format
= DEMUXER_TYPE_MPEG_PS
;
623 update_title_len(stream
);
624 if(!stream
->pos
&& p
->track
> 0)
625 mp_msg(MSGT_OPEN
,MSGL_ERR
, "INIT ERROR: couldn't get init pos %s\r\n", dvdnav_err_to_string(priv
->dvdnav
));
627 mp_msg(MSGT_OPEN
,MSGL_INFO
, "Remember to disable MPlayer's cache when playing dvdnav:// streams (adding -nocache to your command line)\r\n");
633 void mp_dvdnav_handle_input(stream_t
*stream
, int cmd
, int *button
) {
634 dvdnav_priv_t
* priv
= stream
->priv
;
635 dvdnav_t
*nav
= priv
->dvdnav
;
636 dvdnav_status_t status
=DVDNAV_STATUS_ERR
;
637 pci_t
*pci
= dvdnav_get_current_nav_pci(nav
);
639 if(cmd
!= MP_CMD_DVDNAV_SELECT
&& !pci
)
643 case MP_CMD_DVDNAV_UP
:
644 status
= dvdnav_upper_button_select(nav
, pci
);
646 case MP_CMD_DVDNAV_DOWN
:
647 status
= dvdnav_lower_button_select(nav
, pci
);
649 case MP_CMD_DVDNAV_LEFT
:
650 status
= dvdnav_left_button_select(nav
, pci
);
652 case MP_CMD_DVDNAV_RIGHT
:
653 status
= dvdnav_right_button_select(nav
, pci
);
655 case MP_CMD_DVDNAV_MENU
:
656 status
= dvdnav_menu_call(nav
,DVD_MENU_Root
);
658 case MP_CMD_DVDNAV_PREVMENU
: {
661 dvdnav_current_title_info(nav
, &title
, &part
);
663 if((status
=dvdnav_menu_call(nav
, DVD_MENU_Part
)) == DVDNAV_STATUS_OK
)
666 if((status
=dvdnav_menu_call(nav
, DVD_MENU_Title
)) == DVDNAV_STATUS_OK
)
668 status
=dvdnav_menu_call(nav
, DVD_MENU_Root
);
671 case MP_CMD_DVDNAV_SELECT
:
672 status
= dvdnav_button_activate(nav
, pci
);
674 case MP_CMD_DVDNAV_MOUSECLICK
:
676 this is a workaround: in theory the simple dvdnav_lower_button_select()+dvdnav_button_activate()
677 should be enough (and generally it is), but there are cases when the calls to dvdnav_lower_button_select()
678 and friends fail! Hence we have to call dvdnav_mouse_activate(priv->mousex, priv->mousey) with
679 the coodinates saved by mp_dvdnav_update_mouse_pos().
680 This last call always works well
682 status
= dvdnav_mouse_activate(nav
, pci
, priv
->mousex
, priv
->mousey
);
685 mp_msg(MSGT_CPLAYER
, MSGL_V
, "Unknown DVDNAV cmd %d\n", cmd
);
689 if(status
== DVDNAV_STATUS_OK
)
690 dvdnav_get_current_highlight(nav
, button
);
693 void mp_dvdnav_update_mouse_pos(stream_t
*stream
, int32_t x
, int32_t y
, int* button
) {
694 dvdnav_priv_t
* priv
= stream
->priv
;
695 dvdnav_t
*nav
= priv
->dvdnav
;
696 dvdnav_status_t status
;
697 pci_t
*pci
= dvdnav_get_current_nav_pci(nav
);
701 status
= dvdnav_mouse_select(nav
, pci
, x
, y
);
702 if(status
== DVDNAV_STATUS_OK
) dvdnav_get_current_highlight(nav
, button
);
708 static int mp_dvdnav_get_aid_from_format (stream_t
*stream
, int index
, uint8_t lg
) {
709 dvdnav_priv_t
* priv
= stream
->priv
;
712 format
= dvdnav_audio_stream_format(priv
->dvdnav
, lg
);
714 case DVDNAV_FORMAT_AC3
:
716 case DVDNAV_FORMAT_DTS
:
718 case DVDNAV_FORMAT_LPCM
:
720 case DVDNAV_FORMAT_MPEGAUDIO
:
730 * \brief mp_dvdnav_aid_from_lang() returns the audio id corresponding to the language code 'lang'
731 * \param stream: - stream pointer
732 * \param lang: 2-characters language code[s], eventually separated by spaces of commas
733 * \return -1 on error, current subtitle id if successful
735 int mp_dvdnav_aid_from_lang(stream_t
*stream
, unsigned char *language
) {
736 dvdnav_priv_t
* priv
= stream
->priv
;
739 uint16_t lang
, lcode
;
741 while(language
&& strlen(language
)>=2) {
742 lcode
= (language
[0] << 8) | (language
[1]);
743 for(k
=0; k
<32; k
++) {
744 lg
= dvdnav_get_audio_logical_stream(priv
->dvdnav
, k
);
745 if(lg
== 0xff) continue;
746 lang
= dvdnav_audio_stream_to_lang(priv
->dvdnav
, lg
);
747 if(lang
!= 0xFFFF && lang
== lcode
)
748 return mp_dvdnav_get_aid_from_format (stream
, k
, lg
);
751 while(language
[0]==',' || language
[0]==' ') ++language
;
757 * \brief mp_dvdnav_lang_from_aid() assigns to buf the language corresponding to audio id 'aid'
758 * \param stream: - stream pointer
759 * \param sid: physical subtitle id
760 * \param buf: buffer to contain the 2-chars language string
761 * \return 0 on error, 1 if successful
763 int mp_dvdnav_lang_from_aid(stream_t
*stream
, int aid
, unsigned char *buf
) {
766 dvdnav_priv_t
* priv
= stream
->priv
;
770 lg
= dvdnav_get_audio_logical_stream(priv
->dvdnav
, aid
& 0x7);
771 if(lg
== 0xff) return 0;
772 lang
= dvdnav_audio_stream_to_lang(priv
->dvdnav
, lg
);
773 if(lang
== 0xffff) return 0;
775 buf
[1] = lang
& 0xFF;
782 * \brief mp_dvdnav_sid_from_lang() returns the subtitle id corresponding to the language code 'lang'
783 * \param stream: - stream pointer
784 * \param lang: 2-characters language code[s], eventually separated by spaces of commas
785 * \return -1 on error, current subtitle id if successful
787 int mp_dvdnav_sid_from_lang(stream_t
*stream
, unsigned char *language
) {
788 dvdnav_priv_t
* priv
= stream
->priv
;
790 uint16_t lang
, lcode
;
792 while(language
&& strlen(language
)>=2) {
793 lcode
= (language
[0] << 8) | (language
[1]);
794 for(k
=0; k
<32; k
++) {
795 lg
= dvdnav_get_spu_logical_stream(priv
->dvdnav
, k
);
796 if(lg
== 0xff) continue;
797 lang
= dvdnav_spu_stream_to_lang(priv
->dvdnav
, k
);
798 if(lang
!= 0xFFFF && lang
== lcode
) {
803 while(language
[0]==',' || language
[0]==' ') ++language
;
809 * \brief mp_dvdnav_lang_from_sid() assigns to buf the language corresponding to subtitle id 'sid'
810 * \param stream: - stream pointer
811 * \param sid: physical subtitle id
812 * \param buf: buffer to contain the 2-chars language string
813 * \return 0 on error, 1 if successful
815 int mp_dvdnav_lang_from_sid(stream_t
*stream
, int sid
, unsigned char *buf
) {
818 dvdnav_priv_t
*priv
= stream
->priv
;
819 if(sid
< 0) return 0;
821 if (dvdnav_get_spu_logical_stream(priv
->dvdnav
, k
) == sid
)
825 lang
= dvdnav_spu_stream_to_lang(priv
->dvdnav
, k
);
826 if(lang
== 0xffff) return 0;
828 buf
[1] = lang
& 0xFF;
834 * \brief mp_dvdnav_number_of_subs() returns the count of available subtitles
835 * \param stream: - stream pointer
836 * \return 0 on error, something meaningful otherwise
838 int mp_dvdnav_number_of_subs(stream_t
*stream
) {
839 dvdnav_priv_t
* priv
= stream
->priv
;
842 if (priv
->state
& NAV_FLAG_VTS_DOMAIN
) return 0;
843 for(k
=0; k
<32; k
++) {
844 lg
= dvdnav_get_spu_logical_stream(priv
->dvdnav
, k
);
845 if(lg
== 0xff) continue;
846 if(lg
>= n
) n
= lg
+ 1;
852 * \brief mp_dvdnav_get_spu_clut() returns the spu clut
853 * \param stream: - stream pointer
854 * \return spu clut pointer
856 unsigned int *mp_dvdnav_get_spu_clut(stream_t
*stream
) {
857 dvdnav_priv_t
*priv
= stream
->priv
;
858 return (priv
->state
& NAV_FLAG_SPU_SET
) ? priv
->spu_clut
: NULL
;
862 * \brief mp_dvdnav_get_highlight() get dvdnav highlight struct
863 * \param stream: - stream pointer
864 * \param hl : - highlight struct pointer
866 void mp_dvdnav_get_highlight (stream_t
*stream
, nav_highlight_t
*hl
) {
867 dvdnav_priv_t
*priv
= stream
->priv
;
868 dvdnav_highlight_event_t hlev
= priv
->hlev
;
874 hl
->palette
= hlev
.palette
;
877 void mp_dvdnav_switch_title (stream_t
*stream
, int title
) {
878 dvdnav_priv_t
*priv
= stream
->priv
;
881 dvdnav_get_number_of_titles (priv
->dvdnav
, &titles
);
882 if (title
> 0 && title
<= titles
)
883 dvdnav_title_play (priv
->dvdnav
, title
);
887 * \brief Check if end of stream has been reached
888 * \param stream: - stream pointer
889 * \return 1 on really eof
891 int mp_dvdnav_is_eof (stream_t
*stream
) {
892 return ((dvdnav_priv_t
*) stream
->priv
)->state
& NAV_FLAG_EOF
;
896 * \brief Skip still frame
897 * \param stream: - stream pointer
898 * \return 0 on success
900 int mp_dvdnav_skip_still (stream_t
*stream
) {
901 dvdnav_priv_t
*priv
= stream
->priv
;
902 if (priv
->still_length
== 0xff)
904 dvdnav_still_skip(priv
->dvdnav
);
909 * \brief Skip wait event
910 * \param stream: - stream pointer
911 * \return 0 on success
913 int mp_dvdnav_skip_wait (stream_t
*stream
) {
914 dvdnav_priv_t
*priv
= stream
->priv
;
915 if (!(priv
->state
& NAV_FLAG_WAIT
))
917 priv
->state
&= ~NAV_FLAG_WAIT
;
918 dvdnav_wait_skip(priv
->dvdnav
);
923 * \brief Set wait mode
924 * \param stream : - stream pointer
925 * \param mode : - if true, then suspend block read
926 * \param automode: - if true, then VTS or cell change set wait mode
928 void mp_dvdnav_read_wait (stream_t
*stream
, int mode
, int automode
) {
929 dvdnav_priv_t
*priv
= stream
->priv
;
931 priv
->state
&= ~NAV_FLAG_WAIT_READ
;
933 priv
->state
|= NAV_FLAG_WAIT_READ
;
935 priv
->state
&= ~NAV_FLAG_WAIT_READ_AUTO
;
937 priv
->state
|= NAV_FLAG_WAIT_READ_AUTO
;
941 * \brief Check if cell has changed
942 * \param stream: - stream pointer
943 * \param clear : - if true, then clear cell change flag
944 * \return 1 if cell has changed
946 int mp_dvdnav_cell_has_changed (stream_t
*stream
, int clear
) {
947 dvdnav_priv_t
*priv
= stream
->priv
;
948 if (!(priv
->state
& NAV_FLAG_CELL_CHANGE
))
951 priv
->state
&= ~NAV_FLAG_CELL_CHANGE
;
952 priv
->state
|= NAV_FLAG_STREAM_CHANGE
;
958 * \brief Check if audio has changed
959 * \param stream: - stream pointer
960 * \param clear : - if true, then clear audio change flag
961 * \return 1 if audio has changed
963 int mp_dvdnav_audio_has_changed (stream_t
*stream
, int clear
) {
964 dvdnav_priv_t
*priv
= stream
->priv
;
966 if (!(priv
->state
& NAV_FLAG_AUDIO_CHANGE
))
970 priv
->state
&= ~NAV_FLAG_AUDIO_CHANGE
;
976 * \brief Check if SPU has changed
977 * \param stream: - stream pointer
978 * \param clear : - if true, then clear spu change flag
979 * \return 1 if spu has changed
981 int mp_dvdnav_spu_has_changed (stream_t
*stream
, int clear
) {
982 dvdnav_priv_t
*priv
= stream
->priv
;
984 if (!(priv
->state
& NAV_FLAG_SPU_CHANGE
))
988 priv
->state
&= ~NAV_FLAG_SPU_CHANGE
;
993 /* Notify if something has changed in stream
994 * Can be related to title, chapter, audio or SPU
996 int mp_dvdnav_stream_has_changed (stream_t
*stream
) {
997 dvdnav_priv_t
*priv
= stream
->priv
;
999 if (!(priv
->state
& NAV_FLAG_STREAM_CHANGE
))
1002 priv
->state
&= ~NAV_FLAG_STREAM_CHANGE
;
1006 const stream_info_t stream_info_dvdnav
= {
1014 1 // Urls are an option string