Mercurial > libdvdnav.hg
annotate dvd_udf.c @ 219:f4c5d4d3c831 src
Get libdvdnav to compile with libtool 1.4.3
We can put this back in when libtool is fixed.
author | jcdutton |
---|---|
date | Wed, 31 Dec 2003 21:38:49 +0000 |
parents | 6b67914ae021 |
children |
rev | line source |
---|---|
168 | 1 /* |
2 * This code is based on dvdudf by: | |
3 * Christian Wolff <scarabaeus@convergence.de>. | |
4 * | |
5 * Modifications by: | |
6 * Billy Biggs <vektor@dumbterm.net>. | |
7 * Björn Englund <d4bjorn@dtek.chalmers.se>. | |
8 * | |
9 * dvdudf: parse and read the UDF volume information of a DVD Video | |
10 * Copyright (C) 1999 Christian Wolff for convergence integrated media | |
11 * GmbH The author can be reached at scarabaeus@convergence.de, the | |
12 * project's page is at http://linuxtv.org/dvd/ | |
13 * | |
14 * This program is free software; you can redistribute it and/or modify | |
15 * it under the terms of the GNU General Public License as published by | |
16 * the Free Software Foundation; either version 2 of the License, or (at | |
17 * your option) any later version. | |
18 * | |
19 * This program is distributed in the hope that it will be useful, but | |
20 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
22 * General Public License for more details. | |
23 * | |
24 * You should have received a copy of the GNU General Public License | |
25 * along with this program; if not, write to the Free Software | |
26 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | |
27 * 02111-1307, USA. Or, point your browser to | |
28 * http://www.gnu.org/copyleft/gpl.html | |
29 */ | |
30 | |
31 #include "config.h" | |
32 | |
33 #include <stdio.h> | |
34 #include <stdlib.h> | |
35 #include <string.h> | |
176 | 36 |
37 #ifndef _MSC_VER | |
168 | 38 #include <sys/ioctl.h> |
176 | 39 #endif /* _MSC_VER */ |
40 | |
168 | 41 #include <sys/types.h> |
42 #include <sys/stat.h> | |
43 #include <unistd.h> | |
44 #include <inttypes.h> | |
45 | |
46 #include "dvd_reader.h" | |
47 #include "dvd_udf.h" | |
48 | |
49 /* Private but located in/shared with dvd_reader.c */ | |
50 extern int UDFReadBlocksRaw( dvd_reader_t *device, uint32_t lb_number, | |
51 size_t block_count, unsigned char *data, | |
52 int encrypted ); | |
53 | |
54 /* It's required to either fail or deliver all the blocks asked for. */ | |
55 static int DVDReadLBUDF( dvd_reader_t *device, uint32_t lb_number, | |
56 size_t block_count, unsigned char *data, | |
57 int encrypted ) | |
58 { | |
59 int ret; | |
60 size_t count = block_count; | |
61 | |
62 while(count > 0) { | |
63 | |
64 ret = UDFReadBlocksRaw(device, lb_number, count, data, encrypted); | |
65 | |
66 if(ret <= 0) { | |
67 /* One of the reads failed or nothing more to read, too bad. | |
68 * We won't even bother returning the reads that went ok. */ | |
69 return ret; | |
70 } | |
71 | |
72 count -= (size_t)ret; | |
73 lb_number += (uint32_t)ret; | |
74 } | |
75 | |
76 return block_count; | |
77 } | |
78 | |
79 | |
80 #ifndef NULL | |
81 #define NULL ((void *)0) | |
82 #endif | |
83 | |
84 struct Partition { | |
85 int valid; | |
86 char VolumeDesc[128]; | |
87 uint16_t Flags; | |
88 uint16_t Number; | |
89 char Contents[32]; | |
90 uint32_t AccessType; | |
91 uint32_t Start; | |
92 uint32_t Length; | |
93 }; | |
94 | |
95 struct AD { | |
96 uint32_t Location; | |
97 uint32_t Length; | |
98 uint8_t Flags; | |
99 uint16_t Partition; | |
100 }; | |
101 | |
102 struct extent_ad { | |
103 uint32_t location; | |
104 uint32_t length; | |
105 }; | |
106 | |
107 struct avdp_t { | |
108 struct extent_ad mvds; | |
109 struct extent_ad rvds; | |
110 }; | |
111 | |
112 struct pvd_t { | |
113 uint8_t VolumeIdentifier[32]; | |
114 uint8_t VolumeSetIdentifier[128]; | |
115 }; | |
116 | |
117 struct lbudf { | |
118 uint32_t lb; | |
119 uint8_t *data; | |
120 }; | |
121 | |
122 struct icbmap { | |
123 uint32_t lbn; | |
124 struct AD file; | |
125 uint8_t filetype; | |
126 }; | |
127 | |
128 struct udf_cache { | |
129 int avdp_valid; | |
130 struct avdp_t avdp; | |
131 int pvd_valid; | |
132 struct pvd_t pvd; | |
133 int partition_valid; | |
134 struct Partition partition; | |
135 int rooticb_valid; | |
136 struct AD rooticb; | |
137 int lb_num; | |
138 struct lbudf *lbs; | |
139 int map_num; | |
140 struct icbmap *maps; | |
141 }; | |
142 | |
143 typedef enum { | |
144 PartitionCache, RootICBCache, LBUDFCache, MapCache, AVDPCache, PVDCache | |
145 } UDFCacheType; | |
146 | |
147 void FreeUDFCache(void *cache) | |
148 { | |
149 struct udf_cache *c = (struct udf_cache *)cache; | |
150 if(c == NULL) { | |
151 return; | |
152 } | |
153 if(c->lbs) { | |
154 free(c->lbs); | |
155 } | |
156 if(c->maps) { | |
157 free(c->maps); | |
158 } | |
159 free(c); | |
160 } | |
161 | |
162 | |
163 static int GetUDFCache(dvd_reader_t *device, UDFCacheType type, | |
164 uint32_t nr, void *data) | |
165 { | |
166 int n; | |
167 struct udf_cache *c; | |
168 | |
169 if(DVDUDFCacheLevel(device, -1) <= 0) { | |
170 return 0; | |
171 } | |
172 | |
173 c = (struct udf_cache *)GetUDFCacheHandle(device); | |
174 | |
175 if(c == NULL) { | |
176 return 0; | |
177 } | |
178 | |
179 switch(type) { | |
180 case AVDPCache: | |
181 if(c->avdp_valid) { | |
182 *(struct avdp_t *)data = c->avdp; | |
183 return 1; | |
184 } | |
185 break; | |
186 case PVDCache: | |
187 if(c->pvd_valid) { | |
188 *(struct pvd_t *)data = c->pvd; | |
189 return 1; | |
190 } | |
191 break; | |
192 case PartitionCache: | |
193 if(c->partition_valid) { | |
194 *(struct Partition *)data = c->partition; | |
195 return 1; | |
196 } | |
197 break; | |
198 case RootICBCache: | |
199 if(c->rooticb_valid) { | |
200 *(struct AD *)data = c->rooticb; | |
201 return 1; | |
202 } | |
203 break; | |
204 case LBUDFCache: | |
205 for(n = 0; n < c->lb_num; n++) { | |
206 if(c->lbs[n].lb == nr) { | |
207 *(uint8_t **)data = c->lbs[n].data; | |
208 return 1; | |
209 } | |
210 } | |
211 break; | |
212 case MapCache: | |
213 for(n = 0; n < c->map_num; n++) { | |
214 if(c->maps[n].lbn == nr) { | |
215 *(struct icbmap *)data = c->maps[n]; | |
216 return 1; | |
217 } | |
218 } | |
219 break; | |
220 default: | |
221 break; | |
222 } | |
223 | |
224 return 0; | |
225 } | |
226 | |
227 static int SetUDFCache(dvd_reader_t *device, UDFCacheType type, | |
228 uint32_t nr, void *data) | |
229 { | |
230 int n; | |
231 struct udf_cache *c; | |
232 | |
233 if(DVDUDFCacheLevel(device, -1) <= 0) { | |
234 return 0; | |
235 } | |
236 | |
237 c = (struct udf_cache *)GetUDFCacheHandle(device); | |
238 | |
239 if(c == NULL) { | |
240 c = calloc(1, sizeof(struct udf_cache)); | |
183 | 241 /* fprintf(stderr, "calloc: %d\n", sizeof(struct udf_cache)); */ |
168 | 242 if(c == NULL) { |
243 return 0; | |
244 } | |
245 SetUDFCacheHandle(device, c); | |
246 } | |
247 | |
248 | |
249 switch(type) { | |
250 case AVDPCache: | |
251 c->avdp = *(struct avdp_t *)data; | |
252 c->avdp_valid = 1; | |
253 break; | |
254 case PVDCache: | |
255 c->pvd = *(struct pvd_t *)data; | |
256 c->pvd_valid = 1; | |
257 break; | |
258 case PartitionCache: | |
259 c->partition = *(struct Partition *)data; | |
260 c->partition_valid = 1; | |
261 break; | |
262 case RootICBCache: | |
263 c->rooticb = *(struct AD *)data; | |
264 c->rooticb_valid = 1; | |
265 break; | |
266 case LBUDFCache: | |
267 for(n = 0; n < c->lb_num; n++) { | |
268 if(c->lbs[n].lb == nr) { | |
269 /* replace with new data */ | |
270 c->lbs[n].data = *(uint8_t **)data; | |
271 c->lbs[n].lb = nr; | |
272 return 1; | |
273 } | |
274 } | |
275 c->lb_num++; | |
276 c->lbs = realloc(c->lbs, c->lb_num * sizeof(struct lbudf)); | |
277 /* | |
278 fprintf(stderr, "realloc lb: %d * %d = %d\n", | |
279 c->lb_num, sizeof(struct lbudf), | |
280 c->lb_num * sizeof(struct lbudf)); | |
281 */ | |
282 if(c->lbs == NULL) { | |
283 c->lb_num = 0; | |
284 return 0; | |
285 } | |
286 c->lbs[n].data = *(uint8_t **)data; | |
287 c->lbs[n].lb = nr; | |
288 break; | |
289 case MapCache: | |
290 for(n = 0; n < c->map_num; n++) { | |
291 if(c->maps[n].lbn == nr) { | |
292 /* replace with new data */ | |
293 c->maps[n] = *(struct icbmap *)data; | |
294 c->maps[n].lbn = nr; | |
295 return 1; | |
296 } | |
297 } | |
298 c->map_num++; | |
299 c->maps = realloc(c->maps, c->map_num * sizeof(struct icbmap)); | |
300 /* | |
301 fprintf(stderr, "realloc maps: %d * %d = %d\n", | |
302 c->map_num, sizeof(struct icbmap), | |
303 c->map_num * sizeof(struct icbmap)); | |
304 */ | |
305 if(c->maps == NULL) { | |
306 c->map_num = 0; | |
307 return 0; | |
308 } | |
309 c->maps[n] = *(struct icbmap *)data; | |
310 c->maps[n].lbn = nr; | |
311 break; | |
312 default: | |
313 return 0; | |
314 } | |
315 | |
316 return 1; | |
317 } | |
318 | |
319 | |
320 /* For direct data access, LSB first */ | |
321 #define GETN1(p) ((uint8_t)data[p]) | |
322 #define GETN2(p) ((uint16_t)data[p] | ((uint16_t)data[(p) + 1] << 8)) | |
323 #define GETN3(p) ((uint32_t)data[p] | ((uint32_t)data[(p) + 1] << 8) \ | |
324 | ((uint32_t)data[(p) + 2] << 16)) | |
325 #define GETN4(p) ((uint32_t)data[p] \ | |
326 | ((uint32_t)data[(p) + 1] << 8) \ | |
327 | ((uint32_t)data[(p) + 2] << 16) \ | |
328 | ((uint32_t)data[(p) + 3] << 24)) | |
329 /* This is wrong with regard to endianess */ | |
330 #define GETN(p, n, target) memcpy(target, &data[p], n) | |
331 | |
332 static int Unicodedecode( uint8_t *data, int len, char *target ) | |
333 { | |
334 int p = 1, i = 0; | |
335 | |
336 if( ( data[ 0 ] == 8 ) || ( data[ 0 ] == 16 ) ) do { | |
337 if( data[ 0 ] == 16 ) p++; /* Ignore MSB of unicode16 */ | |
338 if( p < len ) { | |
339 target[ i++ ] = data[ p++ ]; | |
340 } | |
341 } while( p < len ); | |
342 | |
343 target[ i ] = '\0'; | |
344 return 0; | |
345 } | |
346 | |
347 static int UDFDescriptor( uint8_t *data, uint16_t *TagID ) | |
348 { | |
349 *TagID = GETN2(0); | |
183 | 350 /* TODO: check CRC 'n stuff */ |
168 | 351 return 0; |
352 } | |
353 | |
354 static int UDFExtentAD( uint8_t *data, uint32_t *Length, uint32_t *Location ) | |
355 { | |
356 *Length = GETN4(0); | |
357 *Location = GETN4(4); | |
358 return 0; | |
359 } | |
360 | |
361 static int UDFShortAD( uint8_t *data, struct AD *ad, | |
362 struct Partition *partition ) | |
363 { | |
364 ad->Length = GETN4(0); | |
365 ad->Flags = ad->Length >> 30; | |
366 ad->Length &= 0x3FFFFFFF; | |
367 ad->Location = GETN4(4); | |
183 | 368 ad->Partition = partition->Number; /* use number of current partition */ |
168 | 369 return 0; |
370 } | |
371 | |
372 static int UDFLongAD( uint8_t *data, struct AD *ad ) | |
373 { | |
374 ad->Length = GETN4(0); | |
375 ad->Flags = ad->Length >> 30; | |
376 ad->Length &= 0x3FFFFFFF; | |
377 ad->Location = GETN4(4); | |
378 ad->Partition = GETN2(8); | |
183 | 379 /* GETN(10, 6, Use); */ |
168 | 380 return 0; |
381 } | |
382 | |
383 static int UDFExtAD( uint8_t *data, struct AD *ad ) | |
384 { | |
385 ad->Length = GETN4(0); | |
386 ad->Flags = ad->Length >> 30; | |
387 ad->Length &= 0x3FFFFFFF; | |
388 ad->Location = GETN4(12); | |
389 ad->Partition = GETN2(16); | |
183 | 390 /* GETN(10, 6, Use); */ |
168 | 391 return 0; |
392 } | |
393 | |
394 static int UDFICB( uint8_t *data, uint8_t *FileType, uint16_t *Flags ) | |
395 { | |
396 *FileType = GETN1(11); | |
397 *Flags = GETN2(18); | |
398 return 0; | |
399 } | |
400 | |
401 | |
402 static int UDFPartition( uint8_t *data, uint16_t *Flags, uint16_t *Number, | |
403 char *Contents, uint32_t *Start, uint32_t *Length ) | |
404 { | |
405 *Flags = GETN2(20); | |
406 *Number = GETN2(22); | |
407 GETN(24, 32, Contents); | |
408 *Start = GETN4(188); | |
409 *Length = GETN4(192); | |
410 return 0; | |
411 } | |
412 | |
413 /** | |
414 * Reads the volume descriptor and checks the parameters. Returns 0 on OK, 1 | |
415 * on error. | |
416 */ | |
417 static int UDFLogVolume( uint8_t *data, char *VolumeDescriptor ) | |
418 { | |
419 uint32_t lbsize, MT_L, N_PM; | |
420 Unicodedecode(&data[84], 128, VolumeDescriptor); | |
183 | 421 lbsize = GETN4(212); /* should be 2048 */ |
422 MT_L = GETN4(264); /* should be 6 */ | |
423 N_PM = GETN4(268); /* should be 1 */ | |
168 | 424 if (lbsize != DVD_VIDEO_LB_LEN) return 1; |
425 return 0; | |
426 } | |
427 | |
428 static int UDFFileEntry( uint8_t *data, uint8_t *FileType, | |
429 struct Partition *partition, struct AD *ad ) | |
430 { | |
431 uint16_t flags; | |
432 uint32_t L_EA, L_AD; | |
433 unsigned int p; | |
434 | |
435 UDFICB( &data[ 16 ], FileType, &flags ); | |
436 | |
437 /* Init ad for an empty file (i.e. there isn't a AD, L_AD == 0 ) */ | |
183 | 438 ad->Length = GETN4( 60 ); /* Really 8 bytes a 56 */ |
168 | 439 ad->Flags = 0; |
183 | 440 ad->Location = 0; /* what should we put here? */ |
441 ad->Partition = partition->Number; /* use number of current partition */ | |
168 | 442 |
443 L_EA = GETN4( 168 ); | |
444 L_AD = GETN4( 172 ); | |
445 p = 176 + L_EA; | |
446 while( p < 176 + L_EA + L_AD ) { | |
447 switch( flags & 0x0007 ) { | |
448 case 0: UDFShortAD( &data[ p ], ad, partition ); p += 8; break; | |
449 case 1: UDFLongAD( &data[ p ], ad ); p += 16; break; | |
450 case 2: UDFExtAD( &data[ p ], ad ); p += 20; break; | |
451 case 3: | |
452 switch( L_AD ) { | |
453 case 8: UDFShortAD( &data[ p ], ad, partition ); break; | |
454 case 16: UDFLongAD( &data[ p ], ad ); break; | |
455 case 20: UDFExtAD( &data[ p ], ad ); break; | |
456 } | |
457 p += L_AD; | |
458 break; | |
459 default: | |
460 p += L_AD; break; | |
461 } | |
462 } | |
463 return 0; | |
464 } | |
465 | |
466 static int UDFFileIdentifier( uint8_t *data, uint8_t *FileCharacteristics, | |
467 char *FileName, struct AD *FileICB ) | |
468 { | |
469 uint8_t L_FI; | |
470 uint16_t L_IU; | |
471 | |
472 *FileCharacteristics = GETN1(18); | |
473 L_FI = GETN1(19); | |
474 UDFLongAD(&data[20], FileICB); | |
475 L_IU = GETN2(36); | |
476 if (L_FI) Unicodedecode(&data[38 + L_IU], L_FI, FileName); | |
477 else FileName[0] = '\0'; | |
478 return 4 * ((38 + L_FI + L_IU + 3) / 4); | |
479 } | |
480 | |
481 /** | |
482 * Maps ICB to FileAD | |
483 * ICB: Location of ICB of directory to scan | |
484 * FileType: Type of the file | |
485 * File: Location of file the ICB is pointing to | |
486 * return 1 on success, 0 on error; | |
487 */ | |
488 static int UDFMapICB( dvd_reader_t *device, struct AD ICB, uint8_t *FileType, | |
489 struct Partition *partition, struct AD *File ) | |
490 { | |
183 | 491 uint8_t LogBlock_base[DVD_VIDEO_LB_LEN + 2048]; |
211
7eda95524e83
use uintptr_t for pointer arithmetics for AMD64 compatibility
mroi
parents:
183
diff
changeset
|
492 uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~2047) + 2048); |
168 | 493 uint32_t lbnum; |
494 uint16_t TagID; | |
495 struct icbmap tmpmap; | |
496 | |
497 lbnum = partition->Start + ICB.Location; | |
498 tmpmap.lbn = lbnum; | |
499 if(GetUDFCache(device, MapCache, lbnum, &tmpmap)) { | |
500 *FileType = tmpmap.filetype; | |
501 *File = tmpmap.file; | |
502 return 1; | |
503 } | |
504 | |
505 do { | |
506 if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 ) { | |
507 TagID = 0; | |
508 } else { | |
509 UDFDescriptor( LogBlock, &TagID ); | |
510 } | |
511 | |
512 if( TagID == 261 ) { | |
513 UDFFileEntry( LogBlock, FileType, partition, File ); | |
514 tmpmap.file = *File; | |
515 tmpmap.filetype = *FileType; | |
516 SetUDFCache(device, MapCache, tmpmap.lbn, &tmpmap); | |
517 return 1; | |
518 }; | |
519 } while( ( lbnum <= partition->Start + ICB.Location + ( ICB.Length - 1 ) | |
520 / DVD_VIDEO_LB_LEN ) && ( TagID != 261 ) ); | |
521 | |
522 return 0; | |
523 } | |
524 | |
525 /** | |
526 * Dir: Location of directory to scan | |
527 * FileName: Name of file to look for | |
528 * FileICB: Location of ICB of the found file | |
529 * return 1 on success, 0 on error; | |
530 */ | |
531 static int UDFScanDir( dvd_reader_t *device, struct AD Dir, char *FileName, | |
532 struct Partition *partition, struct AD *FileICB, | |
533 int cache_file_info) | |
534 { | |
535 char filename[ MAX_UDF_FILE_NAME_LEN ]; | |
183 | 536 uint8_t directory_base[ 2 * DVD_VIDEO_LB_LEN + 2048]; |
211
7eda95524e83
use uintptr_t for pointer arithmetics for AMD64 compatibility
mroi
parents:
183
diff
changeset
|
537 uint8_t *directory = (uint8_t *)(((uintptr_t)directory_base & ~2047) + 2048); |
168 | 538 uint32_t lbnum; |
539 uint16_t TagID; | |
540 uint8_t filechar; | |
541 unsigned int p; | |
183 | 542 uint8_t *cached_dir_base = NULL, *cached_dir; |
168 | 543 uint32_t dir_lba; |
544 struct AD tmpICB; | |
545 int found = 0; | |
546 int in_cache = 0; | |
547 | |
548 /* Scan dir for ICB of file */ | |
549 lbnum = partition->Start + Dir.Location; | |
550 | |
551 if(DVDUDFCacheLevel(device, -1) > 0) { | |
552 /* caching */ | |
553 | |
554 if(!GetUDFCache(device, LBUDFCache, lbnum, &cached_dir)) { | |
555 dir_lba = (Dir.Length + DVD_VIDEO_LB_LEN) / DVD_VIDEO_LB_LEN; | |
183 | 556 if((cached_dir_base = malloc(dir_lba * DVD_VIDEO_LB_LEN + 2048)) == NULL) { |
168 | 557 return 0; |
558 } | |
211
7eda95524e83
use uintptr_t for pointer arithmetics for AMD64 compatibility
mroi
parents:
183
diff
changeset
|
559 cached_dir = (uint8_t *)(((uintptr_t)cached_dir_base & ~2047) + 2048); |
168 | 560 if( DVDReadLBUDF( device, lbnum, dir_lba, cached_dir, 0) <= 0 ) { |
183 | 561 free(cached_dir_base); |
168 | 562 cached_dir = NULL; |
563 } | |
564 /* | |
565 if(cached_dir) { | |
566 fprintf(stderr, "malloc dir: %d\n", | |
567 dir_lba * DVD_VIDEO_LB_LEN); | |
568 } | |
569 */ | |
570 SetUDFCache(device, LBUDFCache, lbnum, &cached_dir); | |
571 } else { | |
572 in_cache = 1; | |
573 } | |
574 | |
575 if(cached_dir == NULL) { | |
576 return 0; | |
577 } | |
578 | |
579 p = 0; | |
580 | |
581 while( p < Dir.Length ) { | |
582 UDFDescriptor( &cached_dir[ p ], &TagID ); | |
583 if( TagID == 257 ) { | |
584 p += UDFFileIdentifier( &cached_dir[ p ], &filechar, | |
585 filename, &tmpICB ); | |
586 if(cache_file_info && !in_cache) { | |
587 uint8_t tmpFiletype; | |
588 struct AD tmpFile; | |
589 | |
590 if( !strcasecmp( FileName, filename ) ) { | |
591 *FileICB = tmpICB; | |
592 found = 1; | |
593 | |
594 } | |
595 UDFMapICB(device, tmpICB, &tmpFiletype, | |
596 partition, &tmpFile); | |
597 } else { | |
598 if( !strcasecmp( FileName, filename ) ) { | |
599 *FileICB = tmpICB; | |
600 return 1; | |
601 } | |
602 } | |
603 } else { | |
604 if(cache_file_info && (!in_cache) && found) { | |
605 return 1; | |
606 } | |
607 return 0; | |
608 } | |
609 } | |
610 if(cache_file_info && (!in_cache) && found) { | |
611 return 1; | |
612 } | |
613 return 0; | |
614 } | |
615 | |
616 if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 ) { | |
617 return 0; | |
618 } | |
619 | |
620 p = 0; | |
621 while( p < Dir.Length ) { | |
622 if( p > DVD_VIDEO_LB_LEN ) { | |
623 ++lbnum; | |
624 p -= DVD_VIDEO_LB_LEN; | |
625 Dir.Length -= DVD_VIDEO_LB_LEN; | |
626 if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 ) { | |
627 return 0; | |
628 } | |
629 } | |
630 UDFDescriptor( &directory[ p ], &TagID ); | |
631 if( TagID == 257 ) { | |
632 p += UDFFileIdentifier( &directory[ p ], &filechar, | |
633 filename, FileICB ); | |
634 if( !strcasecmp( FileName, filename ) ) { | |
635 return 1; | |
636 } | |
637 } else { | |
638 return 0; | |
639 } | |
640 } | |
641 | |
642 return 0; | |
643 } | |
644 | |
645 | |
646 static int UDFGetAVDP( dvd_reader_t *device, | |
647 struct avdp_t *avdp) | |
648 { | |
183 | 649 uint8_t Anchor_base[ DVD_VIDEO_LB_LEN + 2048 ]; |
211
7eda95524e83
use uintptr_t for pointer arithmetics for AMD64 compatibility
mroi
parents:
183
diff
changeset
|
650 uint8_t *Anchor = (uint8_t *)(((uintptr_t)Anchor_base & ~2047) + 2048); |
168 | 651 uint32_t lbnum, MVDS_location, MVDS_length; |
652 uint16_t TagID; | |
653 uint32_t lastsector; | |
654 int terminate; | |
655 struct avdp_t; | |
656 | |
657 if(GetUDFCache(device, AVDPCache, 0, avdp)) { | |
658 return 1; | |
659 } | |
660 | |
661 /* Find Anchor */ | |
662 lastsector = 0; | |
663 lbnum = 256; /* Try #1, prime anchor */ | |
664 terminate = 0; | |
665 | |
666 for(;;) { | |
667 if( DVDReadLBUDF( device, lbnum, 1, Anchor, 0 ) > 0 ) { | |
668 UDFDescriptor( Anchor, &TagID ); | |
669 } else { | |
670 TagID = 0; | |
671 } | |
672 if (TagID != 2) { | |
673 /* Not an anchor */ | |
674 if( terminate ) return 0; /* Final try failed */ | |
675 | |
676 if( lastsector ) { | |
677 | |
678 /* We already found the last sector. Try #3, alternative | |
679 * backup anchor. If that fails, don't try again. | |
680 */ | |
681 lbnum = lastsector; | |
682 terminate = 1; | |
683 } else { | |
684 /* TODO: Find last sector of the disc (this is optional). */ | |
685 if( lastsector ) { | |
686 /* Try #2, backup anchor */ | |
687 lbnum = lastsector - 256; | |
688 } else { | |
689 /* Unable to find last sector */ | |
690 return 0; | |
691 } | |
692 } | |
693 } else { | |
694 /* It's an anchor! We can leave */ | |
695 break; | |
696 } | |
697 } | |
698 /* Main volume descriptor */ | |
699 UDFExtentAD( &Anchor[ 16 ], &MVDS_length, &MVDS_location ); | |
700 avdp->mvds.location = MVDS_location; | |
701 avdp->mvds.length = MVDS_length; | |
702 | |
703 /* Backup volume descriptor */ | |
704 UDFExtentAD( &Anchor[ 24 ], &MVDS_length, &MVDS_location ); | |
705 avdp->rvds.location = MVDS_location; | |
706 avdp->rvds.length = MVDS_length; | |
707 | |
708 SetUDFCache(device, AVDPCache, 0, avdp); | |
709 | |
710 return 1; | |
711 } | |
712 | |
713 /** | |
714 * Looks for partition on the disc. Returns 1 if partition found, 0 on error. | |
715 * partnum: Number of the partition, starting at 0. | |
716 * part: structure to fill with the partition information | |
717 */ | |
718 static int UDFFindPartition( dvd_reader_t *device, int partnum, | |
719 struct Partition *part ) | |
720 { | |
183 | 721 uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ]; |
211
7eda95524e83
use uintptr_t for pointer arithmetics for AMD64 compatibility
mroi
parents:
183
diff
changeset
|
722 uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~2047) + 2048); |
168 | 723 uint32_t lbnum, MVDS_location, MVDS_length; |
724 uint16_t TagID; | |
725 int i, volvalid; | |
726 struct avdp_t avdp; | |
727 | |
728 | |
729 if(!UDFGetAVDP(device, &avdp)) { | |
730 return 0; | |
731 } | |
732 | |
733 /* Main volume descriptor */ | |
734 MVDS_location = avdp.mvds.location; | |
735 MVDS_length = avdp.mvds.length; | |
736 | |
737 part->valid = 0; | |
738 volvalid = 0; | |
739 part->VolumeDesc[ 0 ] = '\0'; | |
740 i = 1; | |
741 do { | |
742 /* Find Volume Descriptor */ | |
743 lbnum = MVDS_location; | |
744 do { | |
745 | |
746 if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 ) { | |
747 TagID = 0; | |
748 } else { | |
749 UDFDescriptor( LogBlock, &TagID ); | |
750 } | |
751 | |
752 if( ( TagID == 5 ) && ( !part->valid ) ) { | |
753 /* Partition Descriptor */ | |
754 UDFPartition( LogBlock, &part->Flags, &part->Number, | |
755 part->Contents, &part->Start, &part->Length ); | |
756 part->valid = ( partnum == part->Number ); | |
757 } else if( ( TagID == 6 ) && ( !volvalid ) ) { | |
758 /* Logical Volume Descriptor */ | |
759 if( UDFLogVolume( LogBlock, part->VolumeDesc ) ) { | |
760 /* TODO: sector size wrong! */ | |
761 } else { | |
762 volvalid = 1; | |
763 } | |
764 } | |
765 | |
766 } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 ) | |
767 / DVD_VIDEO_LB_LEN ) && ( TagID != 8 ) | |
768 && ( ( !part->valid ) || ( !volvalid ) ) ); | |
769 | |
770 if( ( !part->valid) || ( !volvalid ) ) { | |
771 /* Backup volume descriptor */ | |
772 MVDS_location = avdp.mvds.location; | |
773 MVDS_length = avdp.mvds.length; | |
774 } | |
775 } while( i-- && ( ( !part->valid ) || ( !volvalid ) ) ); | |
776 | |
777 /* We only care for the partition, not the volume */ | |
778 return part->valid; | |
779 } | |
780 | |
781 uint32_t UDFFindFile( dvd_reader_t *device, char *filename, | |
782 uint32_t *filesize ) | |
783 { | |
183 | 784 uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ]; |
211
7eda95524e83
use uintptr_t for pointer arithmetics for AMD64 compatibility
mroi
parents:
183
diff
changeset
|
785 uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~2047) + 2048); |
168 | 786 uint32_t lbnum; |
787 uint16_t TagID; | |
788 struct Partition partition; | |
789 struct AD RootICB, File, ICB; | |
790 char tokenline[ MAX_UDF_FILE_NAME_LEN ]; | |
791 char *token; | |
792 uint8_t filetype; | |
793 | |
794 *filesize = 0; | |
795 tokenline[0] = '\0'; | |
796 strcat( tokenline, filename ); | |
797 | |
798 | |
799 if(!(GetUDFCache(device, PartitionCache, 0, &partition) && | |
800 GetUDFCache(device, RootICBCache, 0, &RootICB))) { | |
801 /* Find partition, 0 is the standard location for DVD Video.*/ | |
802 if( !UDFFindPartition( device, 0, &partition ) ) return 0; | |
803 SetUDFCache(device, PartitionCache, 0, &partition); | |
804 | |
805 /* Find root dir ICB */ | |
806 lbnum = partition.Start; | |
807 do { | |
808 if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 ) { | |
809 TagID = 0; | |
810 } else { | |
811 UDFDescriptor( LogBlock, &TagID ); | |
812 } | |
813 | |
814 /* File Set Descriptor */ | |
183 | 815 if( TagID == 256 ) { /* File Set Descriptor */ |
168 | 816 UDFLongAD( &LogBlock[ 400 ], &RootICB ); |
817 } | |
818 } while( ( lbnum < partition.Start + partition.Length ) | |
819 && ( TagID != 8 ) && ( TagID != 256 ) ); | |
820 | |
821 /* Sanity checks. */ | |
822 if( TagID != 256 ) return 0; | |
823 if( RootICB.Partition != 0 ) return 0; | |
824 SetUDFCache(device, RootICBCache, 0, &RootICB); | |
825 } | |
826 | |
827 /* Find root dir */ | |
828 if( !UDFMapICB( device, RootICB, &filetype, &partition, &File ) ) return 0; | |
829 if( filetype != 4 ) return 0; /* Root dir should be dir */ | |
830 | |
831 { | |
832 int cache_file_info = 0; | |
833 /* Tokenize filepath */ | |
834 token = strtok(tokenline, "/"); | |
835 | |
836 while( token != NULL ) { | |
837 | |
838 if( !UDFScanDir( device, File, token, &partition, &ICB, | |
839 cache_file_info)) { | |
840 return 0; | |
841 } | |
842 if( !UDFMapICB( device, ICB, &filetype, &partition, &File ) ) { | |
843 return 0; | |
844 } | |
845 if(!strcmp(token, "VIDEO_TS")) { | |
846 cache_file_info = 1; | |
847 } | |
848 token = strtok( NULL, "/" ); | |
849 } | |
850 } | |
851 | |
852 /* Sanity check. */ | |
853 if( File.Partition != 0 ) return 0; | |
854 | |
855 *filesize = File.Length; | |
856 /* Hack to not return partition.Start for empty files. */ | |
857 if( !File.Location ) | |
858 return 0; | |
859 else | |
860 return partition.Start + File.Location; | |
861 } | |
862 | |
863 | |
864 | |
865 /** | |
866 * Gets a Descriptor . | |
867 * Returns 1 if descriptor found, 0 on error. | |
868 * id, tagid of descriptor | |
869 * bufsize, size of BlockBuf (must be >= DVD_VIDEO_LB_LEN). | |
870 */ | |
871 static int UDFGetDescriptor( dvd_reader_t *device, int id, | |
872 uint8_t *descriptor, int bufsize) | |
873 { | |
874 uint32_t lbnum, MVDS_location, MVDS_length; | |
875 struct avdp_t avdp; | |
876 uint16_t TagID; | |
877 uint32_t lastsector; | |
878 int i, terminate; | |
879 int desc_found = 0; | |
880 /* Find Anchor */ | |
881 lastsector = 0; | |
882 lbnum = 256; /* Try #1, prime anchor */ | |
883 terminate = 0; | |
884 if(bufsize < DVD_VIDEO_LB_LEN) { | |
885 return 0; | |
886 } | |
887 | |
888 if(!UDFGetAVDP(device, &avdp)) { | |
889 return 0; | |
890 } | |
891 | |
892 /* Main volume descriptor */ | |
893 MVDS_location = avdp.mvds.location; | |
894 MVDS_length = avdp.mvds.length; | |
895 | |
896 i = 1; | |
897 do { | |
898 /* Find Descriptor */ | |
899 lbnum = MVDS_location; | |
900 do { | |
901 | |
902 if( DVDReadLBUDF( device, lbnum++, 1, descriptor, 0 ) <= 0 ) { | |
903 TagID = 0; | |
904 } else { | |
905 UDFDescriptor( descriptor, &TagID ); | |
906 } | |
907 | |
908 if( (TagID == id) && ( !desc_found ) ) { | |
909 /* Descriptor */ | |
910 desc_found = 1; | |
911 } | |
912 } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 ) | |
913 / DVD_VIDEO_LB_LEN ) && ( TagID != 8 ) | |
914 && ( !desc_found) ); | |
915 | |
916 if( !desc_found ) { | |
917 /* Backup volume descriptor */ | |
918 MVDS_location = avdp.rvds.location; | |
919 MVDS_length = avdp.rvds.length; | |
920 } | |
921 } while( i-- && ( !desc_found ) ); | |
922 | |
923 return desc_found; | |
924 } | |
925 | |
926 | |
927 static int UDFGetPVD(dvd_reader_t *device, struct pvd_t *pvd) | |
928 { | |
183 | 929 uint8_t pvd_buf_base[DVD_VIDEO_LB_LEN + 2048]; |
211
7eda95524e83
use uintptr_t for pointer arithmetics for AMD64 compatibility
mroi
parents:
183
diff
changeset
|
930 uint8_t *pvd_buf = (uint8_t *)(((uintptr_t)pvd_buf_base & ~2047) + 2048); |
168 | 931 |
932 if(GetUDFCache(device, PVDCache, 0, pvd)) { | |
933 return 1; | |
934 } | |
935 | |
936 if(!UDFGetDescriptor( device, 1, pvd_buf, sizeof(pvd_buf))) { | |
937 return 0; | |
938 } | |
939 | |
940 memcpy(pvd->VolumeIdentifier, &pvd_buf[24], 32); | |
941 memcpy(pvd->VolumeSetIdentifier, &pvd_buf[72], 128); | |
942 SetUDFCache(device, PVDCache, 0, pvd); | |
943 | |
944 return 1; | |
945 } | |
946 | |
947 /** | |
948 * Gets the Volume Identifier string, in 8bit unicode (latin-1) | |
949 * volid, place to put the string | |
950 * volid_size, size of the buffer volid points to | |
951 * returns the size of buffer needed for all data | |
952 */ | |
953 int UDFGetVolumeIdentifier(dvd_reader_t *device, char *volid, | |
954 unsigned int volid_size) | |
955 { | |
956 struct pvd_t pvd; | |
957 unsigned int volid_len; | |
958 | |
959 /* get primary volume descriptor */ | |
960 if(!UDFGetPVD(device, &pvd)) { | |
961 return 0; | |
962 } | |
963 | |
964 volid_len = pvd.VolumeIdentifier[31]; | |
965 if(volid_len > 31) { | |
966 /* this field is only 32 bytes something is wrong */ | |
967 volid_len = 31; | |
968 } | |
969 if(volid_size > volid_len) { | |
970 volid_size = volid_len; | |
971 } | |
972 Unicodedecode(pvd.VolumeIdentifier, volid_size, volid); | |
973 | |
974 return volid_len; | |
975 } | |
976 | |
977 /** | |
978 * Gets the Volume Set Identifier, as a 128-byte dstring (not decoded) | |
979 * WARNING This is not a null terminated string | |
980 * volsetid, place to put the data | |
981 * volsetid_size, size of the buffer volsetid points to | |
982 * the buffer should be >=128 bytes to store the whole volumesetidentifier | |
983 * returns the size of the available volsetid information (128) | |
984 * or 0 on error | |
985 */ | |
986 int UDFGetVolumeSetIdentifier(dvd_reader_t *device, uint8_t *volsetid, | |
987 unsigned int volsetid_size) | |
988 { | |
989 struct pvd_t pvd; | |
990 | |
991 /* get primary volume descriptor */ | |
992 if(!UDFGetPVD(device, &pvd)) { | |
993 return 0; | |
994 } | |
995 | |
996 | |
997 if(volsetid_size > 128) { | |
998 volsetid_size = 128; | |
999 } | |
1000 | |
1001 memcpy(volsetid, pvd.VolumeSetIdentifier, volsetid_size); | |
1002 | |
1003 return 128; | |
1004 } |