Mercurial > libdvdnav.hg
annotate dvdnav.c @ 278:ef3b33441db5 src
include inttypes.h wherever necessary
author | nicodvb |
---|---|
date | Mon, 16 Apr 2007 22:43:56 +0000 |
parents | 12beff7f4482 |
children | 52877d182e96 |
rev | line source |
---|---|
0 | 1 /* |
2 * Copyright (C) 2000 Rich Wareham <richwareham@users.sourceforge.net> | |
3 * | |
4 * This file is part of libdvdnav, a DVD navigation library. | |
5 * | |
6 * libdvdnav is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; either version 2 of the License, or | |
9 * (at your option) any later version. | |
10 * | |
11 * libdvdnav is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License | |
17 * along with this program; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA | |
19 * | |
20 * $Id$ | |
21 * | |
22 */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
25 #include "config.h" | |
26 #endif | |
27 | |
31 | 28 /* |
29 #define LOG_DEBUG | |
30 */ | |
31 | |
278 | 32 #include <inttypes.h> |
0 | 33 #include "dvdnav_internal.h" |
34 #include "read_cache.h" | |
231 | 35 #include "nav_read.h" |
0 | 36 |
37 #include <stdlib.h> | |
38 #include <stdio.h> | |
84 | 39 #include <sys/time.h> |
0 | 40 |
97
c1dff1899bda
First patch for personalized dvd viewing. I have not tested it yet.
jcdutton
parents:
92
diff
changeset
|
41 #include "remap.h" |
c1dff1899bda
First patch for personalized dvd viewing. I have not tested it yet.
jcdutton
parents:
92
diff
changeset
|
42 |
114 | 43 static dvdnav_status_t dvdnav_clear(dvdnav_t * this) { |
44 /* clear everything except file, vm, mutex, readahead */ | |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
45 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
46 if (this->file) DVDCloseFile(this->file); |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
47 this->file = NULL; |
4
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
48 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
49 memset(&this->pci,0,sizeof(this->pci)); |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
50 memset(&this->dsi,0,sizeof(this->dsi)); |
197
a20a5976a207
last_cmd_nav_lbn has to be initialized with an invalid value, so that the first
mroi
parents:
195
diff
changeset
|
51 this->last_cmd_nav_lbn = SRI_END_OF_CELL; |
4
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
52 |
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
53 /* Set initial values of flags */ |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
54 this->position_current.still = 0; |
23 | 55 this->skip_still = 0; |
116 | 56 this->sync_wait = 0; |
57 this->sync_wait_skip = 0; | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
58 this->spu_clut_changed = 0; |
114 | 59 this->started = 0; |
269
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
60 this->cur_cell_time = 0; |
4
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
61 |
34
1f29402ef2ef
'Objectified' the read-ahead cache in preparation to implement a 'proper' threaded cache a-la that recommended in the DVD Demystified book.
richwareham
parents:
33
diff
changeset
|
62 dvdnav_read_cache_clear(this->cache); |
1f29402ef2ef
'Objectified' the read-ahead cache in preparation to implement a 'proper' threaded cache a-la that recommended in the DVD Demystified book.
richwareham
parents:
33
diff
changeset
|
63 |
193 | 64 return DVDNAV_STATUS_OK; |
4
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
65 } |
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
66 |
114 | 67 dvdnav_status_t dvdnav_open(dvdnav_t** dest, const char *path) { |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
68 dvdnav_t *this; |
84 | 69 struct timeval time; |
0 | 70 |
71 /* Create a new structure */ | |
100 | 72 fprintf(MSG_OUT, "libdvdnav: Using dvdnav version %s from http://dvd.sf.net\n", VERSION); |
82 | 73 |
0 | 74 (*dest) = NULL; |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
75 this = (dvdnav_t*)malloc(sizeof(dvdnav_t)); |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
76 if(!this) |
193 | 77 return DVDNAV_STATUS_ERR; |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
78 memset(this, 0, (sizeof(dvdnav_t) ) ); /* Make sure this structure is clean */ |
114 | 79 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
80 pthread_mutex_init(&this->vm_lock, NULL); |
0 | 81 /* Initialise the error string */ |
82 printerr(""); | |
83 | |
84 /* Initialise the VM */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
85 this->vm = vm_new_vm(); |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
86 if(!this->vm) { |
114 | 87 printerr("Error initialising the DVD VM."); |
92 | 88 pthread_mutex_destroy(&this->vm_lock); |
89 free(this); | |
193 | 90 return DVDNAV_STATUS_ERR; |
0 | 91 } |
114 | 92 if(!vm_reset(this->vm, path)) { |
93 printerr("Error starting the VM / opening the DVD device."); | |
92 | 94 pthread_mutex_destroy(&this->vm_lock); |
95 vm_free_vm(this->vm); | |
96 free(this); | |
193 | 97 return DVDNAV_STATUS_ERR; |
0 | 98 } |
99 | |
100 /* Set the path. FIXME: Is a deep copy 'right' */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
101 strncpy(this->path, path, MAX_PATH_LEN); |
0 | 102 |
103 /* Pre-open and close a file so that the CSS-keys are cached. */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
104 this->file = DVDOpenFile(vm_get_dvd_reader(this->vm), 0, DVD_READ_MENU_VOBS); |
0 | 105 |
34
1f29402ef2ef
'Objectified' the read-ahead cache in preparation to implement a 'proper' threaded cache a-la that recommended in the DVD Demystified book.
richwareham
parents:
33
diff
changeset
|
106 /* Start the read-ahead cache. */ |
1f29402ef2ef
'Objectified' the read-ahead cache in preparation to implement a 'proper' threaded cache a-la that recommended in the DVD Demystified book.
richwareham
parents:
33
diff
changeset
|
107 this->cache = dvdnav_read_cache_new(this); |
84 | 108 |
114 | 109 /* Seed the random numbers. So that the DVD VM Command rand() |
110 * gives a different start value each time a DVD is played. */ | |
111 gettimeofday(&time, NULL); | |
84 | 112 srand(time.tv_usec); |
113 | |
114 | 114 dvdnav_clear(this); |
115 | |
116 (*dest) = this; | |
193 | 117 return DVDNAV_STATUS_OK; |
0 | 118 } |
119 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
120 dvdnav_status_t dvdnav_close(dvdnav_t *this) { |
114 | 121 |
31 | 122 #ifdef LOG_DEBUG |
76 | 123 fprintf(MSG_OUT, "libdvdnav: close:called\n"); |
31 | 124 #endif |
34
1f29402ef2ef
'Objectified' the read-ahead cache in preparation to implement a 'proper' threaded cache a-la that recommended in the DVD Demystified book.
richwareham
parents:
33
diff
changeset
|
125 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
126 if (this->file) { |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
127 DVDCloseFile(this->file); |
31 | 128 #ifdef LOG_DEBUG |
76 | 129 fprintf(MSG_OUT, "libdvdnav: close:file closing\n"); |
31 | 130 #endif |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
131 this->file = NULL; |
0 | 132 } |
133 | |
134 /* Free the VM */ | |
114 | 135 if(this->vm) |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
136 vm_free_vm(this->vm); |
114 | 137 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
138 pthread_mutex_destroy(&this->vm_lock); |
60 | 139 |
140 /* We leave the final freeing of the entire structure to the cache, | |
141 * because we don't know, if there are still buffers out in the wild, | |
142 * that must return first. */ | |
114 | 143 if(this->cache) |
60 | 144 dvdnav_read_cache_free(this->cache); |
114 | 145 else |
146 free(this); | |
0 | 147 |
193 | 148 return DVDNAV_STATUS_OK; |
0 | 149 } |
150 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
151 dvdnav_status_t dvdnav_reset(dvdnav_t *this) { |
4
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
152 dvdnav_status_t result; |
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
153 |
31 | 154 #ifdef LOG_DEBUG |
76 | 155 fprintf(MSG_OUT, "libdvdnav: reset:called\n"); |
31 | 156 #endif |
114 | 157 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
158 pthread_mutex_lock(&this->vm_lock); |
114 | 159 |
31 | 160 #ifdef LOG_DEBUG |
76 | 161 fprintf(MSG_OUT, "libdvdnav: reseting vm\n"); |
31 | 162 #endif |
114 | 163 if(!vm_reset(this->vm, NULL)) { |
164 printerr("Error restarting the VM."); | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
165 pthread_mutex_unlock(&this->vm_lock); |
193 | 166 return DVDNAV_STATUS_ERR; |
4
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
167 } |
31 | 168 #ifdef LOG_DEBUG |
76 | 169 fprintf(MSG_OUT, "libdvdnav: clearing dvdnav\n"); |
31 | 170 #endif |
114 | 171 result = dvdnav_clear(this); |
172 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
173 pthread_mutex_unlock(&this->vm_lock); |
4
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
174 return result; |
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
175 } |
99bed5d6db2f
Added reset patch from Kees Cook <kees@outflux.net>
richwareham
parents:
3
diff
changeset
|
176 |
114 | 177 dvdnav_status_t dvdnav_path(dvdnav_t *this, const char** path) { |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
178 (*path) = this->path; |
0 | 179 |
193 | 180 return DVDNAV_STATUS_OK; |
0 | 181 } |
182 | |
114 | 183 const char* dvdnav_err_to_string(dvdnav_t *this) { |
184 | |
185 if(!this) | |
3
328eadb3f37e
Added initial example programs directory and make sure all debug/error output goes to stderr.
richwareham
parents:
0
diff
changeset
|
186 return "Hey! You gave me a NULL pointer you naughty person!"; |
0 | 187 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
188 return this->err_str; |
0 | 189 } |
190 | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
191 /* converts a dvd_time_t to PTS ticks */ |
265 | 192 int64_t dvdnav_convert_time(dvd_time_t *time) { |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
193 int64_t result; |
195 | 194 int64_t frames; |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
195 |
135 | 196 result = (time->hour >> 4 ) * 10 * 60 * 60 * 90000; |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
197 result += (time->hour & 0x0f) * 60 * 60 * 90000; |
135 | 198 result += (time->minute >> 4 ) * 10 * 60 * 90000; |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
199 result += (time->minute & 0x0f) * 60 * 90000; |
135 | 200 result += (time->second >> 4 ) * 10 * 90000; |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
201 result += (time->second & 0x0f) * 90000; |
135 | 202 |
203 frames = ((time->frame_u & 0x30) >> 4) * 10; | |
204 frames += ((time->frame_u & 0x0f) ) ; | |
205 | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
206 if (time->frame_u & 0x80) |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
207 result += frames * 3000; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
208 else |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
209 result += frames * 3600; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
210 |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
211 return result; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
212 } |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
213 |
114 | 214 /* |
0 | 215 * Returns 1 if block contains NAV packet, 0 otherwise. |
217 | 216 * Processes said NAV packet if present. |
0 | 217 * |
218 * Most of the code in here is copied from xine's MPEG demuxer | |
219 * so any bugs which are found in that should be corrected here also. | |
220 */ | |
195 | 221 static int32_t dvdnav_decode_packet(dvdnav_t *this, uint8_t *p, dsi_t *nav_dsi, pci_t *nav_pci) { |
222 int32_t bMpeg1 = 0; | |
0 | 223 uint32_t nHeaderLen; |
224 uint32_t nPacketLen; | |
225 uint32_t nStreamID; | |
226 | |
227 if (p[3] == 0xBA) { /* program stream pack header */ | |
195 | 228 int32_t nStuffingBytes; |
0 | 229 |
230 bMpeg1 = (p[4] & 0x40) == 0; | |
231 | |
232 if (bMpeg1) { | |
114 | 233 p += 12; |
0 | 234 } else { /* mpeg2 */ |
235 nStuffingBytes = p[0xD] & 0x07; | |
236 p += 14 + nStuffingBytes; | |
237 } | |
238 } | |
239 | |
240 if (p[3] == 0xbb) { /* program stream system header */ | |
241 nHeaderLen = (p[4] << 8) | p[5]; | |
242 p += 6 + nHeaderLen; | |
243 } | |
244 | |
245 /* we should now have a PES packet here */ | |
246 if (p[0] || p[1] || (p[2] != 1)) { | |
76 | 247 fprintf(MSG_OUT, "libdvdnav: demux error! %02x %02x %02x (should be 0x000001) \n",p[0],p[1],p[2]); |
0 | 248 return 0; |
249 } | |
250 | |
251 nPacketLen = p[4] << 8 | p[5]; | |
252 nStreamID = p[3]; | |
253 | |
254 nHeaderLen = 6; | |
255 p += nHeaderLen; | |
256 | |
257 if (nStreamID == 0xbf) { /* Private stream 2 */ | |
114 | 258 #if 0 |
195 | 259 int32_t i; |
114 | 260 fprintf(MSG_OUT, "libdvdnav: nav packet=%u\n",p-p_start-6); |
261 for(i=0;i<80;i++) | |
262 fprintf(MSG_OUT, "%02x ",p[i-6]); | |
263 fprintf(MSG_OUT, "\n"); | |
264 #endif | |
265 | |
0 | 266 if(p[0] == 0x00) { |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
267 navRead_PCI(nav_pci, p+1); |
0 | 268 } |
269 | |
270 p += nPacketLen; | |
271 | |
272 /* We should now have a DSI packet. */ | |
273 if(p[6] == 0x01) { | |
274 nPacketLen = p[4] << 8 | p[5]; | |
275 p += 6; | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
276 navRead_DSI(nav_dsi, p+1); |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
277 } |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
278 return 1; |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
279 } |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
280 return 0; |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
281 } |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
282 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
283 /* DSI is used for most angle stuff. |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
284 * PCI is used for only non-seemless angle stuff |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
285 */ |
195 | 286 static int32_t dvdnav_get_vobu(dvdnav_t *this, dsi_t *nav_dsi, pci_t *nav_pci, dvdnav_vobu_t *vobu) { |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
287 uint32_t next; |
195 | 288 int32_t angle, num_angle; |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
289 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
290 vobu->vobu_start = nav_dsi->dsi_gi.nv_pck_lbn; /* Absolute offset from start of disk */ |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
291 vobu->vobu_length = nav_dsi->dsi_gi.vobu_ea; /* Relative offset from vobu_start */ |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
292 |
43
0ba15bf3dc25
Biiiiiiig change to let doxygen generate some docs for the library. Note that I'm in no way sure that the autoconf stuff plays nice.
richwareham
parents:
42
diff
changeset
|
293 /* |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
294 * If we're not at the end of this cell, we can determine the next |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
295 * VOBU to display using the VOBU_SRI information section of the |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
296 * DSI. Using this value correctly follows the current angle, |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
297 * avoiding the doubled scenes in The Matrix, and makes our life |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
298 * really happy. |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
299 * |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
300 * vobu_next is an offset value, 0x3fffffff = SRI_END_OF_CELL |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
301 * DVDs are about 6 Gigs, which is only up to 0x300000 blocks |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
302 * Should really assert if bit 31 != 1 |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
303 */ |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
304 |
114 | 305 #if 0 |
306 /* Old code -- may still be useful one day */ | |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
307 if(nav_dsi->vobu_sri.next_vobu != SRI_END_OF_CELL ) { |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
308 vobu->vobu_next = ( nav_dsi->vobu_sri.next_vobu & 0x3fffffff ); |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
309 } else { |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
310 vobu->vobu_next = vobu->vobu_length; |
114 | 311 } |
312 #else | |
313 /* Relative offset from vobu_start */ | |
314 vobu->vobu_next = ( nav_dsi->vobu_sri.next_vobu & 0x3fffffff ); | |
315 #endif | |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
316 |
114 | 317 vm_get_angle_info(this->vm, &angle, &num_angle); |
318 | |
319 /* FIMXE: The angle reset doesn't work for some reason for the moment */ | |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
320 #if 0 |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
321 if((num_angle < angle) && (angle != 1)) { |
114 | 322 fprintf(MSG_OUT, "libdvdnav: angle ends!\n"); |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
323 |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
324 /* This is to switch back to angle one when we |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
325 * finish with angles. */ |
114 | 326 dvdnav_angle_change(this, 1); |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
327 } |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
328 #endif |
0 | 329 |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
330 if(num_angle != 0) { |
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
331 |
114 | 332 if((next = nav_pci->nsml_agli.nsml_agl_dsta[angle-1]) != 0) { |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
333 if((next & 0x3fffffff) != 0) { |
114 | 334 if(next & 0x80000000) |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
335 vobu->vobu_next = - (int32_t)(next & 0x3fffffff); |
114 | 336 else |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
337 vobu->vobu_next = + (int32_t)(next & 0x3fffffff); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
338 } |
114 | 339 } else if((next = nav_dsi->sml_agli.data[angle-1].address) != 0) { |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
340 vobu->vobu_length = nav_dsi->sml_pbi.ilvu_ea; |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
341 |
114 | 342 if((next & 0x80000000) && (next != 0x7fffffff)) |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
343 vobu->vobu_next = - (int32_t)(next & 0x3fffffff); |
114 | 344 else |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
345 vobu->vobu_next = + (int32_t)(next & 0x3fffffff); |
0 | 346 } |
347 } | |
33
ef2136c4e7b2
Angles now work (still a few wrinkles though -- e.g. angle does not reset to '1' when returning to menus)
richwareham
parents:
31
diff
changeset
|
348 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
349 return 1; |
0 | 350 } |
60 | 351 |
114 | 352 /* |
353 * These are the main get_next_block function which actually get the media stream video and audio etc. | |
354 * | |
355 * There are two versions: The second one is using the zero-copy read ahead cache and therefore | |
356 * hands out pointers targetting directly into the cache. | |
357 * The first one uses a memcopy to fill this cache block into the application provided memory. | |
358 * The benefit of this first one is that no special memory management is needed. The application is | |
359 * the only one responsible of allocating and freeing the memory associated with the pointer. | |
360 * The drawback is the additional memcopy. | |
28 | 361 */ |
60 | 362 |
195 | 363 dvdnav_status_t dvdnav_get_next_block(dvdnav_t *this, uint8_t *buf, |
364 int32_t *event, int32_t *len) { | |
60 | 365 unsigned char *block; |
366 dvdnav_status_t status; | |
367 | |
368 block = buf; | |
369 status = dvdnav_get_next_cache_block(this, &block, event, len); | |
193 | 370 if (status == DVDNAV_STATUS_OK && block != buf) { |
60 | 371 /* we received a block from the cache, copy it, so we can give it back */ |
372 memcpy(buf, block, DVD_VIDEO_LB_LEN); | |
373 dvdnav_free_cache_block(this, block); | |
374 } | |
375 return status; | |
376 } | |
269
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
377 |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
378 int64_t dvdnav_get_current_time(dvdnav_t *this) { |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
379 int i; |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
380 int64_t tm=0; |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
381 dvd_state_t *state = &this->vm->state; |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
382 |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
383 for(i=0; i<state->cellN-1; i++) { |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
384 if(! |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
385 (state->pgc->cell_playback[i].block_type == BLOCK_TYPE_ANGLE_BLOCK && |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
386 state->pgc->cell_playback[i].block_mode != BLOCK_MODE_FIRST_CELL) |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
387 ) |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
388 tm += dvdnav_convert_time(&state->pgc->cell_playback[i].playback_time); |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
389 } |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
390 tm += this->cur_cell_time; |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
391 |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
392 return tm; |
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
393 } |
60 | 394 |
195 | 395 dvdnav_status_t dvdnav_get_next_cache_block(dvdnav_t *this, uint8_t **buf, |
396 int32_t *event, int32_t *len) { | |
0 | 397 dvd_state_t *state; |
195 | 398 int32_t result; |
114 | 399 |
400 pthread_mutex_lock(&this->vm_lock); | |
0 | 401 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
402 if(!this->started) { |
0 | 403 /* Start the VM */ |
256
6299ccea8a38
killing a lot of asserts and turning them into forced executions of Exit,
mroi
parents:
249
diff
changeset
|
404 if (!vm_start(this->vm)) { |
6299ccea8a38
killing a lot of asserts and turning them into forced executions of Exit,
mroi
parents:
249
diff
changeset
|
405 printerr("Encrypted or faulty DVD"); |
6299ccea8a38
killing a lot of asserts and turning them into forced executions of Exit,
mroi
parents:
249
diff
changeset
|
406 return DVDNAV_STATUS_ERR; |
6299ccea8a38
killing a lot of asserts and turning them into forced executions of Exit,
mroi
parents:
249
diff
changeset
|
407 } |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
408 this->started = 1; |
0 | 409 } |
410 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
411 state = &(this->vm->state); |
0 | 412 (*event) = DVDNAV_NOP; |
413 (*len) = 0; | |
414 | |
415 /* Check the STOP flag */ | |
114 | 416 if(this->vm->stopped) { |
121 | 417 vm_stop(this->vm); |
0 | 418 (*event) = DVDNAV_STOP; |
114 | 419 this->started = 0; |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
420 pthread_mutex_unlock(&this->vm_lock); |
193 | 421 return DVDNAV_STATUS_OK; |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
422 } |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
423 |
114 | 424 vm_position_get(this->vm, &this->position_next); |
0 | 425 |
126 | 426 #ifdef LOG_DEBUG |
114 | 427 fprintf(MSG_OUT, "libdvdnav: POS-NEXT "); |
428 vm_position_print(this->vm, &this->position_next); | |
116 | 429 fprintf(MSG_OUT, "libdvdnav: POS-CUR "); |
114 | 430 vm_position_print(this->vm, &this->position_current); |
31 | 431 #endif |
114 | 432 |
433 /* did we hop? */ | |
434 if(this->position_current.hop_channel != this->position_next.hop_channel) { | |
435 (*event) = DVDNAV_HOP_CHANNEL; | |
58 | 436 #ifdef LOG_DEBUG |
114 | 437 fprintf(MSG_OUT, "libdvdnav: HOP_CHANNEL\n"); |
31 | 438 #endif |
115 | 439 if (this->position_next.hop_channel - this->position_current.hop_channel >= HOP_SEEK) { |
195 | 440 int32_t num_angles = 0, current; |
114 | 441 |
442 /* we seeked -> check for multiple angles */ | |
443 vm_get_angle_info(this->vm, ¤t, &num_angles); | |
444 if (num_angles > 1) { | |
195 | 445 int32_t result, block; |
114 | 446 /* we have to skip the first VOBU when seeking in a multiangle feature, |
447 * because it might belong to the wrong angle */ | |
448 block = this->position_next.cell_start + this->position_next.block; | |
449 result = dvdnav_read_cache_block(this->cache, block, 1, buf); | |
450 if(result <= 0) { | |
451 printerr("Error reading NAV packet."); | |
452 pthread_mutex_unlock(&this->vm_lock); | |
193 | 453 return DVDNAV_STATUS_ERR; |
114 | 454 } |
455 /* Decode nav into pci and dsi. Then get next VOBU info. */ | |
456 if(!dvdnav_decode_packet(this, *buf, &this->dsi, &this->pci)) { | |
457 printerr("Expected NAV packet but none found."); | |
458 pthread_mutex_unlock(&this->vm_lock); | |
193 | 459 return DVDNAV_STATUS_ERR; |
114 | 460 } |
461 dvdnav_get_vobu(this, &this->dsi, &this->pci, &this->vobu); | |
462 /* skip to next, if there is a next */ | |
463 if (this->vobu.vobu_next != SRI_END_OF_CELL) { | |
464 this->vobu.vobu_start += this->vobu.vobu_next; | |
465 this->vobu.vobu_next = 0; | |
466 } | |
467 /* update VM state */ | |
468 this->vm->state.blockN = this->vobu.vobu_start - this->position_next.cell_start; | |
469 } | |
470 } | |
471 this->position_current.hop_channel = this->position_next.hop_channel; | |
141
8f63f4c25f2f
update position on HOP_CHANNEL, do not rely on a following CELL_CHANGE
mroi
parents:
135
diff
changeset
|
472 /* update VOBU info */ |
8f63f4c25f2f
update position on HOP_CHANNEL, do not rely on a following CELL_CHANGE
mroi
parents:
135
diff
changeset
|
473 this->vobu.vobu_start = this->position_next.cell_start + this->position_next.block; |
8f63f4c25f2f
update position on HOP_CHANNEL, do not rely on a following CELL_CHANGE
mroi
parents:
135
diff
changeset
|
474 this->vobu.vobu_next = 0; |
127 | 475 /* Make blockN == vobu_length to do expected_nav */ |
114 | 476 this->vobu.vobu_length = 0; |
127 | 477 this->vobu.blockN = 0; |
116 | 478 this->sync_wait = 0; |
30 | 479 pthread_mutex_unlock(&this->vm_lock); |
193 | 480 return DVDNAV_STATUS_OK; |
0 | 481 } |
482 | |
116 | 483 /* Check the HIGHLIGHT flag */ |
484 if(this->position_current.button != this->position_next.button) { | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
485 dvdnav_highlight_event_t *hevent = (dvdnav_highlight_event_t *)*buf; |
116 | 486 |
487 (*event) = DVDNAV_HIGHLIGHT; | |
488 #ifdef LOG_DEBUG | |
489 fprintf(MSG_OUT, "libdvdnav: HIGHLIGHT\n"); | |
490 #endif | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
491 (*len) = sizeof(dvdnav_highlight_event_t); |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
492 hevent->display = 1; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
493 hevent->buttonN = this->position_next.button; |
116 | 494 this->position_current.button = this->position_next.button; |
495 pthread_mutex_unlock(&this->vm_lock); | |
193 | 496 return DVDNAV_STATUS_OK; |
116 | 497 } |
498 | |
499 /* Check the WAIT flag */ | |
500 if(this->sync_wait) { | |
501 (*event) = DVDNAV_WAIT; | |
502 #ifdef LOG_DEBUG | |
503 fprintf(MSG_OUT, "libdvdnav: WAIT\n"); | |
504 #endif | |
505 (*len) = 0; | |
506 pthread_mutex_unlock(&this->vm_lock); | |
193 | 507 return DVDNAV_STATUS_OK; |
116 | 508 } |
509 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
510 /* Check to see if we need to change the currently opened VOB */ |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
511 if((this->position_current.vts != this->position_next.vts) || |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
512 (this->position_current.domain != this->position_next.domain)) { |
0 | 513 dvd_read_domain_t domain; |
195 | 514 int32_t vtsN; |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
515 dvdnav_vts_change_event_t *vts_event = (dvdnav_vts_change_event_t *)*buf; |
0 | 516 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
517 if(this->file) { |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
518 DVDCloseFile(this->file); |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
519 this->file = NULL; |
0 | 520 } |
521 | |
217 | 522 vts_event->old_vtsN = this->position_current.vts; |
523 vts_event->old_domain = this->position_current.domain; | |
0 | 524 |
114 | 525 /* Use the DOMAIN to find whether to open menu or title VOBs */ |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
526 switch(this->position_next.domain) { |
114 | 527 case FP_DOMAIN: |
528 case VMGM_DOMAIN: | |
0 | 529 domain = DVD_READ_MENU_VOBS; |
530 vtsN = 0; | |
531 break; | |
114 | 532 case VTSM_DOMAIN: |
0 | 533 domain = DVD_READ_MENU_VOBS; |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
534 vtsN = this->position_next.vts; |
0 | 535 break; |
114 | 536 case VTS_DOMAIN: |
0 | 537 domain = DVD_READ_TITLE_VOBS; |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
538 vtsN = this->position_next.vts; |
0 | 539 break; |
114 | 540 default: |
0 | 541 printerr("Unknown domain when changing VTS."); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
542 pthread_mutex_unlock(&this->vm_lock); |
193 | 543 return DVDNAV_STATUS_ERR; |
0 | 544 } |
545 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
546 this->position_current.vts = this->position_next.vts; |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
547 this->position_current.domain = this->position_next.domain; |
34
1f29402ef2ef
'Objectified' the read-ahead cache in preparation to implement a 'proper' threaded cache a-la that recommended in the DVD Demystified book.
richwareham
parents:
33
diff
changeset
|
548 dvdnav_read_cache_clear(this->cache); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
549 this->file = DVDOpenFile(vm_get_dvd_reader(this->vm), vtsN, domain); |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
550 vts_event->new_vtsN = this->position_next.vts; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
551 vts_event->new_domain = this->position_next.domain; |
0 | 552 |
553 /* If couldn't open the file for some reason, moan */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
554 if(this->file == NULL) { |
0 | 555 printerrf("Error opening vtsN=%i, domain=%i.", vtsN, domain); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
556 pthread_mutex_unlock(&this->vm_lock); |
193 | 557 return DVDNAV_STATUS_ERR; |
0 | 558 } |
559 | |
560 /* File opened successfully so return a VTS change event */ | |
561 (*event) = DVDNAV_VTS_CHANGE; | |
114 | 562 #ifdef LOG_DEBUG |
563 fprintf(MSG_OUT, "libdvdnav: VTS_CHANGE\n"); | |
564 #endif | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
565 (*len) = sizeof(dvdnav_vts_change_event_t); |
0 | 566 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
567 this->spu_clut_changed = 1; |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
568 this->position_current.cell = -1; /* Force an update */ |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
569 this->position_current.spu_channel = -1; /* Force an update */ |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
570 this->position_current.audio_channel = -1; /* Force an update */; |
0 | 571 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
572 pthread_mutex_unlock(&this->vm_lock); |
193 | 573 return DVDNAV_STATUS_OK; |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
574 } |
114 | 575 |
576 /* Check if the cell changed */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
577 if( (this->position_current.cell != this->position_next.cell) || |
50
578ce1d41479
Rename some of the functions in vm.c to help readability.
jcdutton
parents:
45
diff
changeset
|
578 (this->position_current.cell_restart != this->position_next.cell_restart) || |
114 | 579 (this->position_current.cell_start != this->position_next.cell_start) ) { |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
580 dvdnav_cell_change_event_t *cell_event = (dvdnav_cell_change_event_t *)*buf; |
195 | 581 int32_t first_cell_nr, last_cell_nr, i; |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
582 dvd_state_t *state = &this->vm->state; |
114 | 583 |
269
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
584 this->cur_cell_time = 0; |
114 | 585 (*event) = DVDNAV_CELL_CHANGE; |
586 #ifdef LOG_DEBUG | |
587 fprintf(MSG_OUT, "libdvdnav: CELL_CHANGE\n"); | |
588 #endif | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
589 (*len) = sizeof(dvdnav_cell_change_event_t); |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
590 |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
591 cell_event->cellN = state->cellN; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
592 cell_event->pgN = state->pgN; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
593 cell_event->cell_length = |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
594 dvdnav_convert_time(&state->pgc->cell_playback[state->cellN-1].playback_time); |
161 | 595 |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
596 cell_event->pg_length = 0; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
597 /* Find start cell of program. */ |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
598 first_cell_nr = state->pgc->program_map[state->pgN-1]; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
599 /* Find end cell of program */ |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
600 if(state->pgN < state->pgc->nr_of_programs) |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
601 last_cell_nr = state->pgc->program_map[state->pgN] - 1; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
602 else |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
603 last_cell_nr = state->pgc->nr_of_cells; |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
604 for (i = first_cell_nr; i <= last_cell_nr; i++) |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
605 cell_event->pg_length += |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
606 dvdnav_convert_time(&state->pgc->cell_playback[i - 1].playback_time); |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
607 cell_event->pgc_length = dvdnav_convert_time(&state->pgc->playback_time); |
151 | 608 |
609 cell_event->cell_start = 0; | |
610 for (i = 1; i < state->cellN; i++) | |
611 cell_event->cell_start += | |
612 dvdnav_convert_time(&state->pgc->cell_playback[i - 1].playback_time); | |
161 | 613 |
614 cell_event->pg_start = 0; | |
615 for (i = 1; i < state->pgc->program_map[state->pgN-1]; i++) | |
616 cell_event->pg_start += | |
617 dvdnav_convert_time(&state->pgc->cell_playback[i - 1].playback_time); | |
618 | |
114 | 619 this->position_current.cell = this->position_next.cell; |
50
578ce1d41479
Rename some of the functions in vm.c to help readability.
jcdutton
parents:
45
diff
changeset
|
620 this->position_current.cell_restart = this->position_next.cell_restart; |
114 | 621 this->position_current.cell_start = this->position_next.cell_start; |
622 this->position_current.block = this->position_next.block; | |
623 | |
624 /* vobu info is used for mid cell resumes */ | |
625 this->vobu.vobu_start = this->position_next.cell_start + this->position_next.block; | |
626 this->vobu.vobu_next = 0; | |
127 | 627 /* Make blockN == vobu_length to do expected_nav */ |
114 | 628 this->vobu.vobu_length = 0; |
127 | 629 this->vobu.blockN = 0; |
114 | 630 |
631 /* update the spu palette at least on PGC changes */ | |
632 this->spu_clut_changed = 1; | |
633 this->position_current.spu_channel = -1; /* Force an update */ | |
634 this->position_current.audio_channel = -1; /* Force an update */ | |
635 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
636 pthread_mutex_unlock(&this->vm_lock); |
193 | 637 return DVDNAV_STATUS_OK; |
0 | 638 } |
639 | |
114 | 640 /* has the CLUT changed? */ |
641 if(this->spu_clut_changed) { | |
642 (*event) = DVDNAV_SPU_CLUT_CHANGE; | |
643 #ifdef LOG_DEBUG | |
644 fprintf(MSG_OUT, "libdvdnav: SPU_CLUT_CHANGE\n"); | |
645 #endif | |
646 (*len) = 16 * sizeof(uint32_t); | |
647 memcpy(*buf, &(state->pgc->palette), 16 * sizeof(uint32_t)); | |
648 this->spu_clut_changed = 0; | |
649 pthread_mutex_unlock(&this->vm_lock); | |
193 | 650 return DVDNAV_STATUS_OK; |
114 | 651 } |
652 | |
653 /* has the SPU channel changed? */ | |
654 if(this->position_current.spu_channel != this->position_next.spu_channel) { | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
655 dvdnav_spu_stream_change_event_t *stream_change = (dvdnav_spu_stream_change_event_t *)*buf; |
114 | 656 |
657 (*event) = DVDNAV_SPU_STREAM_CHANGE; | |
658 #ifdef LOG_DEBUG | |
659 fprintf(MSG_OUT, "libdvdnav: SPU_STREAM_CHANGE\n"); | |
660 #endif | |
661 (*len) = sizeof(dvdnav_spu_stream_change_event_t); | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
662 stream_change->physical_wide = vm_get_subp_active_stream(this->vm, 0); |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
663 stream_change->physical_letterbox = vm_get_subp_active_stream(this->vm, 1); |
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
664 stream_change->physical_pan_scan = vm_get_subp_active_stream(this->vm, 2); |
114 | 665 this->position_current.spu_channel = this->position_next.spu_channel; |
666 #ifdef LOG_DEBUG | |
143
0b302ca31859
merge James fixes from xine-lib cvs back into libdvdnav cvs so they will not be lost
mroi
parents:
142
diff
changeset
|
667 fprintf(MSG_OUT, "libdvdnav: SPU_STREAM_CHANGE stream_id_wide=%d\n",stream_change->physical_wide); |
0b302ca31859
merge James fixes from xine-lib cvs back into libdvdnav cvs so they will not be lost
mroi
parents:
142
diff
changeset
|
668 fprintf(MSG_OUT, "libdvdnav: SPU_STREAM_CHANGE stream_id_letterbox=%d\n",stream_change->physical_letterbox); |
0b302ca31859
merge James fixes from xine-lib cvs back into libdvdnav cvs so they will not be lost
mroi
parents:
142
diff
changeset
|
669 fprintf(MSG_OUT, "libdvdnav: SPU_STREAM_CHANGE stream_id_pan_scan=%d\n",stream_change->physical_pan_scan); |
249
5d643668f1e3
I added this code myself a long time ago, but now I am quite convinced that
mroi
parents:
231
diff
changeset
|
670 fprintf(MSG_OUT, "libdvdnav: SPU_STREAM_CHANGE returning DVDNAV_STATUS_OK\n"); |
114 | 671 #endif |
249
5d643668f1e3
I added this code myself a long time ago, but now I am quite convinced that
mroi
parents:
231
diff
changeset
|
672 pthread_mutex_unlock(&this->vm_lock); |
5d643668f1e3
I added this code myself a long time ago, but now I am quite convinced that
mroi
parents:
231
diff
changeset
|
673 return DVDNAV_STATUS_OK; |
114 | 674 } |
0 | 675 |
114 | 676 /* has the audio channel changed? */ |
677 if(this->position_current.audio_channel != this->position_next.audio_channel) { | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
678 dvdnav_audio_stream_change_event_t *stream_change = (dvdnav_audio_stream_change_event_t *)*buf; |
114 | 679 |
680 (*event) = DVDNAV_AUDIO_STREAM_CHANGE; | |
681 #ifdef LOG_DEBUG | |
682 fprintf(MSG_OUT, "libdvdnav: AUDIO_STREAM_CHANGE\n"); | |
683 #endif | |
684 (*len) = sizeof(dvdnav_audio_stream_change_event_t); | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
685 stream_change->physical = vm_get_audio_active_stream( this->vm ); |
114 | 686 this->position_current.audio_channel = this->position_next.audio_channel; |
687 #ifdef LOG_DEBUG | |
193 | 688 fprintf(MSG_OUT, "libdvdnav: AUDIO_STREAM_CHANGE stream_id=%d returning DVDNAV_STATUS_OK\n",stream_change->physical); |
114 | 689 #endif |
690 pthread_mutex_unlock(&this->vm_lock); | |
193 | 691 return DVDNAV_STATUS_OK; |
114 | 692 } |
693 | |
694 /* Check the STILLFRAME flag */ | |
695 if(this->position_current.still != 0) { | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
696 dvdnav_still_event_t *still_event = (dvdnav_still_event_t *)*buf; |
114 | 697 |
698 (*event) = DVDNAV_STILL_FRAME; | |
699 #ifdef LOG_DEBUG | |
700 fprintf(MSG_OUT, "libdvdnav: STILL_FRAME\n"); | |
701 #endif | |
702 (*len) = sizeof(dvdnav_still_event_t); | |
134
d9d75a22a061
- new event on cell changes to report program and cell number and some time info
mroi
parents:
127
diff
changeset
|
703 still_event->length = this->position_current.still; |
114 | 704 pthread_mutex_unlock(&this->vm_lock); |
194 | 705 return DVDNAV_STATUS_OK; |
114 | 706 } |
707 | |
708 /* Have we reached the end of a VOBU? */ | |
709 if (this->vobu.blockN >= this->vobu.vobu_length) { | |
710 | |
711 /* Have we reached the end of a cell? */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
712 if(this->vobu.vobu_next == SRI_END_OF_CELL) { |
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
713 /* End of Cell from NAV DSI info */ |
31 | 714 #ifdef LOG_DEBUG |
76 | 715 fprintf(MSG_OUT, "libdvdnav: Still set to %x\n", this->position_next.still); |
31 | 716 #endif |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
717 this->position_current.still = this->position_next.still; |
0 | 718 |
116 | 719 /* we are about to leave a cell, so a lot of state changes could occur; |
720 * under certain conditions, the application should get in sync with us before this, | |
721 * otherwise it might show stills or menus too shortly */ | |
722 if ((this->position_current.still || this->pci.hli.hl_gi.hli_ss) && !this->sync_wait_skip) { | |
723 this->sync_wait = 1; | |
724 } else { | |
725 if( this->position_current.still == 0 || this->skip_still ) { | |
726 /* no active cell still -> get us to the next cell */ | |
727 vm_get_next_cell(this->vm); | |
728 this->position_current.still = 0; /* still gets activated at end of cell */ | |
729 this->skip_still = 0; | |
730 this->sync_wait_skip = 0; | |
731 } | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
732 } |
114 | 733 /* handle related state changes in next iteration */ |
734 (*event) = DVDNAV_NOP; | |
735 (*len) = 0; | |
736 pthread_mutex_unlock(&this->vm_lock); | |
193 | 737 return DVDNAV_STATUS_OK; |
114 | 738 } |
0 | 739 |
114 | 740 /* Perform remapping jump if necessary (this is always a |
0 | 741 * VOBU boundary). */ |
114 | 742 if (this->vm->map) { |
743 this->vobu.vobu_next = remap_block( this->vm->map, | |
744 this->vm->state.domain, this->vm->state.TTN_REG, | |
745 this->vm->state.pgN, | |
746 this->vobu.vobu_start, this->vobu.vobu_next); | |
747 } | |
0 | 748 |
114 | 749 /* at the start of the next VOBU -> expecting NAV packet */ |
45 | 750 result = dvdnav_read_cache_block(this->cache, this->vobu.vobu_start + this->vobu.vobu_next, 1, buf); |
0 | 751 |
752 if(result <= 0) { | |
753 printerr("Error reading NAV packet."); | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
754 pthread_mutex_unlock(&this->vm_lock); |
193 | 755 return DVDNAV_STATUS_ERR; |
0 | 756 } |
114 | 757 /* Decode nav into pci and dsi. Then get next VOBU info. */ |
758 if(!dvdnav_decode_packet(this, *buf, &this->dsi, &this->pci)) { | |
0 | 759 printerr("Expected NAV packet but none found."); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
760 pthread_mutex_unlock(&this->vm_lock); |
193 | 761 return DVDNAV_STATUS_ERR; |
0 | 762 } |
114 | 763 /* We need to update the vm state->blockN with which VOBU we are in. |
764 * This is so RSM resumes to the VOBU level and not just the CELL level. | |
28 | 765 */ |
114 | 766 this->vm->state.blockN = this->vobu.vobu_start - this->position_current.cell_start; |
767 | |
768 dvdnav_get_vobu(this, &this->dsi, &this->pci, &this->vobu); | |
769 this->vobu.blockN = 0; | |
770 /* Give the cache a hint about the size of next VOBU. | |
771 * This improves pre-caching, because the VOBU will almost certainly be read entirely. | |
45 | 772 */ |
773 dvdnav_pre_cache_blocks(this->cache, this->vobu.vobu_start+1, this->vobu.vobu_length+1); | |
0 | 774 |
191
dbea22936623
when a command has been issued to leave a menu, filter all further commands
mroi
parents:
179
diff
changeset
|
775 /* release NAV menu filter, when we reach the same NAV packet again */ |
dbea22936623
when a command has been issued to leave a menu, filter all further commands
mroi
parents:
179
diff
changeset
|
776 if (this->last_cmd_nav_lbn == this->pci.pci_gi.nv_pck_lbn) |
198
373f27da196b
This one should also be reset to an invalid value, but 0 is not invalid.
mroi
parents:
197
diff
changeset
|
777 this->last_cmd_nav_lbn = SRI_END_OF_CELL; |
191
dbea22936623
when a command has been issued to leave a menu, filter all further commands
mroi
parents:
179
diff
changeset
|
778 |
0 | 779 /* Successfully got a NAV packet */ |
780 (*event) = DVDNAV_NAV_PACKET; | |
114 | 781 #ifdef LOG_DEBUG |
782 fprintf(MSG_OUT, "libdvdnav: NAV_PACKET\n"); | |
783 #endif | |
3
328eadb3f37e
Added initial example programs directory and make sure all debug/error output goes to stderr.
richwareham
parents:
0
diff
changeset
|
784 (*len) = 2048; |
269
77e472cef5f8
implemented dvdnav_get_current_time() with obvious meaning
nicodvb
parents:
266
diff
changeset
|
785 this->cur_cell_time = dvdnav_convert_time(&this->dsi.dsi_gi.c_eltm); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
786 pthread_mutex_unlock(&this->vm_lock); |
193 | 787 return DVDNAV_STATUS_OK; |
0 | 788 } |
789 | |
790 /* If we've got here, it must just be a normal block. */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
791 if(!this->file) { |
114 | 792 printerr("Attempting to read without opening file."); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
793 pthread_mutex_unlock(&this->vm_lock); |
193 | 794 return DVDNAV_STATUS_ERR; |
0 | 795 } |
796 | |
114 | 797 this->vobu.blockN++; |
34
1f29402ef2ef
'Objectified' the read-ahead cache in preparation to implement a 'proper' threaded cache a-la that recommended in the DVD Demystified book.
richwareham
parents:
33
diff
changeset
|
798 result = dvdnav_read_cache_block(this->cache, this->vobu.vobu_start + this->vobu.blockN, 1, buf); |
0 | 799 if(result <= 0) { |
800 printerr("Error reading from DVD."); | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
801 pthread_mutex_unlock(&this->vm_lock); |
193 | 802 return DVDNAV_STATUS_ERR; |
0 | 803 } |
114 | 804 (*event) = DVDNAV_BLOCK_OK; |
0 | 805 (*len) = 2048; |
806 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
807 pthread_mutex_unlock(&this->vm_lock); |
193 | 808 return DVDNAV_STATUS_OK; |
0 | 809 } |
810 | |
114 | 811 dvdnav_status_t dvdnav_get_title_string(dvdnav_t *this, const char **title_str) { |
812 (*title_str) = this->vm->dvd_name; | |
193 | 813 return DVDNAV_STATUS_OK; |
114 | 814 } |
815 | |
816 uint8_t dvdnav_get_video_aspect(dvdnav_t *this) { | |
817 uint8_t retval; | |
273
bd734ab914d0
removed nonsensical checks on the sanity of dvdnav_t *this
nicodvb
parents:
272
diff
changeset
|
818 |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
819 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
820 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
821 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
822 } |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
823 |
114 | 824 pthread_mutex_lock(&this->vm_lock); |
825 retval = (uint8_t)vm_get_video_aspect(this->vm); | |
826 pthread_mutex_unlock(&this->vm_lock); | |
827 | |
828 return retval; | |
829 } | |
830 | |
831 uint8_t dvdnav_get_video_scale_permission(dvdnav_t *this) { | |
832 uint8_t retval; | |
833 | |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
834 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
835 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
836 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
837 } |
114 | 838 |
839 pthread_mutex_lock(&this->vm_lock); | |
840 retval = (uint8_t)vm_get_video_scale_permission(this->vm); | |
841 pthread_mutex_unlock(&this->vm_lock); | |
842 | |
843 return retval; | |
844 } | |
845 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
846 uint16_t dvdnav_audio_stream_to_lang(dvdnav_t *this, uint8_t stream) { |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
847 audio_attr_t attr; |
0 | 848 |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
849 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
850 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
851 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
852 } |
0 | 853 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
854 pthread_mutex_lock(&this->vm_lock); |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
855 attr = vm_get_audio_attr(this->vm, stream); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
856 pthread_mutex_unlock(&this->vm_lock); |
0 | 857 |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
858 if(attr.lang_type != 1) |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
859 return 0xffff; |
0 | 860 |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
861 return attr.lang_code; |
0 | 862 } |
863 | |
266 | 864 uint16_t dvdnav_audio_stream_format(dvdnav_t *this, uint8_t stream) { |
865 audio_attr_t attr; | |
866 uint16_t format; | |
867 | |
868 if(!this->started) { | |
869 printerr("Virtual DVD machine not started."); | |
870 return -1; /* 0xffff */ | |
871 } | |
872 | |
873 pthread_mutex_lock(&this->vm_lock); | |
874 attr = vm_get_audio_attr(this->vm, stream); | |
875 pthread_mutex_unlock(&this->vm_lock); | |
876 | |
877 switch(attr.audio_format) { | |
878 case 0: | |
879 format = DVDNAV_FORMAT_AC3; | |
880 break; | |
881 case 2: /* MPEG-1 or MPEG-2 without extension bitstream. */ | |
882 case 3: /* MPEG-2 with extension bitstream. */ | |
883 format = DVDNAV_FORMAT_MPEGAUDIO; | |
884 break; | |
885 case 4: | |
886 format = DVDNAV_FORMAT_LPCM; | |
887 break; | |
888 case 6: | |
889 format = DVDNAV_FORMAT_DTS; | |
890 break; | |
891 case 7: | |
892 format = DVDNAV_FORMAT_SDDS; | |
893 break; | |
894 default: | |
895 format = 0xffff; | |
896 break; | |
897 } | |
898 | |
899 return format; | |
900 } | |
901 | |
272
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
902 uint16_t dvdnav_audio_stream_channels(dvdnav_t *this, uint8_t stream) { |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
903 audio_attr_t attr; |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
904 |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
905 if(!this->started) { |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
906 printerr("Virtual DVD machine not started."); |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
907 return -1; /* 0xffff */ |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
908 } |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
909 |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
910 pthread_mutex_lock(&this->vm_lock); |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
911 attr = vm_get_audio_attr(this->vm, stream); |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
912 pthread_mutex_unlock(&this->vm_lock); |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
913 |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
914 return attr.channels + 1; |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
915 } |
baec6f29fb76
added dvdnav_audio_stream_channels(); patch by Andreas Oman (andreas olebyn nu)
nicodvb
parents:
269
diff
changeset
|
916 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
917 uint16_t dvdnav_spu_stream_to_lang(dvdnav_t *this, uint8_t stream) { |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
918 subp_attr_t attr; |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
919 |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
920 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
921 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
922 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
923 } |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
924 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
925 pthread_mutex_lock(&this->vm_lock); |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
926 attr = vm_get_subp_attr(this->vm, stream); |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
927 pthread_mutex_unlock(&this->vm_lock); |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
928 |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
929 if(attr.type != 1) |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
930 return 0xffff; |
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
931 |
25
df024077cbc1
Why rewrite vm function, use it instead (this remark is for me, of course ;-) ).
f1rmb
parents:
24
diff
changeset
|
932 return attr.lang_code; |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
933 } |
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
934 |
114 | 935 int8_t dvdnav_get_audio_logical_stream(dvdnav_t *this, uint8_t audio_num) { |
936 int8_t retval; | |
937 | |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
938 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
939 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
940 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
941 } |
114 | 942 |
943 pthread_mutex_lock(&this->vm_lock); | |
944 if (!this->vm->state.pgc) { | |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
945 printerr("No current PGC."); |
114 | 946 pthread_mutex_unlock(&this->vm_lock); |
947 return -1; | |
948 } | |
949 retval = vm_get_audio_stream(this->vm, audio_num); | |
950 pthread_mutex_unlock(&this->vm_lock); | |
951 | |
952 return retval; | |
953 } | |
954 | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
955 int8_t dvdnav_get_spu_logical_stream(dvdnav_t *this, uint8_t subp_num) { |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
956 int8_t retval; |
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
957 |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
958 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
959 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
960 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
961 } |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
962 |
114 | 963 pthread_mutex_lock(&this->vm_lock); |
964 if (!this->vm->state.pgc) { | |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
965 printerr("No current PGC."); |
114 | 966 pthread_mutex_unlock(&this->vm_lock); |
967 return -1; | |
968 } | |
969 retval = vm_get_subp_stream(this->vm, subp_num, 0); | |
970 pthread_mutex_unlock(&this->vm_lock); | |
971 | |
972 return retval; | |
973 } | |
974 | |
975 int8_t dvdnav_get_active_audio_stream(dvdnav_t *this) { | |
976 int8_t retval; | |
977 | |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
978 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
979 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
980 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
981 } |
114 | 982 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
983 pthread_mutex_lock(&this->vm_lock); |
114 | 984 if (!this->vm->state.pgc) { |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
985 printerr("No current PGC."); |
114 | 986 pthread_mutex_unlock(&this->vm_lock); |
987 return -1; | |
988 } | |
989 retval = vm_get_audio_active_stream(this->vm); | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
990 pthread_mutex_unlock(&this->vm_lock); |
114 | 991 |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
992 return retval; |
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
993 } |
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
994 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
995 int8_t dvdnav_get_active_spu_stream(dvdnav_t *this) { |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
996 int8_t retval; |
0 | 997 |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
998 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
999 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
1000 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
1001 } |
0 | 1002 |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
1003 pthread_mutex_lock(&this->vm_lock); |
114 | 1004 if (!this->vm->state.pgc) { |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
1005 printerr("No current PGC."); |
114 | 1006 pthread_mutex_unlock(&this->vm_lock); |
1007 return -1; | |
1008 } | |
1009 retval = vm_get_subp_active_stream(this->vm, 0); | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
1010 pthread_mutex_unlock(&this->vm_lock); |
0 | 1011 |
21
d2d73f2ad8d3
Change/fix SPU active stream id. Same for audio. Few new functions, largely
f1rmb
parents:
17
diff
changeset
|
1012 return retval; |
0 | 1013 } |
1014 | |
114 | 1015 static int8_t dvdnav_is_domain(dvdnav_t *this, domain_t domain) { |
1016 int8_t retval; | |
1017 | |
142
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
1018 if(!this->started) { |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
1019 printerr("Virtual DVD machine not started."); |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
1020 return -1; |
e375b765ebf5
some more sanity checking will prevent segfaults in these functions
mroi
parents:
141
diff
changeset
|
1021 } |
114 | 1022 |
1023 pthread_mutex_lock(&this->vm_lock); | |
1024 retval = (this->vm->state.domain == domain); | |
1025 pthread_mutex_unlock(&this->vm_lock); | |
1026 | |
1027 return retval; | |
1028 } | |
1029 | |
0 | 1030 /* First Play domain. (Menu) */ |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
1031 int8_t dvdnav_is_domain_fp(dvdnav_t *this) { |
114 | 1032 return dvdnav_is_domain(this, FP_DOMAIN); |
0 | 1033 } |
1034 /* Video management Menu domain. (Menu) */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
1035 int8_t dvdnav_is_domain_vmgm(dvdnav_t *this) { |
114 | 1036 return dvdnav_is_domain(this, VMGM_DOMAIN); |
0 | 1037 } |
1038 /* Video Title Menu domain (Menu) */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
1039 int8_t dvdnav_is_domain_vtsm(dvdnav_t *this) { |
114 | 1040 return dvdnav_is_domain(this, VTSM_DOMAIN); |
0 | 1041 } |
1042 /* Video Title domain (playing movie). */ | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
1043 int8_t dvdnav_is_domain_vts(dvdnav_t *this) { |
114 | 1044 return dvdnav_is_domain(this, VTS_DOMAIN); |
0 | 1045 } |
1046 | |
114 | 1047 /* Generally delegate angle information handling to VM */ |
195 | 1048 dvdnav_status_t dvdnav_angle_change(dvdnav_t *this, int32_t angle) { |
1049 int32_t num, current; | |
0 | 1050 |
114 | 1051 pthread_mutex_lock(&this->vm_lock); |
1052 vm_get_angle_info(this->vm, ¤t, &num); | |
0 | 1053 /* Set angle SPRM if valid */ |
1054 if((angle > 0) && (angle <= num)) { | |
22
3c1df0cb3aee
Start of rewrite of libdvdnav. Still need to re-implement seeking.
jcdutton
parents:
21
diff
changeset
|
1055 this->vm->state.AGL_REG = angle; |
0 | 1056 } else { |
114 | 1057 printerr("Passed an invalid angle number."); |
1058 pthread_mutex_unlock(&this->vm_lock); | |
193 | 1059 return DVDNAV_STATUS_ERR; |
0 | 1060 } |
114 | 1061 pthread_mutex_unlock(&this->vm_lock); |
0 | 1062 |
193 | 1063 return DVDNAV_STATUS_OK; |
0 | 1064 } |
1065 | |
195 | 1066 dvdnav_status_t dvdnav_get_angle_info(dvdnav_t *this, int32_t *current_angle, |
1067 int32_t *number_of_angles) { | |
114 | 1068 pthread_mutex_lock(&this->vm_lock); |
1069 vm_get_angle_info(this->vm, current_angle, number_of_angles); | |
1070 pthread_mutex_unlock(&this->vm_lock); | |
1071 | |
193 | 1072 return DVDNAV_STATUS_OK; |
114 | 1073 } |
0 | 1074 |
67
61c0ee1bbb7a
Moved get_current_nav_pci into dvdnac.c, changed example to use it instead of 'home-rolled'
richwareham
parents:
66
diff
changeset
|
1075 pci_t* dvdnav_get_current_nav_pci(dvdnav_t *this) { |
114 | 1076 if(!this) return 0; |
67
61c0ee1bbb7a
Moved get_current_nav_pci into dvdnac.c, changed example to use it instead of 'home-rolled'
richwareham
parents:
66
diff
changeset
|
1077 return &this->pci; |
61c0ee1bbb7a
Moved get_current_nav_pci into dvdnac.c, changed example to use it instead of 'home-rolled'
richwareham
parents:
66
diff
changeset
|
1078 } |
61c0ee1bbb7a
Moved get_current_nav_pci into dvdnac.c, changed example to use it instead of 'home-rolled'
richwareham
parents:
66
diff
changeset
|
1079 |
66
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1080 dsi_t* dvdnav_get_current_nav_dsi(dvdnav_t *this) { |
114 | 1081 if(!this) return 0; |
66
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1082 return &this->dsi; |
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1083 } |
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1084 |
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1085 uint32_t dvdnav_get_next_still_flag(dvdnav_t *this) { |
114 | 1086 if(!this) return -1; |
66
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1087 return this->position_next.still; |
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1088 } |
2bd4a78eefce
Patch from aschultz@cs.uni-magdeburg.de to allow for still-frame 'peek-ahead'
richwareham
parents:
60
diff
changeset
|
1089 |
262 | 1090 user_ops_t dvdnav_get_restrictions(dvdnav_t* this) { |
1091 /* | |
1092 * user_ops_t is a structure of 32 bits. We want to compute | |
1093 * the union of two of those bitfields so to make this quicker | |
1094 * than performing 32 ORs, we will access them as 32bits words. | |
1095 */ | |
264 | 1096 union { |
1097 user_ops_t ops_struct; | |
1098 uint32_t ops_int; | |
1099 } ops; | |
1100 | |
1101 ops.ops_int = 0; | |
262 | 1102 |
263 | 1103 if(!this->started) { |
1104 printerr("Virtual DVD machine not started."); | |
264 | 1105 return ops.ops_struct; |
263 | 1106 } |
1107 | |
1108 pthread_mutex_lock(&this->vm_lock); | |
264 | 1109 ops.ops_int |= *(uint32_t*)&this->pci.pci_gi.vobu_uop_ctl; |
262 | 1110 |
1111 if(this->vm && this->vm->state.pgc) | |
264 | 1112 ops.ops_int |= *(uint32_t*)&this->vm->state.pgc->prohibited_ops; |
263 | 1113 pthread_mutex_unlock(&this->vm_lock); |
262 | 1114 |
264 | 1115 return ops.ops_struct; |
262 | 1116 } |