Mercurial > mplayer.hg
annotate stream/stream_dvd.c @ 23510:a6c619ee9d30
Teletext support for tv:// (v4l and v4l2 only)
modified patch from Otvos Attila oattila at chello dot hu
Module uses zvbi library for all low-level VBI operations (like I/O with vbi
device, converting vbi pages into usefull vbi_page stuctures, rendering them
into RGB32 images).
All teletext related stuff (except properties, slave commands and rendering
osd in text mode or RGB32 rendered teletext pages in spu mode) is implemented
in tvi_vbi.c
New properties:
teletext_page - switching between pages
teletext_mode - switch between on/off/opaque/transparent modes
teletext_format - (currently read-only) allows to get format info
(black/white,gray,text)
teletext_half_page - trivial zooming (displaying top/bottom half of teletext
page)
New slave commands:
teletext_add_dec - user interface for jumping to any page by editing page number
interactively
teletext_go_link - goes though links, specified on current page
author | voroshil |
---|---|
date | Sun, 10 Jun 2007 00:06:12 +0000 |
parents | 300e9b7c499f |
children | 0f1c9cf1752d |
rev | line source |
---|---|
15518 | 1 |
2 | |
3 #include <ctype.h> | |
4 #include <stdio.h> | |
5 #include <stdlib.h> | |
6 #include <string.h> | |
7 #include <unistd.h> | |
8 #include <fcntl.h> | |
9 #include <string.h> | |
10 | |
11 #include "config.h" | |
12 #include "mp_msg.h" | |
13 #include "help_mp.h" | |
14 | |
15 #ifdef __FreeBSD__ | |
16 #include <sys/cdrio.h> | |
17 #endif | |
18 | |
21636
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
19 #ifdef __linux__ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
20 #include <linux/cdrom.h> |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
21 #include <scsi/sg.h> |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
22 #include <sys/types.h> |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
23 #include <sys/stat.h> |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
24 #include <sys/ioctl.h> |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
25 #endif |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
26 |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
27 #define FIRST_AC3_AID 128 |
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
28 #define FIRST_DTS_AID 136 |
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
29 #define FIRST_MPG_AID 0 |
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
30 #define FIRST_PCM_AID 160 |
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
31 |
15518 | 32 #include "stream.h" |
17012 | 33 #include "m_option.h" |
34 #include "m_struct.h" | |
15518 | 35 |
18682
bee3186a06f7
include stream_dvd's interface from libmpdemux/stream_dvd.h
nicodvb
parents:
18366
diff
changeset
|
36 #include "stream_dvd.h" |
21926
a8cd73869242
at open() assign *file_format=DEMUXER_TYPE_MPEG_PS to avoid useless demuxer probing
nicodvb
parents:
21731
diff
changeset
|
37 #include "libmpdemux/demuxer.h" |
18682
bee3186a06f7
include stream_dvd's interface from libmpdemux/stream_dvd.h
nicodvb
parents:
18366
diff
changeset
|
38 |
20840
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
39 extern int stream_cache_size; |
15518 | 40 /// We keep these 2 for the gui atm, but they will be removed. |
17191
6ac0b5f0d1ed
fix compilation when dvdkit and dvdread are not available
nicodvb
parents:
17012
diff
changeset
|
41 extern int dvd_title; |
6ac0b5f0d1ed
fix compilation when dvdkit and dvdread are not available
nicodvb
parents:
17012
diff
changeset
|
42 extern int dvd_chapter; |
6ac0b5f0d1ed
fix compilation when dvdkit and dvdread are not available
nicodvb
parents:
17012
diff
changeset
|
43 extern int dvd_last_chapter; |
6ac0b5f0d1ed
fix compilation when dvdkit and dvdread are not available
nicodvb
parents:
17012
diff
changeset
|
44 extern char* dvd_device; |
15518 | 45 int dvd_angle=1; |
21636
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
46 int dvd_speed=0; /* 0 => don't touch speed */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
47 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
48 static void dvd_set_speed(char *device, unsigned speed) |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
49 { |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
50 #if defined(__linux__) && defined(SG_IO) && defined(GPCMD_SET_STREAMING) |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
51 int fd; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
52 unsigned char buffer[28]; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
53 unsigned char cmd[16]; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
54 unsigned char sense[16]; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
55 struct sg_io_hdr sghdr; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
56 struct stat st; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
57 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
58 memset(&sghdr, 0, sizeof(sghdr)); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
59 memset(buffer, 0, sizeof(buffer)); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
60 memset(sense, 0, sizeof(sense)); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
61 memset(cmd, 0, sizeof(cmd)); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
62 memset(&st, 0, sizeof(st)); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
63 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
64 if (stat(device, &st) == -1) return; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
65 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
66 if (!S_ISBLK(st.st_mode)) return; /* not a block device */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
67 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
68 if ((fd = open(device, O_RDWR | O_NONBLOCK)) == -1) { |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
69 mp_msg(MSGT_OPEN, MSGL_INFO, MSGTR_DVDspeedCantOpen); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
70 return; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
71 } |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
72 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
73 if (speed < 100) { /* speed times 1350KB/s (DVD single speed) */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
74 speed *= 1350; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
75 } |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
76 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
77 switch (speed) { |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
78 case 0: /* don't touch speed setting */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
79 return; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
80 case -1: /* restore default value */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
81 if (dvd_speed == 0) return; /* we haven't touched the speed setting */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
82 speed = 0; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
83 buffer[0] = 4; /* restore default */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
84 mp_msg(MSGT_OPEN, MSGL_INFO, MSGTR_DVDrestoreSpeed); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
85 break; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
86 default: /* limit to <speed> KB/s */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
87 mp_msg(MSGT_OPEN, MSGL_INFO, MSGTR_DVDlimitSpeed, speed); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
88 break; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
89 } |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
90 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
91 sghdr.interface_id = 'S'; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
92 sghdr.timeout = 5000; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
93 sghdr.dxfer_direction = SG_DXFER_TO_DEV; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
94 sghdr.mx_sb_len = sizeof(sense); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
95 sghdr.dxfer_len = sizeof(buffer); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
96 sghdr.cmd_len = sizeof(cmd); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
97 sghdr.sbp = sense; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
98 sghdr.dxferp = buffer; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
99 sghdr.cmdp = cmd; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
100 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
101 cmd[0] = GPCMD_SET_STREAMING; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
102 cmd[10] = sizeof(buffer); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
103 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
104 buffer[8] = 0xff; /* first sector 0, last sector 0xffffffff */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
105 buffer[9] = 0xff; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
106 buffer[10] = 0xff; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
107 buffer[11] = 0xff; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
108 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
109 buffer[12] = buffer[20] = (speed >> 24) & 0xff; /* <speed> kilobyte */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
110 buffer[13] = buffer[21] = (speed >> 16) & 0xff; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
111 buffer[14] = buffer[22] = (speed >> 8) & 0xff; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
112 buffer[15] = buffer[23] = speed & 0xff; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
113 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
114 buffer[18] = buffer[26] = 0x03; /* 1 second */ |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
115 buffer[19] = buffer[27] = 0xe8; |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
116 |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
117 if (ioctl(fd, SG_IO, &sghdr) < 0) { |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
118 mp_msg(MSGT_OPEN, MSGL_INFO, MSGTR_DVDlimitFail); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
119 } |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
120 mp_msg(MSGT_OPEN, MSGL_INFO, MSGTR_DVDlimitOk); |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
121 #endif |
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
122 } |
15518 | 123 |
124 #ifdef USE_DVDREAD | |
17257 | 125 #define LIBDVDREAD_VERSION(maj,min,micro) ((maj)*10000 + (min)*100 + (micro)) |
15518 | 126 /* |
127 * Try to autodetect the libdvd-0.9.0 library | |
128 * (0.9.0 removed the <dvdread/dvd_udf.h> header, and moved the two defines | |
129 * DVD_VIDEO_LB_LEN and MAX_UDF_FILE_NAME_LEN from it to | |
130 * <dvdread/dvd_reader.h>) | |
131 */ | |
17257 | 132 #ifndef DVDREAD_VERSION |
15518 | 133 #if defined(DVD_VIDEO_LB_LEN) && defined(MAX_UDF_FILE_NAME_LEN) |
17257 | 134 #define DVDREAD_VERSION LIBDVDREAD_VERSION(0,9,0) |
15518 | 135 #else |
17257 | 136 #define DVDREAD_VERSION LIBDVDREAD_VERSION(0,8,0) |
137 #endif | |
15518 | 138 #endif |
139 | |
140 char * dvd_audio_stream_types[8] = { "ac3","unknown","mpeg1","mpeg2ext","lpcm","unknown","dts" }; | |
141 char * dvd_audio_stream_channels[6] = { "mono", "stereo", "unknown", "unknown", "5.1/6.1", "5.1" }; | |
18867 | 142 #endif /* #ifdef USE_DVDREAD */ |
15518 | 143 |
144 | |
145 static struct stream_priv_s { | |
146 int title; | |
147 } stream_priv_dflts = { | |
148 1 | |
149 }; | |
150 | |
151 #define ST_OFF(f) M_ST_OFF(struct stream_priv_s,f) | |
152 /// URL definition | |
153 static m_option_t stream_opts_fields[] = { | |
154 { "hostname", ST_OFF(title), CONF_TYPE_INT, M_OPT_MIN, 1, 0, NULL }, | |
155 { NULL, NULL, 0, 0, 0, 0, NULL } | |
156 }; | |
157 static struct m_struct_st stream_opts = { | |
158 "dvd", | |
159 sizeof(struct stream_priv_s), | |
160 &stream_priv_dflts, | |
161 stream_opts_fields | |
162 }; | |
163 | |
164 int dvd_parse_chapter_range(m_option_t *conf, const char *range) { | |
165 const char *s; | |
166 char *t; | |
167 if (!range) | |
168 return M_OPT_MISSING_PARAM; | |
169 s = range; | |
170 dvd_chapter = 1; | |
171 dvd_last_chapter = 0; | |
172 if(*range && isdigit(*range)) { | |
173 dvd_chapter = strtol(range, &s, 10); | |
174 if(range == s) { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
175 mp_msg(MSGT_OPEN, MSGL_ERR, MSGTR_DVDinvalidChapterRange, range); |
15518 | 176 return M_OPT_INVALID; |
177 } | |
178 } | |
179 if(*s == 0) | |
180 return 0; | |
181 else if(*s != '-') { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
182 mp_msg(MSGT_OPEN, MSGL_ERR, MSGTR_DVDinvalidChapterRange, range); |
15518 | 183 return M_OPT_INVALID; |
184 } | |
185 ++s; | |
186 if(*s == 0) | |
187 return 0; | |
188 if(! isdigit(*s)) { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
189 mp_msg(MSGT_OPEN, MSGL_ERR, MSGTR_DVDinvalidChapterRange, range); |
15518 | 190 return M_OPT_INVALID; |
191 } | |
192 dvd_last_chapter = strtol(s, &t, 10); | |
193 if (s == t || *t) { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
194 mp_msg(MSGT_OPEN, MSGL_ERR, MSGTR_DVDinvalidChapterRange, range); |
15518 | 195 return M_OPT_INVALID; |
196 } | |
197 return 0; | |
198 } | |
199 | |
200 #ifdef USE_DVDREAD | |
201 int dvd_chapter_from_cell(dvd_priv_t* dvd,int title,int cell) | |
202 { | |
203 pgc_t * cur_pgc; | |
204 ptt_info_t* ptt; | |
205 int chapter = cell; | |
206 int pgc_id,pgn; | |
207 if(title < 0 || cell < 0){ | |
208 return 0; | |
209 } | |
210 /* for most DVD's chapter == cell */ | |
211 /* but there are more complecated cases... */ | |
212 if(chapter >= dvd->vmg_file->tt_srpt->title[title].nr_of_ptts) { | |
213 chapter = dvd->vmg_file->tt_srpt->title[title].nr_of_ptts-1; | |
214 } | |
215 title = dvd->tt_srpt->title[title].vts_ttn-1; | |
216 ptt = dvd->vts_file->vts_ptt_srpt->title[title].ptt; | |
217 while(chapter >= 0) { | |
218 pgc_id = ptt[chapter].pgcn; | |
219 pgn = ptt[chapter].pgn; | |
220 cur_pgc = dvd->vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc; | |
221 if(cell >= cur_pgc->program_map[pgn-1]-1) { | |
222 return chapter; | |
223 } | |
224 --chapter; | |
225 } | |
226 /* didn't find a chapter ??? */ | |
227 return chapter; | |
228 } | |
229 | |
20156 | 230 int dvd_lang_from_aid(stream_t *stream, int id) { |
231 dvd_priv_t *d; | |
20158 | 232 int i; |
20156 | 233 if (!stream) return 0; |
234 d = stream->priv; | |
235 if (!d) return 0; | |
236 for(i=0;i<d->nr_of_channels;i++) { | |
237 if(d->audio_streams[i].id==id) | |
238 return d->audio_streams[i].language; | |
239 } | |
240 return 0; | |
241 } | |
242 | |
15518 | 243 int dvd_aid_from_lang(stream_t *stream, unsigned char* lang) { |
244 dvd_priv_t *d=stream->priv; | |
245 int code,i; | |
246 if(lang) { | |
247 while(strlen(lang)>=2) { | |
248 code=lang[1]|(lang[0]<<8); | |
249 for(i=0;i<d->nr_of_channels;i++) { | |
250 if(d->audio_streams[i].language==code) { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
251 mp_msg(MSGT_OPEN,MSGL_INFO,MSGTR_DVDaudioChannel, |
15518 | 252 d->audio_streams[i].id, lang[0],lang[1]); |
253 return d->audio_streams[i].id; | |
254 } | |
255 //printf("%X != %X (%c%c)\n",code,d->audio_streams[i].language,lang[0],lang[1]); | |
256 } | |
257 lang+=2; while (lang[0]==',' || lang[0]==' ') ++lang; | |
258 } | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
259 mp_msg(MSGT_OPEN,MSGL_WARN,MSGTR_DVDnoMatchingAudio); |
15518 | 260 } |
261 return -1; | |
262 } | |
263 | |
264 int dvd_number_of_subs(stream_t *stream) { | |
265 dvd_priv_t *d; | |
266 if (!stream) return -1; | |
267 d = stream->priv; | |
268 if (!d) return -1; | |
269 return d->nr_of_subtitles; | |
270 } | |
271 | |
272 int dvd_lang_from_sid(stream_t *stream, int id) { | |
273 dvd_priv_t *d; | |
274 if (!stream) return 0; | |
275 d = stream->priv; | |
276 if (!d) return 0; | |
277 if (id >= d->nr_of_subtitles) return 0; | |
278 return d->subtitles[id].language; | |
279 } | |
280 | |
281 int dvd_sid_from_lang(stream_t *stream, unsigned char* lang) { | |
282 dvd_priv_t *d=stream->priv; | |
283 int code,i; | |
284 while(lang && strlen(lang)>=2) { | |
285 code=lang[1]|(lang[0]<<8); | |
286 for(i=0;i<d->nr_of_subtitles;i++) { | |
287 if(d->subtitles[i].language==code) { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
288 mp_msg(MSGT_OPEN,MSGL_INFO,MSGTR_DVDsubtitleChannel, i, lang[0],lang[1]); |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
289 return i; |
15518 | 290 } |
291 } | |
292 lang+=2; | |
293 while (lang[0]==',' || lang[0]==' ') ++lang; | |
294 } | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
295 mp_msg(MSGT_OPEN,MSGL_WARN,MSGTR_DVDnoMatchingSubtitle); |
15518 | 296 return -1; |
297 } | |
298 | |
299 static int dvd_next_cell(dvd_priv_t *d) { | |
300 int next_cell=d->cur_cell; | |
301 | |
15551
f62be65f7df3
Reduce senseless spamminess of DVD playback in verbose mode.
diego
parents:
15518
diff
changeset
|
302 mp_msg(MSGT_DVD,MSGL_DBG2, "dvd_next_cell: next1=0x%X \n",next_cell); |
15518 | 303 if( d->cur_pgc->cell_playback[ next_cell ].block_type == BLOCK_TYPE_ANGLE_BLOCK ) { |
304 while(next_cell<d->last_cell) { | |
305 if( d->cur_pgc->cell_playback[next_cell].block_mode == BLOCK_MODE_LAST_CELL ) | |
306 break; | |
307 ++next_cell; | |
308 } | |
309 } | |
15551
f62be65f7df3
Reduce senseless spamminess of DVD playback in verbose mode.
diego
parents:
15518
diff
changeset
|
310 mp_msg(MSGT_DVD,MSGL_DBG2, "dvd_next_cell: next2=0x%X \n",next_cell); |
15518 | 311 |
312 ++next_cell; | |
313 if(next_cell>=d->last_cell) | |
314 return -1; // EOF | |
315 if(d->cur_pgc->cell_playback[next_cell].block_type == BLOCK_TYPE_ANGLE_BLOCK ) { | |
316 next_cell+=dvd_angle; | |
317 if(next_cell>=d->last_cell) | |
318 return -1; // EOF | |
319 } | |
15551
f62be65f7df3
Reduce senseless spamminess of DVD playback in verbose mode.
diego
parents:
15518
diff
changeset
|
320 mp_msg(MSGT_DVD,MSGL_DBG2, "dvd_next_cell: next3=0x%X \n",next_cell); |
15518 | 321 return next_cell; |
322 } | |
323 | |
324 int dvd_read_sector(dvd_priv_t *d,unsigned char* data) { | |
325 int len; | |
326 | |
327 if(d->packs_left==0) { | |
328 /** | |
329 * If we're not at the end of this cell, we can determine the next | |
330 * VOBU to display using the VOBU_SRI information section of the | |
331 * DSI. Using this value correctly follows the current angle, | |
332 * avoiding the doubled scenes in The Matrix, and makes our life | |
333 * really happy. | |
334 * | |
335 * Otherwise, we set our next address past the end of this cell to | |
336 * force the code above to go to the next cell in the program. | |
337 */ | |
338 if(d->dsi_pack.vobu_sri.next_vobu != SRI_END_OF_CELL) { | |
339 d->cur_pack= d->dsi_pack.dsi_gi.nv_pck_lbn + ( d->dsi_pack.vobu_sri.next_vobu & 0x7fffffff ); | |
340 mp_msg(MSGT_DVD,MSGL_DBG2, "Navi new pos=0x%X \n",d->cur_pack); | |
341 } else { | |
342 // end of cell! find next cell! | |
343 mp_msg(MSGT_DVD,MSGL_V, "--- END OF CELL !!! ---\n"); | |
344 d->cur_pack=d->cell_last_pack+1; | |
345 } | |
346 } | |
347 | |
348 read_next: | |
349 if(d->cur_pack>d->cell_last_pack) { | |
350 // end of cell! | |
351 int next=dvd_next_cell(d); | |
352 if(next>=0) { | |
353 d->cur_cell=next; | |
354 // if( d->cur_pgc->cell_playback[d->cur_cell].block_type | |
355 // == BLOCK_TYPE_ANGLE_BLOCK ) d->cur_cell+=dvd_angle; | |
356 d->cur_pack = d->cur_pgc->cell_playback[ d->cur_cell ].first_sector; | |
357 d->cell_last_pack=d->cur_pgc->cell_playback[ d->cur_cell ].last_sector; | |
358 mp_msg(MSGT_DVD,MSGL_V, "DVD next cell: %d pack: 0x%X-0x%X \n",d->cur_cell,d->cur_pack,d->cell_last_pack); | |
359 } else | |
360 return -1; // EOF | |
361 } | |
362 | |
363 len = DVDReadBlocks(d->title, d->cur_pack, 1, data); | |
364 if(!len) return -1; //error | |
365 | |
366 if(data[38]==0 && data[39]==0 && data[40]==1 && data[41]==0xBF && | |
367 data[1024]==0 && data[1025]==0 && data[1026]==1 && data[1027]==0xBF) { | |
368 // found a Navi packet!!! | |
17257 | 369 #if DVDREAD_VERSION >= LIBDVDREAD_VERSION(0,9,0) |
15518 | 370 navRead_DSI(&d->dsi_pack, &(data[ DSI_START_BYTE ])); |
371 #else | |
372 navRead_DSI(&d->dsi_pack, &(data[ DSI_START_BYTE ]), sizeof(dsi_t)); | |
373 #endif | |
374 if(d->cur_pack != d->dsi_pack.dsi_gi.nv_pck_lbn ) { | |
375 mp_msg(MSGT_DVD,MSGL_V, "Invalid NAVI packet! lba=0x%X navi=0x%X \n", | |
376 d->cur_pack,d->dsi_pack.dsi_gi.nv_pck_lbn); | |
377 } else { | |
378 // process! | |
379 d->packs_left = d->dsi_pack.dsi_gi.vobu_ea; | |
380 mp_msg(MSGT_DVD,MSGL_DBG2, "Found NAVI packet! lba=0x%X len=%d \n",d->cur_pack,d->packs_left); | |
381 //navPrint_DSI(&d->dsi_pack); | |
382 mp_msg(MSGT_DVD,MSGL_DBG3,"\r### CELL %d: Navi: %d/%d IFO: %d/%d \n",d->cur_cell, | |
383 d->dsi_pack.dsi_gi.vobu_c_idn,d->dsi_pack.dsi_gi.vobu_vob_idn, | |
384 d->cur_pgc->cell_position[d->cur_cell].cell_nr, | |
385 d->cur_pgc->cell_position[d->cur_cell].vob_id_nr); | |
386 | |
387 if(d->angle_seek) { | |
388 int i,skip=0; | |
389 #if defined(__GNUC__) && ( defined(__sparc__) || defined(hpux) ) | |
390 // workaround for a bug in the sparc/hpux version of gcc 2.95.X ... 3.2, | |
391 // it generates incorrect code for unaligned access to a packed | |
392 // structure member, resulting in an mplayer crash with a SIGBUS | |
393 // signal. | |
394 // | |
395 // See also gcc problem report PR c/7847: | |
396 // http://gcc.gnu.org/cgi-bin/gnatsweb.pl?database=gcc&cmd=view+audit-trail&pr=7847 | |
397 for(i=0;i<9;i++) { // check if all values zero: | |
398 typeof(d->dsi_pack.sml_agli.data[i].address) tmp_addr; | |
399 memcpy(&tmp_addr,&d->dsi_pack.sml_agli.data[i].address,sizeof(tmp_addr)); | |
400 if((skip=tmp_addr)!=0) break; | |
401 } | |
402 #else | |
403 for(i=0;i<9;i++) // check if all values zero: | |
404 if((skip=d->dsi_pack.sml_agli.data[i].address)!=0) break; | |
405 #endif | |
406 if(skip) { | |
407 // sml_agli table has valid data (at least one non-zero): | |
408 d->cur_pack=d->dsi_pack.dsi_gi.nv_pck_lbn+ | |
409 d->dsi_pack.sml_agli.data[dvd_angle].address; | |
410 d->angle_seek=0; | |
411 mp_msg(MSGT_DVD,MSGL_V, "Angle-seek synced using sml_agli map! new_lba=0x%X \n",d->cur_pack); | |
412 } else { | |
413 // check if we're in the right cell, jump otherwise: | |
414 if( (d->dsi_pack.dsi_gi.vobu_c_idn==d->cur_pgc->cell_position[d->cur_cell].cell_nr) && | |
415 (d->dsi_pack.dsi_gi.vobu_vob_idn==d->cur_pgc->cell_position[d->cur_cell].vob_id_nr) ){ | |
416 d->angle_seek=0; | |
417 mp_msg(MSGT_DVD,MSGL_V, "Angle-seek synced by cell/vob IDN search! \n"); | |
418 } else { | |
419 // wrong angle, skip this vobu: | |
420 d->cur_pack=d->dsi_pack.dsi_gi.nv_pck_lbn+ | |
421 d->dsi_pack.dsi_gi.vobu_ea; | |
422 d->angle_seek=2; // DEBUG | |
423 } | |
424 } | |
425 } | |
426 } | |
427 ++d->cur_pack; | |
428 goto read_next; | |
429 } | |
430 | |
431 ++d->cur_pack; | |
432 if(d->packs_left>=0) --d->packs_left; | |
433 | |
434 if(d->angle_seek) { | |
435 if(d->angle_seek==2) mp_msg(MSGT_DVD,MSGL_V, "!!! warning! reading packet while angle_seek !!!\n"); | |
436 goto read_next; // searching for Navi packet | |
437 } | |
438 | |
439 return d->cur_pack-1; | |
440 } | |
441 | |
442 void dvd_seek(dvd_priv_t *d,int pos) { | |
443 d->packs_left=-1; | |
444 d->cur_pack=pos; | |
445 | |
446 // check if we stay in current cell (speedup things, and avoid angle skip) | |
447 if(d->cur_pack>d->cell_last_pack || | |
448 d->cur_pack<d->cur_pgc->cell_playback[ d->cur_cell ].first_sector) { | |
449 | |
450 // ok, cell change, find the right cell! | |
451 d->cur_cell=0; | |
452 if(d->cur_pgc->cell_playback[d->cur_cell].block_type == BLOCK_TYPE_ANGLE_BLOCK ) | |
453 d->cur_cell+=dvd_angle; | |
454 | |
455 while(1) { | |
456 int next; | |
457 d->cell_last_pack=d->cur_pgc->cell_playback[ d->cur_cell ].last_sector; | |
458 if(d->cur_pack<d->cur_pgc->cell_playback[ d->cur_cell ].first_sector) { | |
459 d->cur_pack=d->cur_pgc->cell_playback[ d->cur_cell ].first_sector; | |
460 break; | |
461 } | |
462 if(d->cur_pack<=d->cell_last_pack) break; // ok, we find it! :) | |
463 next=dvd_next_cell(d); | |
464 if(next<0) { | |
465 //d->cur_pack=d->cell_last_pack+1; | |
466 break; // we're after the last cell | |
467 } | |
468 d->cur_cell=next; | |
469 } | |
470 } | |
471 | |
472 mp_msg(MSGT_DVD,MSGL_V, "DVD Seek! lba=0x%X cell=%d packs: 0x%X-0x%X \n", | |
473 d->cur_pack,d->cur_cell,d->cur_pgc->cell_playback[ d->cur_cell ].first_sector,d->cell_last_pack); | |
474 | |
475 // if we're in interleaved multi-angle cell, find the right angle chain! | |
476 // (read Navi block, and use the seamless angle jump table) | |
477 d->angle_seek=1; | |
478 } | |
479 | |
480 void dvd_close(dvd_priv_t *d) { | |
481 ifoClose(d->vts_file); | |
482 ifoClose(d->vmg_file); | |
483 DVDCloseFile(d->title); | |
484 DVDClose(d->dvd); | |
485 dvd_chapter = 1; | |
486 dvd_last_chapter = 0; | |
21636
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
487 dvd_set_speed(dvd_device, -1); /* -1 => restore default */ |
15518 | 488 } |
489 | |
18867 | 490 #endif /* #ifdef USE_DVDREAD */ |
15518 | 491 |
492 static int fill_buffer(stream_t *s, char *but, int len) | |
493 { | |
494 #ifdef USE_DVDREAD | |
495 if(s->type == STREAMTYPE_DVD) { | |
496 off_t pos=dvd_read_sector(s->priv,s->buffer); | |
497 if(pos>=0) { | |
498 len=2048; // full sector | |
499 s->pos=2048*pos-len; | |
500 } else len=-1; // error | |
501 } | |
502 #endif | |
503 return len; | |
504 } | |
505 | |
506 static int seek(stream_t *s, off_t newpos) { | |
507 #ifdef USE_DVDREAD | |
508 s->pos=newpos; // real seek | |
509 dvd_seek(s->priv,s->pos/2048); | |
510 #endif | |
511 return 1; | |
512 } | |
513 | |
514 static void stream_dvd_close(stream_t *s) { | |
515 #ifdef USE_DVDREAD | |
516 dvd_close(s->priv); | |
517 #endif | |
518 } | |
519 | |
16544
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
520 /** |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
521 \brief Converts DVD time structure to milliseconds. |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
522 \param *dev the DVD time structure to convert |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
523 \return returns the time in milliseconds |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
524 */ |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
525 static int dvdtimetomsec(dvd_time_t *dt) |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
526 { |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
527 static int framerates[4] = {0, 2500, 0, 2997}; |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
528 int framerate = framerates[(dt->frame_u & 0xc0) >> 6]; |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
529 int msec = (((dt->hour & 0xf0) >> 3) * 5 + (dt->hour & 0x0f)) * 3600000; |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
530 msec += (((dt->minute & 0xf0) >> 3) * 5 + (dt->minute & 0x0f)) * 60000; |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
531 msec += (((dt->second & 0xf0) >> 3) * 5 + (dt->second & 0x0f)) * 1000; |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
532 if(framerate > 0) |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
533 msec += (((dt->frame_u & 0x30) >> 3) * 5 + (dt->frame_u & 0x0f)) * 100000 / framerate; |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
534 return msec; |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
535 } |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
536 |
18091
71f9a4e7fd9d
remove vts_no parameter from mp_get_titleset_length - it is not only useless,
reimar
parents:
18078
diff
changeset
|
537 static int mp_get_titleset_length(ifo_handle_t *vts_file, tt_srpt_t *tt_srpt, int title_no) |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
538 { |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
539 int vts_ttn; ///< title number within video title set |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
540 int pgc_no; ///< program chain number |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
541 int msec; ///< time length in milliseconds |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
542 |
17817
560617cdcc3b
init msec in mp_get_titleset_length() before using it; closes cid 251
nicodvb
parents:
17698
diff
changeset
|
543 msec=0; |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
544 if(!vts_file || !tt_srpt) |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
545 return 0; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
546 |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
547 if(vts_file->vtsi_mat && vts_file->vts_pgcit) |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
548 { |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
549 vts_ttn = tt_srpt->title[title_no].vts_ttn - 1; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
550 pgc_no = vts_file->vts_ptt_srpt->title[vts_ttn].ptt[0].pgcn - 1; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
551 msec = dvdtimetomsec(&vts_file->vts_pgcit->pgci_srp[pgc_no].pgc->playback_time); |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
552 } |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
553 return msec; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
554 } |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
555 |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
556 |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
557 static int mp_describe_titleset(dvd_reader_t *dvd, tt_srpt_t *tt_srpt, int vts_no) |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
558 { |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
559 ifo_handle_t *vts_file; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
560 int title_no, msec=0; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
561 |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
562 vts_file = ifoOpen(dvd, vts_no); |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
563 if(!vts_file) |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
564 return 0; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
565 |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
566 if(!vts_file->vtsi_mat || !vts_file->vts_pgcit) |
18078
aeb937690d3d
missing ifoClose and return 1. Patch by kiriuja (mplayer-patches at en-directo net)
reimar
parents:
18071
diff
changeset
|
567 { |
aeb937690d3d
missing ifoClose and return 1. Patch by kiriuja (mplayer-patches at en-directo net)
reimar
parents:
18071
diff
changeset
|
568 ifoClose(vts_file); |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
569 return 0; |
18078
aeb937690d3d
missing ifoClose and return 1. Patch by kiriuja (mplayer-patches at en-directo net)
reimar
parents:
18071
diff
changeset
|
570 } |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
571 |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
572 for(title_no = 0; title_no < tt_srpt->nr_of_srpts; title_no++) |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
573 { |
18071
1e144ef9759b
do not print the title length from a non-matching titleset.
reimar
parents:
17817
diff
changeset
|
574 if (tt_srpt->title[title_no].title_set_nr != vts_no) |
1e144ef9759b
do not print the title length from a non-matching titleset.
reimar
parents:
17817
diff
changeset
|
575 continue; |
18091
71f9a4e7fd9d
remove vts_no parameter from mp_get_titleset_length - it is not only useless,
reimar
parents:
18078
diff
changeset
|
576 msec = mp_get_titleset_length(vts_file, tt_srpt, title_no); |
18237
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
577 mp_msg(MSGT_IDENTIFY, MSGL_V, "ID_DVD_TITLE_%d_LENGTH=%d.%03d\n", title_no + 1, msec / 1000, msec % 1000); |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
578 } |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
579 ifoClose(vts_file); |
18078
aeb937690d3d
missing ifoClose and return 1. Patch by kiriuja (mplayer-patches at en-directo net)
reimar
parents:
18071
diff
changeset
|
580 return 1; |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
581 } |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
582 |
19440
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
583 static int seek_to_chapter(stream_t *stream, ifo_handle_t *vts_file, tt_srpt_t *tt_srpt, int title_no, int chapter) |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
584 { |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
585 int cell; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
586 ptt_info_t ptt; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
587 pgc_t *pgc; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
588 off_t pos; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
589 |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
590 if(!vts_file || !tt_srpt) |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
591 return 0; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
592 |
19442
ab91d0304070
sanity check: since chapter is 0-based it can't exceed nr_of_ptts-1
nicodvb
parents:
19440
diff
changeset
|
593 if(chapter < 0 || chapter > vts_file->vts_ptt_srpt->title[title_no].nr_of_ptts-1) //no such chapter |
19440
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
594 return 0; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
595 |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
596 ptt = vts_file->vts_ptt_srpt->title[title_no].ptt[chapter]; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
597 pgc = vts_file->vts_pgcit->pgci_srp[ptt.pgcn-1].pgc; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
598 |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
599 cell = pgc->program_map[ptt.pgn - 1] - 1; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
600 pos = (off_t) pgc->cell_playback[cell].first_sector * 2048; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
601 mp_msg(MSGT_OPEN,MSGL_V,"\r\nSTREAM_DVD, seeked to chapter: %d, cell: %u, pos: %"PRIu64"\n", |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
602 chapter, pgc->cell_playback[cell].first_sector, pos); |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
603 stream_seek(stream, pos); |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
604 |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
605 return chapter; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
606 } |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
607 |
20812
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
608 static void list_chapters(pgc_t *pgc) |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
609 { |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
610 unsigned int i, cell; |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
611 unsigned int t=0, t2=0; |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
612 |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
613 if(pgc->nr_of_programs < 2) |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
614 return; |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
615 |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
616 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "CHAPTERS: "); |
23368
cef784b467ac
fixed off-by-one bug during chapter-listing; fixed by Jared Breland (list-mplayer@legroom.net) and me
nicodvb
parents:
22412
diff
changeset
|
617 for(i=0; i<pgc->nr_of_programs; i++) |
20812
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
618 { |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
619 cell = pgc->program_map[i]; //here the cell is 1-based |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
620 t2 = t/1000; |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
621 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "%02d:%02d:%02d,", t2/3600, (t2/60)%60, t2%60); |
23368
cef784b467ac
fixed off-by-one bug during chapter-listing; fixed by Jared Breland (list-mplayer@legroom.net) and me
nicodvb
parents:
22412
diff
changeset
|
622 while(i+1<pgc->nr_of_programs && cell < pgc->program_map[i+1]) { |
20812
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
623 if(!(pgc->cell_playback[cell-1].block_type == BLOCK_TYPE_ANGLE_BLOCK && |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
624 pgc->cell_playback[cell-1].block_mode != BLOCK_MODE_FIRST_CELL) |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
625 ) |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
626 t += dvdtimetomsec(&pgc->cell_playback[cell-1].playback_time); |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
627 cell++; |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
628 } |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
629 } |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
630 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "\n"); |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
631 } |
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
632 |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
633 static double dvd_get_current_time(stream_t *stream, int cell) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
634 { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
635 int i, tm; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
636 dvd_priv_t *d = stream->priv; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
637 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
638 tm=0; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
639 if(!cell) cell=d->cur_cell; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
640 for(i=0; i<d->cur_cell; i++) { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
641 if(d->cur_pgc->cell_playback[i].block_type == BLOCK_TYPE_ANGLE_BLOCK && |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
642 d->cur_pgc->cell_playback[i].block_mode != BLOCK_MODE_FIRST_CELL |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
643 ) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
644 continue; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
645 tm += d->cell_times_table[i]; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
646 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
647 tm += dvdtimetomsec(&d->dsi_pack.dsi_gi.c_eltm); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
648 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
649 return (double)tm/1000.0; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
650 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
651 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
652 static int dvd_seek_to_time(stream_t *stream, ifo_handle_t *vts_file, double sec) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
653 { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
654 unsigned int i, j, k, timeunit, ac_time, tmap_sector=0, cell_sector=0, vobu_sector=0; |
23381
300e9b7c499f
Remove some unused variables, patch by timwoj ieee org.
diego
parents:
23368
diff
changeset
|
655 int t=0; |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
656 double tm, duration; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
657 off_t pos = -1; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
658 dvd_priv_t *d = stream->priv; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
659 vts_tmapt_t *vts_tmapt = vts_file->vts_tmapt; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
660 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
661 if(!vts_file->vts_tmapt || sec < 0) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
662 return 0; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
663 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
664 duration = (double) mp_get_titleset_length(d->vts_file, d->tt_srpt, d->cur_title-1) / 1000.0f; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
665 if(sec > duration) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
666 return 0; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
667 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
668 i=d->cur_pgc_idx; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
669 timeunit = vts_tmapt->tmap[i].tmu; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
670 for(j = 0; j < vts_tmapt->tmap[i].nr_of_entries; j++) { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
671 ac_time = timeunit * (j + 1); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
672 if(ac_time >= sec) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
673 break; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
674 tmap_sector = vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
675 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
676 //search enclosing cell |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
677 for(i=0; i<d->cur_pgc->nr_of_cells; i++) { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
678 if(tmap_sector >= d->cur_pgc->cell_playback[i].first_sector && tmap_sector <= d->cur_pgc->cell_playback[i].last_sector) { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
679 cell_sector = d->cur_pgc->cell_playback[i].first_sector; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
680 break; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
681 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
682 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
683 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
684 pos = ((off_t)cell_sector)<<11; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
685 stream_seek(stream, pos); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
686 do { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
687 stream_skip(stream, 2048); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
688 t = dvdtimetomsec(&d->dsi_pack.dsi_gi.c_eltm); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
689 } while(!t); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
690 tm = dvd_get_current_time(stream, 0); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
691 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
692 pos = ((off_t)tmap_sector)<<11; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
693 stream_seek(stream, pos); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
694 //now get current time in terms of the cell+cell time offset |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
695 memset(&d->dsi_pack.dsi_gi.c_eltm, 0, sizeof(dvd_time_t)); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
696 while(tm <= sec) { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
697 if(!stream_skip(stream, 2048)) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
698 break; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
699 tm = dvd_get_current_time(stream, 0); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
700 }; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
701 tmap_sector = stream->pos >> 11; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
702 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
703 //search closest VOBU sector |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
704 k=(vts_file->vts_vobu_admap->last_byte + 1 - VOBU_ADMAP_SIZE)/4; //entries in the vobu admap |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
705 for(i=1; i<k; i++) { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
706 if(vts_file->vts_vobu_admap->vobu_start_sectors[i] > tmap_sector) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
707 break; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
708 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
709 vobu_sector = vts_file->vts_vobu_admap->vobu_start_sectors[i-1]; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
710 pos = ((off_t)vobu_sector) << 11; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
711 stream_seek(stream, pos); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
712 |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
713 return 1; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
714 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
715 |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
716 static int control(stream_t *stream,int cmd,void* arg) |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
717 { |
19440
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
718 dvd_priv_t *d = stream->priv; |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
719 switch(cmd) |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
720 { |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
721 case STREAM_CTRL_GET_TIME_LENGTH: |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
722 { |
20851
6602a90a06ec
consistency fix: STREAM_CTRL_GET_TIME_LENGTH and STREAM_CTRL_GET_CURRENT_TIME now return time in (double) seconds
nicodvb
parents:
20840
diff
changeset
|
723 *((double *)arg) = (double) mp_get_titleset_length(d->vts_file, d->tt_srpt, d->cur_title-1)/1000.0; |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
724 return 1; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
725 } |
19476 | 726 case STREAM_CTRL_GET_NUM_CHAPTERS: |
727 { | |
728 if(! d->cur_pgc->nr_of_programs) return STREAM_UNSUPORTED; | |
729 *((unsigned int *)arg) = d->cur_pgc->nr_of_programs; | |
730 return 1; | |
731 } | |
19440
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
732 case STREAM_CTRL_SEEK_TO_CHAPTER: |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
733 { |
20840
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
734 int r; |
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
735 if(stream_cache_size > 0) return STREAM_UNSUPORTED; |
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
736 r = seek_to_chapter(stream, d->vts_file, d->tt_srpt, d->cur_title-1, *((unsigned int *)arg)); |
19440
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
737 if(! r) return STREAM_UNSUPORTED; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
738 |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
739 return 1; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
740 } |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
741 case STREAM_CTRL_GET_CURRENT_CHAPTER: |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
742 { |
20840
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
743 if(stream_cache_size > 0) return STREAM_UNSUPORTED; |
19440
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
744 *((unsigned int *)arg) = dvd_chapter_from_cell(d, d->cur_title-1, d->cur_cell); |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
745 return 1; |
9847a1bd66a0
support for seeking to chapter and getting current playing chapter
nicodvb
parents:
19271
diff
changeset
|
746 } |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
747 case STREAM_CTRL_GET_CURRENT_TIME: |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
748 { |
20840
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
749 double tm; |
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
750 if(stream_cache_size > 0) return STREAM_UNSUPORTED; |
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
751 tm = dvd_get_current_time(stream, 0); |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
752 if(tm != -1) { |
20851
6602a90a06ec
consistency fix: STREAM_CTRL_GET_TIME_LENGTH and STREAM_CTRL_GET_CURRENT_TIME now return time in (double) seconds
nicodvb
parents:
20840
diff
changeset
|
753 *((double *)arg) = tm; |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
754 return 1; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
755 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
756 break; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
757 } |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
758 case STREAM_CTRL_SEEK_TO_TIME: |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
759 { |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
760 dvd_priv_t *d = stream->priv; |
20840
70b6f88bd23c
make fail STREAM_CTRLs related to seeking/fetching time/chapter when the cache is enabled: they can't work atm
nicodvb
parents:
20812
diff
changeset
|
761 if(stream_cache_size > 0) return STREAM_UNSUPORTED; |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
762 if(dvd_seek_to_time(stream, d->vts_file, *((double*)arg))) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
763 return 1; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
764 break; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
765 } |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
766 } |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
767 return STREAM_UNSUPORTED; |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
768 } |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
769 |
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
770 |
15518 | 771 static int open_s(stream_t *stream,int mode, void* opts, int* file_format) { |
772 struct stream_priv_s* p = (struct stream_priv_s*)opts; | |
773 char *filename; | |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
774 int k; |
15518 | 775 |
776 filename = strdup(stream->url); | |
777 mp_msg(MSGT_OPEN,MSGL_V,"URL: %s\n", filename); | |
778 dvd_title = p->title; | |
779 #ifdef USE_DVDREAD | |
780 if(1){ | |
781 //int ret,ret2; | |
782 dvd_priv_t *d; | |
783 int ttn,pgc_id,pgn; | |
784 dvd_reader_t *dvd; | |
785 dvd_file_t *title; | |
786 ifo_handle_t *vmg_file; | |
787 tt_srpt_t *tt_srpt; | |
788 ifo_handle_t *vts_file; | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
789 pgc_t *pgc; |
15518 | 790 /** |
791 * Open the disc. | |
792 */ | |
793 if(!dvd_device) dvd_device=strdup(DEFAULT_DVD_DEVICE); | |
794 #ifdef SYS_DARWIN | |
795 /* Dynamic DVD drive selection on Darwin */ | |
796 if(!strcmp(dvd_device, "/dev/rdiskN")) { | |
797 int i; | |
22404
521cd55ab99b
10000l; in previous commit I allocated a buffer 1 byte too short
nicodvb
parents:
22403
diff
changeset
|
798 size_t len = strlen(dvd_device)+1; |
22403
11e7787eb78b
replaced 1 instances of sprintf() with snprintf(); patch by njkain gmail com.
nicodvb
parents:
22204
diff
changeset
|
799 char *temp_device = malloc(len); |
15518 | 800 |
801 for (i = 1; i < 10; i++) { | |
22403
11e7787eb78b
replaced 1 instances of sprintf() with snprintf(); patch by njkain gmail com.
nicodvb
parents:
22204
diff
changeset
|
802 snprintf(temp_device, len, "/dev/rdisk%d", i); |
15518 | 803 dvd = DVDOpen(temp_device); |
804 if(!dvd) { | |
805 mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_CantOpenDVD,temp_device); | |
806 } else { | |
17490
acef9166db2f
MPlayer OSX port: Add a call to UDFFindFile to verify that we are opening a valid udf image. Patch by Emanuele Giaquita <emanuele.giaquinta@gmail.com>
nplourde
parents:
17257
diff
changeset
|
807 #if DVDREAD_VERSION <= LIBDVDREAD_VERSION(0,9,4) |
21731
61c0bae18c23
replace call to UDFFindFile() (that is not part of the public API) with DVDOpenFile()
nicodvb
parents:
21636
diff
changeset
|
808 dvd_file_t *dvdfile = DVDOpenFile(dvd,dvd_title,DVD_READ_INFO_FILE); |
61c0bae18c23
replace call to UDFFindFile() (that is not part of the public API) with DVDOpenFile()
nicodvb
parents:
21636
diff
changeset
|
809 if(!dvdfile) { |
17490
acef9166db2f
MPlayer OSX port: Add a call to UDFFindFile to verify that we are opening a valid udf image. Patch by Emanuele Giaquita <emanuele.giaquinta@gmail.com>
nplourde
parents:
17257
diff
changeset
|
810 mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_CantOpenDVD,temp_device); |
acef9166db2f
MPlayer OSX port: Add a call to UDFFindFile to verify that we are opening a valid udf image. Patch by Emanuele Giaquita <emanuele.giaquinta@gmail.com>
nplourde
parents:
17257
diff
changeset
|
811 DVDClose(dvd); |
21731
61c0bae18c23
replace call to UDFFindFile() (that is not part of the public API) with DVDOpenFile()
nicodvb
parents:
21636
diff
changeset
|
812 continue; |
61c0bae18c23
replace call to UDFFindFile() (that is not part of the public API) with DVDOpenFile()
nicodvb
parents:
21636
diff
changeset
|
813 } |
61c0bae18c23
replace call to UDFFindFile() (that is not part of the public API) with DVDOpenFile()
nicodvb
parents:
21636
diff
changeset
|
814 DVDCloseFile(dvdfile); |
17490
acef9166db2f
MPlayer OSX port: Add a call to UDFFindFile to verify that we are opening a valid udf image. Patch by Emanuele Giaquita <emanuele.giaquinta@gmail.com>
nplourde
parents:
17257
diff
changeset
|
815 #endif |
15518 | 816 break; |
817 } | |
818 } | |
21731
61c0bae18c23
replace call to UDFFindFile() (that is not part of the public API) with DVDOpenFile()
nicodvb
parents:
21636
diff
changeset
|
819 free(temp_device); |
15518 | 820 |
821 if(!dvd) { | |
822 m_struct_free(&stream_opts,opts); | |
823 return STREAM_UNSUPORTED; | |
824 } | |
825 } else | |
826 #endif /* SYS_DARWIN */ | |
827 { | |
828 dvd = DVDOpen(dvd_device); | |
829 if(!dvd) { | |
830 mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_CantOpenDVD,dvd_device); | |
831 m_struct_free(&stream_opts,opts); | |
832 return STREAM_UNSUPORTED; | |
833 } | |
834 } | |
21636
1e8b1b5b1ccc
support for limiting dvd speed; patch by Tobias Diedrich (ranma tdiedrich se)
nicodvb
parents:
21554
diff
changeset
|
835 dvd_set_speed(dvd_device, dvd_speed); |
15518 | 836 |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
837 mp_msg(MSGT_OPEN,MSGL_V,"Reading disc structure, please wait...\n"); |
15518 | 838 |
839 /** | |
840 * Load the video manager to find out the information about the titles on | |
841 * this disc. | |
842 */ | |
843 vmg_file = ifoOpen(dvd, 0); | |
844 if(!vmg_file) { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
845 mp_msg(MSGT_OPEN,MSGL_ERR, MSGTR_DVDnoVMG); |
15518 | 846 DVDClose( dvd ); |
847 m_struct_free(&stream_opts,opts); | |
848 return STREAM_UNSUPORTED; | |
849 } | |
850 tt_srpt = vmg_file->tt_srpt; | |
18237
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
851 if (mp_msg_test(MSGT_IDENTIFY, MSGL_INFO)) |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
852 { |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
853 int title_no; ///< title number |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
854 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DVD_TITLES=%d\n", tt_srpt->nr_of_srpts); |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
855 for (title_no = 0; title_no < tt_srpt->nr_of_srpts; title_no++) |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
856 { |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
857 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DVD_TITLE_%d_CHAPTERS=%d\n", title_no + 1, tt_srpt->title[title_no].nr_of_ptts); |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
858 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DVD_TITLE_%d_ANGLES=%d\n", title_no + 1, tt_srpt->title[title_no].nr_of_angles); |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
859 } |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
860 } |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
861 if (mp_msg_test(MSGT_IDENTIFY, MSGL_V)) |
16544
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
862 { |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
863 unsigned char discid [16]; ///< disk ID, a 128 bit MD5 sum |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
864 int vts_no; ///< video title set number |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
865 for (vts_no = 1; vts_no <= vmg_file->vts_atrt->nr_of_vtss; vts_no++) |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
866 mp_describe_titleset(dvd, tt_srpt, vts_no); |
16544
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
867 if (DVDDiscID(dvd, discid) >= 0) |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
868 { |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
869 int i; |
22412 | 870 mp_msg(MSGT_IDENTIFY, MSGL_V, "ID_DVD_DISC_ID="); |
16544
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
871 for (i = 0; i < 16; i ++) |
22412 | 872 mp_msg(MSGT_IDENTIFY, MSGL_V, "%02X", discid[i]); |
873 mp_msg(MSGT_IDENTIFY, MSGL_V, "\n"); | |
16544
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
874 } |
a10adcba312f
Prints the number of titles, DVD disk ID, the numbers of chapters and
gpoirier
parents:
15551
diff
changeset
|
875 } |
15518 | 876 /** |
877 * Make sure our title number is valid. | |
878 */ | |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
879 mp_msg(MSGT_OPEN,MSGL_STATUS, MSGTR_DVDnumTitles, tt_srpt->nr_of_srpts ); |
15518 | 880 if(dvd_title < 1 || dvd_title > tt_srpt->nr_of_srpts) { |
881 mp_msg(MSGT_OPEN,MSGL_ERR, MSGTR_DVDinvalidTitle, dvd_title); | |
882 ifoClose( vmg_file ); | |
883 DVDClose( dvd ); | |
884 m_struct_free(&stream_opts,opts); | |
885 return STREAM_UNSUPORTED; | |
886 } | |
20086 | 887 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DVD_CURRENT_TITLE=%d\n", dvd_title); |
15518 | 888 --dvd_title; // remap 1.. -> 0.. |
889 /** | |
890 * Make sure the chapter number is valid for this title. | |
891 */ | |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
892 mp_msg(MSGT_OPEN,MSGL_STATUS, MSGTR_DVDnumChapters, tt_srpt->title[dvd_title].nr_of_ptts); |
15518 | 893 if(dvd_chapter<1 || dvd_chapter>tt_srpt->title[dvd_title].nr_of_ptts) { |
894 mp_msg(MSGT_OPEN,MSGL_ERR, MSGTR_DVDinvalidChapter, dvd_chapter); | |
895 ifoClose( vmg_file ); | |
896 DVDClose( dvd ); | |
897 m_struct_free(&stream_opts,opts); | |
898 return STREAM_UNSUPORTED; | |
899 } | |
900 if(dvd_last_chapter>0) { | |
901 if(dvd_last_chapter<dvd_chapter || dvd_last_chapter>tt_srpt->title[dvd_title].nr_of_ptts) { | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
902 mp_msg(MSGT_OPEN,MSGL_ERR, MSGTR_DVDinvalidLastChapter, dvd_last_chapter); |
15518 | 903 ifoClose( vmg_file ); |
904 DVDClose( dvd ); | |
905 m_struct_free(&stream_opts,opts); | |
906 return STREAM_UNSUPORTED; | |
907 } | |
908 } | |
909 --dvd_chapter; // remap 1.. -> 0.. | |
910 /* XXX No need to remap dvd_last_chapter */ | |
911 /** | |
912 * Make sure the angle number is valid for this title. | |
913 */ | |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
914 mp_msg(MSGT_OPEN,MSGL_STATUS, MSGTR_DVDnumAngles, tt_srpt->title[dvd_title].nr_of_angles); |
15518 | 915 if(dvd_angle<1 || dvd_angle>tt_srpt->title[dvd_title].nr_of_angles) { |
916 mp_msg(MSGT_OPEN,MSGL_ERR, MSGTR_DVDinvalidAngle, dvd_angle); | |
917 ifoClose( vmg_file ); | |
918 DVDClose( dvd ); | |
919 m_struct_free(&stream_opts,opts); | |
920 return STREAM_UNSUPORTED; | |
921 } | |
922 --dvd_angle; // remap 1.. -> 0.. | |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
923 |
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
924 ttn = tt_srpt->title[dvd_title].vts_ttn - 1; |
15518 | 925 /** |
926 * Load the VTS information for the title set our title is in. | |
927 */ | |
928 vts_file = ifoOpen( dvd, tt_srpt->title[dvd_title].title_set_nr ); | |
929 if(!vts_file) { | |
930 mp_msg(MSGT_OPEN,MSGL_ERR, MSGTR_DVDnoIFO, tt_srpt->title[dvd_title].title_set_nr ); | |
931 ifoClose( vmg_file ); | |
932 DVDClose( dvd ); | |
933 m_struct_free(&stream_opts,opts); | |
934 return STREAM_UNSUPORTED; | |
935 } | |
936 /** | |
937 * We've got enough info, time to open the title set data. | |
938 */ | |
939 title = DVDOpenFile(dvd, tt_srpt->title[dvd_title].title_set_nr, DVD_READ_TITLE_VOBS); | |
940 if(!title) { | |
941 mp_msg(MSGT_OPEN,MSGL_ERR, MSGTR_DVDnoVOBs, tt_srpt->title[dvd_title].title_set_nr); | |
942 ifoClose( vts_file ); | |
943 ifoClose( vmg_file ); | |
944 DVDClose( dvd ); | |
945 m_struct_free(&stream_opts,opts); | |
946 return STREAM_UNSUPORTED; | |
947 } | |
948 | |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
949 mp_msg(MSGT_OPEN,MSGL_V, "DVD successfully opened.\n"); |
15518 | 950 // store data |
951 d=malloc(sizeof(dvd_priv_t)); memset(d,0,sizeof(dvd_priv_t)); | |
952 d->dvd=dvd; | |
953 d->title=title; | |
954 d->vmg_file=vmg_file; | |
955 d->tt_srpt=tt_srpt; | |
956 d->vts_file=vts_file; | |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
957 d->cur_title = dvd_title+1; |
15518 | 958 |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
959 pgc = vts_file->vts_pgcit ? vts_file->vts_pgcit->pgci_srp[ttn].pgc : NULL; |
15518 | 960 /** |
961 * Check number of audio channels and types | |
962 */ | |
963 { | |
964 d->nr_of_channels=0; | |
965 if(vts_file->vts_pgcit) { | |
966 int i; | |
967 for(i=0;i<8;i++) | |
20635
9ed557ae1383
Streamline and simplify internal vs external libdvdread handling.
diego
parents:
20158
diff
changeset
|
968 #ifdef USE_DVDREAD_INTERNAL |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
969 if(pgc->audio_control[i].present) { |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
970 #else |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
971 if(pgc->audio_control[i] & 0x8000) { |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
972 #endif |
15518 | 973 audio_attr_t * audio = &vts_file->vtsi_mat->vts_audio_attr[i]; |
974 int language = 0; | |
975 char tmp[] = "unknown"; | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
976 stream_language_t *audio_stream = &d->audio_streams[d->nr_of_channels]; |
15518 | 977 |
978 if(audio->lang_type == 1) { | |
979 language=audio->lang_code; | |
980 tmp[0]=language>>8; | |
981 tmp[1]=language&0xff; | |
982 tmp[2]=0; | |
983 } | |
984 | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
985 audio_stream->language=language; |
20635
9ed557ae1383
Streamline and simplify internal vs external libdvdread handling.
diego
parents:
20158
diff
changeset
|
986 #ifdef USE_DVDREAD_INTERNAL |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
987 audio_stream->id=pgc->audio_control[i].s_audio; |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
988 #else |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
989 audio_stream->id=pgc->audio_control[i] >> 8 & 7; |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
990 #endif |
15518 | 991 switch(audio->audio_format) { |
992 case 0: // ac3 | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
993 audio_stream->id+=FIRST_AC3_AID; |
15518 | 994 break; |
995 case 6: // dts | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
996 audio_stream->id+=FIRST_DTS_AID; |
15518 | 997 break; |
998 case 2: // mpeg layer 1/2/3 | |
999 case 3: // mpeg2 ext | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1000 audio_stream->id+=FIRST_MPG_AID; |
15518 | 1001 break; |
1002 case 4: // lpcm | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1003 audio_stream->id+=FIRST_PCM_AID; |
15518 | 1004 break; |
1005 } | |
1006 | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1007 audio_stream->type=audio->audio_format; |
15518 | 1008 // Pontscho: to my mind, tha channels: |
1009 // 1 - stereo | |
1010 // 5 - 5.1 | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1011 audio_stream->channels=audio->channels; |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
1012 mp_msg(MSGT_OPEN,MSGL_STATUS,MSGTR_DVDaudioStreamInfo, |
15518 | 1013 d->nr_of_channels, |
1014 dvd_audio_stream_types[ audio->audio_format ], | |
1015 dvd_audio_stream_channels[ audio->channels ], | |
1016 tmp, | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1017 audio_stream->id |
15518 | 1018 ); |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1019 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_ID=%d\n", audio_stream->id); |
18237
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
1020 if(language && tmp[0]) |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1021 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", audio_stream->id, tmp); |
15518 | 1022 |
1023 d->nr_of_channels++; | |
1024 } | |
1025 } | |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
1026 mp_msg(MSGT_OPEN,MSGL_STATUS,MSGTR_DVDnumAudioChannels,d->nr_of_channels ); |
15518 | 1027 } |
1028 | |
1029 /** | |
1030 * Check number of subtitles and language | |
1031 */ | |
1032 { | |
1033 int i; | |
1034 | |
1035 d->nr_of_subtitles=0; | |
1036 for(i=0;i<32;i++) | |
20635
9ed557ae1383
Streamline and simplify internal vs external libdvdread handling.
diego
parents:
20158
diff
changeset
|
1037 #ifdef USE_DVDREAD_INTERNAL |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1038 if(pgc->subp_control[i].present) { |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
1039 #else |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1040 if(pgc->subp_control[i] & 0x80000000) { |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
1041 #endif |
15518 | 1042 subp_attr_t * subtitle = &vts_file->vtsi_mat->vts_subp_attr[i]; |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
1043 video_attr_t *video = &vts_file->vtsi_mat->vts_video_attr; |
15518 | 1044 int language = 0; |
1045 char tmp[] = "unknown"; | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1046 stream_language_t *sub_stream = &d->subtitles[d->nr_of_subtitles]; |
15518 | 1047 |
1048 if(subtitle->type == 1) { | |
1049 language=subtitle->lang_code; | |
1050 tmp[0]=language>>8; | |
1051 tmp[1]=language&0xff; | |
1052 tmp[2]=0; | |
1053 } | |
1054 | |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1055 sub_stream->language=language; |
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1056 sub_stream->id=d->nr_of_subtitles; |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
1057 if(video->display_aspect_ratio == 0) /* 4:3 */ |
20635
9ed557ae1383
Streamline and simplify internal vs external libdvdread handling.
diego
parents:
20158
diff
changeset
|
1058 #ifdef USE_DVDREAD_INTERNAL |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1059 sub_stream->id = pgc->subp_control[i].s_4p3; |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
1060 #else |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1061 sub_stream->id = pgc->subp_control[i] >> 24 & 31; |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
1062 #endif |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
1063 else if(video->display_aspect_ratio == 3) /* 16:9 */ |
20635
9ed557ae1383
Streamline and simplify internal vs external libdvdread handling.
diego
parents:
20158
diff
changeset
|
1064 #ifdef USE_DVDREAD_INTERNAL |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1065 sub_stream->id = pgc->subp_control[i].s_lbox; |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
1066 #else |
22204
da9d0425a72a
Simplify code by using separate variables for large common expressions.
reimar
parents:
21926
diff
changeset
|
1067 sub_stream->id = pgc->subp_control[i] >> 8 & 31; |
16770
a580febbb306
ugly hack to make it work again with external libdvdread
reimar
parents:
16649
diff
changeset
|
1068 #endif |
15518 | 1069 |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
1070 mp_msg(MSGT_OPEN,MSGL_STATUS,MSGTR_DVDsubtitleLanguage, d->nr_of_subtitles, tmp); |
21554
77ec48709f36
ID_SUBTITLE_ID should show the -sid number, not the vobsub id also for dvd subs.
reimar
parents:
20851
diff
changeset
|
1071 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SUBTITLE_ID=%d\n", d->nr_of_subtitles); |
18237
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
1072 if(language && tmp[0]) |
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18091
diff
changeset
|
1073 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", d->nr_of_subtitles, tmp); |
15518 | 1074 d->nr_of_subtitles++; |
1075 } | |
19448
ebaf8067faae
Print DVD audio channel and subtitle track information in non-verbose mode,
diego
parents:
19442
diff
changeset
|
1076 mp_msg(MSGT_OPEN,MSGL_STATUS,MSGTR_DVDnumSubtitles,d->nr_of_subtitles); |
15518 | 1077 } |
1078 | |
1079 /** | |
1080 * Determine which program chain we want to watch. This is based on the | |
1081 * chapter number. | |
1082 */ | |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
1083 pgc_id = vts_file->vts_ptt_srpt->title[ttn].ptt[dvd_chapter].pgcn; // local |
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
1084 pgn = vts_file->vts_ptt_srpt->title[ttn].ptt[dvd_chapter].pgn; // local |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1085 d->cur_pgc_idx = pgc_id-1; |
15518 | 1086 d->cur_pgc = vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc; |
1087 d->cur_cell = d->cur_pgc->program_map[pgn-1] - 1; // start playback here | |
1088 d->packs_left=-1; // for Navi stuff | |
1089 d->angle_seek=0; | |
1090 /* XXX dvd_last_chapter is in the range 1..nr_of_ptts */ | |
1091 if(dvd_last_chapter > 0 && dvd_last_chapter < tt_srpt->title[dvd_title].nr_of_ptts) { | |
16649
e1d6fbd607e0
Fix DVD audio and subtitle stream mapping, esp. for DVD with both 4:3 and
reimar
parents:
16544
diff
changeset
|
1092 pgn=vts_file->vts_ptt_srpt->title[ttn].ptt[dvd_last_chapter].pgn; |
15518 | 1093 d->last_cell=d->cur_pgc->program_map[pgn-1] - 1; |
1094 } else | |
1095 d->last_cell=d->cur_pgc->nr_of_cells; | |
1096 | |
1097 if(d->cur_pgc->cell_playback[d->cur_cell].block_type == BLOCK_TYPE_ANGLE_BLOCK ) | |
1098 d->cur_cell+=dvd_angle; | |
1099 d->cur_pack = d->cur_pgc->cell_playback[ d->cur_cell ].first_sector; | |
1100 d->cell_last_pack=d->cur_pgc->cell_playback[ d->cur_cell ].last_sector; | |
1101 mp_msg(MSGT_DVD,MSGL_V, "DVD start cell: %d pack: 0x%X-0x%X \n",d->cur_cell,d->cur_pack,d->cell_last_pack); | |
1102 | |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1103 //assign cell_times_table |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1104 d->cell_times_table = malloc(sizeof(unsigned int) * d->cur_pgc->nr_of_cells); |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1105 if(d->cell_times_table == NULL) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1106 return STREAM_UNSUPORTED; |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1107 for(k=0; k<d->cur_pgc->nr_of_cells; k++) |
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1108 d->cell_times_table[k] = dvdtimetomsec(&d->cur_pgc->cell_playback[k].playback_time); |
20812
2e78c538db90
idenfify now shows the timings of chapters of the chosen pgc
nicodvb
parents:
20746
diff
changeset
|
1109 list_chapters(d->cur_pgc); |
20746
a40246d0c941
implemented STREAM_CTRL_GET_CURRENT_TIME and STREAM_CTRL_SEEK_TO_TIME (precise seeking)
nicodvb
parents:
20635
diff
changeset
|
1110 |
15518 | 1111 // ... (unimplemented) |
1112 // return NULL; | |
1113 stream->type = STREAMTYPE_DVD; | |
1114 stream->sector_size = 2048; | |
1115 stream->flags = STREAM_READ | STREAM_SEEK; | |
1116 stream->fill_buffer = fill_buffer; | |
1117 stream->seek = seek; | |
17698
14830cce6098
implement STREAM_CTRL_GET_TIME_LENGTH to return the duration of the dvd currently playing
nicodvb
parents:
17490
diff
changeset
|
1118 stream->control = control; |
15518 | 1119 stream->close = stream_dvd_close; |
1120 stream->start_pos = (off_t)d->cur_pack*2048; | |
1121 stream->end_pos = (off_t)(d->cur_pgc->cell_playback[d->last_cell-1].last_sector)*2048; | |
21926
a8cd73869242
at open() assign *file_format=DEMUXER_TYPE_MPEG_PS to avoid useless demuxer probing
nicodvb
parents:
21731
diff
changeset
|
1122 *file_format = DEMUXER_TYPE_MPEG_PS; |
15518 | 1123 mp_msg(MSGT_DVD,MSGL_V,"DVD start=%d end=%d \n",d->cur_pack,d->cur_pgc->cell_playback[d->last_cell-1].last_sector); |
1124 stream->priv = (void*)d; | |
1125 return STREAM_OK; | |
1126 } | |
18867 | 1127 #endif /* #ifdef USE_DVDREAD */ |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16770
diff
changeset
|
1128 mp_msg(MSGT_DVD,MSGL_ERR,MSGTR_NoDVDSupport); |
15518 | 1129 m_struct_free(&stream_opts,opts); |
1130 return STREAM_UNSUPORTED; | |
1131 } | |
1132 | |
1133 | |
1134 stream_info_t stream_info_dvd = { | |
1135 "DVD stream", | |
1136 "null", | |
1137 "", | |
1138 "", | |
1139 open_s, | |
1140 { "dvd", NULL }, | |
1141 &stream_opts, | |
1142 1 // Urls are an option string | |
1143 }; |