diff options
Diffstat (limited to 'libdvdread-embedded/src')
25 files changed, 10045 insertions, 0 deletions
diff --git a/libdvdread-embedded/src/bitreader.c b/libdvdread-embedded/src/bitreader.c new file mode 100644 index 0000000..f6a2183 --- /dev/null +++ b/libdvdread-embedded/src/bitreader.c @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2000, 2001, 2002, 2003 Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <inttypes.h> +#include <assert.h> + +#include "dvdread/bitreader.h" + +int dvdread_getbits_init(getbits_state_t *state, const uint8_t *start) { + if ((state == NULL) || (start == NULL)) return 0; + state->start = start; + state->bit_position = 0; + state->byte_position = 0; + return 1; +} + +/* Non-optimized getbits. */ +/* This can easily be optimized for particular platforms. */ +uint32_t dvdread_getbits(getbits_state_t *state, uint32_t number_of_bits) { + uint32_t result=0; + uint8_t byte=0; + if (number_of_bits > 32) { + printf("Number of bits > 32 in getbits\n"); + abort(); + } + + if ((state->bit_position) > 0) { /* Last getbits left us in the middle of a byte. */ + if (number_of_bits > (8-state->bit_position)) { /* this getbits will span 2 or more bytes. */ + byte = state->start[state->byte_position] << state->bit_position; + byte = byte >> (state->bit_position); + result = byte; + number_of_bits -= (8-state->bit_position); + state->bit_position = 0; + state->byte_position++; + } else { + byte = state->start[state->byte_position] << state->bit_position; + byte = byte >> (8 - number_of_bits); + result = byte; + state->bit_position += number_of_bits; /* Here it is impossible for bit_position > 8 */ + if (state->bit_position == 8) { + state->bit_position = 0; + state->byte_position++; + } + number_of_bits = 0; + } + } + if ((state->bit_position) == 0) { + while (number_of_bits > 7) { + result = (result << 8) + state->start[state->byte_position]; + state->byte_position++; + number_of_bits -= 8; + } + if (number_of_bits > 0) { /* number_of_bits < 8 */ + byte = state->start[state->byte_position] << state->bit_position; + state->bit_position += number_of_bits; /* Here it is impossible for bit_position > 7 */ + byte = byte >> (8 - number_of_bits); + result = (result << number_of_bits) + byte; + number_of_bits = 0; + } + } + + return result; +} + +#if 0 /* TODO: optimized versions not yet used */ + +/* WARNING: This function can only be used on a byte boundary. + No checks are made that we are in fact on a byte boundary. + */ +uint16_t dvdread_get16bits(getbits_state_t *state) { + uint16_t result; + state->byte_position++; + result = (state->byte << 8) + state->start[state->byte_position++]; + state->byte = state->start[state->byte_position]; + return result; +} + +/* WARNING: This function can only be used on a byte boundary. + No checks are made that we are in fact on a byte boundary. + */ +uint32_t dvdread_get32bits(getbits_state_t *state) { + uint32_t result; + state->byte_position++; + result = (state->byte << 8) + state->start[state->byte_position++]; + result = (result << 8) + state->start[state->byte_position++]; + result = (result << 8) + state->start[state->byte_position++]; + state->byte = state->start[state->byte_position]; + return result; +} + +#endif + +#ifdef BITREADER_TESTS + +int main() +{ + uint8_t buff[2] = { + 0x6E, 0xC2 + // 0b 01101110 11000010 + }; + getbits_state_t state; + dvdread_getbits_init(&state, buff); + + uint32_t bits = dvdread_getbits(&state, 3); + assert(bits == 3); + + bits = dvdread_getbits(&state, 3); + assert(bits == 3); + + bits = dvdread_getbits(&state, 4); + assert(bits == 11); + + bits = dvdread_getbits(&state, 6); + assert(bits == 2); + + dvdread_getbits_init(&state, buff); + bits = dvdread_getbits(&state, 10); + assert(bits == 443); + + bits = dvdread_getbits(&state, 6); + assert(bits == 2); + + dvdread_getbits_init(&state, buff); + bits = dvdread_getbits(&state, 16); + assert(bits == 28354); + + buff[0] = buff[1] = 0xFF; + dvdread_getbits_init(&state, buff); + bits = dvdread_getbits(&state, 16); + assert(bits == 0xFFFF); + + uint8_t large[5] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; + dvdread_getbits_init(&state, large); + bits = dvdread_getbits(&state, 8); + assert(bits == 0xFF); + bits = dvdread_getbits(&state, 32); + assert(bits == 0xFFFFFFFF); + + return 0; +} + +#endif diff --git a/libdvdread-embedded/src/bswap.h b/libdvdread-embedded/src/bswap.h new file mode 100644 index 0000000..d3b2383 --- /dev/null +++ b/libdvdread-embedded/src/bswap.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2000, 2001 Billy Biggs <vektor@dumbterm.net>, + * Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_BSWAP_H +#define LIBDVDREAD_BSWAP_H + +#include <config.h> + +#if defined(WORDS_BIGENDIAN) +/* All bigendian systems are fine, just ignore the swaps. */ +#define B2N_16(x) (void)(x) +#define B2N_32(x) (void)(x) +#define B2N_64(x) (void)(x) + +#else + +/* For __FreeBSD_version */ +#if defined(HAVE_SYS_PARAM_H) +#include <sys/param.h> +#endif + +#if defined(__linux__) || defined(__GLIBC__) +#include <byteswap.h> +#define B2N_16(x) x = bswap_16(x) +#define B2N_32(x) x = bswap_32(x) +#define B2N_64(x) x = bswap_64(x) + +#elif defined(__APPLE__) +#include <libkern/OSByteOrder.h> +#define B2N_16(x) x = OSSwapBigToHostInt16(x) +#define B2N_32(x) x = OSSwapBigToHostInt32(x) +#define B2N_64(x) x = OSSwapBigToHostInt64(x) + +#elif defined(__NetBSD__) +#include <sys/endian.h> +#define B2N_16(x) BE16TOH(x) +#define B2N_32(x) BE32TOH(x) +#define B2N_64(x) BE64TOH(x) + +#elif defined(__OpenBSD__) +#include <sys/endian.h> +#define B2N_16(x) x = swap16(x) +#define B2N_32(x) x = swap32(x) +#define B2N_64(x) x = swap64(x) + +#elif defined(__FreeBSD__) && __FreeBSD_version >= 470000 +#include <sys/endian.h> +#define B2N_16(x) x = be16toh(x) +#define B2N_32(x) x = be32toh(x) +#define B2N_64(x) x = be64toh(x) + +#elif defined(__QNXNTO__) +#include <gulliver.h> +#define B2N_16(x) x = ENDIAN_RET16(x) +#define B2N_32(x) x = ENDIAN_RET32(x) +#define B2N_64(x) x = ENDIAN_RET64(x) + +#elif defined(__DragonFly__) +#include <sys/endian.h> +#define B2N_16(x) x = bswap16(x) +#define B2N_32(x) x = bswap32(x) +#define B2N_64(x) x = bswap64(x) + +/* This is a slow but portable implementation, it has multiple evaluation + * problems so beware. + * Old FreeBSD's and Solaris don't have <byteswap.h> or any other such + * functionality! + */ + +#elif defined(__FreeBSD__) || defined(__sun) || defined(__bsdi__) || defined(_WIN32) || defined(__CYGWIN__) || defined(__BEOS__) || defined(__OS2__) +#define B2N_16(x) \ + x = ((((x) & 0xff00) >> 8) | \ + (((x) & 0x00ff) << 8)) +#define B2N_32(x) \ + x = ((((x) & 0xff000000) >> 24) | \ + (((x) & 0x00ff0000) >> 8) | \ + (((x) & 0x0000ff00) << 8) | \ + (((x) & 0x000000ff) << 24)) +#define B2N_64(x) \ + x = ((((x) & 0xff00000000000000ULL) >> 56) | \ + (((x) & 0x00ff000000000000ULL) >> 40) | \ + (((x) & 0x0000ff0000000000ULL) >> 24) | \ + (((x) & 0x000000ff00000000ULL) >> 8) | \ + (((x) & 0x00000000ff000000ULL) << 8) | \ + (((x) & 0x0000000000ff0000ULL) << 24) | \ + (((x) & 0x000000000000ff00ULL) << 40) | \ + (((x) & 0x00000000000000ffULL) << 56)) + +#else + +/* If there isn't a header provided with your system with this functionality + * add the relevant || define( ) to the portable implementation above. + */ +#error "You need to add endian swap macros for your system" + +#endif + +#endif /* WORDS_BIGENDIAN */ + +#endif /* LIBDVDREAD_BSWAP_H */ diff --git a/libdvdread-embedded/src/dvd_input.c b/libdvdread-embedded/src/dvd_input.c new file mode 100644 index 0000000..26b6928 --- /dev/null +++ b/libdvdread-embedded/src/dvd_input.c @@ -0,0 +1,483 @@ +/* + * Copyright (C) 2002 Samuel Hocevar <sam@zoy.org>, + * Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" /* Required for HAVE_DVDCSS_DVDCSS_H */ +#include <stdio.h> /* fprintf */ +#include <stdlib.h> /* free */ +#include <fcntl.h> /* open */ +#include <unistd.h> /* lseek */ +#include <string.h> /* strerror */ +#include <errno.h> + +#ifdef _WIN32 +#include <windows.h> +#include "../msvc/contrib/win32_cs.h" +#endif + +#include "dvdread/dvd_reader.h" /* DVD_VIDEO_LB_LEN */ +#include "dvdread_internal.h" +#include "dvd_input.h" +#include "logger.h" + + +/* The function pointers that is the exported interface of this file. */ +dvd_input_t (*dvdinput_open) (void *, dvd_logger_cb *, + const char *,dvd_reader_stream_cb *); +int (*dvdinput_close) (dvd_input_t); +int (*dvdinput_seek) (dvd_input_t, int); +int (*dvdinput_title) (dvd_input_t, int); +int (*dvdinput_read) (dvd_input_t, void *, int, int); + +#ifdef HAVE_DVDCSS_DVDCSS_H +/* linking to libdvdcss */ +# include <dvdcss/dvdcss.h> +# define DVDcss_open_stream(a, b) \ + dvdcss_open_stream((void*)(a), (dvdcss_stream_cb*)(b)) +# define DVDcss_open(a) dvdcss_open((char*)(a)) +# define DVDcss_close dvdcss_close +# define DVDcss_seek dvdcss_seek +# define DVDcss_read dvdcss_read +#else + +/* dlopening libdvdcss */ +# if defined(HAVE_DLFCN_H) && !defined(USING_BUILTIN_DLFCN) +# include <dlfcn.h> +# else +# if defined(_WIN32) +/* Only needed on MINGW at the moment */ +# include "../msvc/contrib/dlfcn.c" +# endif +# endif + +typedef struct dvdcss_s *dvdcss_t; +typedef struct dvdcss_stream_cb dvdcss_stream_cb; +static dvdcss_t (*DVDcss_open_stream) (void *, dvdcss_stream_cb *); +static dvdcss_t (*DVDcss_open) (const char *); +static int (*DVDcss_close) (dvdcss_t); +static int (*DVDcss_seek) (dvdcss_t, int, int); +static int (*DVDcss_read) (dvdcss_t, void *, int, int); +#define DVDCSS_SEEK_KEY (1 << 1) +#endif + +#ifdef _WIN32 +static int open_win32(const char *path, int flags) +{ + wchar_t *wpath; + int fd; + + wpath = _utf8_to_wchar(path); + if (!wpath) { + return -1; + } + fd = _wopen(wpath, flags); + free(wpath); + return fd; +} +#endif + +/* The DVDinput handle, add stuff here for new input methods. + * NOTE: All members of this structure must be initialized in dvd_input_New + */ +struct dvd_input_s { + /* libdvdcss handle */ + dvdcss_t dvdcss; + /* */ + void *priv; + dvd_logger_cb *logcb; + off_t ipos; + + /* dummy file input */ + int fd; + /* stream input */ + dvd_reader_stream_cb *stream_cb; +}; + +static dvd_input_t dvd_input_New(void *priv, dvd_logger_cb *logcb) +{ + dvd_input_t dev = calloc(1, sizeof(*dev)); + if(dev) + { + dev->priv = priv; + dev->logcb = logcb; + dev->ipos = 0; + + /* Initialize all inputs to safe defaults */ + dev->dvdcss = NULL; + dev->fd = -1; + dev->stream_cb = NULL; + } + return dev; +} + +/** + * initialize and open a DVD (device or file or stream_cb) + */ +static dvd_input_t css_open(void *priv, dvd_logger_cb *logcb, + const char *target, + dvd_reader_stream_cb *stream_cb) +{ + dvd_input_t dev; + + /* Allocate the handle structure */ + dev = dvd_input_New(priv, logcb); + if(dev == NULL) { + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_ERROR, + "Could not allocate memory."); + return NULL; + } + + /* Really open it with libdvdcss */ + if(target) + dev->dvdcss = DVDcss_open(target); + else if(priv && stream_cb) { +#ifdef HAVE_DVDCSS_DVDCSS_H + dev->dvdcss = DVDcss_open_stream(priv, (dvdcss_stream_cb *)stream_cb); +#else + dev->dvdcss = DVDcss_open_stream ? + DVDcss_open_stream(priv, (dvdcss_stream_cb *)stream_cb) : + NULL; +#endif + } + if(dev->dvdcss == NULL) { + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_ERROR, + "Could not open %s with libdvdcss.", target); + free(dev); + return NULL; + } + + return dev; +} + +/** + * seek into the device. + */ +static int css_seek(dvd_input_t dev, int blocks) +{ + /* DVDINPUT_NOFLAGS should match the DVDCSS_NOFLAGS value. */ + return DVDcss_seek(dev->dvdcss, blocks, DVDINPUT_NOFLAGS); +} + +/** + * set the block for the beginning of a new title (key). + */ +static int css_title(dvd_input_t dev, int block) +{ + return DVDcss_seek(dev->dvdcss, block, DVDCSS_SEEK_KEY); +} + +/** + * read data from the device. + */ +static int css_read(dvd_input_t dev, void *buffer, int blocks, int flags) +{ + return DVDcss_read(dev->dvdcss, buffer, blocks, flags); +} + +/** + * close the DVD device and clean up the library. + */ +static int css_close(dvd_input_t dev) +{ + int ret; + + ret = DVDcss_close(dev->dvdcss); + + free(dev); + + return ret; +} + +/** + * initialize and open a DVD device or file. + */ +static dvd_input_t file_open(void *priv, dvd_logger_cb *logcb, + const char *target, + dvd_reader_stream_cb *stream_cb) +{ + dvd_input_t dev; + + /* Allocate the library structure */ + dev = dvd_input_New(priv, logcb); + if(dev == NULL) { + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_ERROR, + "Could not allocate memory."); + return NULL; + } + + /* Initialize with stream callback if it is specified */ + if (stream_cb) { + if (!stream_cb->pf_read || !stream_cb->pf_seek) { + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_ERROR, + "Stream callback provided but lacks of pf_read or pf_seek methods."); + free(dev); + return NULL; + } + dev->stream_cb = stream_cb; + return dev; + } + + /* Open the device */ + if(target == NULL) { + free(dev); + return NULL; + } +#if defined(_WIN32) + dev->fd = open_win32(target, O_RDONLY | O_BINARY); +#elif defined(__OS2__) + dev->fd = open(target, O_RDONLY | O_BINARY); +#else + dev->fd = open(target, O_RDONLY); +#endif + if(dev->fd < 0) { + char buf[256]; +#if defined(HAVE_STRERROR_R) && defined(HAVE_DECL_STRERROR_R) + #ifdef STRERROR_R_CHAR_P + *buf=0; + if(strerror_r(errno, buf, 256) == NULL) + *buf=0; + #else + if(strerror_r(errno, buf, 256) != 0) + *buf=0; + #endif +#else + #if defined(HAVE_STRERR_S) + if(strerror_s(buf, 256, errno) != 0) + *buf=0; + #else + *buf=0; + #endif +#endif + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_ERROR, + "Could not open input: %s", buf); + free(dev); + return NULL; + } + + return dev; +} + +/** + * seek into the device. + */ +static int file_seek(dvd_input_t dev, int blocks) +{ + off_t pos = -1; + + if(dev->ipos == blocks) + { + /* We are already in position */ + return blocks; + } + + if (dev->stream_cb) { + /* Returns 0 on successful completion and -1 on error */ + pos = dev->stream_cb->pf_seek(dev->priv, (off_t)blocks * (off_t)DVD_VIDEO_LB_LEN); + + if (!pos) { + dev->ipos = blocks; + } + } else { + /* Returns position as the number of bytes from beginning of file + * or -1 on error + */ + pos = lseek(dev->fd, (off_t)blocks * (off_t)DVD_VIDEO_LB_LEN, SEEK_SET); + + if (pos >= 0) { + dev->ipos = pos / DVD_VIDEO_LB_LEN; + } + } + + if(pos < 0) { + return pos; + } + + /* assert pos % DVD_VIDEO_LB_LEN == 0 */ + return (int) dev->ipos; +} + +/** + * set the block for the beginning of a new title (key). + */ +static int file_title(dvd_input_t dev UNUSED, int block UNUSED) +{ + return -1; +} + +/** + * read data from the device. + */ +static int file_read(dvd_input_t dev, void *buffer, int blocks, + int flags UNUSED) +{ + size_t len, bytes, blocks_read; + + len = (size_t)blocks * DVD_VIDEO_LB_LEN; + bytes = 0; + blocks_read = 0; + + while(len > 0) { + ssize_t ret = -1; + + /* Perform read based on the input type */ + if (dev->stream_cb) { + /* Returns the number of bytes read or -1 on error */ + ret = dev->stream_cb->pf_read(dev->priv, ((char*)buffer) + bytes, len); + } else { + /* Returns the number of bytes read or -1 on error */ + ret = read(dev->fd, ((char*)buffer) + bytes, len); + } + + if(ret < 0) { + /* One of the reads failed, too bad. We won't even bother + * returning the reads that went OK, and as in the POSIX spec + * the file position is left unspecified after a failure. */ + dev->ipos = -1; + return ret; + } + + if(ret == 0) { + /* Nothing more to read. Return all of the whole blocks, if any. + * Adjust the file position back to the previous block boundary. */ + ret = file_seek(dev, dev->ipos + blocks_read); + if(ret < 0) + return ret; + + return (int) blocks_read; + } + + len -= ret; + bytes += ret; + blocks_read = bytes / DVD_VIDEO_LB_LEN; + } + + dev->ipos += blocks_read; + return blocks; +} + +/** + * close the DVD device and clean up. + */ +static int file_close(dvd_input_t dev) +{ + int ret = 0; + + /* close file if it was open */ + + if (dev->fd >= 0) { + ret = close(dev->fd); + } + + free(dev); + + return ret; +} + +/** + * Setup read functions with either libdvdcss or minimal DVD access. + */ +int dvdinput_setup(void *priv, dvd_logger_cb *logcb) +{ + void *dvdcss_library = NULL; + +#ifdef HAVE_DVDCSS_DVDCSS_H + /* linking to libdvdcss */ + dvdcss_library = &dvdcss_library; /* Give it some value != NULL */ + +#else + /* dlopening libdvdcss */ + +#ifdef __APPLE__ + #define CSS_LIB "libdvdcss.2.dylib" +#elif defined(_WIN32) + #define CSS_LIB "libdvdcss-2.dll" +#elif defined(__OS2__) + #define CSS_LIB "dvdcss2.dll" +#elif defined(__OpenBSD__) + #define CSS_LIB "libdvdcss.so" +#else + #define CSS_LIB "libdvdcss.so.2" +#endif + dvdcss_library = dlopen(CSS_LIB, RTLD_LAZY); + + if(dvdcss_library != NULL) { +#ifdef __OS2__ +#define U_S "_" +#else +#define U_S +#endif + DVDcss_open_stream = (dvdcss_t (*)(void *, dvdcss_stream_cb *)) + dlsym(dvdcss_library, U_S "dvdcss_open_stream"); + DVDcss_open = (dvdcss_t (*)(const char*)) + dlsym(dvdcss_library, U_S "dvdcss_open"); + DVDcss_close = (int (*)(dvdcss_t)) + dlsym(dvdcss_library, U_S "dvdcss_close"); + DVDcss_seek = (int (*)(dvdcss_t, int, int)) + dlsym(dvdcss_library, U_S "dvdcss_seek"); + DVDcss_read = (int (*)(dvdcss_t, void*, int, int)) + dlsym(dvdcss_library, U_S "dvdcss_read"); + + if(dlsym(dvdcss_library, U_S "dvdcss_crack")) { + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_ERROR, + "Old (pre-0.0.2) version of libdvdcss found. " + "libdvdread: You should get the latest version from " + "http://www.videolan.org/" ); + dlclose(dvdcss_library); + dvdcss_library = NULL; + } else if(!DVDcss_open || !DVDcss_close || !DVDcss_seek + || !DVDcss_read) { + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_ERROR, + "Missing symbols in %s, " + "this shouldn't happen !", CSS_LIB); + dlclose(dvdcss_library); + dvdcss_library = NULL; + } + } +#endif /* HAVE_DVDCSS_DVDCSS_H */ + + if(dvdcss_library != NULL) { + /* + char *psz_method = getenv( "DVDCSS_METHOD" ); + char *psz_verbose = getenv( "DVDCSS_VERBOSE" ); + fprintf(stderr, "DVDCSS_METHOD %s\n", psz_method); + fprintf(stderr, "DVDCSS_VERBOSE %s\n", psz_verbose); + */ + + /* libdvdcss wrapper functions */ + dvdinput_open = css_open; + dvdinput_close = css_close; + dvdinput_seek = css_seek; + dvdinput_title = css_title; + dvdinput_read = css_read; + return 1; + + } else { + DVDReadLog(priv, logcb, DVD_LOGGER_LEVEL_WARN, + "Encrypted DVD support unavailable."); + + /* libdvdcss replacement functions */ + dvdinput_open = file_open; + dvdinput_close = file_close; + dvdinput_seek = file_seek; + dvdinput_title = file_title; + dvdinput_read = file_read; + return 0; + } +} diff --git a/libdvdread-embedded/src/dvd_input.h b/libdvdread-embedded/src/dvd_input.h new file mode 100644 index 0000000..470cfa4 --- /dev/null +++ b/libdvdread-embedded/src/dvd_input.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2001, 2002 Samuel Hocevar <sam@zoy.org>, + * Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_DVD_INPUT_H +#define LIBDVDREAD_DVD_INPUT_H + +/** + * Defines and flags. Make sure they fit the libdvdcss API! + */ +#define DVDINPUT_NOFLAGS 0 + +#define DVDINPUT_READ_DECRYPT (1 << 0) + +typedef struct dvd_input_s *dvd_input_t; + +#if defined( __MINGW32__ ) +# undef lseek +# define lseek _lseeki64 +# undef off_t +# define off_t off64_t +# undef stat +# define stat _stati64 +# undef fstat +# define fstat _fstati64 +# undef wstat +# define wstat _wstati64 +#endif + +#ifdef __ANDROID__ +# undef lseek +# define lseek lseek64 +# undef off_t +# define off_t off64_t +#endif + +/** + * Function pointers that will be filled in by the input implementation. + * These functions provide the main API. + */ +extern dvd_input_t (*dvdinput_open) (void *, dvd_logger_cb *, + const char *, + dvd_reader_stream_cb *); +extern int (*dvdinput_close) (dvd_input_t); +extern int (*dvdinput_seek) (dvd_input_t, int); +extern int (*dvdinput_title) (dvd_input_t, int); +extern int (*dvdinput_read) (dvd_input_t, void *, int, int); + +/** + * Setup function accessed by dvd_reader.c. Returns 1 if there is CSS support. + */ +int dvdinput_setup(void *, dvd_logger_cb *); + +#endif /* LIBDVDREAD_DVD_INPUT_H */ diff --git a/libdvdread-embedded/src/dvd_reader.c b/libdvdread-embedded/src/dvd_reader.c new file mode 100644 index 0000000..c4d9641 --- /dev/null +++ b/libdvdread-embedded/src/dvd_reader.c @@ -0,0 +1,1690 @@ +/* + * Copyright (C) 2001-2004 Billy Biggs <vektor@dumbterm.net>, + * Håkan Hjort <d95hjort@dtek.chalmers.se>, + * Björn Englund <d4bjorn@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include <sys/types.h> /* off_t */ +#include <sys/stat.h> /* stat */ +#include <sys/time.h> /* For the timing of dvdcss_title crack. */ +#include <fcntl.h> /* open */ +#include <stdlib.h> /* free */ +#include <stdio.h> /* fprintf */ +#include <errno.h> /* errno, EIN* */ +#include <string.h> /* memcpy, strlen */ +#include <unistd.h> /* pclose */ +#include <limits.h> /* PATH_MAX */ +#include <dirent.h> /* opendir, readdir */ +#include <ctype.h> /* isalpha */ + +#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__bsdi__) || defined(__APPLE__) +# define SYS_BSD 1 +#endif + +#if defined(__sun) +# include <sys/mnttab.h> +#elif defined(__APPLE__) +# include <sys/param.h> +# include <sys/ucred.h> +# include <sys/mount.h> +#elif defined(SYS_BSD) +# include <fstab.h> +#elif defined(__linux__) +# include <mntent.h> +# include <paths.h> +#endif + +#include "dvdread/dvd_udf.h" +#include "dvdread/dvd_reader.h" +#include "dvd_input.h" +#include "dvdread_internal.h" +#include "md5.h" +#include "dvdread/ifo_read.h" + +#if defined(_WIN32) +# include <windows.h> +# include "msvc/contrib/win32_cs.h" +#endif + +/* misc win32 helpers */ + +#ifdef _WIN32 +# ifndef HAVE_GETTIMEOFDAY + /* replacement gettimeofday implementation */ +# include <sys/timeb.h> +static inline int _private_gettimeofday( struct timeval *tv, void *tz ) +{ + struct timeb t; + ftime( &t ); + tv->tv_sec = t.time; + tv->tv_usec = t.millitm * 1000; + return 0; +} +# define gettimeofday(TV, TZ) _private_gettimeofday((TV), (TZ)) +# endif +#endif /* _WIN32 */ + +/* Compat wrapper for stat() */ + +#if defined(_WIN32) +/* can't re-define stat (used in both function name and struct name) */ +typedef struct _stat64 dvdstat_t; +static inline int dvdstat(const char *path, dvdstat_t *st) +{ + wchar_t *wpath, *it; + int ret; + + wpath = _utf8_to_wchar(path); + if (!wpath) { + return -1; + } + + /* need to strip possible trailing \\ */ + for (it = wpath; *it; it++) + if ((*it == '\\' || *it == '/') && *(it+1) == 0) + *it = 0; + + ret = _wstat64(wpath, st); + free(wpath); + return ret; +} +#else +typedef struct stat dvdstat_t; +static inline int dvdstat(const char *file, dvdstat_t *st) { + return stat(file, st); +} +#endif + +#if defined(_WIN32) +/* UTF-8 aware version of opendir()/readdir() */ + +#include <io.h> + +typedef struct { + intptr_t handle; + struct _wfinddata_t went; + struct dirent ent; +} win32_dir_t; + +win32_dir_t *win32_opendir(const char *path) +{ + char *filespec; + wchar_t *wfilespec; + win32_dir_t *d; + + d = calloc(1, sizeof(*d)); + if (!d) + return NULL; + + filespec = malloc(strlen(path) + 3); + if (!filespec) { + goto fail; + } + sprintf(filespec, "%s\\*", path); + + wfilespec = _utf8_to_wchar(filespec); + free(filespec); + if (!wfilespec) { + goto fail; + } + + d->handle = _wfindfirst(wfilespec, &d->went); + free(wfilespec); + if (d->handle != -1) { + return d; + } + + fail: + free(d); + return NULL; +} + +static struct dirent *win32_readdir(win32_dir_t *dir) +{ + if (dir->went.name[0]) { + if (!WideCharToMultiByte(CP_UTF8, 0, dir->went.name, -1, dir->ent.d_name, sizeof(dir->ent.d_name), NULL, NULL)) + dir->ent.d_name[0] = 0; /* allow reading next */ + dir->went.name[0] = 0; + _wfindnext(dir->handle, &dir->went); + return &dir->ent; + } + + return NULL; +} + +static void win32_closedir(win32_dir_t *dir) +{ + _findclose(dir->handle); + free(dir); +} + +#define DIR win32_dir_t +#define opendir win32_opendir +#define readdir win32_readdir +#define closedir win32_closedir + +#endif /* _WIN32 */ + +#define DEFAULT_UDF_CACHE_LEVEL 1 + +struct dvd_reader_device_s { + /* Basic information. */ + int isImageFile; + + /* Hack for keeping track of the css status. + * 0: no css, 1: perhaps (need init of keys), 2: have done init */ + int css_state; + int css_title; /* Last title that we have called dvdinpute_title for. */ + + /* Information required for an image file. */ + dvd_input_t dev; + + /* Information required for a directory path drive. */ + char *path_root; + + /* Filesystem cache */ + int udfcache_level; /* 0 - turned off, 1 - on */ + void *udfcache; +}; + +#define TITLES_MAX 9 + +struct dvd_file_s { + /* Basic information. */ + dvd_reader_t *ctx; + + /* Hack for selecting the right css title. */ + int css_title; + + /* Information required for an image file. */ + uint32_t lb_start; + uint32_t seek_pos; + + /* Information required for a directory path drive. */ + size_t title_sizes[ TITLES_MAX ]; + dvd_input_t title_devs[ TITLES_MAX ]; + + /* Calculated at open-time, size in blocks. */ + ssize_t filesize; + + /* Cache of the dvd_file. If not NULL, the cache corresponds to the whole + * dvd_file. Used only for IFO and BUP. */ + unsigned char *cache; +}; + +/** + * Set the level of caching on udf + * level = 0 (no caching) + * level = 1 (caching filesystem info) + */ +int DVDUDFCacheLevel(dvd_reader_t *reader, int level) +{ + dvd_reader_device_t *dev = reader->rd; + + if(level > 0) { + level = 1; + } else if(level < 0) { + return dev->udfcache_level; + } + + dev->udfcache_level = level; + + return level; +} + +void *GetUDFCacheHandle(dvd_reader_t *reader) +{ + dvd_reader_device_t *dev = reader->rd; + + return dev->udfcache; +} + +void SetUDFCacheHandle(dvd_reader_t *reader, void *cache) +{ + dvd_reader_device_t *dev = reader->rd; + + dev->udfcache = cache; +} + + + +/* Loop over all titles and call dvdcss_title to crack the keys. */ +static int initAllCSSKeys( dvd_reader_t *ctx ) +{ + dvd_reader_device_t *dvd = ctx->rd; + struct timeval all_s, all_e; + struct timeval t_s, t_e; + char filename[ MAX_UDF_FILE_NAME_LEN ]; + uint32_t start, len; + int title; + + const char *nokeys_str = getenv("DVDREAD_NOKEYS"); + if(nokeys_str != NULL) + return 0; + + Log2(ctx,"Attempting to retrieve all CSS keys" ); + Log2(ctx,"This can take a _long_ time, please be patient" ); + gettimeofday(&all_s, NULL); + + for( title = 0; title < 100; title++ ) { + gettimeofday( &t_s, NULL ); + if( title == 0 ) { + strcpy( filename, "/VIDEO_TS/VIDEO_TS.VOB" ); + } else { + sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 0 ); + } + start = UDFFindFile( ctx, filename, &len ); + if( start != 0 && len != 0 ) { + /* Perform CSS key cracking for this title. */ + Log3(ctx,"Get key for %s at 0x%08x",filename, start ); + if( dvdinput_title( dvd->dev, (int)start ) < 0 ) { + Log1(ctx,"Error cracking CSS key for %s (0x%08x)", filename, start); + } + gettimeofday( &t_e, NULL ); + Log3(ctx,"Elapsed time %ld", (long int) t_e.tv_sec - t_s.tv_sec ); + } + + if( title == 0 ) continue; + + gettimeofday( &t_s, NULL ); + sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 1 ); + start = UDFFindFile( ctx, filename, &len ); + if( start == 0 || len == 0 ) break; + + /* Perform CSS key cracking for this title. */ + Log3(ctx,"Get key for %s at 0x%08x",filename, start ); + if( dvdinput_title( dvd->dev, (int)start ) < 0 ) { + Log1(ctx,"Error cracking CSS key for %s (0x%08x)", filename, start); + } + gettimeofday( &t_e, NULL ); + Log3(ctx,"Elapsed time %ld", (long int) t_e.tv_sec - t_s.tv_sec ); + } + title--; + + Log3(ctx,"Found %d VTS's", title ); + gettimeofday(&all_e, NULL); + Log3(ctx,"Elapsed time %ld", (long int) all_e.tv_sec - all_s.tv_sec ); + + return 0; +} + + + +/** + * Open a DVD image or block device file or use stream_cb functions. + */ +static dvd_reader_device_t *DVDOpenImageFile( dvd_reader_t *ctx, + const char *location, + dvd_reader_stream_cb *stream_cb, + int have_css ) +{ + dvd_reader_device_t *dvd; + dvd_input_t dev; + + dev = dvdinput_open( ctx->priv, &ctx->logcb, location, stream_cb ); + if( !dev ) { + Log0(ctx,"Can't open %s for reading", location ); + return NULL; + } + + dvd = calloc( 1, sizeof( dvd_reader_device_t ) ); + if( !dvd ) { + dvdinput_close(dev); + return NULL; + } + dvd->isImageFile = 1; + dvd->dev = dev; + + dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL; + + if( have_css ) { + /* Only if DVDCSS_METHOD = title, a bit if it's disc or if + * DVDCSS_METHOD = key but region mismatch. Unfortunately we + * don't have that information. */ + + dvd->css_state = 1; /* Need key init. */ + } + + return dvd; +} + +static dvd_reader_device_t *DVDOpenPath( const char *path_root ) +{ + dvd_reader_device_t *dvd; + + dvd = calloc( 1, sizeof( dvd_reader_device_t ) ); + if( !dvd ) return NULL; + dvd->path_root = strdup( path_root ); + if(!dvd->path_root) { + free(dvd); + return NULL; + } + dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL; + + return dvd; +} + +#if defined(__sun) +/* /dev/rdsk/c0t6d0s0 (link to /devices/...) + /vol/dev/rdsk/c0t6d0/?? + /vol/rdsk/<name> */ +static char *sun_block2char( const char *path ) +{ + char *new_path; + + /* Must contain "/dsk/" */ + if( !strstr( path, "/dsk/" ) ) return (char *) strdup( path ); + + /* Replace "/dsk/" with "/rdsk/" */ + new_path = malloc( strlen(path) + 2 ); + if(!new_path) return NULL; + strcpy( new_path, path ); + strcpy( strstr( new_path, "/dsk/" ), "" ); + strcat( new_path, "/rdsk/" ); + strcat( new_path, strstr( path, "/dsk/" ) + strlen( "/dsk/" ) ); + + return new_path; +} +#endif + +#if defined(SYS_BSD) +/* FreeBSD /dev/(r)(a)cd0c (a is for atapi), recommended to _not_ use r + update: FreeBSD and DragonFly no longer uses the prefix so don't add it. + OpenBSD /dev/rcd0c, it needs to be the raw device + NetBSD /dev/rcd0[d|c|..] d for x86, c (for non x86), perhaps others + Darwin /dev/rdisk0, it needs to be the raw device + BSD/OS /dev/sr0c (if not mounted) or /dev/rsr0c ('c' any letter will do) + returns a string allocated with strdup. It should be freed when no longer + used. */ +static char *bsd_block2char( const char *path ) +{ +#if defined(__FreeBSD__) || defined(__DragonFly__) + return (char *) strdup( path ); +#else + char *new_path; + + /* If it doesn't start with "/dev/" or does start with "/dev/r" exit */ + if( strncmp( path, "/dev/", 5 ) || !strncmp( path, "/dev/r", 6 ) ) + return (char *) strdup( path ); + + /* Replace "/dev/" with "/dev/r" */ + new_path = malloc( strlen(path) + 2 ); + if(!new_path) return NULL; + strcpy( new_path, "/dev/r" ); + strcat( new_path, path + strlen( "/dev/" ) ); + + return new_path; +#endif /* __FreeBSD__ || __DragonFly__ */ +} +#endif + +static dvd_reader_t *DVDOpenCommon( void *priv, + const dvd_logger_cb *logcb, + const char *ppath, + dvd_reader_stream_cb *stream_cb ) +{ + dvdstat_t fileinfo; + int ret, have_css, cdir = -1; + char *dev_name = NULL; + char *path = NULL, *new_path = NULL, *path_copy = NULL; + dvd_reader_t *ctx = calloc(1, sizeof(*ctx)); + if(!ctx) + return NULL; + + ctx->priv = priv; + if(logcb) + ctx->logcb = *logcb; + +#if defined(_WIN32) || defined(__OS2__) + int len; +#endif + + /* Try to open DVD using stream_cb functions */ + if( priv != NULL && stream_cb != NULL ) + { + have_css = dvdinput_setup( ctx->priv, &ctx->logcb ); + ctx->rd = DVDOpenImageFile( ctx, NULL, stream_cb, have_css ); + if(!ctx->rd) + { + free(ctx); + return NULL; + } + return ctx; + } + + if( ppath == NULL ) + goto DVDOpen_error; + + path = strdup(ppath); + if( path == NULL ) + goto DVDOpen_error; + + /* Try to open libdvdcss or fall back to standard functions */ + have_css = dvdinput_setup( ctx->priv, &ctx->logcb ); + +#if defined(_WIN32) || defined(__OS2__) + /* Strip off the trailing \ if it is not a drive */ + len = strlen(path); + if ((len > 1) && + (path[len - 1] == '\\') && + (path[len - 2] != ':')) + { + path[len-1] = '\0'; + } +#endif + + ret = dvdstat( path, &fileinfo ); + + if( ret < 0 ) { + + /* maybe "host:port" url? try opening it with acCeSS library */ + if( strchr(path,':') ) { + ctx->rd = DVDOpenImageFile( ctx, path, NULL, have_css ); + free(path); + if(!ctx->rd) + { + free(ctx); + return NULL; + } + return ctx; + } + + /* If we can't stat the file, give up */ + Log0(ctx, "Can't stat %s", path ); + perror(""); + goto DVDOpen_error; + } + + /* First check if this is a block/char device or a file*/ + if( S_ISBLK( fileinfo.st_mode ) || + S_ISCHR( fileinfo.st_mode ) || + S_ISREG( fileinfo.st_mode ) ) { + + /** + * Block devices and regular files are assumed to be DVD-Video images. + */ +#if defined(__sun) + dev_name = sun_block2char( path ); +#elif defined(SYS_BSD) + dev_name = bsd_block2char( path ); +#else + dev_name = strdup( path ); +#endif + if(!dev_name) + goto DVDOpen_error; + ctx->rd = DVDOpenImageFile( ctx, dev_name, NULL, have_css ); + free( dev_name ); + free(path); + if(!ctx->rd) + { + free(ctx); + return NULL; + } + return ctx; + } else if( S_ISDIR( fileinfo.st_mode ) ) { +#if defined(SYS_BSD) + struct fstab* fe; +#elif defined(__sun) || defined(__linux__) + FILE *mntfile; +#endif + + /* XXX: We should scream real loud here. */ + if( !(path_copy = strdup( path ) ) ) + goto DVDOpen_error; + +#ifndef _WIN32 /* win32 doesn't have realpath */ + /* Also WIN32 does not have symlinks, so we don't need this bit of code. */ + + /* Resolve any symlinks and get the absolute dir name. */ + { + new_path = realpath( path_copy, NULL ); + if( new_path == NULL ) { + goto DVDOpen_error; + } + free(path_copy); + path_copy = new_path; + new_path = NULL; + } +#endif + + /** + * If we're being asked to open a directory, check if that directory + * is the mount point for a DVD-ROM which we can use instead. + */ + + if( strlen( path_copy ) > 1 ) { + if( path_copy[ strlen( path_copy ) - 1 ] == '/' ) { + path_copy[ strlen( path_copy ) - 1 ] = '\0'; + } + } + +#if defined(_WIN32) || defined(__OS2__) + if( strlen( path_copy ) > 9 ) { + if( !strcasecmp( &(path_copy[ strlen( path_copy ) - 9 ]), + "\\video_ts")) + path_copy[ strlen( path_copy ) - (9-1) ] = '\0'; + } +#endif + if( strlen( path_copy ) > 9 ) { + if( !strcasecmp( &(path_copy[ strlen( path_copy ) - 9 ]), + "/video_ts" ) ) { + path_copy[ strlen( path_copy ) - 9 ] = '\0'; + } + } + + if(path_copy[0] == '\0') { + free( path_copy ); + if( !(path_copy = strdup( "/" ) ) ) + goto DVDOpen_error; + } + +#if defined(__APPLE__) + struct statfs s[128]; + int r = getfsstat(NULL, 0, MNT_NOWAIT); + if (r > 0) { + if (r > 128) + r = 128; + r = getfsstat(s, r * sizeof(s[0]), MNT_NOWAIT); + int i; + for (i=0; i<r; i++) { + if (!strcmp(path_copy, s[i].f_mntonname)) { + dev_name = bsd_block2char(s[i].f_mntfromname); + Log3(ctx, "Attempting to use device %s" + " mounted on %s for CSS authentication", + dev_name, + s[i].f_mntonname); + ctx->rd = DVDOpenImageFile( ctx, dev_name, NULL, have_css ); + break; + } + } + } +#elif defined(SYS_BSD) + if( ( fe = getfsfile( path_copy ) ) ) { + dev_name = bsd_block2char( fe->fs_spec ); + Log3(ctx, "Attempting to use device %s" + " mounted on %s for CSS authentication", + dev_name, + fe->fs_file ); + ctx->rd = DVDOpenImageFile( ctx, dev_name, NULL, have_css ); + } +#elif defined(__sun) + mntfile = fopen( MNTTAB, "r" ); + if( mntfile ) { + struct mnttab mp; + int res; + + while( ( res = getmntent( mntfile, &mp ) ) != -1 ) { + if( res == 0 && !strcmp( mp.mnt_mountp, path_copy ) ) { + dev_name = sun_block2char( mp.mnt_special ); + Log3(ctx, "Attempting to use device %s" + " mounted on %s for CSS authentication", + dev_name, + mp.mnt_mountp ); + ctx->rd = DVDOpenImageFile( ctx, dev_name, NULL, have_css ); + break; + } + } + fclose( mntfile ); + } +#elif defined(__linux__) + mntfile = fopen( _PATH_MOUNTED, "r" ); + if( mntfile ) { + +#ifdef HAVE_GETMNTENT_R + struct mntent *me, mbuf; + char buf [8192]; + while( ( me = getmntent_r( mntfile, &mbuf, buf, sizeof(buf) ) ) ) { +#else + struct mntent *me; + while( ( me = getmntent( mntfile ) ) ) { +#endif + if( !strcmp( me->mnt_dir, path_copy ) ) { + Log3(ctx, "Attempting to use device %s" + " mounted on %s for CSS authentication", + me->mnt_fsname, + me->mnt_dir ); + ctx->rd = DVDOpenImageFile( ctx, me->mnt_fsname, NULL, have_css ); + dev_name = strdup(me->mnt_fsname); + break; + } + } + fclose( mntfile ); + } +#elif defined(_WIN32) || defined(__OS2__) +#ifdef __OS2__ + /* Use DVDOpenImageFile() only if it is a drive */ + if(isalpha(path[0]) && path[1] == ':' && + ( !path[2] || + ((path[2] == '\\' || path[2] == '/') && !path[3]))) +#endif + ctx->rd = DVDOpenImageFile( ctx, path, NULL, have_css ); +#endif + +#if !defined(_WIN32) && !defined(__OS2__) + if( !dev_name ) { + Log0(ctx, "Couldn't find device name." ); + } else if( !ctx->rd ) { + Log0(ctx, "Device %s inaccessible, " + "CSS authentication not available.", dev_name ); + } +#else + if( !ctx->rd ) { + Log0(ctx, "Device %s inaccessible, " + "CSS authentication not available.", path ); + } +#endif + + free( dev_name ); + dev_name = NULL; + free( path_copy ); + path_copy = NULL; + + /** + * If we've opened a drive, just use that. + */ + if(ctx->rd) + { + free(path); + return ctx; + } + /** + * Otherwise, we now try to open the directory tree instead. + */ + ctx->rd = DVDOpenPath( path ); + free( path ); + if(!ctx->rd) + { + free(ctx); + return NULL; + } + return ctx; + } + +DVDOpen_error: + /* If it's none of the above, screw it. */ + Log0(ctx, "Could not open %s", path ); + free( path ); + free( path_copy ); + if ( cdir >= 0 ) + close( cdir ); + free( new_path ); + return NULL; +} + +dvd_reader_t *DVDOpen( const char *ppath ) +{ + return DVDOpenCommon( NULL, NULL, ppath, NULL ); +} + +dvd_reader_t *DVDOpenStream( void *stream, + dvd_reader_stream_cb *stream_cb ) +{ + return DVDOpenCommon( stream, NULL, NULL, stream_cb ); +} + +dvd_reader_t *DVDOpen2( void *priv, const dvd_logger_cb *logcb, + const char *ppath ) +{ + return DVDOpenCommon( priv, logcb, ppath, NULL ); +} + +dvd_reader_t *DVDOpenStream2( void *priv, const dvd_logger_cb *logcb, + dvd_reader_stream_cb *stream_cb ) +{ + return DVDOpenCommon( priv, logcb, NULL, stream_cb ); +} + +void DVDClose( dvd_reader_t *dvd ) +{ + if( dvd ) { + if( dvd->rd->dev ) dvdinput_close( dvd->rd->dev ); + if( dvd->rd->path_root ) free( dvd->rd->path_root ); + if( dvd->rd->udfcache ) FreeUDFCache( dvd->rd->udfcache ); + free( dvd->rd ); + free( dvd ); + } +} + +/** + * Open an unencrypted file on a DVD image file. + */ +static dvd_file_t *DVDOpenFileUDF( dvd_reader_t *ctx, const char *filename, + int do_cache ) +{ + uint32_t start, len; + dvd_file_t *dvd_file; + + start = UDFFindFile( ctx, filename, &len ); + if( !start ) { + Log0(ctx, "DVDOpenFileUDF:UDFFindFile %s failed", filename ); + return NULL; + } + + dvd_file = calloc( 1, sizeof( dvd_file_t ) ); + if( !dvd_file ) { + Log0(ctx, "DVDOpenFileUDF:malloc failed" ); + return NULL; + } + dvd_file->ctx = ctx; + dvd_file->lb_start = start; + dvd_file->filesize = len / DVD_VIDEO_LB_LEN; + + /* Read the whole file in cache (unencrypted) if asked and if it doesn't + * exceed 128KB */ + if( do_cache && len < 64 * DVD_VIDEO_LB_LEN ) { + int ret; + + dvd_file->cache = malloc( len ); + if( !dvd_file->cache ) + return dvd_file; + + ret = InternalUDFReadBlocksRaw( ctx, dvd_file->lb_start, + dvd_file->filesize, dvd_file->cache, + DVDINPUT_NOFLAGS ); + if( ret != dvd_file->filesize ) { + free( dvd_file->cache ); + dvd_file->cache = NULL; + } + } + + return dvd_file; +} + +/** + * Searches for <file> in directory <path>, ignoring case. + * Returns 0 and full filename in <filename>. + * or -1 on file not found. + * or -2 on path not found. + */ +static int findDirFile( const char *path, const char *file, char *filename ) +{ + DIR *dir; + struct dirent *ent; + + dir = opendir( path ); + if( !dir ) return -2; + + while( ( ent = readdir( dir ) ) != NULL ) { + if( !strcasecmp( ent->d_name, file ) ) { + sprintf( filename, "%s%s%s", path, + ( ( path[ strlen( path ) - 1 ] == '/' ) ? "" : "/" ), + ent->d_name ); + closedir(dir); + return 0; + } + } + closedir(dir); + return -1; +} + +static int findDVDFile( dvd_reader_t *dvd, const char *file, char *filename ) +{ + const char *nodirfile; + int ret; + + /* Strip off the directory for our search */ + if( !strncasecmp( "/VIDEO_TS/", file, 10 ) ) { + nodirfile = &(file[ 10 ]); + } else { + nodirfile = file; + } + + ret = findDirFile( dvd->rd->path_root, nodirfile, filename ); + if( ret < 0 ) { + char video_path[ PATH_MAX + 1 ]; + + /* Try also with adding the path, just in case. */ + sprintf( video_path, "%s/VIDEO_TS/", dvd->rd->path_root ); + ret = findDirFile( video_path, nodirfile, filename ); + if( ret < 0 ) { + /* Try with the path, but in lower case. */ + sprintf( video_path, "%s/video_ts/", dvd->rd->path_root ); + ret = findDirFile( video_path, nodirfile, filename ); + if( ret < 0 ) { + return 0; + } + } + } + + return 1; +} + +/** + * Open an unencrypted file from a DVD directory tree. + */ +static dvd_file_t *DVDOpenFilePath( dvd_reader_t *ctx, const char *filename ) +{ + char full_path[ PATH_MAX + 1 ]; + dvd_file_t *dvd_file; + dvdstat_t fileinfo; + dvd_input_t dev; + + /* Get the full path of the file. */ + if( !findDVDFile( ctx, filename, full_path ) ) { + Log0(ctx, "DVDOpenFilePath:findDVDFile %s failed", filename ); + return NULL; + } + + dev = dvdinput_open( ctx->priv, &ctx->logcb, full_path, NULL ); + if( !dev ) { + Log0(ctx, "DVDOpenFilePath:dvdinput_open %s failed", full_path ); + return NULL; + } + + dvd_file = calloc( 1, sizeof( dvd_file_t ) ); + if( !dvd_file ) { + Log0(ctx, "DVDOpenFilePath:dvd_file malloc failed" ); + dvdinput_close(dev); + return NULL; + } + dvd_file->ctx = ctx; + + if( dvdstat( full_path, &fileinfo ) < 0 ) { + Log0(ctx, "Can't stat() %s.", filename ); + free( dvd_file ); + dvdinput_close( dev ); + return NULL; + } + dvd_file->title_sizes[ 0 ] = fileinfo.st_size / DVD_VIDEO_LB_LEN; + dvd_file->title_devs[ 0 ] = dev; + dvd_file->filesize = dvd_file->title_sizes[ 0 ]; + + return dvd_file; +} + +static dvd_file_t *DVDOpenVOBUDF( dvd_reader_t *ctx, int title, int menu ) +{ + char filename[ MAX_UDF_FILE_NAME_LEN ]; + uint32_t start, len; + dvd_file_t *dvd_file; + + if( title == 0 ) { + strcpy( filename, "/VIDEO_TS/VIDEO_TS.VOB" ); + } else { + sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, menu ? 0 : 1 ); + } + start = UDFFindFile( ctx, filename, &len ); + if( start == 0 ) return NULL; + + dvd_file = calloc( 1, sizeof( dvd_file_t ) ); + if( !dvd_file ) return NULL; + dvd_file->ctx = ctx; + /*Hack*/ dvd_file->css_title = title << 1 | menu; + dvd_file->lb_start = start; + dvd_file->filesize = len / DVD_VIDEO_LB_LEN; + + /* Calculate the complete file size for every file in the VOBS */ + if( !menu ) { + int cur; + + for( cur = 2; cur < 10; cur++ ) { + sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, cur ); + if( !UDFFindFile( ctx, filename, &len ) ) break; + dvd_file->filesize += len / DVD_VIDEO_LB_LEN; + } + } + + if( ctx->rd->css_state == 1 /* Need key init */ ) { + initAllCSSKeys( ctx ); + ctx->rd->css_state = 2; + } + /* + if( dvdinput_title( dvd_file->dvd->dev, (int)start ) < 0 ) { + Log0(ctx, "Error cracking CSS key for %s", filename ); + } + */ + + return dvd_file; +} + +static dvd_file_t *DVDOpenVOBPath( dvd_reader_t *ctx, int title, int menu ) +{ + char filename[ MAX_UDF_FILE_NAME_LEN ]; + char full_path[ PATH_MAX + 1 ]; + dvdstat_t fileinfo; + dvd_file_t *dvd_file; + + dvd_file = calloc( 1, sizeof( dvd_file_t ) ); + if( !dvd_file ) return NULL; + dvd_file->ctx = ctx; + /*Hack*/ dvd_file->css_title = title << 1 | menu; + + if( menu ) { + dvd_input_t dev; + + if( title == 0 ) { + strcpy( filename, "VIDEO_TS.VOB" ); + } else { + sprintf( filename, "VTS_%02i_0.VOB", title ); + } + if( !findDVDFile( ctx, filename, full_path ) ) { + free( dvd_file ); + return NULL; + } + + dev = dvdinput_open( ctx->priv, &ctx->logcb, full_path, NULL ); + if( dev == NULL ) { + free( dvd_file ); + return NULL; + } + + if( dvdstat( full_path, &fileinfo ) < 0 ) { + Log0(ctx, "Can't stat() %s.", filename ); + dvdinput_close(dev); + free( dvd_file ); + return NULL; + } + dvd_file->title_sizes[ 0 ] = fileinfo.st_size / DVD_VIDEO_LB_LEN; + dvd_file->title_devs[ 0 ] = dev; + dvdinput_title( dvd_file->title_devs[0], 0); + dvd_file->filesize = dvd_file->title_sizes[ 0 ]; + + } else { + int i; + + for( i = 0; i < TITLES_MAX; ++i ) { + + sprintf( filename, "VTS_%02i_%i.VOB", title, i + 1 ); + if( !findDVDFile( ctx, filename, full_path ) ) { + break; + } + + if( dvdstat( full_path, &fileinfo ) < 0 ) { + Log0(ctx, "Can't stat() %s.", filename ); + break; + } + + dvd_file->title_sizes[ i ] = fileinfo.st_size / DVD_VIDEO_LB_LEN; + dvd_file->title_devs[ i ] = dvdinput_open( ctx->priv, &ctx->logcb, full_path, NULL ); + dvdinput_title( dvd_file->title_devs[ i ], 0 ); + dvd_file->filesize += dvd_file->title_sizes[ i ]; + } + if( !dvd_file->title_devs[ 0 ] ) { + free( dvd_file ); + return NULL; + } + } + + return dvd_file; +} + +dvd_file_t *DVDOpenFile( dvd_reader_t *ctx, int titlenum, + dvd_read_domain_t domain ) +{ + dvd_reader_device_t *dvd = ctx->rd; + char filename[ MAX_UDF_FILE_NAME_LEN ]; + int do_cache = 0; + + /* Check arguments. */ + if( dvd == NULL || titlenum < 0 ) + return NULL; + + switch( domain ) { + case DVD_READ_INFO_FILE: + if( titlenum == 0 ) { + strcpy( filename, "/VIDEO_TS/VIDEO_TS.IFO" ); + } else { + sprintf( filename, "/VIDEO_TS/VTS_%02i_0.IFO", titlenum ); + } + do_cache = 1; + break; + case DVD_READ_INFO_BACKUP_FILE: + if( titlenum == 0 ) { + strcpy( filename, "/VIDEO_TS/VIDEO_TS.BUP" ); + } else { + sprintf( filename, "/VIDEO_TS/VTS_%02i_0.BUP", titlenum ); + } + do_cache = 1; + break; + case DVD_READ_MENU_VOBS: + if( dvd->isImageFile ) { + return DVDOpenVOBUDF( ctx, titlenum, 1 ); + } else { + return DVDOpenVOBPath( ctx, titlenum, 1 ); + } + break; + case DVD_READ_TITLE_VOBS: + if( titlenum == 0 ) return NULL; + if( dvd->isImageFile ) { + return DVDOpenVOBUDF( ctx, titlenum, 0 ); + } else { + return DVDOpenVOBPath( ctx, titlenum, 0 ); + } + break; + default: + Log1(ctx, "Invalid domain for file open." ); + return NULL; + } + + if( dvd->isImageFile ) { + return DVDOpenFileUDF( ctx, filename, do_cache ); + } else { + return DVDOpenFilePath( ctx, filename ); + } +} + +void DVDCloseFile( dvd_file_t *dvd_file ) +{ + dvd_reader_device_t *dvd = dvd_file->ctx->rd; + if( dvd_file && dvd ) { + if( !dvd->isImageFile ) { + int i; + + for( i = 0; i < TITLES_MAX; ++i ) { + if( dvd_file->title_devs[ i ] ) { + dvdinput_close( dvd_file->title_devs[i] ); + } + } + } + + free( dvd_file->cache ); + free( dvd_file ); + dvd_file = NULL; + } +} + +static int DVDFileStatVOBUDF( dvd_reader_t *dvd, int title, + int menu, dvd_stat_t *statbuf ) +{ + char filename[ MAX_UDF_FILE_NAME_LEN ]; + uint32_t size; + off_t tot_size; + off_t parts_size[ 9 ]; + int nr_parts = 0; + int n; + + if( title == 0 ) + strcpy( filename, "/VIDEO_TS/VIDEO_TS.VOB" ); + else + sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, menu ? 0 : 1 ); + + if( !UDFFindFile( dvd, filename, &size ) ) + return -1; + + tot_size = size; + nr_parts = 1; + parts_size[ 0 ] = size; + + if( !menu ) { + int cur; + + for( cur = 2; cur < 10; cur++ ) { + sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, cur ); + if( !UDFFindFile( dvd, filename, &size ) ) + break; + + parts_size[ nr_parts ] = size; + tot_size += size; + nr_parts++; + } + } + + statbuf->size = tot_size; + statbuf->nr_parts = nr_parts; + for( n = 0; n < nr_parts; n++ ) + statbuf->parts_size[ n ] = parts_size[ n ]; + + return 0; +} + + +static int DVDFileStatVOBPath( dvd_reader_t *dvd, int title, + int menu, dvd_stat_t *statbuf ) +{ + char filename[ MAX_UDF_FILE_NAME_LEN ]; + char full_path[ PATH_MAX + 1 ]; + dvdstat_t fileinfo; + off_t tot_size; + off_t parts_size[ 9 ]; + int nr_parts = 0; + int n; + + if( title == 0 ) + strcpy( filename, "VIDEO_TS.VOB" ); + else + sprintf( filename, "VTS_%02d_%d.VOB", title, menu ? 0 : 1 ); + + if( !findDVDFile( dvd, filename, full_path ) ) + return -1; + + if( dvdstat( full_path, &fileinfo ) < 0 ) { + Log1(dvd, "Can't stat() %s.", filename ); + return -1; + } + + tot_size = fileinfo.st_size; + nr_parts = 1; + parts_size[ 0 ] = fileinfo.st_size; + + if( !menu ) { + int cur; + for( cur = 2; cur < 10; cur++ ) { + sprintf( filename, "VTS_%02d_%d.VOB", title, cur ); + if( !findDVDFile( dvd, filename, full_path ) ) + break; + + if( dvdstat( full_path, &fileinfo ) < 0 ) { + Log1(dvd, "Can't stat() %s.", filename ); + break; + } + + parts_size[ nr_parts ] = fileinfo.st_size; + tot_size += parts_size[ nr_parts ]; + nr_parts++; + } + } + + statbuf->size = tot_size; + statbuf->nr_parts = nr_parts; + for( n = 0; n < nr_parts; n++ ) + statbuf->parts_size[ n ] = parts_size[ n ]; + + return 0; +} + + +int DVDFileStat( dvd_reader_t *reader, int titlenum, + dvd_read_domain_t domain, dvd_stat_t *statbuf ) +{ + dvd_reader_device_t *dvd = reader->rd; + char filename[ MAX_UDF_FILE_NAME_LEN ]; + dvdstat_t fileinfo; + uint32_t size; + + /* Check arguments. */ + if( dvd == NULL || titlenum < 0 ) { + errno = EINVAL; + return -1; + } + + switch( domain ) { + case DVD_READ_INFO_FILE: + if( titlenum == 0 ) + strcpy( filename, "/VIDEO_TS/VIDEO_TS.IFO" ); + else + sprintf( filename, "/VIDEO_TS/VTS_%02i_0.IFO", titlenum ); + + break; + case DVD_READ_INFO_BACKUP_FILE: + if( titlenum == 0 ) + strcpy( filename, "/VIDEO_TS/VIDEO_TS.BUP" ); + else + sprintf( filename, "/VIDEO_TS/VTS_%02i_0.BUP", titlenum ); + + break; + case DVD_READ_MENU_VOBS: + if( dvd->isImageFile ) + return DVDFileStatVOBUDF( reader, titlenum, 1, statbuf ); + else + return DVDFileStatVOBPath( reader, titlenum, 1, statbuf ); + + break; + case DVD_READ_TITLE_VOBS: + if( titlenum == 0 ) + return -1; + + if( dvd->isImageFile ) + return DVDFileStatVOBUDF( reader, titlenum, 0, statbuf ); + else + return DVDFileStatVOBPath( reader, titlenum, 0, statbuf ); + + break; + default: + Log1(reader, "Invalid domain for file stat." ); + errno = EINVAL; + return -1; + } + + if( dvd->isImageFile ) { + if( UDFFindFile( reader, filename, &size ) ) { + statbuf->size = size; + statbuf->nr_parts = 1; + statbuf->parts_size[ 0 ] = size; + return 0; + } + } else { + char full_path[ PATH_MAX + 1 ]; + + if( findDVDFile( reader, filename, full_path ) ) { + if( dvdstat( full_path, &fileinfo ) < 0 ) + Log1(reader, "Can't stat() %s.", filename ); + else { + statbuf->size = fileinfo.st_size; + statbuf->nr_parts = 1; + statbuf->parts_size[ 0 ] = statbuf->size; + return 0; + } + } + } + return -1; +} + +/* Internal, but used from dvd_udf.c */ +int InternalUDFReadBlocksRaw( const dvd_reader_t *ctx, uint32_t lb_number, + size_t block_count, unsigned char *data, + int encrypted ) +{ + int ret; + + if( !ctx->rd->dev ) { + Log0(ctx, "Fatal error in block read." ); + return -1; + } + + ret = dvdinput_seek( ctx->rd->dev, (int) lb_number ); + if( ret != (int) lb_number ) { + Log1(ctx, "Can't seek to block %u", lb_number ); + return ret; + } + + ret = dvdinput_read( ctx->rd->dev, (char *) data, + (int) block_count, encrypted ); + return ret; +} + +/* This is using a single input and starting from 'dvd_file->lb_start' offset. + * + * Reads 'block_count' blocks from 'dvd_file' at block offset 'offset' + * into the buffer located at 'data' and if 'encrypted' is set + * descramble the data if it's encrypted. Returning either an + * negative error or the number of blocks read. */ +static int DVDReadBlocksUDF( const dvd_file_t *dvd_file, uint32_t offset, + size_t block_count, unsigned char *data, + int encrypted ) +{ + /* If the cache is present and we don't need to decrypt, use the cache to + * feed the data */ + if( dvd_file->cache && (encrypted & DVDINPUT_READ_DECRYPT) == 0 ) { + /* Check if we don't exceed the cache (or file) size */ + if( block_count + offset > (size_t) dvd_file->filesize ) + return 0; + + /* Copy the cache at a specified offset into data. offset and block_count + * must be converted into bytes */ + memcpy( data, dvd_file->cache + (off_t)offset * (off_t)DVD_VIDEO_LB_LEN, + (off_t)block_count * (off_t)DVD_VIDEO_LB_LEN ); + + /* return the amount of blocks copied */ + return block_count; + } else { + /* use dvdinput access */ + return InternalUDFReadBlocksRaw( dvd_file->ctx, dvd_file->lb_start + offset, + block_count, data, encrypted ); + } +} + +/* This is using possibly several inputs and starting from an offset of '0'. + * + * Reads 'block_count' blocks from 'dvd_file' at block offset 'offset' + * into the buffer located at 'data' and if 'encrypted' is set + * descramble the data if it's encrypted. Returning either an + * negative error or the number of blocks read. */ +static int DVDReadBlocksPath( const dvd_file_t *dvd_file, unsigned int offset, + size_t block_count, unsigned char *data, + int encrypted ) +{ + const dvd_reader_t *ctx = dvd_file->ctx; + int i; + int ret, ret2, off; + + ret = 0; + ret2 = 0; + for( i = 0; i < TITLES_MAX; ++i ) { + if( !dvd_file->title_sizes[ i ] ) return 0; /* Past end of file */ + + if( offset < dvd_file->title_sizes[ i ] ) { + if( ( offset + block_count ) <= dvd_file->title_sizes[ i ] ) { + off = dvdinput_seek( dvd_file->title_devs[ i ], (int)offset ); + if( off < 0 || off != (int)offset ) { + Log1(ctx, "Can't seek to block %u", offset ); + return off < 0 ? off : 0; + } + ret = dvdinput_read( dvd_file->title_devs[ i ], data, + (int)block_count, encrypted ); + break; + } else { + size_t part1_size = dvd_file->title_sizes[ i ] - offset; + /* FIXME: Really needs to be a while loop. + * (This is only true if you try and read >1GB at a time) */ + + /* Read part 1 */ + off = dvdinput_seek( dvd_file->title_devs[ i ], (int)offset ); + if( off < 0 || off != (int)offset ) { + Log1(ctx, "Can't seek to block %u", offset ); + return off < 0 ? off : 0; + } + ret = dvdinput_read( dvd_file->title_devs[ i ], data, + (int)part1_size, encrypted ); + if( ret < 0 ) return ret; + /* FIXME: This is wrong if i is the last file in the set. + * also error from this read will not show in ret. */ + + /* Does the next part exist? If not then return now. */ + if( i + 1 >= TITLES_MAX || !dvd_file->title_devs[ i + 1 ] ) + return ret; + + /* Read part 2 */ + off = dvdinput_seek( dvd_file->title_devs[ i + 1 ], 0 ); + if( off < 0 || off != 0 ) { + Log1(ctx, "Can't seek to block %d", 0 ); + return off < 0 ? off : 0; + } + ret2 = dvdinput_read( dvd_file->title_devs[ i + 1 ], + data + ( part1_size + * (int64_t)DVD_VIDEO_LB_LEN ), + (int)(block_count - part1_size), + encrypted ); + if( ret2 < 0 ) return ret2; + break; + } + } else { + offset -= dvd_file->title_sizes[ i ]; + } + } + + return ret + ret2; +} + +/* This is broken reading more than 2Gb at a time is ssize_t is 32-bit. */ +ssize_t DVDReadBlocks( dvd_file_t *dvd_file, int offset, + size_t block_count, unsigned char *data ) +{ + dvd_reader_t *ctx = dvd_file->ctx; + dvd_reader_device_t *dvd = ctx->rd; + int ret; + + /* Check arguments. */ + if( dvd_file == NULL || offset < 0 || data == NULL ) + return -1; + + /* Hack, and it will still fail for multiple opens in a threaded app ! */ + if( dvd->css_title != dvd_file->css_title ) { + dvd->css_title = dvd_file->css_title; + if( dvd->isImageFile ) { + dvdinput_title( dvd->dev, (int)dvd_file->lb_start ); + } + /* Here each vobu has it's own dvdcss handle, so no need to update + else { + dvdinput_title( dvd_file->title_devs[ 0 ], (int)dvd_file->lb_start ); + }*/ + } + + if( dvd->isImageFile ) { + ret = DVDReadBlocksUDF( dvd_file, (uint32_t)offset, + block_count, data, DVDINPUT_READ_DECRYPT ); + } else { + ret = DVDReadBlocksPath( dvd_file, (unsigned int)offset, + block_count, data, DVDINPUT_READ_DECRYPT ); + } + + return (ssize_t)ret; +} + +int32_t DVDFileSeek( dvd_file_t *dvd_file, int32_t offset ) +{ + /* Check arguments. */ + if( dvd_file == NULL || offset < 0 ) + return -1; + + if( offset > dvd_file->filesize * DVD_VIDEO_LB_LEN ) { + return -1; + } + dvd_file->seek_pos = (uint32_t) offset; + return offset; +} + +int DVDFileSeekForce(dvd_file_t *dvd_file, int offset, int force_size) +{ + dvd_reader_t *ctx = dvd_file->ctx; + dvd_reader_device_t *dvd = ctx->rd; + /* Check arguments. */ + if( dvd_file == NULL || offset <= 0 ) + return -1; + + if( dvd->isImageFile ) { + if( force_size < 0 ) + force_size = (offset - 1) / DVD_VIDEO_LB_LEN + 1; + if( dvd_file->filesize < force_size ) { + dvd_file->filesize = force_size; + free(dvd_file->cache); + dvd_file->cache = NULL; + Log2(ctx, "Ignored size of file indicated in UDF."); + } + } + + if( offset > dvd_file->filesize * DVD_VIDEO_LB_LEN ) + return -1; + + dvd_file->seek_pos = (uint32_t) offset; + return offset; +} + +ssize_t DVDReadBytes( dvd_file_t *dvd_file, void *data, size_t byte_size ) +{ + dvd_reader_t *ctx = dvd_file->ctx; + dvd_reader_device_t *dvd = ctx->rd; + unsigned char *secbuf_base, *secbuf; + unsigned int numsec, seek_sector, seek_byte; + int ret; + + /* Check arguments. */ + if( dvd_file == NULL || data == NULL || (ssize_t)byte_size < 0 ) + return -1; + + seek_sector = dvd_file->seek_pos / DVD_VIDEO_LB_LEN; + seek_byte = dvd_file->seek_pos % DVD_VIDEO_LB_LEN; + + numsec = ( ( seek_byte + byte_size ) / DVD_VIDEO_LB_LEN ) + + ( ( ( seek_byte + byte_size ) % DVD_VIDEO_LB_LEN ) ? 1 : 0 ); + + secbuf_base = malloc( numsec * DVD_VIDEO_LB_LEN + 2048 ); + if( !secbuf_base ) { + Log0(ctx, "Can't allocate memory for file read" ); + return 0; + } + secbuf = (unsigned char *)(((uintptr_t)secbuf_base & ~((uintptr_t)2047)) + 2048); + + if( dvd->isImageFile ) { + ret = DVDReadBlocksUDF( dvd_file, (uint32_t) seek_sector, + (size_t) numsec, secbuf, DVDINPUT_NOFLAGS ); + } else { + ret = DVDReadBlocksPath( dvd_file, seek_sector, + (size_t) numsec, secbuf, DVDINPUT_NOFLAGS ); + } + + if( ret != (int) numsec ) { + free( secbuf_base ); + return ret < 0 ? ret : 0; + } + + memcpy( data, &(secbuf[ seek_byte ]), byte_size ); + free( secbuf_base ); + + DVDFileSeekForce(dvd_file, dvd_file->seek_pos + byte_size, -1); + return byte_size; +} + +ssize_t DVDFileSize( dvd_file_t *dvd_file ) +{ + /* Check arguments. */ + if( dvd_file == NULL ) + return -1; + + return dvd_file->filesize; +} + +int DVDDiscID( dvd_reader_t *dvd, unsigned char *discid ) +{ + struct md5_s ctx; + int title; + int title_sets; + int nr_of_files = 0; + ifo_handle_t *vmg_ifo; + + /* Check arguments. */ + if( dvd == NULL || discid == NULL ) + return 0; + + vmg_ifo = ifoOpen( dvd, 0 ); + if( !vmg_ifo ) { + Log0(dvd, "DVDDiscId, failed to open VMG IFO" ); + return -1; + } + + title_sets = vmg_ifo->vmgi_mat->vmg_nr_of_title_sets + 1; + ifoClose( vmg_ifo ); + + if( title_sets > 10 ) + title_sets = 10; + + /* Go through the first IFO:s, in order, up until the tenth, + * and md5sum them, i.e VIDEO_TS.IFO and VTS_0?_0.IFO */ + InitMD5( &ctx ); + for( title = 0; title < title_sets; title++ ) { + dvd_file_t *dvd_file = DVDOpenFile( dvd, title, DVD_READ_INFO_FILE ); + if( dvd_file != NULL ) { + ssize_t bytes_read; + ssize_t file_size = dvd_file->filesize * DVD_VIDEO_LB_LEN; + char *buffer_base = malloc( file_size + 2048 ); + + if( buffer_base == NULL ) { + DVDCloseFile( dvd_file ); + Log0(dvd, "DVDDiscId, failed to allocate memory for file read" ); + return -1; + } + + char *buffer = (char *)(((uintptr_t)buffer_base & ~((uintptr_t)2047)) + 2048); + + bytes_read = DVDReadBytes( dvd_file, buffer, file_size ); + if( bytes_read != file_size ) { + Log1(dvd, "DVDDiscId read returned %zd bytes" + ", wanted %zd", bytes_read, file_size ); + DVDCloseFile( dvd_file ); + free( buffer_base ); + return -1; + } + + AddMD5( &ctx, buffer, file_size ); + + DVDCloseFile( dvd_file ); + free( buffer_base ); + nr_of_files++; + } + } + EndMD5( &ctx ); + memcpy( discid, ctx.buf, 16 ); + if(!nr_of_files) + return -1; + + return 0; +} + + +int DVDISOVolumeInfo( dvd_reader_t *ctx, + char *volid, unsigned int volid_size, + unsigned char *volsetid, unsigned int volsetid_size ) +{ + dvd_reader_device_t *dvd = ctx->rd; + unsigned char *buffer, *buffer_base; + int ret; + + /* Check arguments. */ + if( dvd == NULL ) + return 0; + + if( dvd->dev == NULL ) { + /* No block access, so no ISO... */ + return -1; + } + + buffer_base = malloc( DVD_VIDEO_LB_LEN + 2048 ); + + if( buffer_base == NULL ) { + Log0(ctx, "DVDISOVolumeInfo, failed to " + "allocate memory for file read" ); + return -1; + } + + buffer = (unsigned char *)(((uintptr_t)buffer_base & ~((uintptr_t)2047)) + 2048); + + ret = InternalUDFReadBlocksRaw( ctx, 16, 1, buffer, 0 ); + if( ret != 1 ) { + Log0(ctx, "DVDISOVolumeInfo, failed to " + "read ISO9660 Primary Volume Descriptor" ); + free( buffer_base ); + return -1; + } + + if( (volid != NULL) && (volid_size > 0) ) { + unsigned int n; + for(n = 0; n < 32; n++) { + if(buffer[40+n] == 0x20) { + break; + } + } + + if(volid_size > n+1) { + volid_size = n+1; + } + + memcpy(volid, &buffer[40], volid_size-1); + volid[volid_size-1] = '\0'; + } + + if( (volsetid != NULL) && (volsetid_size > 0) ) { + if(volsetid_size > 128) { + volsetid_size = 128; + } + memcpy(volsetid, &buffer[190], volsetid_size); + } + free( buffer_base ); + return 0; +} + + +int DVDUDFVolumeInfo( dvd_reader_t *ctx, + char *volid, unsigned int volid_size, + unsigned char *volsetid, unsigned int volsetid_size ) +{ + int ret; + /* Check arguments. */ + if( ctx == NULL || ctx->rd == NULL ) + return -1; + + if( ctx->rd->dev == NULL ) { + /* No block access, so no UDF VolumeSet Identifier */ + return -1; + } + + if( (volid != NULL) && (volid_size > 0) ) { + ret = UDFGetVolumeIdentifier(ctx, volid, volid_size); + if(!ret) { + return -1; + } + } + if( (volsetid != NULL) && (volsetid_size > 0) ) { + ret = UDFGetVolumeSetIdentifier(ctx, volsetid, volsetid_size); + if(!ret) { + return -1; + } + } + + return 0; +} diff --git a/libdvdread-embedded/src/dvd_udf.c b/libdvdread-embedded/src/dvd_udf.c new file mode 100644 index 0000000..4d90ba4 --- /dev/null +++ b/libdvdread-embedded/src/dvd_udf.c @@ -0,0 +1,1033 @@ +/* + * This code is based on dvdudf by: + * Christian Wolff <scarabaeus@convergence.de>. + * + * Modifications by: + * Billy Biggs <vektor@dumbterm.net>. + * Björn Englund <d4bjorn@dtek.chalmers.se>. + * + * dvdudf: parse and read the UDF volume information of a DVD Video + * Copyright (C) 1999 Christian Wolff for convergence integrated media + * GmbH The author can be reached at scarabaeus@convergence.de, the + * project's page is at http://linuxtv.org/dvd/ + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <strings.h> + +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#include <inttypes.h> + +#include "dvdread_internal.h" +#include "dvdread/dvd_reader.h" +#include "dvdread/dvd_udf.h" + +/* It's required to either fail or deliver all the blocks asked for. */ +static int DVDReadLBUDF( dvd_reader_t *ctx, uint32_t lb_number, + size_t block_count, unsigned char *data, + int encrypted ) +{ + size_t count = block_count; + + while(count > 0) { + int ret; + + ret = InternalUDFReadBlocksRaw(ctx, lb_number, count, data + DVD_VIDEO_LB_LEN * (block_count - count), encrypted); + + if(ret <= 0) { + /* One of the reads failed or nothing more to read, too bad. + * We won't even bother returning the reads that went ok. */ + return ret; + } + + count -= (size_t)ret; + lb_number += (uint32_t)ret; + } + + return block_count; +} + + +#ifndef NULL +#define NULL ((void *)0) +#endif + +struct Partition { + int valid; + uint16_t Flags; + uint16_t Number; + char Contents[32]; + uint32_t AccessType; + uint32_t Start; + uint32_t Length; +}; + +struct AD { + uint32_t Location; + uint32_t Length; + uint8_t Flags; + uint16_t Partition; +}; + +struct extent_ad { + uint32_t location; + uint32_t length; +}; + +struct avdp_t { + struct extent_ad mvds; + struct extent_ad rvds; +}; + +struct pvd_t { + uint8_t VolumeIdentifier[32]; + uint8_t VolumeSetIdentifier[128]; +}; + +struct lbudf { + uint32_t lb; + uint8_t *data; + /* needed for proper freeing */ + uint8_t *data_base; +}; + +struct icbmap { + uint32_t lbn; + struct AD file; + uint8_t filetype; +}; + +struct udf_cache { + int avdp_valid; + struct avdp_t avdp; + int pvd_valid; + struct pvd_t pvd; + int partition_valid; + struct Partition partition; + int rooticb_valid; + struct AD rooticb; + int lb_num; + struct lbudf *lbs; + int map_num; + struct icbmap *maps; +}; + +typedef enum { + PartitionCache, RootICBCache, LBUDFCache, MapCache, AVDPCache, PVDCache +} UDFCacheType; + +void FreeUDFCache(void *cache) +{ + struct udf_cache *c = (struct udf_cache *)cache; + if(c == NULL) + return; + + if(c->lbs) { + int n; + for(n = 0; n < c->lb_num; n++) + free(c->lbs[n].data_base); + free(c->lbs); + } + if(c->maps) + free(c->maps); + free(c); +} + + +static int GetUDFCache(dvd_reader_t *ctx, UDFCacheType type, + uint32_t nr, void *data) +{ + int n; + struct udf_cache *c; + + if(DVDUDFCacheLevel(ctx, -1) <= 0) + return 0; + + c = (struct udf_cache *)GetUDFCacheHandle(ctx); + + if(c == NULL) + return 0; + + switch(type) { + case AVDPCache: + if(c->avdp_valid) { + *(struct avdp_t *)data = c->avdp; + return 1; + } + break; + case PVDCache: + if(c->pvd_valid) { + *(struct pvd_t *)data = c->pvd; + return 1; + } + break; + case PartitionCache: + if(c->partition_valid) { + *(struct Partition *)data = c->partition; + return 1; + } + break; + case RootICBCache: + if(c->rooticb_valid) { + *(struct AD *)data = c->rooticb; + return 1; + } + break; + case LBUDFCache: + for(n = 0; n < c->lb_num; n++) { + if(c->lbs[n].lb == nr) { + *(uint8_t **)data = c->lbs[n].data; + return 1; + } + } + break; + case MapCache: + for(n = 0; n < c->map_num; n++) { + if(c->maps[n].lbn == nr) { + *(struct icbmap *)data = c->maps[n]; + return 1; + } + } + break; + default: + break; + } + + return 0; +} + +static int SetUDFCache(dvd_reader_t *ctx, UDFCacheType type, + uint32_t nr, void *data) +{ + int n; + struct udf_cache *c; + void *tmp; + + if(DVDUDFCacheLevel(ctx, -1) <= 0) + return 0; + + c = (struct udf_cache *)GetUDFCacheHandle(ctx); + + if(c == NULL) { + c = calloc(1, sizeof(struct udf_cache)); + /* Log3(ctx, "calloc: %d", sizeof(struct udf_cache)); */ + if(c == NULL) + return 0; + SetUDFCacheHandle(ctx, c); + } + + + switch(type) { + case AVDPCache: + c->avdp = *(struct avdp_t *)data; + c->avdp_valid = 1; + break; + case PVDCache: + c->pvd = *(struct pvd_t *)data; + c->pvd_valid = 1; + break; + case PartitionCache: + c->partition = *(struct Partition *)data; + c->partition_valid = 1; + break; + case RootICBCache: + c->rooticb = *(struct AD *)data; + c->rooticb_valid = 1; + break; + case LBUDFCache: + for(n = 0; n < c->lb_num; n++) { + if(c->lbs[n].lb == nr) { + /* replace with new data */ + c->lbs[n].data_base = ((uint8_t **)data)[0]; + c->lbs[n].data = ((uint8_t **)data)[1]; + c->lbs[n].lb = nr; + return 1; + } + } + c->lb_num++; + tmp = realloc(c->lbs, c->lb_num * sizeof(struct lbudf)); + /* + Log3(ctx, "realloc lb: %d * %d = %d", + c->lb_num, sizeof(struct lbudf), + c->lb_num * sizeof(struct lbudf)); + */ + if(tmp == NULL) { + if(c->lbs) free(c->lbs); + c->lb_num = 0; + return 0; + } + c->lbs = tmp; + c->lbs[n].data_base = ((uint8_t **)data)[0]; + c->lbs[n].data = ((uint8_t **)data)[1]; + c->lbs[n].lb = nr; + break; + case MapCache: + for(n = 0; n < c->map_num; n++) { + if(c->maps[n].lbn == nr) { + /* replace with new data */ + c->maps[n] = *(struct icbmap *)data; + c->maps[n].lbn = nr; + return 1; + } + } + c->map_num++; + tmp = realloc(c->maps, c->map_num * sizeof(struct icbmap)); + /* + Log3(ctx, "realloc maps: %d * %d = %d\n", + c->map_num, sizeof(struct icbmap), + c->map_num * sizeof(struct icbmap)); + */ + if(tmp == NULL) { + if(c->maps) free(c->maps); + c->map_num = 0; + return 0; + } + c->maps = tmp; + c->maps[n] = *(struct icbmap *)data; + c->maps[n].lbn = nr; + break; + default: + return 0; + } + + return 1; +} + + +/* For direct data access, LSB first */ +#define GETN1(p) ((uint8_t)data[p]) +#define GETN2(p) ((uint16_t)data[p] | ((uint16_t)data[(p) + 1] << 8)) +#define GETN3(p) ((uint32_t)data[p] | ((uint32_t)data[(p) + 1] << 8) \ + | ((uint32_t)data[(p) + 2] << 16)) +#define GETN4(p) ((uint32_t)data[p] \ + | ((uint32_t)data[(p) + 1] << 8) \ + | ((uint32_t)data[(p) + 2] << 16) \ + | ((uint32_t)data[(p) + 3] << 24)) +/* This is wrong with regard to endianness */ +#define GETN(p, n, target) memcpy(target, &data[p], n) + +static int Unicodedecode( uint8_t *data, int len, char *target ) +{ + int p = 1, i = 0; + int err = 0; + + if( ( data[ 0 ] == 8 ) || ( data[ 0 ] == 16 ) ) do { + if( data[ 0 ] == 16 ) err |= data[p++]; /* character cannot be converted to 8bit, return error */ + if( p < len ) { + target[ i++ ] = data[ p++ ]; + } + } while( p < len ); + + target[ i ] = '\0'; + return !err; +} + +static int UDFDescriptor( uint8_t *data, uint16_t *TagID ) +{ + *TagID = GETN2(0); + /* TODO: check CRC 'n stuff */ + return 0; +} + +static int UDFExtentAD( uint8_t *data, uint32_t *Length, uint32_t *Location ) +{ + *Length = GETN4(0); + *Location = GETN4(4); + return 0; +} + +static int UDFShortAD( uint8_t *data, struct AD *ad, + struct Partition *partition ) +{ + ad->Length = GETN4(0); + ad->Flags = ad->Length >> 30; + ad->Length &= 0x3FFFFFFF; + ad->Location = GETN4(4); + ad->Partition = partition->Number; /* use number of current partition */ + return 0; +} + +static int UDFLongAD( uint8_t *data, struct AD *ad ) +{ + ad->Length = GETN4(0); + ad->Flags = ad->Length >> 30; + ad->Length &= 0x3FFFFFFF; + ad->Location = GETN4(4); + ad->Partition = GETN2(8); + /* GETN(10, 6, Use); */ + return 0; +} + +static int UDFExtAD( uint8_t *data, struct AD *ad ) +{ + ad->Length = GETN4(0); + ad->Flags = ad->Length >> 30; + ad->Length &= 0x3FFFFFFF; + ad->Location = GETN4(12); + ad->Partition = GETN2(16); + /* GETN(10, 6, Use); */ + return 0; +} + +static int UDFICB( uint8_t *data, uint8_t *FileType, uint16_t *Flags ) +{ + *FileType = GETN1(11); + *Flags = GETN2(18); + return 0; +} + + +static int UDFPartition( uint8_t *data, uint16_t *Flags, uint16_t *Number, + char *Contents, uint32_t *Start, uint32_t *Length ) +{ + *Flags = GETN2(20); + *Number = GETN2(22); + GETN(24, 32, Contents); + *Start = GETN4(188); + *Length = GETN4(192); + return 0; +} + +/** + * Reads the volume descriptor and checks the parameters. Returns 0 on OK, 1 + * on error. + */ +static int UDFLogVolume( uint8_t *data ) +{ + uint32_t lbsize; + lbsize = GETN4(212); /* should be 2048 */ + /* MT_L = GETN4(264); */ /* should be 6 */ + /* N_PM = GETN4(268); */ /* should be 1 */ + if (lbsize != DVD_VIDEO_LB_LEN) + return 1; + + return 0; +} + +static int UDFFileEntry( uint8_t *data, uint8_t *FileType, + struct Partition *partition, struct AD *ad ) +{ + uint16_t flags; + uint32_t L_EA, L_AD; + unsigned int p; + struct AD tmpad; + + UDFICB( &data[ 16 ], FileType, &flags ); + + /* Init ad for an empty file (i.e. there isn't a AD, L_AD == 0 ) */ + ad->Length = GETN4( 60 ); /* Really 8 bytes a 56 */ + ad->Flags = 0; + ad->Location = 0; /* what should we put here? */ + ad->Partition = partition->Number; /* use number of current partition */ + + L_EA = GETN4( 168 ); + L_AD = GETN4( 172 ); + + if (176 + L_EA + L_AD > DVD_VIDEO_LB_LEN) + return 0; + + p = 176 + L_EA; + while( p < 176 + L_EA + L_AD ) { + switch( flags & 0x0007 ) { + case 0: + UDFShortAD( &data[ p ], &tmpad, partition ); + if( ad->Location == 0 ) /* We do not support more than one AD */ + *ad = tmpad; /* This was exploited by copy protections adding empty AD */ + p += 8; + break; + case 1: /* FIXME ? UDF 2.60 2.3.7.1 Only Short Allocation Descriptors shall be used */ + UDFLongAD( &data[ p ], ad ); + p += 16; + break; + case 2: + UDFExtAD( &data[ p ], ad ); + p += 20; + break; + case 3: + switch( L_AD ) { + case 8: + UDFShortAD( &data[ p ], ad, partition ); + break; + case 16: + UDFLongAD( &data[ p ], ad ); + break; + case 20: + UDFExtAD( &data[ p ], ad ); + break; + } + p += L_AD; + break; + default: + p += L_AD; + break; + } + } + return 0; +} + +static int UDFFileIdentifier( uint8_t *data, uint8_t *FileCharacteristics, + char *FileName, struct AD *FileICB ) +{ + uint8_t L_FI; + uint16_t L_IU; + + *FileCharacteristics = GETN1(18); + L_FI = GETN1(19); + UDFLongAD(&data[20], FileICB); + L_IU = GETN2(36); + if (L_FI) { + if (!Unicodedecode(&data[38 + L_IU], L_FI, FileName)) FileName[0] = 0; + } else FileName[0] = '\0'; + return 4 * ((38 + L_FI + L_IU + 3) / 4); +} + +/** + * Maps ICB to FileAD + * ICB: Location of ICB of directory to scan + * FileType: Type of the file + * File: Location of file the ICB is pointing to + * return 1 on success, 0 on error; + */ +static int UDFMapICB( dvd_reader_t *ctx, struct AD ICB, uint8_t *FileType, + struct Partition *partition, struct AD *File ) +{ + uint8_t LogBlock_base[DVD_VIDEO_LB_LEN + 2048]; + uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048); + uint32_t lbnum; + uint16_t TagID; + struct icbmap tmpmap; + int ret; + + lbnum = partition->Start + ICB.Location; + tmpmap.lbn = lbnum; + if(GetUDFCache(ctx, MapCache, lbnum, &tmpmap)) { + *FileType = tmpmap.filetype; + memcpy(File, &tmpmap.file, sizeof(tmpmap.file)); + return 1; + } + + do { + ret = DVDReadLBUDF( ctx, lbnum++, 1, LogBlock, 0 ); + if( ret < 0 ) { + return ret; + } + else if( ret == 0 ) { + TagID = 0; + } + else { + UDFDescriptor( LogBlock, &TagID ); + } + + if( TagID == FileEntry ) { + UDFFileEntry( LogBlock, FileType, partition, File ); + memcpy(&tmpmap.file, File, sizeof(tmpmap.file)); + tmpmap.filetype = *FileType; + SetUDFCache(ctx, MapCache, tmpmap.lbn, &tmpmap); + return 1; + }; + } while( ( lbnum <= partition->Start + ICB.Location + ( ICB.Length - 1 ) + / DVD_VIDEO_LB_LEN ) && ( TagID != FileEntry ) ); + + return 0; +} + +/** + * Dir: Location of directory to scan + * FileName: Name of file to look for + * FileICB: Location of ICB of the found file + * return 1 on success, 0 on error; + */ +static int UDFScanDir( dvd_reader_t *ctx, struct AD Dir, char *FileName, + struct Partition *partition, struct AD *FileICB, + int cache_file_info) +{ + char filename[ MAX_UDF_FILE_NAME_LEN ]; + uint8_t directory_base[ 2 * DVD_VIDEO_LB_LEN + 2048]; + uint8_t *directory = (uint8_t *)(((uintptr_t)directory_base & ~((uintptr_t)2047)) + 2048); + uint32_t lbnum; + uint16_t TagID; + uint8_t filechar; + unsigned int p; + uint8_t *cached_dir_base = NULL, *cached_dir; + uint32_t dir_lba; + struct AD tmpICB; + int ret; + + /* Scan dir for ICB of file */ + lbnum = partition->Start + Dir.Location; + + if(DVDUDFCacheLevel(ctx, -1) > 0) { + int found = 0; + int in_cache = 0; + + /* caching */ + + if(!GetUDFCache(ctx, LBUDFCache, lbnum, &cached_dir)) { + dir_lba = (Dir.Length + DVD_VIDEO_LB_LEN) / DVD_VIDEO_LB_LEN; + if((cached_dir_base = malloc(dir_lba * DVD_VIDEO_LB_LEN + 2048)) == NULL) + return 0; + cached_dir = (uint8_t *)(((uintptr_t)cached_dir_base & ~((uintptr_t)2047)) + 2048); + ret = DVDReadLBUDF( ctx, lbnum, dir_lba, cached_dir, 0); + if( ret <= 0 ) { + free(cached_dir_base); + cached_dir_base = NULL; + cached_dir = NULL; + if( ret < 0 ) + return ret; + } + /* + if(cached_dir) { + Log3(ctx, "malloc dir: %d", dir_lba * DVD_VIDEO_LB_LEN); + } + */ + { + uint8_t *data[2]; + data[0] = cached_dir_base; + data[1] = cached_dir; + SetUDFCache(ctx, LBUDFCache, lbnum, data); + } + } else + in_cache = 1; + + if(cached_dir == NULL) { + free(cached_dir_base); + return 0; + } + + p = 0; + + while( p < Dir.Length ) { + + UDFDescriptor( &cached_dir[ p ], &TagID ); + if( TagID == FileIdentifierDescriptor ) { + p += UDFFileIdentifier( &cached_dir[ p ], &filechar, + filename, &tmpICB ); + if(cache_file_info && !in_cache) { + uint8_t tmpFiletype; + struct AD tmpFile; + + if( !strcasecmp( FileName, filename ) ) { + memcpy(FileICB, &tmpICB, sizeof(tmpICB)); + found = 1; + } + if(!UDFMapICB(ctx, tmpICB, &tmpFiletype, partition, &tmpFile)) + return 0; + + } else { + if( !strcasecmp( FileName, filename ) ) { + memcpy(FileICB, &tmpICB, sizeof(tmpICB)); + return 1; + } + } + } else { + if(cache_file_info && (!in_cache) && found) + return 1; + return 0; + } + } + if(cache_file_info && (!in_cache) && found) + return 1; + return 0; + } + + if( DVDReadLBUDF( ctx, lbnum, 2, directory, 0 ) <= 0 ) + return 0; + + p = 0; + while( p < Dir.Length ) { + if( p > DVD_VIDEO_LB_LEN ) { + ++lbnum; + p -= DVD_VIDEO_LB_LEN; + Dir.Length -= DVD_VIDEO_LB_LEN; + if( DVDReadLBUDF( ctx, lbnum, 2, directory, 0 ) <= 0 ) { + return 0; + } + } + UDFDescriptor( &directory[ p ], &TagID ); + if( TagID == FileIdentifierDescriptor ) { + p += UDFFileIdentifier( &directory[ p ], &filechar, + filename, FileICB ); + if( !strcasecmp( FileName, filename ) ) { + return 1; + } + } else + return 0; + } + + return 0; +} + + +static int UDFGetAVDP( dvd_reader_t *ctx, + struct avdp_t *avdp) +{ + uint8_t Anchor_base[ DVD_VIDEO_LB_LEN + 2048 ]; + uint8_t *Anchor = (uint8_t *)(((uintptr_t)Anchor_base & ~((uintptr_t)2047)) + 2048); + uint32_t lbnum, MVDS_location, MVDS_length; + uint16_t TagID; + uint32_t lastsector; + int terminate; + struct avdp_t; + int ret; + + if(GetUDFCache(ctx, AVDPCache, 0, avdp)) + return 1; + + /* Find Anchor */ + lastsector = 0; + lbnum = 256; /* Try #1, prime anchor */ + terminate = 0; + + for(;;) { + ret = DVDReadLBUDF( ctx, lbnum, 1, Anchor, 0 ); + if( ret < 0 ) { + return ret; + } + else if( ret == 0 ) { + TagID = 0; + } + else { + UDFDescriptor( Anchor, &TagID ); + } + if (TagID != AnchorVolumeDescriptorPointer) { + /* Not an anchor */ + if( terminate ) return 0; /* Final try failed */ + + if( lastsector ) { + /* We already found the last sector. Try #3, alternative + * backup anchor. If that fails, don't try again. + */ + lbnum = lastsector; + terminate = 1; + } else { + /* TODO: Find last sector of the disc (this is optional). */ + if( lastsector ) + /* Try #2, backup anchor */ + lbnum = lastsector - 256; + else + /* Unable to find last sector */ + return 0; + } + } else + /* It's an anchor! We can leave */ + break; + } + /* Main volume descriptor */ + UDFExtentAD( &Anchor[ 16 ], &MVDS_length, &MVDS_location ); + avdp->mvds.location = MVDS_location; + avdp->mvds.length = MVDS_length; + + /* Backup volume descriptor */ + UDFExtentAD( &Anchor[ 24 ], &MVDS_length, &MVDS_location ); + avdp->rvds.location = MVDS_location; + avdp->rvds.length = MVDS_length; + + SetUDFCache(ctx, AVDPCache, 0, avdp); + + return 1; +} + +/** + * Looks for partition on the disc. Returns 1 if partition found, 0 on error. + * partnum: Number of the partition, starting at 0. + * part: structure to fill with the partition information + */ +static int UDFFindPartition( dvd_reader_t *ctx, int partnum, + struct Partition *part ) +{ + uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ]; + uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048); + uint32_t lbnum, MVDS_location, MVDS_length; + uint16_t TagID; + int i, volvalid, ret; + struct avdp_t avdp; + + if(!UDFGetAVDP(ctx, &avdp)) + return 0; + + /* Main volume descriptor */ + MVDS_location = avdp.mvds.location; + MVDS_length = avdp.mvds.length; + + part->valid = 0; + volvalid = 0; + i = 1; + do { + /* Find Volume Descriptor */ + lbnum = MVDS_location; + do { + + ret = DVDReadLBUDF( ctx, lbnum++, 1, LogBlock, 0 ); + if( ret < 0 ) { + return ret; + } + else if( ret == 0 ) { + TagID = 0; + } + else { + UDFDescriptor( LogBlock, &TagID ); + } + + if( ( TagID == PartitionDescriptor ) && ( !part->valid ) ) { + /* Partition Descriptor */ + UDFPartition( LogBlock, &part->Flags, &part->Number, + part->Contents, &part->Start, &part->Length ); + part->valid = ( partnum == part->Number ); + } else if( ( TagID == LogicalVolumeDescriptor ) && ( !volvalid ) ) { + /* Logical Volume Descriptor */ + if( UDFLogVolume( LogBlock ) ) { + /* TODO: sector size wrong! */ + } else + volvalid = 1; + } + + } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 ) + / DVD_VIDEO_LB_LEN ) && ( TagID != TerminatingDescriptor ) + && ( ( !part->valid ) || ( !volvalid ) ) ); + + if( ( !part->valid) || ( !volvalid ) ) { + /* Backup volume descriptor */ + MVDS_location = avdp.mvds.location; + MVDS_length = avdp.mvds.length; + } + } while( i-- && ( ( !part->valid ) || ( !volvalid ) ) ); + + /* We only care for the partition, not the volume */ + return part->valid; +} + +uint32_t UDFFindFile( dvd_reader_t *ctx, const char *filename, + uint32_t *filesize ) +{ + uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ]; + uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048); + uint32_t lbnum; + uint16_t TagID; + struct Partition partition; + struct AD RootICB, File, ICB; + char tokenline[ MAX_UDF_FILE_NAME_LEN ]; + uint8_t filetype; + int ret; + + *filesize = 0; + tokenline[0] = '\0'; + strncat(tokenline, filename, MAX_UDF_FILE_NAME_LEN - 1); + memset(&ICB, 0, sizeof(ICB)); + + if(!(GetUDFCache(ctx, PartitionCache, 0, &partition) && + GetUDFCache(ctx, RootICBCache, 0, &RootICB))) { + /* Find partition, 0 is the standard location for DVD Video.*/ + if( !UDFFindPartition( ctx, 0, &partition ) ) return 0; + SetUDFCache(ctx, PartitionCache, 0, &partition); + + /* Find root dir ICB */ + lbnum = partition.Start; + do { + ret = DVDReadLBUDF( ctx, lbnum++, 1, LogBlock, 0 ); + if( ret < 0 ) { + return ret; + } + else if( ret == 0 ) { + TagID = 0; + } + else { + UDFDescriptor( LogBlock, &TagID ); + } + + /* File Set Descriptor */ + if( TagID == FileSetDescriptor ) /* File Set Descriptor */ + UDFLongAD( &LogBlock[ 400 ], &RootICB ); + } while( ( lbnum < partition.Start + partition.Length ) + && ( TagID != TerminatingDescriptor ) && ( TagID != FileSetDescriptor) ); + + /* Sanity checks. */ + if( TagID != FileSetDescriptor ) + return 0; + if( RootICB.Partition != 0 ) + return 0; + SetUDFCache(ctx, RootICBCache, 0, &RootICB); + } + + /* Find root dir */ + if( !UDFMapICB( ctx, RootICB, &filetype, &partition, &File ) ) + return 0; + if( filetype != 4 ) + return 0; /* Root dir should be dir */ + { + int cache_file_info = 0; + /* Tokenize filepath */ + char *token = strtok(tokenline, "/"); + + while( token != NULL ) { + if( !UDFScanDir( ctx, File, token, &partition, &ICB, + cache_file_info)) + return 0; + if( !UDFMapICB( ctx, ICB, &filetype, &partition, &File ) ) + return 0; + if(!strcmp(token, "VIDEO_TS")) + cache_file_info = 1; + token = strtok( NULL, "/" ); + } + } + + /* Sanity check. */ + if( File.Partition != 0 ) + return 0; + *filesize = File.Length; + /* Hack to not return partition.Start for empty files. */ + if( !File.Location ) + return 0; + else + return partition.Start + File.Location; +} + + + +/** + * Gets a Descriptor . + * Returns 1 if descriptor found, 0 on error. + * id, tagid of descriptor + * bufsize, size of BlockBuf (must be >= DVD_VIDEO_LB_LEN). + */ +static int UDFGetDescriptor( dvd_reader_t *ctx, int id, + uint8_t *descriptor, int bufsize) +{ + uint32_t lbnum, MVDS_location, MVDS_length; + struct avdp_t avdp; + uint16_t TagID; + int i, desc_found = 0, ret; + /* Find Anchor */ + lbnum = 256; /* Try #1, prime anchor */ + if(bufsize < DVD_VIDEO_LB_LEN) + return 0; + + if(!UDFGetAVDP(ctx, &avdp)) + return 0; + + /* Main volume descriptor */ + MVDS_location = avdp.mvds.location; + MVDS_length = avdp.mvds.length; + + i = 1; + do { + /* Find Descriptor */ + lbnum = MVDS_location; + do { + ret = DVDReadLBUDF( ctx, lbnum++, 1, descriptor, 0 ); + if( ret < 0 ) { + return ret; + } + else if( ret == 0 ) { + TagID = 0; + } + else { + UDFDescriptor( descriptor, &TagID ); + } + if( (TagID == id) && ( !desc_found ) ) + /* Descriptor */ + desc_found = 1; + } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 ) + / DVD_VIDEO_LB_LEN ) && ( TagID != TerminatingDescriptor ) + && ( !desc_found) ); + + if( !desc_found ) { + /* Backup volume descriptor */ + MVDS_location = avdp.rvds.location; + MVDS_length = avdp.rvds.length; + } + } while( i-- && ( !desc_found ) ); + + return desc_found; +} + + +static int UDFGetPVD(dvd_reader_t *ctx, struct pvd_t *pvd) +{ + uint8_t pvd_buf_base[DVD_VIDEO_LB_LEN + 2048]; + uint8_t *pvd_buf = (uint8_t *)(((uintptr_t)pvd_buf_base & ~((uintptr_t)2047)) + 2048); + if(GetUDFCache(ctx, PVDCache, 0, pvd)) + return 1; + + if(!UDFGetDescriptor( ctx, 1, pvd_buf, DVD_VIDEO_LB_LEN)) + return 0; + + memcpy(pvd->VolumeIdentifier, &pvd_buf[24], 32); + memcpy(pvd->VolumeSetIdentifier, &pvd_buf[72], 128); + SetUDFCache(ctx, PVDCache, 0, pvd); + return 1; +} + +/** + * Gets the Volume Identifier string, in 8bit unicode (latin-1) + * volid, place to put the string + * volid_size, size of the buffer volid points to + * returns the size of buffer needed for all data + */ +int UDFGetVolumeIdentifier(dvd_reader_t *ctx, char *volid, + unsigned int volid_size) +{ + struct pvd_t pvd; + unsigned int volid_len; + + /* get primary volume descriptor */ + if(!UDFGetPVD(ctx, &pvd)) + return 0; + + volid_len = pvd.VolumeIdentifier[31]; + if(volid_len > 31) + /* this field is only 32 bytes something is wrong */ + volid_len = 31; + if(volid_size > volid_len) + volid_size = volid_len; + Unicodedecode(pvd.VolumeIdentifier, volid_size, volid); + + return volid_len; +} + +/** + * Gets the Volume Set Identifier, as a 128-byte dstring (not decoded) + * WARNING This is not a null terminated string + * volsetid, place to put the data + * volsetid_size, size of the buffer volsetid points to + * the buffer should be >=128 bytes to store the whole volumesetidentifier + * returns the size of the available volsetid information (128) + * or 0 on error + */ +int UDFGetVolumeSetIdentifier(dvd_reader_t *ctx, uint8_t *volsetid, + unsigned int volsetid_size) +{ + struct pvd_t pvd; + + /* get primary volume descriptor */ + if(!UDFGetPVD(ctx, &pvd)) + return 0; + + + if(volsetid_size > 128) + volsetid_size = 128; + + memcpy(volsetid, pvd.VolumeSetIdentifier, volsetid_size); + + return 128; +} diff --git a/libdvdread-embedded/src/dvdread/bitreader.h b/libdvdread-embedded/src/dvdread/bitreader.h new file mode 100644 index 0000000..801e3a9 --- /dev/null +++ b/libdvdread-embedded/src/dvdread/bitreader.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2000, 2001, 2002 Håkan Hjort <d95hjort@dtek.chalmers.se>. + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_BITREADER_H +#define LIBDVDREAD_BITREADER_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + const uint8_t *start; + uint32_t byte_position; + uint32_t bit_position; +} getbits_state_t; + +int dvdread_getbits_init(getbits_state_t *state, const uint8_t *start); +uint32_t dvdread_getbits(getbits_state_t *state, uint32_t number_of_bits); + +#ifdef __cplusplus +}; +#endif +#endif /* LIBDVDREAD_BITREADER_H */ diff --git a/libdvdread-embedded/src/dvdread/dvd_reader.h b/libdvdread-embedded/src/dvdread/dvd_reader.h new file mode 100644 index 0000000..54ef5dd --- /dev/null +++ b/libdvdread-embedded/src/dvdread/dvd_reader.h @@ -0,0 +1,365 @@ +/* + * Copyright (C) 2001, 2002 Billy Biggs <vektor@dumbterm.net>, + * Håkan Hjort <d95hjort@dtek.chalmers.se>, + * Björn Englund <d4bjorn@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_DVD_READER_H +#define LIBDVDREAD_DVD_READER_H + +#ifdef _MSC_VER +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#endif + +#include <sys/types.h> +#include <inttypes.h> +#include <stdarg.h> + +/** + * The DVD access interface. + * + * This file contains the functions that form the interface for + * reading files located on a DVD. + */ + +/** + * The current version. + */ +#include "version.h" + +/** + * The length of one Logical Block of a DVD. + */ +#define DVD_VIDEO_LB_LEN 2048 + +/** + * Maximum length of filenames allowed in UDF. + */ +#define MAX_UDF_FILE_NAME_LEN 2048 + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Opaque type that is used as a handle for one instance of an opened DVD. + */ +typedef struct dvd_reader_s dvd_reader_t; +typedef struct dvd_reader_device_s dvd_reader_device_t; + +/** + * Opaque type for a file read handle, much like a normal fd or FILE *. + */ +typedef struct dvd_file_s dvd_file_t; + +struct dvd_reader_stream_cb +{ + int ( *pf_seek ) ( void *p_stream, uint64_t i_pos); + int ( *pf_read ) ( void *p_stream, void* buffer, int i_read); + int ( *pf_readv ) ( void *p_stream, void *p_iovec, int i_blocks); +}; +typedef struct dvd_reader_stream_cb dvd_reader_stream_cb; + +/** + * Custom logger callback for DVDOpen[Stream]2 + * @param private Handle as provided in Open functions + * @param level Log level + * @param fmt Format string + * @param args Arguments list + * pf_log(priv, level, fmt, args); + */ +typedef enum +{ + DVD_LOGGER_LEVEL_INFO, + DVD_LOGGER_LEVEL_ERROR, + DVD_LOGGER_LEVEL_WARN, + DVD_LOGGER_LEVEL_DEBUG, +} dvd_logger_level_t; + +typedef struct +{ + void ( *pf_log ) ( void *, dvd_logger_level_t, const char *, va_list ); +} dvd_logger_cb; + +/** + * Public type that is used to provide statistics on a handle. + */ +typedef struct { + off_t size; /**< Total size of file in bytes */ + int nr_parts; /**< Number of file parts */ + off_t parts_size[9]; /**< Size of each part in bytes */ +} dvd_stat_t; + +/** + * Opens a block device of a DVD-ROM file, or an image file, or a directory + * name for a mounted DVD or HD copy of a DVD. + * The second form of Open function (DVDOpenStream) can be used to + * provide custom stream_cb functions to access the DVD (see libdvdcss). + * + * If the given file is a block device, or is the mountpoint for a block + * device, then that device is used for CSS authentication using libdvdcss. + * If no device is available, then no CSS authentication is performed, + * and we hope that the image is decrypted. + * + * If the path given is a directory, then the files in that directory may be + * in any one of these formats: + * + * path/VIDEO_TS/VTS_01_1.VOB + * path/video_ts/vts_01_1.vob + * path/VTS_01_1.VOB + * path/vts_01_1.vob + * + * @param path Specifies the device, file or directory to be used. + * @param stream is a private handle used by stream_cb + * @param stream_cb is a struct containing seek and read functions + * @return If successful a read handle is returned. Otherwise 0 is returned. + * + * dvd = DVDOpen(path); + * dvd = DVDOpenStream(stream, &stream_cb); + */ +dvd_reader_t *DVDOpen( const char * ); +dvd_reader_t *DVDOpenStream( void *, dvd_reader_stream_cb * ); + +/** + * Same as DVDOpen, but with private handle to be passed back on callbacks + * + * @param path Specifies the device, file or directory to be used. + * @param priv is a private handle + * @param logcb is a custom logger callback struct, or NULL if none needed + * @param stream_cb is a struct containing seek and read functions + * @return If successful a read handle is returned. Otherwise 0 is returned. + * + * dvd = DVDOpen2(priv, logcb, path); + * dvd = DVDOpenStream2(priv, logcb, &stream_cb); + */ +dvd_reader_t *DVDOpen2( void *, const dvd_logger_cb *, const char * ); +dvd_reader_t *DVDOpenStream2( void *, const dvd_logger_cb *, dvd_reader_stream_cb * ); + +/** + * Closes and cleans up the DVD reader object. + * + * You must close all open files before calling this function. + * + * @param dvd A read handle that should be closed. + * + * DVDClose(dvd); + */ +void DVDClose( dvd_reader_t * ); + +/** + * + */ +typedef enum { + DVD_READ_INFO_FILE, /**< VIDEO_TS.IFO or VTS_XX_0.IFO (title) */ + DVD_READ_INFO_BACKUP_FILE, /**< VIDEO_TS.BUP or VTS_XX_0.BUP (title) */ + DVD_READ_MENU_VOBS, /**< VIDEO_TS.VOB or VTS_XX_0.VOB (title) */ + DVD_READ_TITLE_VOBS /**< VTS_XX_[1-9].VOB (title). All files in + the title set are opened and read as a + single file. */ +} dvd_read_domain_t; + +/** + * Stats a file on the DVD given the title number and domain. + * The information about the file is stored in a dvd_stat_t + * which contains information about the size of the file and + * the number of parts in case of a multipart file and the respective + * sizes of the parts. + * A multipart file is for instance VTS_02_1.VOB, VTS_02_2.VOB, VTS_02_3.VOB + * The size of VTS_02_1.VOB will be stored in stat->parts_size[0], + * VTS_02_2.VOB in stat->parts_size[1], ... + * The total size (sum of all parts) is stored in stat->size and + * stat->nr_parts will hold the number of parts. + * Only DVD_READ_TITLE_VOBS (VTS_??_[1-9].VOB) can be multipart files. + * + * This function is only of use if you want to get the size of each file + * in the filesystem. These sizes are not needed to use any other + * functions in libdvdread. + * + * @param dvd A dvd read handle. + * @param titlenum Which Video Title Set should be used, VIDEO_TS is 0. + * @param domain Which domain. + * @param stat Pointer to where the result is stored. + * @return If successful 0, otherwise -1. + * + * int DVDFileStat(dvd, titlenum, domain, stat); + */ +int DVDFileStat(dvd_reader_t *, int, dvd_read_domain_t, dvd_stat_t *); + +/** + * Opens a file on the DVD given the title number and domain. + * + * If the title number is 0, the video manager information is opened + * (VIDEO_TS.[IFO,BUP,VOB]). Returns a file structure which may be + * used for reads, or 0 if the file was not found. + * + * @param dvd A dvd read handle. + * @param titlenum Which Video Title Set should be used, VIDEO_TS is 0. + * @param domain Which domain. + * @return If successful a a file read handle is returned, otherwise 0. + * + * dvd_file = DVDOpenFile(dvd, titlenum, domain); */ +dvd_file_t *DVDOpenFile( dvd_reader_t *, int, dvd_read_domain_t ); + +/** + * Closes a file and frees the associated structure. + * + * @param dvd_file The file read handle to be closed. + * + * DVDCloseFile(dvd_file); + */ +void DVDCloseFile( dvd_file_t * ); + +/** + * Reads block_count number of blocks from the file at the given block offset. + * Returns number of blocks read on success, -1 on error. This call is only + * for reading VOB data, and should not be used when reading the IFO files. + * When reading from an encrypted drive, blocks are decrypted using libdvdcss + * where required. + * + * @param dvd_file A file read handle. + * @param offset Block offset from the start of the file to start reading at. + * @param block_count Number of block to read. + * @param data Pointer to a buffer to write the data into. + * @return Returns number of blocks read on success, -1 on error. + * + * blocks_read = DVDReadBlocks(dvd_file, offset, block_count, data); + */ +ssize_t DVDReadBlocks( dvd_file_t *, int, size_t, unsigned char * ); + +/** + * Seek to the given position in the file. Returns the resulting position in + * bytes from the beginning of the file. The seek position is only used for + * byte reads from the file, the block read call always reads from the given + * offset. + * + * @param dvd_file A file read handle. + * @param seek_offset Byte offset from the start of the file to seek to. + * @return The resulting position in bytes from the beginning of the file. + * + * offset_set = DVDFileSeek(dvd_file, seek_offset); + */ +int32_t DVDFileSeek( dvd_file_t *, int32_t ); + +/** + * Reads the given number of bytes from the file. This call can only be used + * on the information files, and may not be used for reading from a VOB. This + * reads from and increments the current seek position for the file. + * + * @param dvd_file A file read handle. + * @param data Pointer to a buffer to write the data into. + * @param bytes Number of bytes to read. + * @return Returns number of bytes read on success, -1 on error. + * + * bytes_read = DVDReadBytes(dvd_file, data, bytes); + */ +ssize_t DVDReadBytes( dvd_file_t *, void *, size_t ); + +/** + * Returns the file size in blocks. + * + * @param dvd_file A file read handle. + * @return The size of the file in blocks, -1 on error. + * + * blocks = DVDFileSize(dvd_file); + */ +ssize_t DVDFileSize( dvd_file_t * ); + +/** + * Get a unique 128 bit disc ID. + * This is the MD5 sum of VIDEO_TS.IFO and the VTS_0?_0.IFO files + * in title order (those that exist). + * If you need a 'text' representation of the id, print it as a + * hexadecimal number, using lowercase letters, discid[0] first. + * I.e. the same format as the command-line 'md5sum' program uses. + * + * @param dvd A read handle to get the disc ID from + * @param discid The buffer to put the disc ID into. The buffer must + * have room for 128 bits (16 chars). + * @return 0 on success, -1 on error. + */ +int DVDDiscID( dvd_reader_t *, unsigned char * ); + +/** + * Get the UDF VolumeIdentifier and VolumeSetIdentifier + * from the PrimaryVolumeDescriptor. + * + * @param dvd A read handle to get the disc ID from + * @param volid The buffer to put the VolumeIdentifier into. + * The VolumeIdentifier is latin-1 encoded (8bit unicode) + * null terminated and max 32 bytes (including '\0') + * @param volid_size No more than volid_size bytes will be copied to volid. + * If the VolumeIdentifier is truncated because of this + * it will still be null terminated. + * @param volsetid The buffer to put the VolumeSetIdentifier into. + * The VolumeIdentifier is 128 bytes as + * stored in the UDF PrimaryVolumeDescriptor. + * Note that this is not a null terminated string. + * @param volsetid_size At most volsetid_size bytes will be copied to volsetid. + * @return 0 on success, -1 on error. + */ +int DVDUDFVolumeInfo( dvd_reader_t *, char *, unsigned int, + unsigned char *, unsigned int ); + +int DVDFileSeekForce( dvd_file_t *, int offset, int force_size); + +/** + * Get the ISO9660 VolumeIdentifier and VolumeSetIdentifier + * + * * Only use this function as fallback if DVDUDFVolumeInfo returns -1 * + * * this will happen on a disc mastered only with a iso9660 filesystem * + * * All video DVD discs have UDF filesystem * + * + * @param dvd A read handle to get the disc ID from + * @param volid The buffer to put the VolumeIdentifier into. + * The VolumeIdentifier is coded with '0-9','A-Z','_' + * null terminated and max 33 bytes (including '\0') + * @param volid_size No more than volid_size bytes will be copied to volid. + * If the VolumeIdentifier is truncated because of this + * it will still be null terminated. + * @param volsetid The buffer to put the VolumeSetIdentifier into. + * The VolumeIdentifier is 128 bytes as + * stored in the ISO9660 PrimaryVolumeDescriptor. + * Note that this is not a null terminated string. + * @param volsetid_size At most volsetid_size bytes will be copied to volsetid. + * @return 0 on success, -1 on error. + */ +int DVDISOVolumeInfo( dvd_reader_t *, char *, unsigned int, + unsigned char *, unsigned int ); + +/** + * Sets the level of caching that is done when reading from a device + * + * @param dvd A read handle to get the disc ID from + * @param level The level of caching wanted. + * -1 - returns the current setting. + * 0 - UDF Cache turned off. + * 1 - (default level) Pointers to IFO files and some data from + * PrimaryVolumeDescriptor are cached. + * + * @return The level of caching. + */ +int DVDUDFCacheLevel( dvd_reader_t *, int ); + +#ifdef __cplusplus +}; +#endif +#endif /* LIBDVDREAD_DVD_READER_H */ diff --git a/libdvdread-embedded/src/dvdread/dvd_udf.h b/libdvdread-embedded/src/dvdread/dvd_udf.h new file mode 100644 index 0000000..91d5de6 --- /dev/null +++ b/libdvdread-embedded/src/dvdread/dvd_udf.h @@ -0,0 +1,59 @@ +/* + * This code is based on dvdudf by: + * Christian Wolff <scarabaeus@convergence.de>. + * + * Modifications by: + * Billy Biggs <vektor@dumbterm.net>. + * Björn Englund <d4bjorn@dtek.chalmers.se>. + * + * dvdudf: parse and read the UDF volume information of a DVD Video + * Copyright (C) 1999 Christian Wolff for convergence integrated media + * GmbH The author can be reached at scarabaeus@convergence.de, the + * project's page is at http://linuxtv.org/dvd/ + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_DVD_UDF_H +#define LIBDVDREAD_DVD_UDF_H + +#include <inttypes.h> + +#include "dvdread/dvd_reader.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Looks for a file on the UDF disc/imagefile and returns the block number + * where it begins, or 0 if it is not found. The filename should be an + * absolute pathname on the UDF filesystem, starting with '/'. For example, + * '/VIDEO_TS/VTS_01_1.IFO'. On success, filesize will be set to the size of + * the file in bytes. + */ +uint32_t UDFFindFile( dvd_reader_t *, const char *filename, uint32_t *size ); + +int UDFGetVolumeIdentifier(dvd_reader_t *, + char *volid, unsigned int volid_size); +int UDFGetVolumeSetIdentifier(dvd_reader_t *, + uint8_t *volsetid, unsigned int volsetid_size); + +#ifdef __cplusplus +}; +#endif +#endif /* LIBDVDREAD_DVD_UDF_H */ diff --git a/libdvdread-embedded/src/dvdread/ifo_print.h b/libdvdread-embedded/src/dvdread/ifo_print.h new file mode 100644 index 0000000..c3068cb --- /dev/null +++ b/libdvdread-embedded/src/dvdread/ifo_print.h @@ -0,0 +1,28 @@ +/* + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_IFO_PRINT_H +#define LIBDVDREAD_IFO_PRINT_H + +#include <inttypes.h> +#include "ifo_types.h" + +void ifo_print(dvd_reader_t *dvd, int title); +void dvdread_print_time(dvd_time_t *dtime); + +#endif /* LIBDVDREAD_IFO_PRINT_H */ diff --git a/libdvdread-embedded/src/dvdread/ifo_read.h b/libdvdread-embedded/src/dvdread/ifo_read.h new file mode 100644 index 0000000..df538a8 --- /dev/null +++ b/libdvdread-embedded/src/dvdread/ifo_read.h @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2000, 2001, 2002 Björn Englund <d4bjorn@dtek.chalmers.se>, + * Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_IFO_READ_H +#define LIBDVDREAD_IFO_READ_H + +#include "ifo_types.h" +#include "dvdread/dvd_reader.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * handle = ifoOpen(dvd, title); + * + * Opens an IFO and reads in all the data for the IFO file corresponding to the + * given title. If title 0 is given, the video manager IFO file is read. + * Returns a handle to a completely parsed structure. + */ +ifo_handle_t *ifoOpen(dvd_reader_t *, int ); + +/** + * handle = ifoOpenVMGI(dvd); + * + * Opens an IFO and reads in _only_ the vmgi_mat data. This call can be used + * together with the calls below to read in each segment of the IFO file on + * demand. + */ +ifo_handle_t *ifoOpenVMGI(dvd_reader_t *); + +/** + * handle = ifoOpenVTSI(dvd, title); + * + * Opens an IFO and reads in _only_ the vtsi_mat data. This call can be used + * together with the calls below to read in each segment of the IFO file on + * demand. + */ +ifo_handle_t *ifoOpenVTSI(dvd_reader_t *, int); + +/** + * ifoClose(ifofile); + * Cleans up the IFO information. This will free all data allocated for the + * substructures. + */ +void ifoClose(ifo_handle_t *); + +/** + * The following functions are for reading only part of the VMGI/VTSI files. + * Returns 1 if the data was successfully read and 0 on error. + */ + +/** + * okay = ifoRead_PLT_MAIT(ifofile); + * + * Read in the Parental Management Information table, filling the + * ifofile->ptl_mait structure and its substructures. This data is only + * located in the video manager information file. This fills the + * ifofile->ptl_mait structure and all its substructures. + */ +int ifoRead_PTL_MAIT(ifo_handle_t *); + +/** + * okay = ifoRead_VTS_ATRT(ifofile); + * + * Read in the attribute table for the main menu vob, filling the + * ifofile->vts_atrt structure and its substructures. Only located in the + * video manager information file. This fills in the ifofile->vts_atrt + * structure and all its substructures. + */ +int ifoRead_VTS_ATRT(ifo_handle_t *); + +/** + * okay = ifoRead_TT_SRPT(ifofile); + * + * Reads the title info for the main menu, filling the ifofile->tt_srpt + * structure and its substructures. This data is only located in the video + * manager information file. This structure is mandatory in the IFO file. + */ +int ifoRead_TT_SRPT(ifo_handle_t *); + +/** + * okay = ifoRead_VTS_PTT_SRPT(ifofile); + * + * Reads in the part of title search pointer table, filling the + * ifofile->vts_ptt_srpt structure and its substructures. This data is only + * located in the video title set information file. This structure is + * mandatory, and must be included in the VTSI file. + */ +int ifoRead_VTS_PTT_SRPT(ifo_handle_t *); + +/** + * okay = ifoRead_FP_PGC(ifofile); + * + * Reads in the first play program chain data, filling the + * ifofile->first_play_pgc structure. This data is only located in the video + * manager information file (VMGI). This structure is optional. + */ +int ifoRead_FP_PGC(ifo_handle_t *); + +/** + * okay = ifoRead_PGCIT(ifofile); + * + * Reads in the program chain information table for the video title set. Fills + * in the ifofile->vts_pgcit structure and its substructures, which includes + * the data for each program chain in the set. This data is only located in + * the video title set information file. This structure is mandatory, and must + * be included in the VTSI file. + */ +int ifoRead_PGCIT(ifo_handle_t *); + +/** + * okay = ifoRead_PGCI_UT(ifofile); + * + * Reads in the menu PGCI unit table for the menu VOB. For the video manager, + * this corresponds to the VIDEO_TS.VOB file, and for each title set, this + * corresponds to the VTS_XX_0.VOB file. This data is located in both the + * video manager and video title set information files. For VMGI files, this + * fills the ifofile->vmgi_pgci_ut structure and all its substructures. For + * VTSI files, this fills the ifofile->vtsm_pgci_ut structure. + */ +int ifoRead_PGCI_UT(ifo_handle_t *); + +/** + * okay = ifoRead_VTS_TMAPT(ifofile); + * + * Reads in the VTS Time Map Table, this data is only located in the video + * title set information file. This fills the ifofile->vts_tmapt structure + * and all its substructures. When present enables VOBU level time-based + * seeking for One_Sequential_PGC_Titles. + */ +int ifoRead_VTS_TMAPT(ifo_handle_t *); + +/** + * okay = ifoRead_C_ADT(ifofile); + * + * Reads in the cell address table for the menu VOB. For the video manager, + * this corresponds to the VIDEO_TS.VOB file, and for each title set, this + * corresponds to the VTS_XX_0.VOB file. This data is located in both the + * video manager and video title set information files. For VMGI files, this + * fills the ifofile->vmgm_c_adt structure and all its substructures. For VTSI + * files, this fills the ifofile->vtsm_c_adt structure. + */ +int ifoRead_C_ADT(ifo_handle_t *); + +/** + * okay = ifoRead_TITLE_C_ADT(ifofile); + * + * Reads in the cell address table for the video title set corresponding to + * this IFO file. This data is only located in the video title set information + * file. This structure is mandatory, and must be included in the VTSI file. + * This call fills the ifofile->vts_c_adt structure and its substructures. + */ +int ifoRead_TITLE_C_ADT(ifo_handle_t *); + +/** + * okay = ifoRead_VOBU_ADMAP(ifofile); + * + * Reads in the VOBU address map for the menu VOB. For the video manager, this + * corresponds to the VIDEO_TS.VOB file, and for each title set, this + * corresponds to the VTS_XX_0.VOB file. This data is located in both the + * video manager and video title set information files. For VMGI files, this + * fills the ifofile->vmgm_vobu_admap structure and all its substructures. For + * VTSI files, this fills the ifofile->vtsm_vobu_admap structure. + */ +int ifoRead_VOBU_ADMAP(ifo_handle_t *); + +/** + * okay = ifoRead_TITLE_VOBU_ADMAP(ifofile); + * + * Reads in the VOBU address map for the associated video title set. This data + * is only located in the video title set information file. This structure is + * mandatory, and must be included in the VTSI file. Fills the + * ifofile->vts_vobu_admap structure and its substructures. + */ +int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_t *); + +/** + * okay = ifoRead_TXTDT_MGI(ifofile); + * + * Reads in the text data strings for the DVD. Fills the ifofile->txtdt_mgi + * structure and all its substructures. This data is only located in the video + * manager information file. This structure is mandatory, and must be included + * in the VMGI file. + */ +int ifoRead_TXTDT_MGI(ifo_handle_t *); + +/** + * The following functions are used for freeing parsed sections of the + * ifo_handle_t structure and the allocated substructures. The free calls + * below are safe: they will not mind if you attempt to free part of an IFO + * file which was not read in or which does not exist. + */ +void ifoFree_PTL_MAIT(ifo_handle_t *); +void ifoFree_VTS_ATRT(ifo_handle_t *); +void ifoFree_TT_SRPT(ifo_handle_t *); +void ifoFree_VTS_PTT_SRPT(ifo_handle_t *); +void ifoFree_FP_PGC(ifo_handle_t *); +void ifoFree_PGCIT(ifo_handle_t *); +void ifoFree_PGCI_UT(ifo_handle_t *); +void ifoFree_VTS_TMAPT(ifo_handle_t *); +void ifoFree_C_ADT(ifo_handle_t *); +void ifoFree_TITLE_C_ADT(ifo_handle_t *); +void ifoFree_VOBU_ADMAP(ifo_handle_t *); +void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_t *); +void ifoFree_TXTDT_MGI(ifo_handle_t *); + +#ifdef __cplusplus +}; +#endif +#endif /* LIBDVDREAD_IFO_READ_H */ diff --git a/libdvdread-embedded/src/dvdread/ifo_types.h b/libdvdread-embedded/src/dvdread/ifo_types.h new file mode 100644 index 0000000..9293ce7 --- /dev/null +++ b/libdvdread-embedded/src/dvdread/ifo_types.h @@ -0,0 +1,755 @@ +/* + * Copyright (C) 2000, 2001 Björn Englund <d4bjorn@dtek.chalmers.se>, + * Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_IFO_TYPES_H +#define LIBDVDREAD_IFO_TYPES_H + +#include <inttypes.h> +#include "dvdread/dvd_reader.h" + + +#undef ATTRIBUTE_PACKED + +#if defined(__GNUC__) +# if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) +# if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) && !defined(__clang__) +# define ATTRIBUTE_PACKED __attribute__ ((packed,gcc_struct)) +# else +# define ATTRIBUTE_PACKED __attribute__ ((packed)) +# endif +# define PRAGMA_PACK 0 +# endif +#endif + +#if !defined(ATTRIBUTE_PACKED) +#define ATTRIBUTE_PACKED +#define PRAGMA_PACK 1 +#endif + +#if PRAGMA_PACK +#pragma pack(1) +#endif + + +/** + * Common + * + * The following structures are used in both the VMGI and VTSI. + */ + + +/** + * DVD Time Information. + */ +typedef struct { + uint8_t hour; + uint8_t minute; + uint8_t second; + uint8_t frame_u; /* The two high bits are the frame rate. */ +} ATTRIBUTE_PACKED dvd_time_t; + +/** + * Type to store per-command data. + */ +typedef struct { + uint8_t bytes[8]; +} ATTRIBUTE_PACKED vm_cmd_t; +#define COMMAND_DATA_SIZE 8U + + +/** + * Video Attributes. + */ +typedef struct { + unsigned char mpeg_version : 2; + unsigned char video_format : 2; + unsigned char display_aspect_ratio : 2; + unsigned char permitted_df : 2; + + unsigned char line21_cc_1 : 1; + unsigned char line21_cc_2 : 1; + unsigned char unknown1 : 1; + unsigned char bit_rate : 1; + + unsigned char picture_size : 2; + unsigned char letterboxed : 1; + unsigned char film_mode : 1; +} ATTRIBUTE_PACKED video_attr_t; + +/** + * Audio Attributes. + */ +typedef struct { + unsigned char audio_format : 3; + unsigned char multichannel_extension : 1; + unsigned char lang_type : 2; + unsigned char application_mode : 2; + + unsigned char quantization : 2; + unsigned char sample_frequency : 2; + unsigned char unknown1 : 1; + unsigned char channels : 3; + uint16_t lang_code; + uint8_t lang_extension; + uint8_t code_extension; + uint8_t unknown3; + union { + struct ATTRIBUTE_PACKED { + unsigned char unknown4 : 1; + unsigned char channel_assignment : 3; + unsigned char version : 2; + unsigned char mc_intro : 1; /* probably 0: true, 1:false */ + unsigned char mode : 1; /* Karaoke mode 0: solo 1: duet */ + } karaoke; + struct ATTRIBUTE_PACKED { + unsigned char unknown5 : 4; + unsigned char dolby_encoded : 1; /* suitable for surround decoding */ + unsigned char unknown6 : 3; + } surround; + } ATTRIBUTE_PACKED app_info; +} ATTRIBUTE_PACKED audio_attr_t; + + +/** + * MultiChannel Extension + */ +typedef struct { + unsigned char zero1 : 7; + unsigned char ach0_gme : 1; + + unsigned char zero2 : 7; + unsigned char ach1_gme : 1; + + unsigned char zero3 : 4; + unsigned char ach2_gv1e : 1; + unsigned char ach2_gv2e : 1; + unsigned char ach2_gm1e : 1; + unsigned char ach2_gm2e : 1; + + unsigned char zero4 : 4; + unsigned char ach3_gv1e : 1; + unsigned char ach3_gv2e : 1; + unsigned char ach3_gmAe : 1; + unsigned char ach3_se2e : 1; + + unsigned char zero5 : 4; + unsigned char ach4_gv1e : 1; + unsigned char ach4_gv2e : 1; + unsigned char ach4_gmBe : 1; + unsigned char ach4_seBe : 1; + uint8_t zero6[19]; +} ATTRIBUTE_PACKED multichannel_ext_t; + + +/** + * Subpicture Attributes. + */ +typedef struct { + /* + * type: 0 not specified + * 1 language + * 2 other + * coding mode: 0 run length + * 1 extended + * 2 other + * language: indicates language if type == 1 + * lang extension: if type == 1 contains the lang extension + */ + unsigned char code_mode : 3; + unsigned char zero1 : 3; + unsigned char type : 2; + uint8_t zero2; + uint16_t lang_code; + uint8_t lang_extension; + uint8_t code_extension; +} ATTRIBUTE_PACKED subp_attr_t; + + + +/** + * PGC Command Table. + */ +typedef struct { + uint16_t nr_of_pre; + uint16_t nr_of_post; + uint16_t nr_of_cell; + uint16_t last_byte; + vm_cmd_t *pre_cmds; + vm_cmd_t *post_cmds; + vm_cmd_t *cell_cmds; +} ATTRIBUTE_PACKED pgc_command_tbl_t; +#define PGC_COMMAND_TBL_SIZE 8U + +/** + * PGC Program Map + */ +typedef uint8_t pgc_program_map_t; + +/** + * Cell Playback Information. + */ +typedef struct { + unsigned char block_mode : 2; + unsigned char block_type : 2; + unsigned char seamless_play : 1; + unsigned char interleaved : 1; + unsigned char stc_discontinuity: 1; + unsigned char seamless_angle : 1; + unsigned char zero_1 : 1; + unsigned char playback_mode : 1; /**< When set, enter StillMode after each VOBU */ + unsigned char restricted : 1; /**< ?? drop out of fastforward? */ + unsigned char cell_type : 5; /** for karaoke, reserved otherwise */ + uint8_t still_time; + uint8_t cell_cmd_nr; + dvd_time_t playback_time; + uint32_t first_sector; + uint32_t first_ilvu_end_sector; + uint32_t last_vobu_start_sector; + uint32_t last_sector; +} ATTRIBUTE_PACKED cell_playback_t; + +#define BLOCK_TYPE_NONE 0x0 +#define BLOCK_TYPE_ANGLE_BLOCK 0x1 + +#define BLOCK_MODE_NOT_IN_BLOCK 0x0 +#define BLOCK_MODE_FIRST_CELL 0x1 +#define BLOCK_MODE_IN_BLOCK 0x2 +#define BLOCK_MODE_LAST_CELL 0x3 + +/** + * Cell Position Information. + */ +typedef struct { + uint16_t vob_id_nr; + uint8_t zero_1; + uint8_t cell_nr; +} ATTRIBUTE_PACKED cell_position_t; + +/** + * User Operations. + */ +typedef struct { + unsigned char zero : 7; /* 25-31 */ + unsigned char video_pres_mode_change : 1; /* 24 */ + + unsigned char karaoke_audio_pres_mode_change : 1; /* 23 */ + unsigned char angle_change : 1; + unsigned char subpic_stream_change : 1; + unsigned char audio_stream_change : 1; + unsigned char pause_on : 1; + unsigned char still_off : 1; + unsigned char button_select_or_activate : 1; + unsigned char resume : 1; /* 16 */ + + unsigned char chapter_menu_call : 1; /* 15 */ + unsigned char angle_menu_call : 1; + unsigned char audio_menu_call : 1; + unsigned char subpic_menu_call : 1; + unsigned char root_menu_call : 1; + unsigned char title_menu_call : 1; + unsigned char backward_scan : 1; + unsigned char forward_scan : 1; /* 8 */ + + unsigned char next_pg_search : 1; /* 7 */ + unsigned char prev_or_top_pg_search : 1; + unsigned char time_or_chapter_search : 1; + unsigned char go_up : 1; + unsigned char stop : 1; + unsigned char title_play : 1; + unsigned char chapter_search_or_play : 1; + unsigned char title_or_time_play : 1; /* 0 */ +} ATTRIBUTE_PACKED user_ops_t; + +/** + * Program Chain Information. + */ +typedef struct { + uint16_t zero_1; + uint8_t nr_of_programs; + uint8_t nr_of_cells; + dvd_time_t playback_time; + user_ops_t prohibited_ops; + uint16_t audio_control[8]; /* New type? */ + uint32_t subp_control[32]; /* New type? */ + uint16_t next_pgc_nr; + uint16_t prev_pgc_nr; + uint16_t goup_pgc_nr; + uint8_t pg_playback_mode; + uint8_t still_time; + uint32_t palette[16]; /* New type struct {zero_1, Y, Cr, Cb} ? */ + uint16_t command_tbl_offset; + uint16_t program_map_offset; + uint16_t cell_playback_offset; + uint16_t cell_position_offset; + pgc_command_tbl_t *command_tbl; + pgc_program_map_t *program_map; + cell_playback_t *cell_playback; + cell_position_t *cell_position; + int ref_count; +} ATTRIBUTE_PACKED pgc_t; +#define PGC_SIZE 236U + +/** + * Program Chain Information Search Pointer. + */ +typedef struct { + uint8_t entry_id; + unsigned char block_mode : 2; + unsigned char block_type : 2; + unsigned char zero_1 : 4; + uint16_t ptl_id_mask; + uint32_t pgc_start_byte; + pgc_t *pgc; +} ATTRIBUTE_PACKED pgci_srp_t; +#define PGCI_SRP_SIZE 8U + +/** + * Program Chain Information Table. + */ +typedef struct { + uint16_t nr_of_pgci_srp; + uint16_t zero_1; + uint32_t last_byte; + pgci_srp_t *pgci_srp; + int ref_count; +} ATTRIBUTE_PACKED pgcit_t; +#define PGCIT_SIZE 8U + +/** + * Menu PGCI Language Unit. + */ +typedef struct { + uint16_t lang_code; + uint8_t lang_extension; + uint8_t exists; + uint32_t lang_start_byte; + pgcit_t *pgcit; +} ATTRIBUTE_PACKED pgci_lu_t; +#define PGCI_LU_SIZE 8U + +/** + * Menu PGCI Unit Table. + */ +typedef struct { + uint16_t nr_of_lus; + uint16_t zero_1; + uint32_t last_byte; + pgci_lu_t *lu; +} ATTRIBUTE_PACKED pgci_ut_t; +#define PGCI_UT_SIZE 8U + +/** + * Cell Address Information. + */ +typedef struct { + uint16_t vob_id; + uint8_t cell_id; + uint8_t zero_1; + uint32_t start_sector; + uint32_t last_sector; +} ATTRIBUTE_PACKED cell_adr_t; + +/** + * Cell Address Table. + */ +typedef struct { + uint16_t nr_of_vobs; /* VOBs */ + uint16_t zero_1; + uint32_t last_byte; + cell_adr_t *cell_adr_table; /* No explicit size given. */ +} ATTRIBUTE_PACKED c_adt_t; +#define C_ADT_SIZE 8U + +/** + * VOBU Address Map. + */ +typedef struct { + uint32_t last_byte; + uint32_t *vobu_start_sectors; +} ATTRIBUTE_PACKED vobu_admap_t; +#define VOBU_ADMAP_SIZE 4U + + + + +/** + * VMGI + * + * The following structures relate to the Video Manager. + */ + +/** + * Video Manager Information Management Table. + */ +typedef struct { + char vmg_identifier[12]; + uint32_t vmg_last_sector; + uint8_t zero_1[12]; + uint32_t vmgi_last_sector; + uint8_t zero_2; + uint8_t specification_version; + uint32_t vmg_category; + uint16_t vmg_nr_of_volumes; + uint16_t vmg_this_volume_nr; + uint8_t disc_side; + uint8_t zero_3[19]; + uint16_t vmg_nr_of_title_sets; /* Number of VTSs. */ + char provider_identifier[32]; + uint64_t vmg_pos_code; + uint8_t zero_4[24]; + uint32_t vmgi_last_byte; + uint32_t first_play_pgc; + uint8_t zero_5[56]; + uint32_t vmgm_vobs; /* sector */ + uint32_t tt_srpt; /* sector */ + uint32_t vmgm_pgci_ut; /* sector */ + uint32_t ptl_mait; /* sector */ + uint32_t vts_atrt; /* sector */ + uint32_t txtdt_mgi; /* sector */ + uint32_t vmgm_c_adt; /* sector */ + uint32_t vmgm_vobu_admap; /* sector */ + uint8_t zero_6[32]; + + video_attr_t vmgm_video_attr; + uint8_t zero_7; + uint8_t nr_of_vmgm_audio_streams; /* should be 0 or 1 */ + audio_attr_t vmgm_audio_attr; + audio_attr_t zero_8[7]; + uint8_t zero_9[17]; + uint8_t nr_of_vmgm_subp_streams; /* should be 0 or 1 */ + subp_attr_t vmgm_subp_attr; + subp_attr_t zero_10[27]; /* XXX: how much 'padding' here? */ +} ATTRIBUTE_PACKED vmgi_mat_t; + +typedef struct { + unsigned char zero_1 : 1; + unsigned char multi_or_random_pgc_title : 1; /* 0: one sequential pgc title */ + unsigned char jlc_exists_in_cell_cmd : 1; + unsigned char jlc_exists_in_prepost_cmd : 1; + unsigned char jlc_exists_in_button_cmd : 1; + unsigned char jlc_exists_in_tt_dom : 1; + unsigned char chapter_search_or_play : 1; /* UOP 1 */ + unsigned char title_or_time_play : 1; /* UOP 0 */ +} ATTRIBUTE_PACKED playback_type_t; + +/** + * Title Information. + */ +typedef struct { + playback_type_t pb_ty; + uint8_t nr_of_angles; + uint16_t nr_of_ptts; + uint16_t parental_id; + uint8_t title_set_nr; + uint8_t vts_ttn; + uint32_t title_set_sector; +} ATTRIBUTE_PACKED title_info_t; + +/** + * PartOfTitle Search Pointer Table. + */ +typedef struct { + uint16_t nr_of_srpts; + uint16_t zero_1; + uint32_t last_byte; + title_info_t *title; +} ATTRIBUTE_PACKED tt_srpt_t; +#define TT_SRPT_SIZE 8U + + +/** + * Parental Management Information Unit Table. + * Level 1 (US: G), ..., 7 (US: NC-17), 8 + */ +#define PTL_MAIT_NUM_LEVEL 8 +typedef uint16_t pf_level_t[PTL_MAIT_NUM_LEVEL]; + +/** + * Parental Management Information Unit Table. + */ +typedef struct { + uint16_t country_code; + uint16_t zero_1; + uint16_t pf_ptl_mai_start_byte; + uint16_t zero_2; + pf_level_t *pf_ptl_mai; /* table of (nr_of_vtss + 1), video_ts is first */ +} ATTRIBUTE_PACKED ptl_mait_country_t; +#define PTL_MAIT_COUNTRY_SIZE 8U + +/** + * Parental Management Information Table. + */ +typedef struct { + uint16_t nr_of_countries; + uint16_t nr_of_vtss; + uint32_t last_byte; + ptl_mait_country_t *countries; +} ATTRIBUTE_PACKED ptl_mait_t; +#define PTL_MAIT_SIZE 8U + +/** + * Video Title Set Attributes. + */ +typedef struct { + uint32_t last_byte; + uint32_t vts_cat; + + video_attr_t vtsm_vobs_attr; + uint8_t zero_1; + uint8_t nr_of_vtsm_audio_streams; /* should be 0 or 1 */ + audio_attr_t vtsm_audio_attr; + audio_attr_t zero_2[7]; + uint8_t zero_3[16]; + uint8_t zero_4; + uint8_t nr_of_vtsm_subp_streams; /* should be 0 or 1 */ + subp_attr_t vtsm_subp_attr; + subp_attr_t zero_5[27]; + + uint8_t zero_6[2]; + + video_attr_t vtstt_vobs_video_attr; + uint8_t zero_7; + uint8_t nr_of_vtstt_audio_streams; + audio_attr_t vtstt_audio_attr[8]; + uint8_t zero_8[16]; + uint8_t zero_9; + uint8_t nr_of_vtstt_subp_streams; + subp_attr_t vtstt_subp_attr[32]; +} ATTRIBUTE_PACKED vts_attributes_t; +#define VTS_ATTRIBUTES_SIZE 542U +#define VTS_ATTRIBUTES_MIN_SIZE 356U + +/** + * Video Title Set Attribute Table. + */ +typedef struct { + uint16_t nr_of_vtss; + uint16_t zero_1; + uint32_t last_byte; + vts_attributes_t *vts; + uint32_t *vts_atrt_offsets; /* offsets table for each vts_attributes */ +} ATTRIBUTE_PACKED vts_atrt_t; +#define VTS_ATRT_SIZE 8U + +/** + * Text Data. (Incomplete) + */ +typedef struct { + uint32_t last_byte; /* offsets are relative here */ + uint16_t offsets[100]; /* == nr_of_srpts + 1 (first is disc title) */ +#if 0 + uint16_t unknown; /* 0x48 ?? 0x48 words (16bit) info following */ + uint16_t zero_1; + + uint8_t type_of_info; /* ?? 01 == disc, 02 == Title, 04 == Title part */ + uint8_t unknown1; + uint8_t unknown2; + uint8_t unknown3; + uint8_t unknown4; /* ?? always 0x30 language?, text format? */ + uint8_t unknown5; + uint16_t offset; /* from first */ + + char text[12]; /* ended by 0x09 */ +#endif +} ATTRIBUTE_PACKED txtdt_t; + +/** + * Text Data Language Unit. (Incomplete) + */ +typedef struct { + uint16_t lang_code; + uint8_t zero_1; + uint8_t char_set; /* 0x00 reserved Unicode, 0x01 ISO 646, 0x10 JIS Roman & JIS Kanji, 0x11 ISO 8859-1, 0x12 Shift JIS Kanji */ + uint32_t txtdt_start_byte; /* prt, rel start of vmg_txtdt_mgi */ + txtdt_t *txtdt; +} ATTRIBUTE_PACKED txtdt_lu_t; +#define TXTDT_LU_SIZE 8U + +/** + * Text Data Manager Information. (Incomplete) + */ +typedef struct { + char disc_name[12]; + uint16_t unknown1; + uint16_t nr_of_language_units; + uint32_t last_byte; + txtdt_lu_t *lu; +} ATTRIBUTE_PACKED txtdt_mgi_t; +#define TXTDT_MGI_SIZE 20U + + +/** + * VTS + * + * Structures relating to the Video Title Set (VTS). + */ + +/** + * Video Title Set Information Management Table. + */ +typedef struct { + char vts_identifier[12]; + uint32_t vts_last_sector; + uint8_t zero_1[12]; + uint32_t vtsi_last_sector; + uint8_t zero_2; + uint8_t specification_version; + uint32_t vts_category; + uint16_t zero_3; + uint16_t zero_4; + uint8_t zero_5; + uint8_t zero_6[19]; + uint16_t zero_7; + uint8_t zero_8[32]; + uint64_t zero_9; + uint8_t zero_10[24]; + uint32_t vtsi_last_byte; + uint32_t zero_11; + uint8_t zero_12[56]; + uint32_t vtsm_vobs; /* sector */ + uint32_t vtstt_vobs; /* sector */ + uint32_t vts_ptt_srpt; /* sector */ + uint32_t vts_pgcit; /* sector */ + uint32_t vtsm_pgci_ut; /* sector */ + uint32_t vts_tmapt; /* sector */ + uint32_t vtsm_c_adt; /* sector */ + uint32_t vtsm_vobu_admap; /* sector */ + uint32_t vts_c_adt; /* sector */ + uint32_t vts_vobu_admap; /* sector */ + uint8_t zero_13[24]; + + video_attr_t vtsm_video_attr; + uint8_t zero_14; + uint8_t nr_of_vtsm_audio_streams; /* should be 0 or 1 */ + audio_attr_t vtsm_audio_attr; + audio_attr_t zero_15[7]; + uint8_t zero_16[17]; + uint8_t nr_of_vtsm_subp_streams; /* should be 0 or 1 */ + subp_attr_t vtsm_subp_attr; + subp_attr_t zero_17[27]; + uint8_t zero_18[2]; + + video_attr_t vts_video_attr; + uint8_t zero_19; + uint8_t nr_of_vts_audio_streams; + audio_attr_t vts_audio_attr[8]; + uint8_t zero_20[17]; + uint8_t nr_of_vts_subp_streams; + subp_attr_t vts_subp_attr[32]; + uint16_t zero_21; + multichannel_ext_t vts_mu_audio_attr[8]; + /* XXX: how much 'padding' here, if any? */ +} ATTRIBUTE_PACKED vtsi_mat_t; + +/** + * PartOfTitle Unit Information. + */ +typedef struct { + uint16_t pgcn; + uint16_t pgn; +} ATTRIBUTE_PACKED ptt_info_t; + +/** + * PartOfTitle Information. + */ +typedef struct { + uint16_t nr_of_ptts; + ptt_info_t *ptt; +} ATTRIBUTE_PACKED ttu_t; + +/** + * PartOfTitle Search Pointer Table. + */ +typedef struct { + uint16_t nr_of_srpts; + uint16_t zero_1; + uint32_t last_byte; + ttu_t *title; + uint32_t *ttu_offset; /* offset table for each ttu */ +} ATTRIBUTE_PACKED vts_ptt_srpt_t; +#define VTS_PTT_SRPT_SIZE 8U + + +/** + * Time Map Entry. + */ +/* Should this be bit field at all or just the uint32_t? */ +typedef uint32_t map_ent_t; + +/** + * Time Map. + */ +typedef struct { + uint8_t tmu; /* Time unit, in seconds */ + uint8_t zero_1; + uint16_t nr_of_entries; + map_ent_t *map_ent; +} ATTRIBUTE_PACKED vts_tmap_t; +#define VTS_TMAP_SIZE 4U + +/** + * Time Map Table. + */ +typedef struct { + uint16_t nr_of_tmaps; + uint16_t zero_1; + uint32_t last_byte; + vts_tmap_t *tmap; + uint32_t *tmap_offset; /* offset table for each tmap */ +} ATTRIBUTE_PACKED vts_tmapt_t; +#define VTS_TMAPT_SIZE 8U + + +#if PRAGMA_PACK +#pragma pack() +#endif + + +/** + * The following structure defines an IFO file. The structure is divided into + * two parts, the VMGI, or Video Manager Information, which is read from the + * VIDEO_TS.[IFO,BUP] file, and the VTSI, or Video Title Set Information, which + * is read in from the VTS_XX_0.[IFO,BUP] files. + */ +typedef struct { + /* VMGI */ + vmgi_mat_t *vmgi_mat; + tt_srpt_t *tt_srpt; + pgc_t *first_play_pgc; + ptl_mait_t *ptl_mait; + vts_atrt_t *vts_atrt; + txtdt_mgi_t *txtdt_mgi; + + /* Common */ + pgci_ut_t *pgci_ut; + c_adt_t *menu_c_adt; + vobu_admap_t *menu_vobu_admap; + + /* VTSI */ + vtsi_mat_t *vtsi_mat; + vts_ptt_srpt_t *vts_ptt_srpt; + pgcit_t *vts_pgcit; + vts_tmapt_t *vts_tmapt; + c_adt_t *vts_c_adt; + vobu_admap_t *vts_vobu_admap; +} ifo_handle_t; + +#endif /* LIBDVDREAD_IFO_TYPES_H */ diff --git a/libdvdread-embedded/src/dvdread/nav_print.h b/libdvdread-embedded/src/dvdread/nav_print.h new file mode 100644 index 0000000..4960615 --- /dev/null +++ b/libdvdread-embedded/src/dvdread/nav_print.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2001, 2002 Billy Biggs <vektor@dumbterm.net>, + * Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_NAV_PRINT_H +#define LIBDVDREAD_NAV_PRINT_H + +#include "nav_types.h" + +/** + * Pretty printing of the NAV packets, PCI and DSI structs. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Prints information contained in the PCI to stdout. + * + * @param pci Pointer to the PCI data structure to be printed. + */ +void navPrint_PCI(pci_t *); + +/** + * Prints information contained in the DSI to stdout. + * + * @param dsi Pointer to the DSI data structure to be printed. + */ +void navPrint_DSI(dsi_t *); + +#ifdef __cplusplus +}; +#endif +#endif /* LIBDVDREAD_NAV_PRINT_H */ diff --git a/libdvdread-embedded/src/dvdread/nav_read.h b/libdvdread-embedded/src/dvdread/nav_read.h new file mode 100644 index 0000000..256fadb --- /dev/null +++ b/libdvdread-embedded/src/dvdread/nav_read.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2000, 2001, 2002 Håkan Hjort <d95hjort@dtek.chalmers.se>. + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_NAV_READ_H +#define LIBDVDREAD_NAV_READ_H + +#include "nav_types.h" + +/** + * Parsing of NAV data, PCI and DSI parts. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Reads the PCI packet data pointed to into th pci struct. + * + * @param pci Pointer to the PCI data structure to be filled in. + * @param buffer Pointer to the buffer of the on disc PCI data. + */ +void navRead_PCI(pci_t *, unsigned char *); + +/** + * Reads the DSI packet data pointed to into dsi struct. + * + * @param dsi Pointer to the DSI data structure to be filled in. + * @param buffer Pointer to the buffer of the on disc DSI data. + */ +void navRead_DSI(dsi_t *, unsigned char *); + +#ifdef __cplusplus +}; +#endif +#endif /* LIBDVDREAD_NAV_READ_H */ diff --git a/libdvdread-embedded/src/dvdread/nav_types.h b/libdvdread-embedded/src/dvdread/nav_types.h new file mode 100644 index 0000000..3debbee --- /dev/null +++ b/libdvdread-embedded/src/dvdread/nav_types.h @@ -0,0 +1,248 @@ +/* + * Copyright (C) 2000, 2001, 2002 Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * The data structures in this file should represent the layout of the + * pci and dsi packets as they are stored in the stream. Information + * found by reading the source to VOBDUMP is the base for the structure + * and names of these data types. + * + * VOBDUMP: a program for examining DVD .VOB files. + * Copyright 1998, 1999 Eric Smith <eric@brouhaha.com> + * + * VOBDUMP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 or version 3 as + * published by the Free Software Foundation. Note that I am not + * granting permission to redistribute or modify VOBDUMP under the terms + * of any later version of the General Public License. + * + * This program is distributed in the hope that it will be useful (or at + * least amusing), but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + * the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_NAV_TYPES_H +#define LIBDVDREAD_NAV_TYPES_H + +#include <inttypes.h> +#include "ifo_types.h" /* only dvd_time_t, vm_cmd_t and user_ops_t */ + +/* The length including the substream id byte. */ +#define PCI_BYTES 0x3d4 +#define DSI_BYTES 0x3fa + +#define PS2_PCI_SUBSTREAM_ID 0x00 +#define PS2_DSI_SUBSTREAM_ID 0x01 + +/* Remove this */ +#define DSI_START_BYTE 1031 + +/** + * PCI General Information + */ +typedef struct { + uint32_t nv_pck_lbn; /**< sector address of this nav pack */ + uint16_t vobu_cat; /**< 'category' of vobu */ + uint16_t zero1; /**< reserved */ + user_ops_t vobu_uop_ctl; /**< UOP of vobu */ + uint32_t vobu_s_ptm; /**< start presentation time of vobu */ + uint32_t vobu_e_ptm; /**< end presentation time of vobu */ + uint32_t vobu_se_e_ptm; /**< end ptm of sequence end in vobu */ + dvd_time_t e_eltm; /**< Cell elapsed time */ + char vobu_isrc[32]; +} ATTRIBUTE_PACKED pci_gi_t; + +/** + * Non Seamless Angle Information + */ +typedef struct { + uint32_t nsml_agl_dsta[9]; /**< address of destination vobu in AGL_C#n */ +} ATTRIBUTE_PACKED nsml_agli_t; + +/** + * Highlight General Information + * + * For btngrX_dsp_ty the bits have the following meaning: + * 000b: normal 4/3 only buttons + * XX1b: wide (16/9) buttons + * X1Xb: letterbox buttons + * 1XXb: pan&scan buttons + */ +typedef struct { + uint16_t hli_ss; /**< status, only low 2 bits 0: no buttons, 1: different 2: equal 3: eual except for button cmds */ + uint32_t hli_s_ptm; /**< start ptm of hli */ + uint32_t hli_e_ptm; /**< end ptm of hli */ + uint32_t btn_se_e_ptm; /**< end ptm of button select */ + unsigned char zero1 : 2; /**< reserved */ + unsigned char btngr_ns : 2; /**< number of button groups 1, 2 or 3 with 36/18/12 buttons */ + unsigned char zero2 : 1; /**< reserved */ + unsigned char btngr1_dsp_ty : 3; /**< display type of subpic stream for button group 1 */ + unsigned char zero3 : 1; /**< reserved */ + unsigned char btngr2_dsp_ty : 3; /**< display type of subpic stream for button group 2 */ + unsigned char zero4 : 1; /**< reserved */ + unsigned char btngr3_dsp_ty : 3; /**< display type of subpic stream for button group 3 */ + uint8_t btn_ofn; /**< button offset number range 0-255 */ + uint8_t btn_ns; /**< number of valid buttons <= 36/18/12 (low 6 bits) */ + uint8_t nsl_btn_ns; /**< number of buttons selectable by U_BTNNi (low 6 bits) nsl_btn_ns <= btn_ns */ + uint8_t zero5; /**< reserved */ + uint8_t fosl_btnn; /**< forcedly selected button (low 6 bits) */ + uint8_t foac_btnn; /**< forcedly activated button (low 6 bits) */ +} ATTRIBUTE_PACKED hl_gi_t; + + +/** + * Button Color Information Table + * Each entry is a 32bit word that contains the color indices and alpha + * values to use. They are all represented by 4 bit number and stored + * like this [Ci3, Ci2, Ci1, Ci0, A3, A2, A1, A0]. The actual palette + * that the indexes reference is in the PGC. + * @TODO split the uint32_t into a struct + */ +typedef struct { + uint32_t btn_coli[3][2]; /**< [button color number-1][select:0/action:1] */ +} ATTRIBUTE_PACKED btn_colit_t; + +/** + * Button Information + * + * NOTE: I've had to change the structure from the disk layout to get + * the packing to work with Sun's Forte C compiler. + * The 4 and 7 bytes are 'rotated' was: ABC DEF GHIJ is: ABCG DEFH IJ + */ +typedef struct { + unsigned int btn_coln : 2; /**< button color number */ + unsigned int x_start : 10; /**< x start offset within the overlay */ + unsigned int zero1 : 2; /**< reserved */ + unsigned int x_end : 10; /**< x end offset within the overlay */ + + unsigned int auto_action_mode : 2; /**< 0: no, 1: activated if selected */ + unsigned int y_start : 10; /**< y start offset within the overlay */ + unsigned int zero2 : 2; /**< reserved */ + unsigned int y_end : 10; /**< y end offset within the overlay */ + + unsigned int zero3 : 2; /**< reserved */ + unsigned int up : 6; /**< button index when pressing up */ + unsigned int zero4 : 2; /**< reserved */ + unsigned int down : 6; /**< button index when pressing down */ + unsigned int zero5 : 2; /**< reserved */ + unsigned int left : 6; /**< button index when pressing left */ + unsigned int zero6 : 2; /**< reserved */ + unsigned int right : 6; /**< button index when pressing right */ + vm_cmd_t cmd; +} ATTRIBUTE_PACKED btni_t; + +/** + * Highlight Information + */ +typedef struct { + hl_gi_t hl_gi; + btn_colit_t btn_colit; + btni_t btnit[36]; +} ATTRIBUTE_PACKED hli_t; + +/** + * PCI packet + */ +typedef struct { + pci_gi_t pci_gi; + nsml_agli_t nsml_agli; + hli_t hli; + uint8_t zero1[189]; +} ATTRIBUTE_PACKED pci_t; + + + + +/** + * DSI General Information + */ +typedef struct { + uint32_t nv_pck_scr; + uint32_t nv_pck_lbn; /**< sector address of this nav pack */ + uint32_t vobu_ea; /**< end address of this VOBU */ + uint32_t vobu_1stref_ea; /**< end address of the 1st reference image */ + uint32_t vobu_2ndref_ea; /**< end address of the 2nd reference image */ + uint32_t vobu_3rdref_ea; /**< end address of the 3rd reference image */ + uint16_t vobu_vob_idn; /**< VOB Id number that this VOBU is part of */ + uint8_t zero1; /**< reserved */ + uint8_t vobu_c_idn; /**< Cell Id number that this VOBU is part of */ + dvd_time_t c_eltm; /**< Cell elapsed time */ +} ATTRIBUTE_PACKED dsi_gi_t; + +/** + * Seamless Playback Information + */ +typedef struct { + uint16_t category; /**< 'category' of seamless VOBU */ + uint32_t ilvu_ea; /**< end address of interleaved Unit */ + uint32_t ilvu_sa; /**< start address of next interleaved unit */ + uint16_t size; /**< size of next interleaved unit */ + uint32_t vob_v_s_s_ptm; /**< video start ptm in vob */ + uint32_t vob_v_e_e_ptm; /**< video end ptm in vob */ + struct { + uint32_t stp_ptm1; + uint32_t stp_ptm2; + uint32_t gap_len1; + uint32_t gap_len2; + } vob_a[8]; +} ATTRIBUTE_PACKED sml_pbi_t; + +/** + * Seamless Angle Information for one angle + */ +typedef struct { + uint32_t address; /**< offset to next ILVU, high bit is before/after */ + uint16_t size; /**< byte size of the ILVU pointed to by address */ +} ATTRIBUTE_PACKED sml_agl_data_t; + +/** + * Seamless Angle Information + */ +typedef struct { + sml_agl_data_t data[9]; +} ATTRIBUTE_PACKED sml_agli_t; + +/** + * VOBU Search Information + */ +typedef struct { + uint32_t next_video; /**< Next vobu that contains video */ + uint32_t fwda[19]; /**< Forwards, time */ + uint32_t next_vobu; + uint32_t prev_vobu; + uint32_t bwda[19]; /**< Backwards, time */ + uint32_t prev_video; +} ATTRIBUTE_PACKED vobu_sri_t; + +#define SRI_END_OF_CELL 0x3fffffff + +/** + * Synchronous Information + */ +typedef struct { + uint16_t a_synca[8]; /**< offset to first audio packet for this VOBU */ + uint32_t sp_synca[32]; /**< offset to first subpicture packet */ +} ATTRIBUTE_PACKED synci_t; + +/** + * DSI packet + */ +typedef struct { + dsi_gi_t dsi_gi; + sml_pbi_t sml_pbi; + sml_agli_t sml_agli; + vobu_sri_t vobu_sri; + synci_t synci; + uint8_t zero1[471]; +} ATTRIBUTE_PACKED dsi_t; + + +#if PRAGMA_PACK +#pragma pack() +#endif + +#endif /* LIBDVDREAD_NAV_TYPES_H */ diff --git a/libdvdread-embedded/src/dvdread/version.h.in b/libdvdread-embedded/src/dvdread/version.h.in new file mode 100644 index 0000000..0ab1676 --- /dev/null +++ b/libdvdread-embedded/src/dvdread/version.h.in @@ -0,0 +1,37 @@ +/* + * This file is part of libdvdread + * Copyright (C) 2015 VideoLAN + * + * This file is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This file is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>. + */ + +#ifndef DVDREAD_VERSION_H_ +#define DVDREAD_VERSION_H_ + +#define DVDREAD_VERSION_CODE(major, minor, micro) \ + (((major) * 10000) + \ + ((minor) * 100) + \ + ((micro) * 1)) + +#define DVDREAD_VERSION_MAJOR @DVDREAD_VERSION_MAJOR@ +#define DVDREAD_VERSION_MINOR @DVDREAD_VERSION_MINOR@ +#define DVDREAD_VERSION_MICRO @DVDREAD_VERSION_MICRO@ + +#define DVDREAD_VERSION_STRING "@DVDREAD_VERSION_MAJOR@.@DVDREAD_VERSION_MINOR@.@DVDREAD_VERSION_MICRO@" + +#define DVDREAD_VERSION \ + DVDREAD_VERSION_CODE(DVDREAD_VERSION_MAJOR, DVDREAD_VERSION_MINOR, DVDREAD_VERSION_MICRO) + +#endif /* DVDREAD_VERSION_H_ */ diff --git a/libdvdread-embedded/src/dvdread_internal.h b/libdvdread-embedded/src/dvdread_internal.h new file mode 100644 index 0000000..bf4e2e1 --- /dev/null +++ b/libdvdread-embedded/src/dvdread_internal.h @@ -0,0 +1,86 @@ +/* + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef LIBDVDREAD_DVDREAD_INTERNAL_H +#define LIBDVDREAD_DVDREAD_INTERNAL_H + +#include <stdint.h> +#include <stddef.h> +#include <sys/types.h> + +#ifdef _WIN32 +# include <unistd.h> +#endif /* _WIN32 */ + +#include "dvdread/dvd_reader.h" +#include "dvdread/ifo_types.h" +#include "logger.h" + +#define container_of(ptr, type, member) \ + ((type *)(((char *)(ptr)) - offsetof(type, member))) + +struct dvd_reader_s +{ + dvd_reader_device_t *rd; + void *priv; /* User provided context */ + dvd_logger_cb logcb; + /* Set 100 flags for BUP fallback, most signifiant left + [0] for upper remaining VTS, [1] for the first Main + 63 VTS */ + uint64_t ifoBUPflags[2]; +}; + +struct ifo_handle_private_s +{ + ifo_handle_t handle; + dvd_reader_t *ctx; + dvd_file_t *file; +}; + +enum TagIdentifier { + /* ECMA 167 3/7.2.1 */ + PrimaryVolumeDescriptor = 1, + AnchorVolumeDescriptorPointer = 2, + VolumeDescriptorPointer = 3, + ImplementationUseVolumeDescriptor = 4, + PartitionDescriptor = 5, + LogicalVolumeDescriptor = 6, + UnallocatedSpaceDescriptor = 7, + TerminatingDescriptor = 8, + LogicalVolumeIntegrityDescriptor = 9, + /* ECMA 167 4/7.2.1 */ + FileSetDescriptor = 256, + FileIdentifierDescriptor = 257, + AllocationExtentDescriptor = 258, + IndirectEntry = 259, + TerminalEntry = 260, + FileEntry = 261, + ExtendedAttributeHeaderDescriptor = 262, + UnallocatedSpaceEntry = 263, + SpaceBitmapDescriptor = 264, + PartitionIntegrityEntry = 265, + ExtendedFileEntry = 266, +}; + +int InternalUDFReadBlocksRaw(const dvd_reader_t *, uint32_t lb_number, + size_t block_count, unsigned char *data, int encrypted); + +void *GetUDFCacheHandle(dvd_reader_t *); +void SetUDFCacheHandle(dvd_reader_t *, void *cache); +void FreeUDFCache(void *cache); + +#endif /* LIBDVDREAD_DVDREAD_INTERNAL_H */ diff --git a/libdvdread-embedded/src/ifo_print.c b/libdvdread-embedded/src/ifo_print.c new file mode 100644 index 0000000..f61a2b3 --- /dev/null +++ b/libdvdread-embedded/src/ifo_print.c @@ -0,0 +1,1209 @@ +/* + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <inttypes.h> +#include <string.h> +#include <ctype.h> +#include <assert.h> + +#include "dvdread/ifo_types.h" +#include "dvdread/ifo_read.h" +#include "dvdread/ifo_print.h" +#include "dvdread_internal.h" +#include "logger.h" + +/* Put this in some other file / package? It's used in nav_print too. */ +static void ifo_print_time(dvd_time_t *dtime) { + const char *rate; + assert((dtime->hour>>4) < 0xa && (dtime->hour&0xf) < 0xa); + assert((dtime->minute>>4) < 0x7 && (dtime->minute&0xf) < 0xa); + assert((dtime->second>>4) < 0x7 && (dtime->second&0xf) < 0xa); + assert((dtime->frame_u&0xf) < 0xa); + + printf("%02x:%02x:%02x.%02x", + dtime->hour, + dtime->minute, + dtime->second, + dtime->frame_u & 0x3f); + switch((dtime->frame_u & 0xc0) >> 6) { + case 1: + rate = "25.00"; + break; + case 3: + rate = "29.97"; + break; + default: + if(dtime->hour == 0 && dtime->minute == 0 + && dtime->second == 0 && dtime->frame_u == 0) + rate = "no"; + else + rate = "(please send a bug report)"; + break; + } + printf(" @ %s fps", rate); +} + +void dvdread_print_time(dvd_time_t *dtime) { + ifo_print_time(dtime); +} + +/* Put this in some other file / package? It's used in nav_print too. + Possibly also by the vm / navigator. */ +static void ifo_print_cmd(int row, vm_cmd_t *command) { + int i; + + printf("(%03d) ", row + 1); + for(i=0;i<8;i++) + printf("%02x ", command->bytes[i]); + printf("| "); +#if 0 + //disabled call of dvdnav function + vm_print_mnemonic(command); +#endif + printf("\n"); +} + +static void ifo_print_video_attributes(video_attr_t *attr) { + + /* The following test is shorter but not correct ISO C, + memcmp(attr,my_friendly_zeros, sizeof(video_attr_t)) */ + if(attr->mpeg_version == 0 + && attr->video_format == 0 + && attr->display_aspect_ratio == 0 + && attr->permitted_df == 0 + && attr->line21_cc_1 == 0 + && attr->line21_cc_2 == 0 + && attr->unknown1 == 0 + && attr->letterboxed == 0 + && attr->film_mode == 0) { + printf("-- Unspecified --"); + return; + } + + switch(attr->mpeg_version) { + case 0: + printf("mpeg1, "); + break; + case 1: + printf("mpeg2, "); + break; + default: + printf("(please send a bug report), "); + } + + switch(attr->video_format) { + case 0: + printf("ntsc, "); + break; + case 1: + printf("pal, "); + break; + default: + printf("(please send a bug report), "); + } + + switch(attr->display_aspect_ratio) { + case 0: + printf("4:3, "); + break; + case 3: + printf("16:9, "); + break; + default: + printf("(please send a bug report), "); + } + + // Wide is always allowed..!!! + switch(attr->permitted_df) { + case 0: + printf("pan&scan+letterboxed, "); + break; + case 1: + printf("only pan&scan, "); //?? + break; + case 2: + printf("only letterboxed, "); + break; + case 3: + printf("not specified, "); + break; + default: + printf("(please send a bug report), "); + } + + if(attr->line21_cc_1 || attr->line21_cc_2) { + printf("NTSC CC "); + if(attr->line21_cc_1) + printf("1, "); + if(attr->line21_cc_2) + printf("2, "); + } + + { + int height = 480; + if(attr->video_format != 0) + height = 576; + switch(attr->picture_size) { + case 0: + printf("720x%d, ", height); + break; + case 1: + printf("704x%d, ", height); + break; + case 2: + printf("352x%d, ", height); + break; + case 3: + printf("352x%d, ", height/2); + break; + default: + printf("(please send a bug report), "); + } + } + + if(attr->letterboxed) { + printf("source letterboxed, "); + } + + if(attr->film_mode) { + printf("film, "); + } else { + printf("video, "); //camera + } + + printf("Unknown1: %x", attr->unknown1); + +} + +static void ifo_print_audio_attributes(audio_attr_t *attr) { + + if(attr->audio_format == 0 + && attr->multichannel_extension == 0 + && attr->lang_type == 0 + && attr->application_mode == 0 + && attr->quantization == 0 + && attr->sample_frequency == 0 + && attr->unknown1 == 0 + && attr->channels == 0 + && attr->lang_extension == 0 + && attr->unknown3 == 0) { + printf("-- Unspecified --"); + return; + } + + switch(attr->audio_format) { + case 0: + printf("ac3 "); + if(attr->quantization != 3) + printf("(please send a bug report) ac3 quant/drc not 3 (%d)", attr->quantization); + break; + case 1: + printf("(please send a bug report) "); + break; + case 2: + printf("mpeg1 "); + /* Falls Through. */ /* to MPEG-2 */ + case 3: + printf("mpeg2ext "); + switch(attr->quantization) { + case 0: + printf("no drc "); + break; + case 1: + printf("drc "); + break; + default: + printf("(please send a bug report) mpeg reserved quant/drc (%d)", attr->quantization); + } + break; + case 4: + printf("lpcm "); + switch(attr->quantization) { + case 0: + printf("16bit "); + break; + case 1: + printf("20bit "); + break; + case 2: + printf("24bit "); + break; + case 3: + printf("(please send a bug report) lpcm reserved quant/drc (%d)", attr->quantization); + break; + } + break; + case 5: + printf("(please send a bug report) "); + break; + case 6: + printf("dts "); + if(attr->quantization != 3) + printf("(please send a bug report) dts quant/drc not 3 (%d)", attr->quantization); + break; + default: + printf("(please send a bug report) "); + } + + if(attr->multichannel_extension) + printf("multichannel_extension "); + + switch(attr->lang_type) { + case 0: + // not specified + if(attr->lang_code != 0 && attr->lang_code != 0xffff) + printf("Lang_code 0x%x, please send a bug report!", attr->lang_code); + break; + case 1: + printf("%c%c ", attr->lang_code>>8, attr->lang_code & 0xff); + break; + default: + printf("(please send a bug report) "); + } + + switch(attr->application_mode) { + case 0: + // not specified + break; + case 1: + printf("karaoke mode "); + break; + case 2: + printf("surround sound mode "); + break; + default: + printf("(please send a bug report) "); + } + + switch(attr->quantization) { + case 0: + printf("16bit "); + break; + case 1: + printf("20bit "); + break; + case 2: + printf("24bit "); + break; + case 3: + printf("drc "); + break; + default: + printf("(please send a bug report) "); + } + + switch(attr->sample_frequency) { + case 0: + printf("48kHz "); + break; + case 1: + printf("??kHz "); + break; + default: + printf("sample_frequency %i (please send a bug report) ", + attr->sample_frequency); + } + + printf("%dCh ", attr->channels + 1); + + switch(attr->lang_extension) { + case 0: + printf("Not specified "); + break; + case 1: // Normal audio + printf("Normal Caption "); + break; + case 2: // visually impaired + printf("Audio for visually impaired "); + break; + case 3: // Directors 1 + printf("Director's comments 1 "); + break; + case 4: // Directors 2 + printf("Director's comments 2 "); + break; + //case 4: // Music score ? + default: + printf("(please send a bug report) "); + } + + printf("Unknown1: %d ", attr->unknown1); + printf("Unknown3: %d ", attr->unknown3); +} + +static void ifo_print_subp_attributes(subp_attr_t *attr) { + + if(attr->type == 0 + && attr->zero1 == 0 + && attr->zero2 == 0 + && attr->lang_code == 0 + && attr->lang_extension== 0) { + printf("-- Unspecified --"); + return; + } + + printf("type %02x ", attr->type); + + if(isalpha((int)(attr->lang_code >> 8)) + && isalpha((int)(attr->lang_code & 0xff))) { + printf("%c%c ", attr->lang_code >> 8, attr->lang_code & 0xff); + } else { + printf("%02x%02x ", 0xff & (unsigned)(attr->lang_code >> 8), + 0xff & (unsigned)(attr->lang_code & 0xff)); + } + + printf("%d ", attr->zero1); + printf("%d ", attr->zero2); + + switch(attr->lang_extension) { + case 0: + printf("Not specified "); + break; + case 1: + printf("Caption with normal size character "); + break; + case 2: + printf("Caption with bigger size character "); + break; + case 3: + printf("Caption for children "); + break; + case 4: + printf("reserved "); + break; + case 5: + printf("Closed Caption with normal size character "); + break; + case 6: + printf("Closed Caption with bigger size character "); + break; + case 7: + printf("Closed Caption for children "); + break; + case 8: + printf("reserved "); + break; + case 9: + printf("Forced Caption"); + break; + case 10: + printf("reserved "); + break; + case 11: + printf("reserved "); + break; + case 12: + printf("reserved "); + break; + case 13: + printf("Director's comments with normal size character "); + break; + case 14: + printf("Director's comments with bigger size character "); + break; + case 15: + printf("Director's comments for children "); + break; + default: + printf("(please send a bug report) "); + } + +} + + +static void ifoPrint_USER_OPS(user_ops_t *user_ops) { + uint32_t uops; + unsigned char *ptr = (unsigned char *)user_ops; + + uops = (*ptr++ << 24); + uops |= (*ptr++ << 16); + uops |= (*ptr++ << 8); + uops |= (*ptr++); + + if(uops == 0) { + printf("None\n"); + } else if(uops == 0x01ffffff) { + printf("All\n"); + } else { + if(user_ops->title_or_time_play) + printf("Title or Time Play, "); + if(user_ops->chapter_search_or_play) + printf("Chapter Search or Play, "); + if(user_ops->title_play) + printf("Title Play, "); + if(user_ops->stop) + printf("Stop, "); + if(user_ops->go_up) + printf("Go Up, "); + if(user_ops->time_or_chapter_search) + printf("Time or Chapter Search, "); + if(user_ops->prev_or_top_pg_search) + printf("Prev or Top PG Search, "); + if(user_ops->next_pg_search) + printf("Next PG Search, "); + if(user_ops->forward_scan) + printf("Forward Scan, "); + if(user_ops->backward_scan) + printf("Backward Scan, "); + if(user_ops->title_menu_call) + printf("Title Menu Call, "); + if(user_ops->root_menu_call) + printf("Root Menu Call, "); + if(user_ops->subpic_menu_call) + printf("SubPic Menu Call, "); + if(user_ops->audio_menu_call) + printf("Audio Menu Call, "); + if(user_ops->angle_menu_call) + printf("Angle Menu Call, "); + if(user_ops->chapter_menu_call) + printf("Chapter Menu Call, "); + if(user_ops->resume) + printf("Resume, "); + if(user_ops->button_select_or_activate) + printf("Button Select or Activate, "); + if(user_ops->still_off) + printf("Still Off, "); + if(user_ops->pause_on) + printf("Pause On, "); + if(user_ops->audio_stream_change) + printf("Audio Stream Change, "); + if(user_ops->subpic_stream_change) + printf("SubPic Stream Change, "); + if(user_ops->angle_change) + printf("Angle Change, "); + if(user_ops->karaoke_audio_pres_mode_change) + printf("Karaoke Audio Pres Mode Change, "); + if(user_ops->video_pres_mode_change) + printf("Video Pres Mode Change, "); + printf("\n"); + } +} + + +static void ifoPrint_VMGI_MAT(vmgi_mat_t *vmgi_mat) { + + printf("VMG Identifier: %.12s\n", vmgi_mat->vmg_identifier); + printf("Last Sector of VMG: %08x\n", vmgi_mat->vmg_last_sector); + printf("Last Sector of VMGI: %08x\n", vmgi_mat->vmgi_last_sector); + printf("Specification version number: %01x.%01x\n", + vmgi_mat->specification_version >> 4, + vmgi_mat->specification_version & 0xf); + /* Byte 2 of 'VMG Category' (00xx0000) is the Region Code */ + printf("VMG Category: %08x (Region Code=%02x)\n", vmgi_mat->vmg_category, ((vmgi_mat->vmg_category >> 16) & 0xff) ^0xff); + printf("VMG Number of Volumes: %i\n", vmgi_mat->vmg_nr_of_volumes); + printf("VMG This Volume: %i\n", vmgi_mat->vmg_this_volume_nr); + printf("Disc side %i\n", vmgi_mat->disc_side); + printf("VMG Number of Title Sets %i\n", vmgi_mat->vmg_nr_of_title_sets); + printf("Provider ID: %.32s\n", vmgi_mat->provider_identifier); + printf("VMG POS Code: %08x", (uint32_t)(vmgi_mat->vmg_pos_code >> 32)); + printf("%08x\n", (uint32_t)vmgi_mat->vmg_pos_code); + printf("End byte of VMGI_MAT: %08x\n", vmgi_mat->vmgi_last_byte); + printf("Start byte of First Play PGC (FP PGC): %08x\n", + vmgi_mat->first_play_pgc); + printf("Start sector of VMGM_VOBS: %08x\n", vmgi_mat->vmgm_vobs); + printf("Start sector of TT_SRPT: %08x\n", vmgi_mat->tt_srpt); + printf("Start sector of VMGM_PGCI_UT: %08x\n", vmgi_mat->vmgm_pgci_ut); + printf("Start sector of PTL_MAIT: %08x\n", vmgi_mat->ptl_mait); + printf("Start sector of VTS_ATRT: %08x\n", vmgi_mat->vts_atrt); + printf("Start sector of TXTDT_MG: %08x\n", vmgi_mat->txtdt_mgi); + printf("Start sector of VMGM_C_ADT: %08x\n", vmgi_mat->vmgm_c_adt); + printf("Start sector of VMGM_VOBU_ADMAP: %08x\n", + vmgi_mat->vmgm_vobu_admap); + printf("Video attributes of VMGM_VOBS: "); + ifo_print_video_attributes(&vmgi_mat->vmgm_video_attr); + printf("\n"); + printf("VMGM Number of Audio attributes: %i\n", + vmgi_mat->nr_of_vmgm_audio_streams); + if(vmgi_mat->nr_of_vmgm_audio_streams > 0) { + printf("\tstream %i status: ", 1); + ifo_print_audio_attributes(&vmgi_mat->vmgm_audio_attr); + printf("\n"); + } + printf("VMGM Number of Sub-picture attributes: %i\n", + vmgi_mat->nr_of_vmgm_subp_streams); + if(vmgi_mat->nr_of_vmgm_subp_streams > 0) { + printf("\tstream %2i status: ", 1); + ifo_print_subp_attributes(&vmgi_mat->vmgm_subp_attr); + printf("\n"); + } +} + + +static void ifoPrint_VTSI_MAT(vtsi_mat_t *vtsi_mat) { + int i; + + printf("VTS Identifier: %.12s\n", vtsi_mat->vts_identifier); + printf("Last Sector of VTS: %08x\n", vtsi_mat->vts_last_sector); + printf("Last Sector of VTSI: %08x\n", vtsi_mat->vtsi_last_sector); + printf("Specification version number: %01x.%01x\n", + vtsi_mat->specification_version>>4, + vtsi_mat->specification_version&0xf); + printf("VTS Category: %08x\n", vtsi_mat->vts_category); + printf("End byte of VTSI_MAT: %08x\n", vtsi_mat->vtsi_last_byte); + printf("Start sector of VTSM_VOBS: %08x\n", vtsi_mat->vtsm_vobs); + printf("Start sector of VTSTT_VOBS: %08x\n", vtsi_mat->vtstt_vobs); + printf("Start sector of VTS_PTT_SRPT: %08x\n", vtsi_mat->vts_ptt_srpt); + printf("Start sector of VTS_PGCIT: %08x\n", vtsi_mat->vts_pgcit); + printf("Start sector of VTSM_PGCI_UT: %08x\n", vtsi_mat->vtsm_pgci_ut); + printf("Start sector of VTS_TMAPT: %08x\n", vtsi_mat->vts_tmapt); + printf("Start sector of VTSM_C_ADT: %08x\n", vtsi_mat->vtsm_c_adt); + printf("Start sector of VTSM_VOBU_ADMAP: %08x\n",vtsi_mat->vtsm_vobu_admap); + printf("Start sector of VTS_C_ADT: %08x\n", vtsi_mat->vts_c_adt); + printf("Start sector of VTS_VOBU_ADMAP: %08x\n", vtsi_mat->vts_vobu_admap); + + printf("Video attributes of VTSM_VOBS: "); + ifo_print_video_attributes(&vtsi_mat->vtsm_video_attr); + printf("\n"); + + printf("VTSM Number of Audio attributes: %i\n", + vtsi_mat->nr_of_vtsm_audio_streams); + if(vtsi_mat->nr_of_vtsm_audio_streams > 0) { + printf("\tstream %i status: ", 1); + ifo_print_audio_attributes(&vtsi_mat->vtsm_audio_attr); + printf("\n"); + } + + printf("VTSM Number of Sub-picture attributes: %i\n", + vtsi_mat->nr_of_vtsm_subp_streams); + if(vtsi_mat->nr_of_vtsm_subp_streams > 0) { + printf("\tstream %2i status: ", 1); + ifo_print_subp_attributes(&vtsi_mat->vtsm_subp_attr); + printf("\n"); + } + + printf("Video attributes of VTS_VOBS: "); + ifo_print_video_attributes(&vtsi_mat->vts_video_attr); + printf("\n"); + + printf("VTS Number of Audio attributes: %i\n", + vtsi_mat->nr_of_vts_audio_streams); + for(i = 0; i < vtsi_mat->nr_of_vts_audio_streams; i++) { + printf("\tstream %i status: ", i); + ifo_print_audio_attributes(&vtsi_mat->vts_audio_attr[i]); + printf("\n"); + } + + printf("VTS Number of Subpicture attributes: %i\n", + vtsi_mat->nr_of_vts_subp_streams); + for(i = 0; i < vtsi_mat->nr_of_vts_subp_streams; i++) { + printf("\tstream %2i status: ", i); + ifo_print_subp_attributes(&vtsi_mat->vts_subp_attr[i]); + printf("\n"); + } +} + + +static void ifoPrint_PGC_COMMAND_TBL(pgc_command_tbl_t *cmd_tbl) { + int i; + + if(cmd_tbl == NULL) { + printf("No Command table present\n"); + return; + } + + printf("Number of Pre commands: %i\n", cmd_tbl->nr_of_pre); + for(i = 0; i < cmd_tbl->nr_of_pre; i++) { + ifo_print_cmd(i, &cmd_tbl->pre_cmds[i]); + } + + printf("Number of Post commands: %i\n", cmd_tbl->nr_of_post); + for(i = 0; i < cmd_tbl->nr_of_post; i++) { + ifo_print_cmd(i, &cmd_tbl->post_cmds[i]); + } + + printf("Number of Cell commands: %i\n", cmd_tbl->nr_of_cell); + for(i = 0; i < cmd_tbl->nr_of_cell; i++) { + ifo_print_cmd(i, &cmd_tbl->cell_cmds[i]); + } +} + + +static void ifoPrint_PGC_PROGRAM_MAP(pgc_program_map_t *program_map, int nr) { + int i; + + if(program_map == NULL) { + printf("No Program map present\n"); + return; + } + + for(i = 0; i < nr; i++) { + printf("Program %3i Entry Cell: %3i\n", i + 1, program_map[i]); + } +} + + +static void ifoPrint_CELL_PLAYBACK(cell_playback_t *cell_playback, int nr) { + int i; + + if(cell_playback == NULL) { + printf("No Cell Playback info present\n"); + return; + } + + for(i=0;i<nr;i++) { + printf("Cell: %3i ", i + 1); + + dvdread_print_time(&cell_playback[i].playback_time); + printf("\t"); + + if(cell_playback[i].block_mode || cell_playback[i].block_type) { + const char *s; + switch(cell_playback[i].block_mode) { + case 0: + s = "not a"; break; + case 1: + s = "the first"; break; + case 2: + default: + s = ""; break; + case 3: + s = "last"; break; + } + printf("%s cell in the block ", s); + + switch(cell_playback[i].block_type) { + case 0: + printf("not part of the block "); + break; + case 1: + printf("angle block "); + break; + case 2: + case 3: + printf("(send bug report) "); + break; + } + } + if(cell_playback[i].seamless_play) + printf("presented seamlessly "); + if(cell_playback[i].interleaved) + printf("cell is interleaved "); + if(cell_playback[i].stc_discontinuity) + printf("STC_discontinuty "); + if(cell_playback[i].seamless_angle) + printf("only seamless angle "); + if(cell_playback[i].playback_mode) + printf("only still VOBUs "); + if(cell_playback[i].restricted) + printf("restricted cell "); + if(cell_playback[i].cell_type) + printf("cell type 0x%x ", cell_playback[i].cell_type); + if(cell_playback[i].still_time) + printf("still time %d ", cell_playback[i].still_time); + if(cell_playback[i].cell_cmd_nr) + printf("cell command %d", cell_playback[i].cell_cmd_nr); + + printf("\n\tStart sector: %08x\tFirst ILVU end sector: %08x\n", + cell_playback[i].first_sector, + cell_playback[i].first_ilvu_end_sector); + printf("\tEnd sector: %08x\tLast VOBU start sector: %08x\n", + cell_playback[i].last_sector, + cell_playback[i].last_vobu_start_sector); + } +} + +static void ifoPrint_CELL_POSITION(cell_position_t *cell_position, int nr) { + int i; + + if(cell_position == NULL) { + printf("No Cell Position info present\n"); + return; + } + + for(i=0;i<nr;i++) { + printf("Cell: %3i has VOB ID: %3i, Cell ID: %3i\n", i + 1, + cell_position[i].vob_id_nr, cell_position[i].cell_nr); + } +} + + +static void ifoPrint_PGC(pgc_t *pgc) { + int i; + + if (!pgc) { + printf("None\n"); + return; + } + printf("Number of Programs: %i\n", pgc->nr_of_programs); + printf("Number of Cells: %i\n", pgc->nr_of_cells); + /* Check that time is 0:0:0:0 also if nr_of_programs==0 */ + printf("Playback time: "); + dvdread_print_time(&pgc->playback_time); printf("\n"); + + /* If no programs/no time then does this mean anything? */ + printf("Prohibited user operations: "); + ifoPrint_USER_OPS(&pgc->prohibited_ops); + + for(i = 0; i < 8; i++) { + if(pgc->audio_control[i] & 0x8000) { /* The 'is present' bit */ + printf("Audio stream %i control: %04x\n", + i, pgc->audio_control[i]); + } + } + + for(i = 0; i < 32; i++) { + if(pgc->subp_control[i] & 0x80000000) { /* The 'is present' bit */ + printf("Subpicture stream %2i control: %08x: 4:3=%d, Wide=%d, Letterbox=%d, Pan-Scan=%d\n", + i, pgc->subp_control[i], + (pgc->subp_control[i] >>24) & 0x1f, + (pgc->subp_control[i] >>16) & 0x1f, + (pgc->subp_control[i] >>8) & 0x1f, + (pgc->subp_control[i] ) & 0x1f); + } + } + + printf("Next PGC number: %i\n", pgc->next_pgc_nr); + printf("Prev PGC number: %i\n", pgc->prev_pgc_nr); + printf("GoUp PGC number: %i\n", pgc->goup_pgc_nr); + if(pgc->nr_of_programs != 0) { + printf("Still time: %i seconds (255=inf)\n", pgc->still_time); + printf("PG Playback mode %02x\n", pgc->pg_playback_mode); + } + + if(pgc->nr_of_programs != 0) { + for(i = 0; i < 16; i++) { + printf("Color %2i: %08x\n", i, pgc->palette[i]); + } + } + + /* Memory offsets to div. tables. */ + ifoPrint_PGC_COMMAND_TBL(pgc->command_tbl); + ifoPrint_PGC_PROGRAM_MAP(pgc->program_map, pgc->nr_of_programs); + ifoPrint_CELL_PLAYBACK(pgc->cell_playback, pgc->nr_of_cells); + ifoPrint_CELL_POSITION(pgc->cell_position, pgc->nr_of_cells); +} + + +static void ifoPrint_TT_SRPT(tt_srpt_t *tt_srpt) { + int i; + + printf("Number of TitleTrack search pointers: %i\n", + tt_srpt->nr_of_srpts); + for(i=0;i<tt_srpt->nr_of_srpts;i++) { + printf("Title Track index %i\n", i + 1); + printf("\tTitle set number (VTS): %i", + tt_srpt->title[i].title_set_nr); + printf("\tVTS_TTN: %i\n", tt_srpt->title[i].vts_ttn); + printf("\tNumber of PTTs: %i\n", tt_srpt->title[i].nr_of_ptts); + printf("\tNumber of angles: %i\n", + tt_srpt->title[i].nr_of_angles); + + printf("\tTitle playback type: (%02x)\n", + *(uint8_t *)&(tt_srpt->title[i].pb_ty)); + printf("\t\t%s\n", + tt_srpt->title[i].pb_ty.multi_or_random_pgc_title ? "Random or Shuffle" : "Sequential"); + if (tt_srpt->title[i].pb_ty.jlc_exists_in_cell_cmd) printf("\t\tJump/Link/Call exists in cell cmd\n"); + if (tt_srpt->title[i].pb_ty.jlc_exists_in_prepost_cmd) printf("\t\tJump/Link/Call exists in pre/post cmd\n"); + if (tt_srpt->title[i].pb_ty.jlc_exists_in_button_cmd) printf("\t\tJump/Link/Call exists in button cmd\n"); + if (tt_srpt->title[i].pb_ty.jlc_exists_in_tt_dom) printf("\t\tJump/Link/Call exists in tt_dom cmd\n"); + printf("\t\tTitle or time play:%u\n", tt_srpt->title[i].pb_ty.title_or_time_play); + printf("\t\tChapter search or play:%u\n", tt_srpt->title[i].pb_ty.chapter_search_or_play); + + printf("\tParental ID field: %04x\n", + tt_srpt->title[i].parental_id); + printf("\tTitle set starting sector %08x\n", + tt_srpt->title[i].title_set_sector); + } +} + + +static void ifoPrint_VTS_PTT_SRPT(vts_ptt_srpt_t *vts_ptt_srpt) { + int i, j; + printf(" nr_of_srpts %i last byte %i\n", + vts_ptt_srpt->nr_of_srpts, + vts_ptt_srpt->last_byte); + for(i=0;i<vts_ptt_srpt->nr_of_srpts;i++) { + for(j=0;j<vts_ptt_srpt->title[i].nr_of_ptts;j++) { + printf("VTS_PTT_SRPT - Title %3i part %3i: PGC: %3i PG: %3i\n", + i + 1, j + 1, + vts_ptt_srpt->title[i].ptt[j].pgcn, + vts_ptt_srpt->title[i].ptt[j].pgn ); + } + } +} + + +static void hexdump(uint8_t *ptr, int len) { + while(len--) + printf("%02x ", *ptr++); +} + +static void ifoPrint_PTL_MAIT(ptl_mait_t *ptl_mait) { + int i, j; + + printf("Number of Countries: %i\n", ptl_mait->nr_of_countries); + printf("Number of VTSs: %i\n", ptl_mait->nr_of_vtss); + //printf("Last byte: %i\n", ptl_mait->last_byte); + + for(i = 0; i < ptl_mait->nr_of_countries; i++) { + printf("Country code: %c%c\n", + ptl_mait->countries[i].country_code >> 8, + ptl_mait->countries[i].country_code & 0xff); + /* + printf("Start byte: %04x %i\n", + ptl_mait->countries[i].pf_ptl_mai_start_byte, + ptl_mait->countries[i].pf_ptl_mai_start_byte); + */ + /* This seems to be pointing at a array with 8 2byte fields per VTS + ? and one extra for the menu? always an odd number of VTSs on + all the dics I tested so it might be padding to even also. + If it is for the menu it probably the first entry. */ + for(j=0;j<8;j++) { + hexdump( (uint8_t *)ptl_mait->countries - PTL_MAIT_COUNTRY_SIZE + + ptl_mait->countries[i].pf_ptl_mai_start_byte + + j*(ptl_mait->nr_of_vtss+1)*2, (ptl_mait->nr_of_vtss+1)*2); + printf("\n"); + } + } +} + +static void ifoPrint_VTS_TMAPT(vts_tmapt_t *vts_tmapt) { + unsigned int timeunit; + int i, j; + + printf("Number of VTS_TMAPS: %i\n", vts_tmapt->nr_of_tmaps); + printf("Last byte: %i\n", vts_tmapt->last_byte); + + for(i = 0; i < vts_tmapt->nr_of_tmaps; i++) { + printf("TMAP %i (number matches title PGC number.)\n", i + 1); + printf(" offset %d relative to VTS_TMAPTI\n", vts_tmapt->tmap_offset[i]); + printf(" Time unit (seconds): %i\n", vts_tmapt->tmap[i].tmu); + printf(" Number of entries: %i\n", vts_tmapt->tmap[i].nr_of_entries); + timeunit = vts_tmapt->tmap[i].tmu; + for(j = 0; j < vts_tmapt->tmap[i].nr_of_entries; j++) { + unsigned int ac_time = timeunit * (j + 1); + printf("Time: %2i:%02i:%02i VOBU Sector: 0x%08x %s\n", + ac_time / (60 * 60), (ac_time / 60) % 60, ac_time % 60, + vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff, + (vts_tmapt->tmap[i].map_ent[j] >> 31) ? "discontinuity" : ""); + } + } +} + +static void ifoPrint_C_ADT(c_adt_t *c_adt) { + int i, entries; + + printf("Number of VOBs in this VOBS: %i\n", c_adt->nr_of_vobs); + //entries = c_adt->nr_of_vobs; + entries = (c_adt->last_byte + 1 - C_ADT_SIZE)/sizeof(c_adt_t); + + for(i = 0; i < entries; i++) { + printf("VOB ID: %3i, Cell ID: %3i ", + c_adt->cell_adr_table[i].vob_id, c_adt->cell_adr_table[i].cell_id); + printf("Sector (first): 0x%08x (last): 0x%08x\n", + c_adt->cell_adr_table[i].start_sector, + c_adt->cell_adr_table[i].last_sector); + } +} + + +static void ifoPrint_VOBU_ADMAP(vobu_admap_t *vobu_admap) { + int i, entries; + + entries = (vobu_admap->last_byte + 1 - VOBU_ADMAP_SIZE)/4; + for(i = 0; i < entries; i++) { + printf("VOBU %5i First sector: 0x%08x\n", i + 1, + vobu_admap->vobu_start_sectors[i]); + } +} + +static const char *ifo_print_menu_name(int type) { + const char *menu_name; + menu_name=""; + switch (type) { + case 2: + menu_name="Title"; + break; + case 3: + menu_name = "Root"; + break; + case 4: + menu_name = "Sub-Picture"; + break; + case 5: + menu_name = "Audio"; + break; + case 6: + menu_name = "Angle"; + break; + case 7: + menu_name = "PTT (Chapter)"; + break; + default: + menu_name = "Unknown"; + break; + } + return &menu_name[0]; +} + +/* pgc_type=1 for menu, 0 for title. */ +static void ifoPrint_PGCIT(pgcit_t *pgcit, int pgc_type) { + int i; + + printf("\nNumber of Program Chains: %3i\n", pgcit->nr_of_pgci_srp); + for(i = 0; i < pgcit->nr_of_pgci_srp; i++) { + printf("\nProgram (PGC): %3i\n", i + 1); + if (pgc_type) { + printf("PGC Category: Entry PGC %d, Menu Type=0x%02x:%s (Entry id 0x%02x), ", + pgcit->pgci_srp[i].entry_id >> 7, + pgcit->pgci_srp[i].entry_id & 0xf, + ifo_print_menu_name(pgcit->pgci_srp[i].entry_id & 0xf), + pgcit->pgci_srp[i].entry_id); + } else { + printf("PGC Category: %s VTS_TTN:0x%02x (Entry id 0x%02x), ", + pgcit->pgci_srp[i].entry_id >> 7 ? "At Start of" : "During", + pgcit->pgci_srp[i].entry_id & 0xf, + pgcit->pgci_srp[i].entry_id); + } + printf("Parental ID mask 0x%04x\n", pgcit->pgci_srp[i].ptl_id_mask); + ifoPrint_PGC(pgcit->pgci_srp[i].pgc); + } +} + + +static void ifoPrint_PGCI_UT(pgci_ut_t *pgci_ut) { + int i, menu; + + printf("Number of Menu Language Units (PGCI_LU): %3i\n", pgci_ut->nr_of_lus); + for(i = 0; i < pgci_ut->nr_of_lus; i++) { + printf("\nMenu Language Unit %d\n", i+1); + printf("\nMenu Language Code: %c%c\n", + pgci_ut->lu[i].lang_code >> 8, + pgci_ut->lu[i].lang_code & 0xff); + + menu = pgci_ut->lu[i].exists; + printf("Menu Existence: %02x: ", menu); + if (menu == 0) { + printf("No menus "); + } + if (menu & 0x80) { + printf("Root "); + menu^=0x80; + } + if (menu & 0x40) { + printf("Sub-Picture "); + menu^=0x40; + } + if (menu & 0x20) { + printf("Audio "); + menu^=0x20; + } + if (menu & 0x10) { + printf("Angle "); + menu^=0x10; + } + if (menu & 0x08) { + printf("PTT "); + menu^=0x08; + } + if (menu > 0) { + printf("Unknown extra menus "); + menu^=0x08; + } + printf("\n"); + ifoPrint_PGCIT(pgci_ut->lu[i].pgcit, 1); + } +} + + +static void ifoPrint_VTS_ATTRIBUTES(vts_attributes_t *vts_attributes) { + int i; + + printf("VTS_CAT Application type: %08x\n", vts_attributes->vts_cat); + + printf("Video attributes of VTSM_VOBS: "); + ifo_print_video_attributes(&vts_attributes->vtsm_vobs_attr); + printf("\n"); + printf("Number of Audio streams: %i\n", + vts_attributes->nr_of_vtsm_audio_streams); + if(vts_attributes->nr_of_vtsm_audio_streams > 0) { + printf("\tstream %i attributes: ", 1); + ifo_print_audio_attributes(&vts_attributes->vtsm_audio_attr); + printf("\n"); + } + printf("Number of Subpicture streams: %i\n", + vts_attributes->nr_of_vtsm_subp_streams); + if(vts_attributes->nr_of_vtsm_subp_streams > 0) { + printf("\tstream %2i attributes: ", 1); + ifo_print_subp_attributes(&vts_attributes->vtsm_subp_attr); + printf("\n"); + } + + printf("Video attributes of VTSTT_VOBS: "); + ifo_print_video_attributes(&vts_attributes->vtstt_vobs_video_attr); + printf("\n"); + printf("Number of Audio streams: %i\n", + vts_attributes->nr_of_vtstt_audio_streams); + for(i = 0; i < vts_attributes->nr_of_vtstt_audio_streams; i++) { + printf("\tstream %i attributes: ", i); + ifo_print_audio_attributes(&vts_attributes->vtstt_audio_attr[i]); + printf("\n"); + } + + printf("Number of Subpicture streams: %i\n", + vts_attributes->nr_of_vtstt_subp_streams); + for(i = 0; i < vts_attributes->nr_of_vtstt_subp_streams; i++) { + printf("\tstream %2i attributes: ", i); + ifo_print_subp_attributes(&vts_attributes->vtstt_subp_attr[i]); + printf("\n"); + } +} + + +static void ifoPrint_VTS_ATRT(vts_atrt_t *vts_atrt) { + int i; + + printf("Number of Video Title Sets: %3i\n", vts_atrt->nr_of_vtss); + for(i = 0; i < vts_atrt->nr_of_vtss; i++) { + printf("\nVideo Title Set %i\n", i + 1); + ifoPrint_VTS_ATTRIBUTES(&vts_atrt->vts[i]); + } +} + + +void ifo_print(dvd_reader_t *dvd, int title) { + ifo_handle_t *ifohandle; + printf("Local ifo_print\n"); + ifohandle = ifoOpen(dvd, title); + if(!ifohandle) { + Log0(dvd, "Can't open info file for title %d", title); + return; + } + + + if(ifohandle->vmgi_mat) { + + printf("VMG top level\n-------------\n"); + ifoPrint_VMGI_MAT(ifohandle->vmgi_mat); + + printf("\nFirst Play PGC\n--------------\n"); + if(ifohandle->first_play_pgc) + ifoPrint_PGC(ifohandle->first_play_pgc); + else + printf("No First Play PGC present\n"); + + printf("\nTitle Track search pointer table\n"); + printf( "------------------------------------------------\n"); + ifoPrint_TT_SRPT(ifohandle->tt_srpt); + + printf("\nMenu PGCI Unit table\n"); + printf( "--------------------\n"); + if(ifohandle->pgci_ut) { + ifoPrint_PGCI_UT(ifohandle->pgci_ut); + } else { + printf("No PGCI Unit table present\n"); + } + + printf("\nParental Management Information table\n"); + printf( "------------------------------------\n"); + if(ifohandle->ptl_mait) { + ifoPrint_PTL_MAIT(ifohandle->ptl_mait); + } else { + printf("No Parental Management Information present\n"); + } + + printf("\nVideo Title Set Attribute Table\n"); + printf( "-------------------------------\n"); + ifoPrint_VTS_ATRT(ifohandle->vts_atrt); + + printf("\nText Data Manager Information\n"); + printf( "-----------------------------\n"); + if(ifohandle->txtdt_mgi) { + //ifo_print_TXTDT_MGI(&(vmgi->txtdt_mgi)); + } else { + printf("No Text Data Manager Information present\n"); + } + + printf("\nMenu Cell Address table\n"); + printf( "-----------------\n"); + if(ifohandle->menu_c_adt) { + ifoPrint_C_ADT(ifohandle->menu_c_adt); + } else { + printf("No Menu Cell Address table present\n"); + } + + printf("\nVideo Manager Menu VOBU address map\n"); + printf( "-----------------\n"); + if(ifohandle->menu_vobu_admap) { + ifoPrint_VOBU_ADMAP(ifohandle->menu_vobu_admap); + } else { + printf("No Menu VOBU address map present\n"); + } + } + + + if(ifohandle->vtsi_mat) { + + printf("VTS top level\n-------------\n"); + ifoPrint_VTSI_MAT(ifohandle->vtsi_mat); + + printf("\nPart of Title Track search pointer table\n"); + printf( "----------------------------------------------\n"); + ifoPrint_VTS_PTT_SRPT(ifohandle->vts_ptt_srpt); + + printf("\nPGCI Unit table\n"); + printf( "--------------------\n"); + ifoPrint_PGCIT(ifohandle->vts_pgcit, 0); + + printf("\nMenu PGCI Unit table\n"); + printf( "--------------------\n"); + if(ifohandle->pgci_ut) { + ifoPrint_PGCI_UT(ifohandle->pgci_ut); + } else { + printf("No Menu PGCI Unit table present\n"); + } + + printf("\nVTS Time Map table\n"); + printf( "-----------------\n"); + if(ifohandle->vts_tmapt) { + ifoPrint_VTS_TMAPT(ifohandle->vts_tmapt); + } else { + printf("No VTS Time Map table present\n"); + } + + printf("\nMenu Cell Address table\n"); + printf( "-----------------\n"); + if(ifohandle->menu_c_adt) { + ifoPrint_C_ADT(ifohandle->menu_c_adt); + } else { + printf("No Cell Address table present\n"); + } + + printf("\nVideo Title Set Menu VOBU address map\n"); + printf( "-----------------\n"); + if(ifohandle->menu_vobu_admap) { + ifoPrint_VOBU_ADMAP(ifohandle->menu_vobu_admap); + } else { + printf("No Menu VOBU address map present\n"); + } + + printf("\nCell Address table\n"); + printf( "-----------------\n"); + ifoPrint_C_ADT(ifohandle->vts_c_adt); + + printf("\nVideo Title Set VOBU address map\n"); + printf( "-----------------\n"); + ifoPrint_VOBU_ADMAP(ifohandle->vts_vobu_admap); + } + + ifoClose(ifohandle); +} diff --git a/libdvdread-embedded/src/ifo_read.c b/libdvdread-embedded/src/ifo_read.c new file mode 100644 index 0000000..6fd913d --- /dev/null +++ b/libdvdread-embedded/src/ifo_read.c @@ -0,0 +1,2341 @@ +/* + * Copyright (C) 2000, 2001, 2002, 2003 + * Björn Englund <d4bjorn@dtek.chalmers.se>, + * Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" + +#include <stdio.h> +#include <stdlib.h> +#include <inttypes.h> +#include <string.h> + +#include "bswap.h" +#include "dvdread/ifo_types.h" +#include "dvdread/ifo_read.h" +#include "dvdread/dvd_reader.h" +#include "dvdread_internal.h" +#include "dvdread/bitreader.h" + +#ifndef DVD_BLOCK_LEN +#define DVD_BLOCK_LEN 2048 +#endif + +#define PRIV(a) container_of(a, struct ifo_handle_private_s, handle) + +#define CHECK_VALUE(arg)\ + if(!(arg)) {\ + Log1(ifop->ctx, "CHECK_VALUE failed in %s:%i for %s",\ + __FILE__, __LINE__, # arg );\ + } + +#ifndef NDEBUG +static inline char * makehexdump(const uint8_t *p_CZ, size_t i_CZ) +{ + char *alloc = malloc(i_CZ * 2 + 1); + if(alloc) + { + *alloc = 0; + for(size_t i = 0; i < i_CZ; i++) + sprintf(&alloc[i*2], "%02x", *((uint8_t*)&p_CZ[i])); + } + return alloc; +} +#define CHECK_ZERO0(arg) \ + if(arg != 0) { \ + Log1(ifop->ctx, "Zero check failed in %s:%i\n for %s = 0x%x", \ + __FILE__, __LINE__, # arg, arg); \ + } +#define CHECK_ZERO(arg) \ + if(memcmp(my_friendly_zeros, &arg, sizeof(arg))) { \ + char *dump = makehexdump((const uint8_t *)&arg, sizeof(arg)); \ + Log0(ifop->ctx, "Zero check failed in %s:%i for %s : 0x%s", \ + __FILE__, __LINE__, # arg, dump ); \ + free(dump); \ + } +static const uint8_t my_friendly_zeros[2048]; +#else +#define CHECK_ZERO0(arg) (void)(arg) +#define CHECK_ZERO(arg) (void)(arg) +#endif + + +/* Prototypes for internal functions */ +static int ifoRead_VMG(ifo_handle_t *ifofile); +static int ifoRead_VTS(ifo_handle_t *ifofile); +static int ifoRead_PGC(ifo_handle_t *ifofile, pgc_t *pgc, unsigned int offset); +static int ifoRead_PGC_COMMAND_TBL(ifo_handle_t *ifofile, + pgc_command_tbl_t *cmd_tbl, + unsigned int offset); +static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile, + pgc_program_map_t *program_map, + unsigned int nr, unsigned int offset); +static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile, + cell_playback_t *cell_playback, + unsigned int nr, unsigned int offset); +static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile, + cell_position_t *cell_position, + unsigned int nr, unsigned int offset); +static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile, + vts_attributes_t *vts_attributes, + unsigned int offset); +static int ifoRead_C_ADT_internal(ifo_handle_t *ifofile, c_adt_t *c_adt, + unsigned int sector); +static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile, + vobu_admap_t *vobu_admap, + unsigned int sector); +static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit, + unsigned int offset); + +static void ifoFree_PGC(pgc_t **pgc); +static void ifoFree_PGC_COMMAND_TBL(pgc_command_tbl_t *cmd_tbl); +static void ifoFree_PGCIT_internal(pgcit_t **pgcit); + +static inline int DVDFileSeekForce_( dvd_file_t *dvd_file, uint32_t offset, int force_size ) { + return (DVDFileSeekForce(dvd_file, (int)offset, force_size) == (int)offset); +} + +static inline int DVDFileSeek_( dvd_file_t *dvd_file, uint32_t offset ) { + return (DVDFileSeek(dvd_file, (int)offset) == (int)offset); +} + +static void read_video_attr(video_attr_t *va) { + getbits_state_t state; + uint8_t buf[sizeof(video_attr_t)]; + + memcpy(buf, va, sizeof(video_attr_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + va->mpeg_version = dvdread_getbits(&state, 2); + va->video_format = dvdread_getbits(&state, 2); + va->display_aspect_ratio = dvdread_getbits(&state, 2); + va->permitted_df = dvdread_getbits(&state, 2); + va->line21_cc_1 = dvdread_getbits(&state, 1); + va->line21_cc_2 = dvdread_getbits(&state, 1); + va->unknown1 = dvdread_getbits(&state, 1); + va->bit_rate = dvdread_getbits(&state, 1); + va->picture_size = dvdread_getbits(&state, 2); + va->letterboxed = dvdread_getbits(&state, 1); + va->film_mode = dvdread_getbits(&state, 1); +} + +static void read_audio_attr(audio_attr_t *aa) { + getbits_state_t state; + uint8_t buf[sizeof(audio_attr_t)]; + + memcpy(buf, aa, sizeof(audio_attr_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + aa->audio_format = dvdread_getbits(&state, 3); + aa->multichannel_extension = dvdread_getbits(&state, 1); + aa->lang_type = dvdread_getbits(&state, 2); + aa->application_mode = dvdread_getbits(&state, 2); + aa->quantization = dvdread_getbits(&state, 2); + aa->sample_frequency = dvdread_getbits(&state, 2); + aa->unknown1 = dvdread_getbits(&state, 1); + aa->channels = dvdread_getbits(&state, 3); + aa->lang_code = dvdread_getbits(&state, 16); + aa->lang_extension = dvdread_getbits(&state, 8); + aa->code_extension = dvdread_getbits(&state, 8); + aa->unknown3 = dvdread_getbits(&state, 8); + aa->app_info.karaoke.unknown4 = dvdread_getbits(&state, 1); + aa->app_info.karaoke.channel_assignment = dvdread_getbits(&state, 3); + aa->app_info.karaoke.version = dvdread_getbits(&state, 2); + aa->app_info.karaoke.mc_intro = dvdread_getbits(&state, 1); + aa->app_info.karaoke.mode = dvdread_getbits(&state, 1); +} + +static void read_multichannel_ext(multichannel_ext_t *me) { + getbits_state_t state; + uint8_t buf[sizeof(multichannel_ext_t)]; + + memcpy(buf, me, sizeof(multichannel_ext_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + me->zero1 = dvdread_getbits(&state, 7); + me->ach0_gme = dvdread_getbits(&state, 1); + me->zero2 = dvdread_getbits(&state, 7); + me->ach1_gme = dvdread_getbits(&state, 1); + me->zero3 = dvdread_getbits(&state, 4); + me->ach2_gv1e = dvdread_getbits(&state, 1); + me->ach2_gv2e = dvdread_getbits(&state, 1); + me->ach2_gm1e = dvdread_getbits(&state, 1); + me->ach2_gm2e = dvdread_getbits(&state, 1); + me->zero4 = dvdread_getbits(&state, 4); + me->ach3_gv1e = dvdread_getbits(&state, 1); + me->ach3_gv2e = dvdread_getbits(&state, 1); + me->ach3_gmAe = dvdread_getbits(&state, 1); + me->ach3_se2e = dvdread_getbits(&state, 1); + me->zero5 = dvdread_getbits(&state, 4); + me->ach4_gv1e = dvdread_getbits(&state, 1); + me->ach4_gv2e = dvdread_getbits(&state, 1); + me->ach4_gmBe = dvdread_getbits(&state, 1); + me->ach4_seBe = dvdread_getbits(&state, 1); +} + +static void read_subp_attr(subp_attr_t *sa) { + getbits_state_t state; + uint8_t buf[sizeof(subp_attr_t)]; + + memcpy(buf, sa, sizeof(subp_attr_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + sa->code_mode = dvdread_getbits(&state, 3); + sa->zero1 = dvdread_getbits(&state, 3); + sa->type = dvdread_getbits(&state, 2); + sa->zero2 = dvdread_getbits(&state, 8); + sa->lang_code = dvdread_getbits(&state, 16); + sa->lang_extension = dvdread_getbits(&state, 8); + sa->code_extension = dvdread_getbits(&state, 8); +} + +static void read_user_ops(user_ops_t *uo) { + getbits_state_t state; + uint8_t buf[sizeof(user_ops_t)]; + + memcpy(buf, uo, sizeof(user_ops_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + uo->zero = dvdread_getbits(&state, 7); + uo->video_pres_mode_change = dvdread_getbits(&state, 1); + uo->karaoke_audio_pres_mode_change = dvdread_getbits(&state, 1); + uo->angle_change = dvdread_getbits(&state, 1); + uo->subpic_stream_change = dvdread_getbits(&state, 1); + uo->audio_stream_change = dvdread_getbits(&state, 1); + uo->pause_on = dvdread_getbits(&state, 1); + uo->still_off = dvdread_getbits(&state, 1); + uo->button_select_or_activate = dvdread_getbits(&state, 1); + uo->resume = dvdread_getbits(&state, 1); + uo->chapter_menu_call = dvdread_getbits(&state, 1); + uo->angle_menu_call = dvdread_getbits(&state, 1); + uo->audio_menu_call = dvdread_getbits(&state, 1); + uo->subpic_menu_call = dvdread_getbits(&state, 1); + uo->root_menu_call = dvdread_getbits(&state, 1); + uo->title_menu_call = dvdread_getbits(&state, 1); + uo->backward_scan = dvdread_getbits(&state, 1); + uo->forward_scan = dvdread_getbits(&state, 1); + uo->next_pg_search = dvdread_getbits(&state, 1); + uo->prev_or_top_pg_search = dvdread_getbits(&state, 1); + uo->time_or_chapter_search = dvdread_getbits(&state, 1); + uo->go_up = dvdread_getbits(&state, 1); + uo->stop = dvdread_getbits(&state, 1); + uo->title_play = dvdread_getbits(&state, 1); + uo->chapter_search_or_play = dvdread_getbits(&state, 1); + uo->title_or_time_play = dvdread_getbits(&state, 1); +} + +static void read_pgci_srp(pgci_srp_t *ps) { + getbits_state_t state; + uint8_t buf[sizeof(pgci_srp_t)]; + + memcpy(buf, ps, sizeof(pgci_srp_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + ps->entry_id = dvdread_getbits(&state, 8); + ps->block_mode = dvdread_getbits(&state, 2); + ps->block_type = dvdread_getbits(&state, 2); + ps->zero_1 = dvdread_getbits(&state, 4); + ps->ptl_id_mask = dvdread_getbits(&state, 16); + ps->pgc_start_byte = dvdread_getbits(&state, 32); +} + +static void read_cell_playback(cell_playback_t *cp) { + getbits_state_t state; + uint8_t buf[sizeof(cell_playback_t)]; + + memcpy(buf, cp, sizeof(cell_playback_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + cp->block_mode = dvdread_getbits(&state, 2); + cp->block_type = dvdread_getbits(&state, 2); + cp->seamless_play = dvdread_getbits(&state, 1); + cp->interleaved = dvdread_getbits(&state, 1); + cp->stc_discontinuity = dvdread_getbits(&state, 1); + cp->seamless_angle = dvdread_getbits(&state, 1); + cp->zero_1 = dvdread_getbits(&state, 1); + cp->playback_mode = dvdread_getbits(&state, 1); + cp->restricted = dvdread_getbits(&state, 1); + cp->cell_type = dvdread_getbits(&state, 5); + cp->still_time = dvdread_getbits(&state, 8); + cp->cell_cmd_nr = dvdread_getbits(&state, 8); + + cp->playback_time.hour = dvdread_getbits(&state, 8); + cp->playback_time.minute = dvdread_getbits(&state, 8); + cp->playback_time.second = dvdread_getbits(&state, 8); + cp->playback_time.frame_u = dvdread_getbits(&state, 8); + + cp->first_sector = dvdread_getbits(&state, 32); + cp->first_ilvu_end_sector = dvdread_getbits(&state, 32); + cp->last_vobu_start_sector = dvdread_getbits(&state, 32); + cp->last_sector = dvdread_getbits(&state, 32); +} + +static void read_playback_type(playback_type_t *pt) { + getbits_state_t state; + uint8_t buf[sizeof(playback_type_t)]; + + memcpy(buf, pt, sizeof(playback_type_t)); + if (!dvdread_getbits_init(&state, buf)) abort(); + pt->zero_1 = dvdread_getbits(&state, 1); + pt->multi_or_random_pgc_title = dvdread_getbits(&state, 1); + pt->jlc_exists_in_cell_cmd = dvdread_getbits(&state, 1); + pt->jlc_exists_in_prepost_cmd = dvdread_getbits(&state, 1); + pt->jlc_exists_in_button_cmd = dvdread_getbits(&state, 1); + pt->jlc_exists_in_tt_dom = dvdread_getbits(&state, 1); + pt->chapter_search_or_play = dvdread_getbits(&state, 1); + pt->title_or_time_play = dvdread_getbits(&state, 1); +} + +static void free_ptl_mait(ptl_mait_t* ptl_mait, int num_entries) { + int i; + for (i = 0; i < num_entries; i++) + free(ptl_mait->countries[i].pf_ptl_mai); + + free(ptl_mait->countries); + free(ptl_mait); +} + +static ifo_handle_t *ifoOpenFileOrBackup(dvd_reader_t *ctx, int title, + int backup) { + struct ifo_handle_private_s *ifop; + dvd_read_domain_t domain = backup ? DVD_READ_INFO_BACKUP_FILE + : DVD_READ_INFO_FILE; + char ifo_filename[13]; + + ifop = calloc(1, sizeof(*ifop)); + if(!ifop) + return NULL; + + ifop->ctx = ctx; + ifop->file = DVDOpenFile(ctx, title, domain); + if(!ifop->file) + { + free(ifop); + return NULL; + } + + if (title) + snprintf(ifo_filename, 13, "VTS_%02d_0.%s", title, backup ? "BUP" : "IFO"); + else + snprintf(ifo_filename, 13, "VIDEO_TS.%s", backup ? "BUP" : "IFO"); + + if(!ifop->file) { + Log1(ctx, "Can't open file %s.", ifo_filename); + free(ifop); + return NULL; + } + + ifo_handle_t *ifofile = &ifop->handle; + /* First check if this is a VMGI file. */ + if(ifoRead_VMG(ifofile)) { + + /* These are both mandatory. */ + if(!ifoRead_FP_PGC(ifofile) || !ifoRead_TT_SRPT(ifofile)) + goto ifoOpen_fail; + + ifoRead_PGCI_UT(ifofile); + ifoRead_PTL_MAIT(ifofile); + + /* This is also mandatory. */ + if(!ifoRead_VTS_ATRT(ifofile)) + goto ifoOpen_fail; + + ifoRead_TXTDT_MGI(ifofile); + ifoRead_C_ADT(ifofile); + ifoRead_VOBU_ADMAP(ifofile); + + return ifofile; + } + + if(ifoRead_VTS(ifofile)) { + + if(!ifoRead_VTS_PTT_SRPT(ifofile) || !ifoRead_PGCIT(ifofile)) + goto ifoOpen_fail; + + ifoRead_PGCI_UT(ifofile); + ifoRead_VTS_TMAPT(ifofile); + ifoRead_C_ADT(ifofile); + ifoRead_VOBU_ADMAP(ifofile); + + if(!ifoRead_TITLE_C_ADT(ifofile) || !ifoRead_TITLE_VOBU_ADMAP(ifofile)) + goto ifoOpen_fail; + + return ifofile; + } + +ifoOpen_fail: + Log1(ctx, "Invalid IFO for title %d (%s).", title, ifo_filename); + ifoClose(ifofile); + return NULL; +} + +static void ifoSetBupFlag(dvd_reader_t *ctx, int title) +{ + if(title > 63) + ctx->ifoBUPflags[0] |= 1 << (title - 64); + else + ctx->ifoBUPflags[1] |= 1 << title; +} + +static int ifoGetBupFlag(const dvd_reader_t *ctx, int title) +{ + int bupflag; + if(title > 63) + bupflag = !! (ctx->ifoBUPflags[0] & (1 << (title - 64))); + else + bupflag = !! (ctx->ifoBUPflags[1] & (1 << title)); + return bupflag; +} + +ifo_handle_t *ifoOpen(dvd_reader_t *ctx, int title) { + ifo_handle_t *ifofile; + int bupflag = ifoGetBupFlag(ctx, title); + + ifofile = ifoOpenFileOrBackup(ctx, title, bupflag); + if(!ifofile) /* Try backup */ + { + ifofile = ifoOpenFileOrBackup(ctx, title, 1); + if(ifofile && !bupflag) + ifoSetBupFlag(ctx, title); + } + return ifofile; +} + +ifo_handle_t *ifoOpenVMGI(dvd_reader_t *ctx) { + struct ifo_handle_private_s *ifop; + + for(int backup = ifoGetBupFlag(ctx, 0); backup <= 1; backup++) + { + ifop = calloc(1, sizeof(*ifop)); + if(!ifop) + return NULL; + + const dvd_read_domain_t domain = backup ? DVD_READ_INFO_BACKUP_FILE + : DVD_READ_INFO_FILE; + const char *ext = backup ? "BUP" : "IFO"; + + ifop->ctx = ctx; + ifop->file = DVDOpenFile(ctx, 0, domain); + if(!ifop->file) { /* Should really catch any error */ + Log1(ctx, "Can't open file VIDEO_TS.%s.", ext); + free(ifop); + return NULL; + } + + if(ifoRead_VMG(&ifop->handle)) + return &ifop->handle; + + Log1(ctx, "ifoOpenVMGI(): Invalid main menu IFO (VIDEO_TS.%s).", ext); + ifoClose(&ifop->handle); + } + return NULL; +} + + +ifo_handle_t *ifoOpenVTSI(dvd_reader_t *ctx, int title) { + struct ifo_handle_private_s *ifop; + + if(title <= 0 || title > 99) { + Log1(ctx, "ifoOpenVTSI invalid title (%d).", title); + return NULL; + } + + for(int backup = ifoGetBupFlag(ctx, title); backup <= 1; backup++) + { + ifop = calloc(1, sizeof(*ifop)); + if(!ifop) + return NULL; + + const dvd_read_domain_t domain = backup ? DVD_READ_INFO_BACKUP_FILE + : DVD_READ_INFO_FILE; + const char *ext = backup ? "BUP" : "IFO"; + ifop->ctx = ctx; + ifop->file = DVDOpenFile(ctx, title, domain); + /* Should really catch any error */ + if(!ifop->file) { + Log1(ctx, "Can't open file VTS_%02d_0.%s.", title, ext); + free(ifop); + continue; + } + + if(ifoRead_VTS(&ifop->handle) && ifop->handle.vtsi_mat) + return &ifop->handle; + + Log1(ctx, "Invalid IFO for title %d (VTS_%02d_0.%s).", + title, title, ext); + ifoClose(&ifop->handle); + } + + return NULL; +} + + +void ifoClose(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + ifoFree_VOBU_ADMAP(ifofile); + ifoFree_TITLE_VOBU_ADMAP(ifofile); + ifoFree_C_ADT(ifofile); + ifoFree_TITLE_C_ADT(ifofile); + ifoFree_TXTDT_MGI(ifofile); + ifoFree_VTS_ATRT(ifofile); + ifoFree_PTL_MAIT(ifofile); + ifoFree_PGCI_UT(ifofile); + ifoFree_TT_SRPT(ifofile); + ifoFree_FP_PGC(ifofile); + ifoFree_PGCIT(ifofile); + ifoFree_VTS_PTT_SRPT(ifofile); + ifoFree_VTS_TMAPT(ifofile); + + if(ifofile->vmgi_mat) + free(ifofile->vmgi_mat); + + if(ifofile->vtsi_mat) + free(ifofile->vtsi_mat); + + struct ifo_handle_private_s *ifop = PRIV(ifofile); + DVDCloseFile(ifop->file); + free(ifop); +} + + +static int ifoRead_VMG(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + vmgi_mat_t *vmgi_mat; + + vmgi_mat = calloc(1, sizeof(vmgi_mat_t)); + if(!vmgi_mat) + return 0; + + ifofile->vmgi_mat = vmgi_mat; + + if(!DVDFileSeek_(ifop->file, 0)) { + free(ifofile->vmgi_mat); + ifofile->vmgi_mat = NULL; + return 0; + } + + if(!DVDReadBytes(ifop->file, vmgi_mat, sizeof(vmgi_mat_t))) { + free(ifofile->vmgi_mat); + ifofile->vmgi_mat = NULL; + return 0; + } + + if(strncmp("DVDVIDEO-VMG", vmgi_mat->vmg_identifier, 12) != 0) { + free(ifofile->vmgi_mat); + ifofile->vmgi_mat = NULL; + return 0; + } + + B2N_32(vmgi_mat->vmg_last_sector); + B2N_32(vmgi_mat->vmgi_last_sector); + B2N_32(vmgi_mat->vmg_category); + B2N_16(vmgi_mat->vmg_nr_of_volumes); + B2N_16(vmgi_mat->vmg_this_volume_nr); + B2N_16(vmgi_mat->vmg_nr_of_title_sets); + B2N_64(vmgi_mat->vmg_pos_code); + B2N_32(vmgi_mat->vmgi_last_byte); + B2N_32(vmgi_mat->first_play_pgc); + B2N_32(vmgi_mat->vmgm_vobs); + B2N_32(vmgi_mat->tt_srpt); + B2N_32(vmgi_mat->vmgm_pgci_ut); + B2N_32(vmgi_mat->ptl_mait); + B2N_32(vmgi_mat->vts_atrt); + B2N_32(vmgi_mat->txtdt_mgi); + B2N_32(vmgi_mat->vmgm_c_adt); + B2N_32(vmgi_mat->vmgm_vobu_admap); + read_video_attr(&vmgi_mat->vmgm_video_attr); + read_audio_attr(&vmgi_mat->vmgm_audio_attr); + read_subp_attr(&vmgi_mat->vmgm_subp_attr); + + + CHECK_ZERO(vmgi_mat->zero_1); + CHECK_ZERO(vmgi_mat->zero_2); + /* DVDs created by VDR-to-DVD device LG RC590M violate the following check with + * vmgi_mat->zero_3 = 0x00000000010000000000000000000000000000. */ + CHECK_ZERO(vmgi_mat->zero_3); + CHECK_ZERO(vmgi_mat->zero_4); + CHECK_ZERO(vmgi_mat->zero_5); + CHECK_ZERO(vmgi_mat->zero_6); + CHECK_ZERO(vmgi_mat->zero_7); + CHECK_ZERO(vmgi_mat->zero_8); + CHECK_ZERO(vmgi_mat->zero_9); + CHECK_ZERO(vmgi_mat->zero_10); + CHECK_VALUE(vmgi_mat->vmg_last_sector != 0); + CHECK_VALUE(vmgi_mat->vmgi_last_sector != 0); + CHECK_VALUE(vmgi_mat->vmgi_last_sector * 2 <= vmgi_mat->vmg_last_sector); + CHECK_VALUE(vmgi_mat->vmgi_last_sector * 2 <= vmgi_mat->vmg_last_sector); + CHECK_VALUE(vmgi_mat->vmg_nr_of_volumes != 0); + CHECK_VALUE(vmgi_mat->vmg_this_volume_nr != 0); + CHECK_VALUE(vmgi_mat->vmg_this_volume_nr <= vmgi_mat->vmg_nr_of_volumes); + CHECK_VALUE(vmgi_mat->disc_side == 1 || vmgi_mat->disc_side == 2); + CHECK_VALUE(vmgi_mat->vmg_nr_of_title_sets != 0); + CHECK_VALUE(vmgi_mat->vmgi_last_byte >= 341); + CHECK_VALUE(vmgi_mat->vmgi_last_byte / DVD_BLOCK_LEN <= + vmgi_mat->vmgi_last_sector); + /* It seems that first_play_pgc is optional. */ + CHECK_VALUE(vmgi_mat->first_play_pgc < vmgi_mat->vmgi_last_byte); + CHECK_VALUE(vmgi_mat->vmgm_vobs == 0 || + (vmgi_mat->vmgm_vobs > vmgi_mat->vmgi_last_sector && + vmgi_mat->vmgm_vobs < vmgi_mat->vmg_last_sector)); + CHECK_VALUE(vmgi_mat->tt_srpt <= vmgi_mat->vmgi_last_sector); + CHECK_VALUE(vmgi_mat->vmgm_pgci_ut <= vmgi_mat->vmgi_last_sector); + CHECK_VALUE(vmgi_mat->ptl_mait <= vmgi_mat->vmgi_last_sector); + CHECK_VALUE(vmgi_mat->vts_atrt <= vmgi_mat->vmgi_last_sector); + CHECK_VALUE(vmgi_mat->txtdt_mgi <= vmgi_mat->vmgi_last_sector); + CHECK_VALUE(vmgi_mat->vmgm_c_adt <= vmgi_mat->vmgi_last_sector); + CHECK_VALUE(vmgi_mat->vmgm_vobu_admap <= vmgi_mat->vmgi_last_sector); + + CHECK_VALUE(vmgi_mat->nr_of_vmgm_audio_streams <= 1); + CHECK_VALUE(vmgi_mat->nr_of_vmgm_subp_streams <= 1); + + return 1; +} + + +static int ifoRead_VTS(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + vtsi_mat_t *vtsi_mat; + int i; + + vtsi_mat = calloc(1, sizeof(vtsi_mat_t)); + if(!vtsi_mat) + return 0; + + ifofile->vtsi_mat = vtsi_mat; + + if(!DVDFileSeek_(ifop->file, 0)) { + free(ifofile->vtsi_mat); + ifofile->vtsi_mat = NULL; + return 0; + } + + if(!(DVDReadBytes(ifop->file, vtsi_mat, sizeof(vtsi_mat_t)))) { + free(ifofile->vtsi_mat); + ifofile->vtsi_mat = NULL; + return 0; + } + + if(strncmp("DVDVIDEO-VTS", vtsi_mat->vts_identifier, 12) != 0) { + free(ifofile->vtsi_mat); + ifofile->vtsi_mat = NULL; + return 0; + } + + read_video_attr(&vtsi_mat->vtsm_video_attr); + read_video_attr(&vtsi_mat->vts_video_attr); + read_audio_attr(&vtsi_mat->vtsm_audio_attr); + for(i=0; i<8; i++) + read_audio_attr(&vtsi_mat->vts_audio_attr[i]); + read_subp_attr(&vtsi_mat->vtsm_subp_attr); + for(i=0; i<32; i++) + read_subp_attr(&vtsi_mat->vts_subp_attr[i]); + B2N_32(vtsi_mat->vts_last_sector); + B2N_32(vtsi_mat->vtsi_last_sector); + B2N_32(vtsi_mat->vts_category); + B2N_32(vtsi_mat->vtsi_last_byte); + B2N_32(vtsi_mat->vtsm_vobs); + B2N_32(vtsi_mat->vtstt_vobs); + B2N_32(vtsi_mat->vts_ptt_srpt); + B2N_32(vtsi_mat->vts_pgcit); + B2N_32(vtsi_mat->vtsm_pgci_ut); + B2N_32(vtsi_mat->vts_tmapt); + B2N_32(vtsi_mat->vtsm_c_adt); + B2N_32(vtsi_mat->vtsm_vobu_admap); + B2N_32(vtsi_mat->vts_c_adt); + B2N_32(vtsi_mat->vts_vobu_admap); + + + CHECK_ZERO(vtsi_mat->zero_1); + CHECK_ZERO(vtsi_mat->zero_2); + CHECK_ZERO(vtsi_mat->zero_3); + CHECK_ZERO(vtsi_mat->zero_4); + CHECK_ZERO(vtsi_mat->zero_5); + CHECK_ZERO(vtsi_mat->zero_6); + CHECK_ZERO(vtsi_mat->zero_7); + CHECK_ZERO(vtsi_mat->zero_8); + CHECK_ZERO(vtsi_mat->zero_9); + CHECK_ZERO(vtsi_mat->zero_10); + CHECK_ZERO(vtsi_mat->zero_11); + CHECK_ZERO(vtsi_mat->zero_12); + CHECK_ZERO(vtsi_mat->zero_13); + CHECK_ZERO(vtsi_mat->zero_14); + CHECK_ZERO(vtsi_mat->zero_15); + CHECK_ZERO(vtsi_mat->zero_16); + CHECK_ZERO(vtsi_mat->zero_17); + CHECK_ZERO(vtsi_mat->zero_18); + CHECK_ZERO(vtsi_mat->zero_19); + CHECK_ZERO(vtsi_mat->zero_20); + CHECK_ZERO(vtsi_mat->zero_21); + CHECK_VALUE(vtsi_mat->vtsi_last_sector*2 <= vtsi_mat->vts_last_sector); + CHECK_VALUE(vtsi_mat->vtsi_last_byte/DVD_BLOCK_LEN <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vtsm_vobs == 0 || + (vtsi_mat->vtsm_vobs > vtsi_mat->vtsi_last_sector && + vtsi_mat->vtsm_vobs < vtsi_mat->vts_last_sector)); + CHECK_VALUE(vtsi_mat->vtstt_vobs == 0 || + (vtsi_mat->vtstt_vobs > vtsi_mat->vtsi_last_sector && + vtsi_mat->vtstt_vobs < vtsi_mat->vts_last_sector)); + CHECK_VALUE(vtsi_mat->vts_ptt_srpt <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vts_pgcit <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vtsm_pgci_ut <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vts_tmapt <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vtsm_c_adt <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vtsm_vobu_admap <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vts_c_adt <= vtsi_mat->vtsi_last_sector); + CHECK_VALUE(vtsi_mat->vts_vobu_admap <= vtsi_mat->vtsi_last_sector); + + CHECK_VALUE(vtsi_mat->nr_of_vtsm_audio_streams <= 1); + CHECK_VALUE(vtsi_mat->nr_of_vtsm_subp_streams <= 1); + + CHECK_VALUE(vtsi_mat->nr_of_vts_audio_streams <= 8); + for(i = vtsi_mat->nr_of_vts_audio_streams; i < 8; i++) + CHECK_ZERO(vtsi_mat->vts_audio_attr[i]); + + CHECK_VALUE(vtsi_mat->nr_of_vts_subp_streams <= 32); + for(i = vtsi_mat->nr_of_vts_subp_streams; i < 32; i++) + CHECK_ZERO(vtsi_mat->vts_subp_attr[i]); + + for(i = 0; i < 8; i++) { + read_multichannel_ext(&vtsi_mat->vts_mu_audio_attr[i]); + CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero1); + CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero2); + CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero3); + CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero4); + CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero5); + CHECK_ZERO(vtsi_mat->vts_mu_audio_attr[i].zero6); + } + + return 1; +} + + +static int ifoRead_PGC_COMMAND_TBL(ifo_handle_t *ifofile, + pgc_command_tbl_t *cmd_tbl, + unsigned int offset) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + if(!(DVDReadBytes(ifop->file, cmd_tbl, PGC_COMMAND_TBL_SIZE))) + return 0; + + B2N_16(cmd_tbl->nr_of_pre); + B2N_16(cmd_tbl->nr_of_post); + B2N_16(cmd_tbl->nr_of_cell); + B2N_16(cmd_tbl->last_byte); + + CHECK_VALUE(cmd_tbl->nr_of_pre + cmd_tbl->nr_of_post + cmd_tbl->nr_of_cell<= 255); + CHECK_VALUE((cmd_tbl->nr_of_pre + cmd_tbl->nr_of_post + cmd_tbl->nr_of_cell) * COMMAND_DATA_SIZE + + PGC_COMMAND_TBL_SIZE <= cmd_tbl->last_byte + 1); + + if(cmd_tbl->nr_of_pre != 0) { + unsigned int pre_cmds_size = cmd_tbl->nr_of_pre * COMMAND_DATA_SIZE; + cmd_tbl->pre_cmds = malloc(pre_cmds_size); + if(!cmd_tbl->pre_cmds) + return 0; + + if(!(DVDReadBytes(ifop->file, cmd_tbl->pre_cmds, pre_cmds_size))) { + free(cmd_tbl->pre_cmds); + return 0; + } + } + + if(cmd_tbl->nr_of_post != 0) { + unsigned int post_cmds_size = cmd_tbl->nr_of_post * COMMAND_DATA_SIZE; + cmd_tbl->post_cmds = malloc(post_cmds_size); + if(!cmd_tbl->post_cmds) { + if(cmd_tbl->pre_cmds) + free(cmd_tbl->pre_cmds); + return 0; + } + if(!(DVDReadBytes(ifop->file, cmd_tbl->post_cmds, post_cmds_size))) { + if(cmd_tbl->pre_cmds) + free(cmd_tbl->pre_cmds); + free(cmd_tbl->post_cmds); + return 0; + } + } + + if(cmd_tbl->nr_of_cell != 0) { + unsigned int cell_cmds_size = cmd_tbl->nr_of_cell * COMMAND_DATA_SIZE; + cmd_tbl->cell_cmds = malloc(cell_cmds_size); + if(!cmd_tbl->cell_cmds) { + if(cmd_tbl->pre_cmds) + free(cmd_tbl->pre_cmds); + if(cmd_tbl->post_cmds) + free(cmd_tbl->post_cmds); + return 0; + } + if(!(DVDReadBytes(ifop->file, cmd_tbl->cell_cmds, cell_cmds_size))) { + if(cmd_tbl->pre_cmds) + free(cmd_tbl->pre_cmds); + if(cmd_tbl->post_cmds) + free(cmd_tbl->post_cmds); + free(cmd_tbl->cell_cmds); + return 0; + } + } + + /* + * Make a run over all the commands and see that we can interpret them all? + */ + return 1; +} + + +static void ifoFree_PGC_COMMAND_TBL(pgc_command_tbl_t *cmd_tbl) { + if(cmd_tbl) { + if(cmd_tbl->nr_of_pre && cmd_tbl->pre_cmds) + free(cmd_tbl->pre_cmds); + if(cmd_tbl->nr_of_post && cmd_tbl->post_cmds) + free(cmd_tbl->post_cmds); + if(cmd_tbl->nr_of_cell && cmd_tbl->cell_cmds) + free(cmd_tbl->cell_cmds); + free(cmd_tbl); + } +} + +static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile, + pgc_program_map_t *program_map, + unsigned int nr, unsigned int offset) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + unsigned int size = nr * sizeof(pgc_program_map_t); + + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + if(!(DVDReadBytes(ifop->file, program_map, size))) + return 0; + + return 1; +} + +static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile, + cell_playback_t *cell_playback, + unsigned int nr, unsigned int offset) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + unsigned int i; + unsigned int size = nr * sizeof(cell_playback_t); + + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + if(!(DVDReadBytes(ifop->file, cell_playback, size))) + return 0; + + for(i = 0; i < nr; i++) { + read_cell_playback(&cell_playback[i]); + /* Changed < to <= because this was false in the movie 'Pi'. */ + CHECK_VALUE(cell_playback[i].last_vobu_start_sector <= + cell_playback[i].last_sector); + CHECK_VALUE(cell_playback[i].first_sector <= + cell_playback[i].last_vobu_start_sector); + } + + return 1; +} + + +static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile, + cell_position_t *cell_position, + unsigned int nr, unsigned int offset) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + unsigned int i; + unsigned int size = nr * sizeof(cell_position_t); + + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + if(!(DVDReadBytes(ifop->file, cell_position, size))) + return 0; + + for(i = 0; i < nr; i++) { + B2N_16(cell_position[i].vob_id_nr); + CHECK_ZERO(cell_position[i].zero_1); + } + + return 1; +} + +static int ifoRead_PGC(ifo_handle_t *ifofile, pgc_t *pgc, unsigned int offset) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + unsigned int i; + + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + if(!(DVDReadBytes(ifop->file, pgc, PGC_SIZE))) + return 0; + + read_user_ops(&pgc->prohibited_ops); + B2N_16(pgc->next_pgc_nr); + B2N_16(pgc->prev_pgc_nr); + B2N_16(pgc->goup_pgc_nr); + B2N_16(pgc->command_tbl_offset); + B2N_16(pgc->program_map_offset); + B2N_16(pgc->cell_playback_offset); + B2N_16(pgc->cell_position_offset); + + for(i = 0; i < 8; i++) + B2N_16(pgc->audio_control[i]); + for(i = 0; i < 32; i++) + B2N_32(pgc->subp_control[i]); + for(i = 0; i < 16; i++) + B2N_32(pgc->palette[i]); + + CHECK_ZERO(pgc->zero_1); + CHECK_VALUE(pgc->nr_of_programs <= pgc->nr_of_cells); + + /* verify time (look at print_time) */ + for(i = 0; i < 8; i++) + if(!(pgc->audio_control[i] & 0x8000)) /* The 'is present' bit */ + CHECK_ZERO(pgc->audio_control[i]); + for(i = 0; i < 32; i++) + if(!(pgc->subp_control[i] & 0x80000000)) /* The 'is present' bit */ + CHECK_ZERO(pgc->subp_control[i]); + + /* Check that time is 0:0:0:0 also if nr_of_programs == 0 */ + if(pgc->nr_of_programs == 0) { + CHECK_ZERO(pgc->still_time); + CHECK_ZERO(pgc->pg_playback_mode); /* ?? */ + CHECK_VALUE(pgc->program_map_offset == 0); + CHECK_VALUE(pgc->cell_playback_offset == 0); + CHECK_VALUE(pgc->cell_position_offset == 0); + } else { + CHECK_VALUE(pgc->program_map_offset != 0); + CHECK_VALUE(pgc->cell_playback_offset != 0); + CHECK_VALUE(pgc->cell_position_offset != 0); + } + + if(pgc->command_tbl_offset != 0) { + pgc->command_tbl = calloc(1, sizeof(pgc_command_tbl_t)); + if(!pgc->command_tbl) + return 0; + + if(!ifoRead_PGC_COMMAND_TBL(ifofile, pgc->command_tbl, + offset + pgc->command_tbl_offset)) { + return 0; + } + } else { + pgc->command_tbl = NULL; + } + + if(pgc->program_map_offset != 0 && pgc->nr_of_programs>0) { + pgc->program_map = calloc(pgc->nr_of_programs, sizeof(pgc_program_map_t)); + if(!pgc->program_map) { + return 0; + } + if(!ifoRead_PGC_PROGRAM_MAP(ifofile, pgc->program_map,pgc->nr_of_programs, + offset + pgc->program_map_offset)) { + return 0; + } + } else { + pgc->program_map = NULL; + } + + if(pgc->cell_playback_offset != 0 && pgc->nr_of_cells>0) { + pgc->cell_playback = calloc(pgc->nr_of_cells, sizeof(cell_playback_t)); + if(!pgc->cell_playback) { + return 0; + } + if(!ifoRead_CELL_PLAYBACK_TBL(ifofile, pgc->cell_playback, + pgc->nr_of_cells, + offset + pgc->cell_playback_offset)) { + return 0; + } + } else { + pgc->cell_playback = NULL; + } + + if(pgc->cell_position_offset != 0 && pgc->nr_of_cells>0) { + pgc->cell_position = calloc(pgc->nr_of_cells, sizeof(cell_position_t)); + if(!pgc->cell_position) { + return 0; + } + if(!ifoRead_CELL_POSITION_TBL(ifofile, pgc->cell_position, + pgc->nr_of_cells, + offset + pgc->cell_position_offset)) { + return 0; + } + } else { + pgc->cell_position = NULL; + } + + return 1; +} + +int ifoRead_FP_PGC(ifo_handle_t *ifofile) { + + if(!ifofile) + return 0; + + if(!ifofile->vmgi_mat) + return 0; + + /* It seems that first_play_pgc is optional after all. */ + ifofile->first_play_pgc = NULL; + if(!ifofile->vmgi_mat->first_play_pgc) + return 1; + + ifofile->first_play_pgc = calloc(1, sizeof(pgc_t)); + if(!ifofile->first_play_pgc) + return 0; + + ifofile->first_play_pgc->ref_count = 1; + if(!ifoRead_PGC(ifofile, ifofile->first_play_pgc, + ifofile->vmgi_mat->first_play_pgc)) { + ifoFree_PGC(&ifofile->first_play_pgc); + return 0; + } + + return 1; +} + +static void ifoFree_PGC(pgc_t **pgc) { + if(pgc && *pgc && (--(*pgc)->ref_count) <= 0) { + ifoFree_PGC_COMMAND_TBL((*pgc)->command_tbl); + if((*pgc)->program_map) + free((*pgc)->program_map); + if((*pgc)->cell_playback) + free((*pgc)->cell_playback); + if((*pgc)->cell_position) + free((*pgc)->cell_position); + free(*pgc); + } + if (pgc) { + *pgc = NULL; + } +} + +void ifoFree_FP_PGC(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->first_play_pgc) { + ifoFree_PGC(&ifofile->first_play_pgc); + } +} + + +int ifoRead_TT_SRPT(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + tt_srpt_t *tt_srpt; + unsigned int i; + size_t info_length; + + if(!ifofile) + return 0; + + if(!ifofile->vmgi_mat) + return 0; + + if(ifofile->vmgi_mat->tt_srpt == 0) /* mandatory */ + return 0; + + if(!DVDFileSeek_(ifop->file, ifofile->vmgi_mat->tt_srpt * DVD_BLOCK_LEN)) + return 0; + + tt_srpt = calloc(1, sizeof(tt_srpt_t)); + if(!tt_srpt) + return 0; + + ifofile->tt_srpt = tt_srpt; + + if(!(DVDReadBytes(ifop->file, tt_srpt, TT_SRPT_SIZE))) { + Log0(ifop->ctx, "Unable to read read TT_SRPT."); + free(tt_srpt); + return 0; + } + + B2N_16(tt_srpt->nr_of_srpts); + B2N_32(tt_srpt->last_byte); + + /* E-One releases don't fill this field */ + if(tt_srpt->last_byte == 0) { + tt_srpt->last_byte = tt_srpt->nr_of_srpts * sizeof(title_info_t) - 1 + TT_SRPT_SIZE; + } + info_length = tt_srpt->last_byte + 1 - TT_SRPT_SIZE; + + tt_srpt->title = calloc(1, info_length); + if(!tt_srpt->title) { + free(tt_srpt); + ifofile->tt_srpt = NULL; + return 0; + } + if(!(DVDReadBytes(ifop->file, tt_srpt->title, info_length))) { + Log0(ifop->ctx, "libdvdread: Unable to read read TT_SRPT."); + ifoFree_TT_SRPT(ifofile); + return 0; + } + + if(tt_srpt->nr_of_srpts>info_length/sizeof(title_info_t)){ + Log1(ifop->ctx, "data mismatch: info_length (%zd)!= nr_of_srpts (%d). Truncating.", + info_length/sizeof(title_info_t),tt_srpt->nr_of_srpts); + tt_srpt->nr_of_srpts=info_length/sizeof(title_info_t); + } + + for(i = 0; i < tt_srpt->nr_of_srpts; i++) { + B2N_16(tt_srpt->title[i].nr_of_ptts); + B2N_16(tt_srpt->title[i].parental_id); + B2N_32(tt_srpt->title[i].title_set_sector); + } + + + CHECK_ZERO(tt_srpt->zero_1); + CHECK_VALUE(tt_srpt->nr_of_srpts != 0); + CHECK_VALUE(tt_srpt->nr_of_srpts < 100); /* ?? */ + CHECK_VALUE(tt_srpt->nr_of_srpts * sizeof(title_info_t) <= info_length); + + for(i = 0; i < tt_srpt->nr_of_srpts; i++) { + read_playback_type(&tt_srpt->title[i].pb_ty); + CHECK_VALUE(tt_srpt->title[i].pb_ty.zero_1 == 0); + CHECK_VALUE(tt_srpt->title[i].nr_of_angles != 0); + CHECK_VALUE(tt_srpt->title[i].nr_of_angles < 10); + /* CHECK_VALUE(tt_srpt->title[i].nr_of_ptts != 0); */ + /* XXX: this assertion breaks Ghostbusters: */ + CHECK_VALUE(tt_srpt->title[i].nr_of_ptts < 1000); /* ?? */ + CHECK_VALUE(tt_srpt->title[i].title_set_nr != 0); + CHECK_VALUE(tt_srpt->title[i].title_set_nr < 100); /* ?? */ + CHECK_VALUE(tt_srpt->title[i].vts_ttn != 0); + CHECK_VALUE(tt_srpt->title[i].vts_ttn < 100); /* ?? */ + /* CHECK_VALUE(tt_srpt->title[i].title_set_sector != 0); */ + } + + /* Make this a function */ +#if 0 + if(memcmp((uint8_t *)tt_srpt->title + + tt_srpt->nr_of_srpts * sizeof(title_info_t), + my_friendly_zeros, + info_length - tt_srpt->nr_of_srpts * sizeof(title_info_t))) { + Log1(ifop->ctx, "VMG_PTT_SRPT slack is != 0, "); + hexdump((uint8_t *)tt_srpt->title + + tt_srpt->nr_of_srpts * sizeof(title_info_t), + info_length - tt_srpt->nr_of_srpts * sizeof(title_info_t)); + } +#endif + + return 1; +} + + +void ifoFree_TT_SRPT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->tt_srpt) { + free(ifofile->tt_srpt->title); + ifofile->tt_srpt->title = NULL; + free(ifofile->tt_srpt); + ifofile->tt_srpt = NULL; + } +} + + +int ifoRead_VTS_PTT_SRPT(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + vts_ptt_srpt_t *vts_ptt_srpt = NULL; + int info_length, i, j; + uint32_t *data = NULL; + + if(!ifofile) + return 0; + + if(!ifofile->vtsi_mat) + return 0; + + if(ifofile->vtsi_mat->vts_ptt_srpt == 0) /* mandatory */ + return 0; + + if(!DVDFileSeek_(ifop->file, + ifofile->vtsi_mat->vts_ptt_srpt * DVD_BLOCK_LEN)) + return 0; + + vts_ptt_srpt = calloc(1, sizeof(vts_ptt_srpt_t)); + if(!vts_ptt_srpt) + return 0; + + vts_ptt_srpt->title = NULL; + ifofile->vts_ptt_srpt = vts_ptt_srpt; + + if(!(DVDReadBytes(ifop->file, vts_ptt_srpt, VTS_PTT_SRPT_SIZE))) { + Log0(ifop->ctx, "Unable to read PTT search table."); + goto fail; + } + + B2N_16(vts_ptt_srpt->nr_of_srpts); + B2N_32(vts_ptt_srpt->last_byte); + + CHECK_ZERO(vts_ptt_srpt->zero_1); + CHECK_VALUE(vts_ptt_srpt->nr_of_srpts != 0); + CHECK_VALUE(vts_ptt_srpt->nr_of_srpts < 100); /* ?? */ + + /* E-One releases don't fill this field */ + if(vts_ptt_srpt->last_byte == 0) { + vts_ptt_srpt->last_byte = vts_ptt_srpt->nr_of_srpts * sizeof(*data) - 1 + VTS_PTT_SRPT_SIZE; + } + info_length = vts_ptt_srpt->last_byte + 1 - VTS_PTT_SRPT_SIZE; + data = calloc(1, info_length); + if(!data) + goto fail; + + if(!(DVDReadBytes(ifop->file, data, info_length))) { + Log0(ifop->ctx, "Unable to read PTT search table."); + goto fail; + } + + if(vts_ptt_srpt->nr_of_srpts > info_length / sizeof(*data)) { + Log0(ifop->ctx, "PTT search table too small."); + goto fail; + } + + if(vts_ptt_srpt->nr_of_srpts == 0) { + Log0(ifop->ctx, "Zero entries in PTT search table."); + goto fail; + } + + for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) { + /* Transformers 3 has PTT start bytes that point outside the SRPT PTT */ + uint32_t start = data[i]; + B2N_32(start); + if(start + sizeof(ptt_info_t) > vts_ptt_srpt->last_byte + 1) { + /* don't mess with any bytes beyond the end of the allocation */ + vts_ptt_srpt->nr_of_srpts = i; + break; + } + data[i] = start; + /* assert(data[i] + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1); + Magic Knight Rayearth Daybreak is mastered very strange and has + Titles with 0 PTTs. They all have a data[i] offsets beyond the end of + of the vts_ptt_srpt structure. */ + CHECK_VALUE(data[i] + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1 + 4); + } + + vts_ptt_srpt->ttu_offset = data; + + vts_ptt_srpt->title = calloc(vts_ptt_srpt->nr_of_srpts, sizeof(ttu_t)); + if(!vts_ptt_srpt->title) + goto fail; + + for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) { + int n; + if(i < vts_ptt_srpt->nr_of_srpts - 1) + n = (data[i+1] - data[i]); + else + n = (vts_ptt_srpt->last_byte + 1 - data[i]); + + /* assert(n > 0 && (n % 4) == 0); + Magic Knight Rayearth Daybreak is mastered very strange and has + Titles with 0 PTTs. */ + if(n < 0) n = 0; + + /* DVDs created by the VDR-to-DVD device LG RC590M violate the following requirement */ + CHECK_VALUE(n % 4 == 0); + + vts_ptt_srpt->title[i].nr_of_ptts = n / 4; + vts_ptt_srpt->title[i].ptt = calloc(n / 4, sizeof(ptt_info_t)); + if(!vts_ptt_srpt->title[i].ptt) { + for(n = 0; n < i; n++) + free(vts_ptt_srpt->title[n].ptt); + + goto fail; + } + for(j = 0; j < vts_ptt_srpt->title[i].nr_of_ptts; j++) { + /* The assert placed here because of Magic Knight Rayearth Daybreak */ + CHECK_VALUE(data[i] + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1); + vts_ptt_srpt->title[i].ptt[j].pgcn + = *(uint16_t*)(((char *)data) + data[i] + 4*j - VTS_PTT_SRPT_SIZE); + vts_ptt_srpt->title[i].ptt[j].pgn + = *(uint16_t*)(((char *)data) + data[i] + 4*j + 2 - VTS_PTT_SRPT_SIZE); + } + } + + for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) { + for(j = 0; j < vts_ptt_srpt->title[i].nr_of_ptts; j++) { + B2N_16(vts_ptt_srpt->title[i].ptt[j].pgcn); + B2N_16(vts_ptt_srpt->title[i].ptt[j].pgn); + } + } + + for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) { + CHECK_VALUE(vts_ptt_srpt->title[i].nr_of_ptts < 1000); /* ?? */ + for(j = 0; j < vts_ptt_srpt->title[i].nr_of_ptts; j++) { + CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgcn != 0 ); + CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgcn < 1000); /* ?? */ + CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgn != 0); + CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgn < 100); /* ?? */ + //don't abort here. E-One DVDs contain PTT with pgcn or pgn == 0 + } + } + + return 1; + +fail: + free(data); + ifofile->vts_ptt_srpt = NULL; + free(vts_ptt_srpt->title); + free(vts_ptt_srpt); + return 0; +} + + +void ifoFree_VTS_PTT_SRPT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->vts_ptt_srpt) { + int i; + for(i = 0; i < ifofile->vts_ptt_srpt->nr_of_srpts; i++) + free(ifofile->vts_ptt_srpt->title[i].ptt); + free(ifofile->vts_ptt_srpt->ttu_offset); + free(ifofile->vts_ptt_srpt->title); + free(ifofile->vts_ptt_srpt); + ifofile->vts_ptt_srpt = 0; + } +} + + +int ifoRead_PTL_MAIT(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + ptl_mait_t *ptl_mait; + int info_length; + unsigned int i, j; + + if(!ifofile) + return 0; + + if(!ifofile->vmgi_mat) + return 0; + + if(!ifofile->vmgi_mat->ptl_mait) + return 1; + + if(!DVDFileSeek_(ifop->file, ifofile->vmgi_mat->ptl_mait * DVD_BLOCK_LEN)) + return 0; + + ptl_mait = calloc(1, sizeof(ptl_mait_t)); + if(!ptl_mait) + return 0; + + ifofile->ptl_mait = ptl_mait; + + if(!(DVDReadBytes(ifop->file, ptl_mait, PTL_MAIT_SIZE))) { + free(ptl_mait); + ifofile->ptl_mait = NULL; + return 0; + } + + B2N_16(ptl_mait->nr_of_countries); + B2N_16(ptl_mait->nr_of_vtss); + B2N_32(ptl_mait->last_byte); + + CHECK_VALUE(ptl_mait->nr_of_countries != 0); + CHECK_VALUE(ptl_mait->nr_of_countries < 100); /* ?? */ + CHECK_VALUE(ptl_mait->nr_of_vtss != 0); + CHECK_VALUE(ptl_mait->nr_of_vtss < 100); /* ?? */ + CHECK_VALUE(ptl_mait->nr_of_countries * PTL_MAIT_COUNTRY_SIZE + <= ptl_mait->last_byte + 1 - PTL_MAIT_SIZE); + + info_length = ptl_mait->nr_of_countries * sizeof(ptl_mait_country_t); + ptl_mait->countries = calloc(1, info_length); + if(!ptl_mait->countries) { + free(ptl_mait); + ifofile->ptl_mait = NULL; + return 0; + } + for(i = 0; i < ptl_mait->nr_of_countries; i++) { + ptl_mait->countries[i].pf_ptl_mai = NULL; + } + + for(i = 0; i < ptl_mait->nr_of_countries; i++) { + if(!(DVDReadBytes(ifop->file, &ptl_mait->countries[i], PTL_MAIT_COUNTRY_SIZE))) { + Log0(ifop->ctx, "Unable to read PTL_MAIT."); + free(ptl_mait->countries); + free(ptl_mait); + ifofile->ptl_mait = NULL; + return 0; + } + } + + for(i = 0; i < ptl_mait->nr_of_countries; i++) { + B2N_16(ptl_mait->countries[i].country_code); + B2N_16(ptl_mait->countries[i].pf_ptl_mai_start_byte); + } + + for(i = 0; i < ptl_mait->nr_of_countries; i++) { + CHECK_ZERO(ptl_mait->countries[i].zero_1); + CHECK_ZERO(ptl_mait->countries[i].zero_2); + CHECK_VALUE(ptl_mait->countries[i].pf_ptl_mai_start_byte + + sizeof(pf_level_t) * (ptl_mait->nr_of_vtss + 1) <= ptl_mait->last_byte + 1); + } + + for(i = 0; i < ptl_mait->nr_of_countries; i++) { + uint16_t *pf_temp; + + if(!DVDFileSeek_(ifop->file, + ifofile->vmgi_mat->ptl_mait * DVD_BLOCK_LEN + + ptl_mait->countries[i].pf_ptl_mai_start_byte)) { + Log0(ifop->ctx, "Unable to seek PTL_MAIT table at index %d.",i); + free(ptl_mait->countries); + free(ptl_mait); + ifofile->ptl_mait = NULL; + return 0; + } + info_length = (ptl_mait->nr_of_vtss + 1) * sizeof(pf_level_t); + pf_temp = calloc(1, info_length); + if(!pf_temp) { + free_ptl_mait(ptl_mait, i); + ifofile->ptl_mait = NULL; + return 0; + } + if(!(DVDReadBytes(ifop->file, pf_temp, info_length))) { + Log0(ifop->ctx, "Unable to read PTL_MAIT table at index %d.",i); + free(pf_temp); + free_ptl_mait(ptl_mait, i); + ifofile->ptl_mait = NULL; + return 0; + } + for (j = 0; j < ((ptl_mait->nr_of_vtss + 1U) * 8U); j++) { + B2N_16(pf_temp[j]); + } + ptl_mait->countries[i].pf_ptl_mai = calloc(1, info_length); + if(!ptl_mait->countries[i].pf_ptl_mai) { + free(pf_temp); + free_ptl_mait(ptl_mait, i); + ifofile->ptl_mait = NULL; + return 0; + } + { /* Transpose the array so we can use C indexing. */ + int level, vts; + for(level = 0; level < PTL_MAIT_NUM_LEVEL; level++) { + for(vts = 0; vts <= ptl_mait->nr_of_vtss; vts++) { + ptl_mait->countries[i].pf_ptl_mai[vts][level] = + pf_temp[(7-level)*(ptl_mait->nr_of_vtss+1) + vts]; + } + } + free(pf_temp); + } + } + return 1; +} + +void ifoFree_PTL_MAIT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->ptl_mait) { + unsigned int i; + + for(i = 0; i < ifofile->ptl_mait->nr_of_countries; i++) { + free(ifofile->ptl_mait->countries[i].pf_ptl_mai); + } + free(ifofile->ptl_mait->countries); + free(ifofile->ptl_mait); + ifofile->ptl_mait = NULL; + } +} + +int ifoRead_VTS_TMAPT(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + vts_tmapt_t *vts_tmapt; + uint32_t *vts_tmap_srp; + unsigned int offset; + int info_length; + unsigned int i, j; + + if(!ifofile) + return 0; + + if(!ifofile->vtsi_mat) + return 0; + + if(ifofile->vtsi_mat->vts_tmapt == 0) { + ifofile->vts_tmapt = NULL; + return 1; + } + + offset = ifofile->vtsi_mat->vts_tmapt * DVD_BLOCK_LEN; + + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + vts_tmapt = calloc(1, sizeof(vts_tmapt_t)); + if(!vts_tmapt) + return 0; + + ifofile->vts_tmapt = vts_tmapt; + + if(!(DVDReadBytes(ifop->file, vts_tmapt, VTS_TMAPT_SIZE))) { + Log0(ifop->ctx, "Unable to read VTS_TMAPT."); + free(vts_tmapt); + ifofile->vts_tmapt = NULL; + return 0; + } + + B2N_16(vts_tmapt->nr_of_tmaps); + B2N_32(vts_tmapt->last_byte); + + CHECK_ZERO(vts_tmapt->zero_1); + + info_length = vts_tmapt->nr_of_tmaps * 4; + + vts_tmap_srp = calloc(1, info_length); + if(!vts_tmap_srp) { + free(vts_tmapt); + ifofile->vts_tmapt = NULL; + return 0; + } + + vts_tmapt->tmap_offset = vts_tmap_srp; + + if(!(DVDReadBytes(ifop->file, vts_tmap_srp, info_length))) { + Log0(ifop->ctx, "Unable to read VTS_TMAPT."); + free(vts_tmap_srp); + free(vts_tmapt); + ifofile->vts_tmapt = NULL; + return 0; + } + + for (i = 0; i < vts_tmapt->nr_of_tmaps; i++) { + B2N_32(vts_tmap_srp[i]); + } + + + info_length = vts_tmapt->nr_of_tmaps * sizeof(vts_tmap_t); + + vts_tmapt->tmap = calloc(1, info_length); + if(!vts_tmapt->tmap) { + free(vts_tmap_srp); + free(vts_tmapt); + ifofile->vts_tmapt = NULL; + return 0; + } + + for(i = 0; i < vts_tmapt->nr_of_tmaps; i++) { + if(!DVDFileSeek_(ifop->file, offset + vts_tmap_srp[i])) { + ifoFree_VTS_TMAPT(ifofile); + return 0; + } + + if(!(DVDReadBytes(ifop->file, &vts_tmapt->tmap[i], VTS_TMAP_SIZE))) { + Log0(ifop->ctx, "Unable to read VTS_TMAP."); + ifoFree_VTS_TMAPT(ifofile); + return 0; + } + + B2N_16(vts_tmapt->tmap[i].nr_of_entries); + CHECK_ZERO(vts_tmapt->tmap[i].zero_1); + + if(vts_tmapt->tmap[i].nr_of_entries == 0) { /* Early out if zero entries */ + vts_tmapt->tmap[i].map_ent = NULL; + continue; + } + + info_length = vts_tmapt->tmap[i].nr_of_entries * sizeof(map_ent_t); + + vts_tmapt->tmap[i].map_ent = calloc(1, info_length); + if(!vts_tmapt->tmap[i].map_ent) { + ifoFree_VTS_TMAPT(ifofile); + return 0; + } + + if(!(DVDReadBytes(ifop->file, vts_tmapt->tmap[i].map_ent, info_length))) { + Log0(ifop->ctx, "Unable to read VTS_TMAP_ENT."); + ifoFree_VTS_TMAPT(ifofile); + return 0; + } + + for(j = 0; j < vts_tmapt->tmap[i].nr_of_entries; j++) + B2N_32(vts_tmapt->tmap[i].map_ent[j]); + } + + return 1; +} + +void ifoFree_VTS_TMAPT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->vts_tmapt) { + unsigned int i; + + for(i = 0; i < ifofile->vts_tmapt->nr_of_tmaps; i++) + if(ifofile->vts_tmapt->tmap[i].map_ent) + free(ifofile->vts_tmapt->tmap[i].map_ent); + free(ifofile->vts_tmapt->tmap); + free(ifofile->vts_tmapt->tmap_offset); + free(ifofile->vts_tmapt); + ifofile->vts_tmapt = NULL; + } +} + + +int ifoRead_TITLE_C_ADT(ifo_handle_t *ifofile) { + + if(!ifofile) + return 0; + + if(!ifofile->vtsi_mat) + return 0; + + if(ifofile->vtsi_mat->vts_c_adt == 0) /* mandatory */ + return 0; + + ifofile->vts_c_adt = calloc(1, sizeof(c_adt_t)); + if(!ifofile->vts_c_adt) + return 0; + + if(!ifoRead_C_ADT_internal(ifofile, ifofile->vts_c_adt, + ifofile->vtsi_mat->vts_c_adt)) { + free(ifofile->vts_c_adt); + ifofile->vts_c_adt = NULL; + return 0; + } + + return 1; +} + +int ifoRead_C_ADT(ifo_handle_t *ifofile) { + unsigned int sector; + + if(!ifofile) + return 0; + + if(ifofile->vmgi_mat) { + if(ifofile->vmgi_mat->vmgm_c_adt == 0) + return 1; + sector = ifofile->vmgi_mat->vmgm_c_adt; + } else if(ifofile->vtsi_mat) { + if(ifofile->vtsi_mat->vtsm_c_adt == 0) + return 1; + sector = ifofile->vtsi_mat->vtsm_c_adt; + } else { + return 0; + } + + ifofile->menu_c_adt = calloc(1, sizeof(c_adt_t)); + if(!ifofile->menu_c_adt) + return 0; + + if(!ifoRead_C_ADT_internal(ifofile, ifofile->menu_c_adt, sector)) { + free(ifofile->menu_c_adt); + ifofile->menu_c_adt = NULL; + return 0; + } + + return 1; +} + +static int ifoRead_C_ADT_internal(ifo_handle_t *ifofile, + c_adt_t *c_adt, unsigned int sector) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + size_t i, info_length; + + if(!DVDFileSeek_(ifop->file, sector * DVD_BLOCK_LEN)) + return 0; + + if(!(DVDReadBytes(ifop->file, c_adt, C_ADT_SIZE))) + return 0; + + B2N_16(c_adt->nr_of_vobs); + B2N_32(c_adt->last_byte); + + if(c_adt->last_byte + 1 < C_ADT_SIZE) + return 0; + + info_length = c_adt->last_byte + 1 - C_ADT_SIZE; + + CHECK_ZERO(c_adt->zero_1); + /* assert(c_adt->nr_of_vobs > 0); + Magic Knight Rayearth Daybreak is mastered very strange and has + Titles with a VOBS that has no cells. */ + CHECK_VALUE(info_length % sizeof(cell_adr_t) == 0); + + /* assert(info_length / sizeof(cell_adr_t) >= c_adt->nr_of_vobs); + Enemy of the State region 2 (de) has Titles where nr_of_vobs field + is to high, they high ones are never referenced though. */ + if(info_length / sizeof(cell_adr_t) < c_adt->nr_of_vobs) { + Log1(ifop->ctx, "C_ADT nr_of_vobs > available info entries"); + c_adt->nr_of_vobs = info_length / sizeof(cell_adr_t); + } + + c_adt->cell_adr_table = calloc(1, info_length); + if(!c_adt->cell_adr_table) + return 0; + + if(info_length && + !(DVDReadBytes(ifop->file, c_adt->cell_adr_table, info_length))) { + free(c_adt->cell_adr_table); + return 0; + } + + for(i = 0; i < info_length/sizeof(cell_adr_t); i++) { + B2N_16(c_adt->cell_adr_table[i].vob_id); + B2N_32(c_adt->cell_adr_table[i].start_sector); + B2N_32(c_adt->cell_adr_table[i].last_sector); + + CHECK_ZERO(c_adt->cell_adr_table[i].zero_1); + CHECK_VALUE(c_adt->cell_adr_table[i].vob_id > 0); + CHECK_VALUE(c_adt->cell_adr_table[i].vob_id <= c_adt->nr_of_vobs); + CHECK_VALUE(c_adt->cell_adr_table[i].cell_id > 0); + CHECK_VALUE(c_adt->cell_adr_table[i].start_sector < + c_adt->cell_adr_table[i].last_sector); + } + + return 1; +} + + +static void ifoFree_C_ADT_internal(c_adt_t *c_adt) { + if(c_adt) { + free(c_adt->cell_adr_table); + free(c_adt); + } +} + +void ifoFree_C_ADT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + ifoFree_C_ADT_internal(ifofile->menu_c_adt); + ifofile->menu_c_adt = NULL; +} + +void ifoFree_TITLE_C_ADT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + ifoFree_C_ADT_internal(ifofile->vts_c_adt); + ifofile->vts_c_adt = NULL; +} + +int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) { + if(!ifofile) + return 0; + + if(!ifofile->vtsi_mat) + return 0; + + if(ifofile->vtsi_mat->vts_vobu_admap == 0) /* mandatory */ + return 0; + + ifofile->vts_vobu_admap = calloc(1, sizeof(vobu_admap_t)); + if(!ifofile->vts_vobu_admap) + return 0; + + if(!ifoRead_VOBU_ADMAP_internal(ifofile, ifofile->vts_vobu_admap, + ifofile->vtsi_mat->vts_vobu_admap)) { + free(ifofile->vts_vobu_admap); + ifofile->vts_vobu_admap = NULL; + return 0; + } + + return 1; +} + +int ifoRead_VOBU_ADMAP(ifo_handle_t *ifofile) { + unsigned int sector; + + if(!ifofile) + return 0; + + if(ifofile->vmgi_mat) { + if(ifofile->vmgi_mat->vmgm_vobu_admap == 0) + return 1; + sector = ifofile->vmgi_mat->vmgm_vobu_admap; + } else if(ifofile->vtsi_mat) { + if(ifofile->vtsi_mat->vtsm_vobu_admap == 0) + return 1; + sector = ifofile->vtsi_mat->vtsm_vobu_admap; + } else { + return 0; + } + + ifofile->menu_vobu_admap = calloc(1, sizeof(vobu_admap_t)); + if(!ifofile->menu_vobu_admap) + return 0; + + if(!ifoRead_VOBU_ADMAP_internal(ifofile, ifofile->menu_vobu_admap, sector)) { + free(ifofile->menu_vobu_admap); + ifofile->menu_vobu_admap = NULL; + return 0; + } + + return 1; +} + +static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile, + vobu_admap_t *vobu_admap, + unsigned int sector) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + unsigned int i; + int info_length; + + if(!DVDFileSeekForce_(ifop->file, sector * DVD_BLOCK_LEN, sector)) + return 0; + + if(!(DVDReadBytes(ifop->file, vobu_admap, VOBU_ADMAP_SIZE))) + return 0; + + B2N_32(vobu_admap->last_byte); + + info_length = vobu_admap->last_byte + 1 - VOBU_ADMAP_SIZE; + /* assert(info_length > 0); + Magic Knight Rayearth Daybreak is mastered very strange and has + Titles with a VOBS that has no VOBUs. */ + CHECK_VALUE(info_length % sizeof(uint32_t) == 0); + + vobu_admap->vobu_start_sectors = calloc(1, info_length); + if(!vobu_admap->vobu_start_sectors) { + return 0; + } + if(info_length && + !(DVDReadBytes(ifop->file, + vobu_admap->vobu_start_sectors, info_length))) { + free(vobu_admap->vobu_start_sectors); + return 0; + } + + for(i = 0; i < info_length/sizeof(uint32_t); i++) + B2N_32(vobu_admap->vobu_start_sectors[i]); + + return 1; +} + + +static void ifoFree_VOBU_ADMAP_internal(vobu_admap_t *vobu_admap) { + if(vobu_admap) { + free(vobu_admap->vobu_start_sectors); + free(vobu_admap); + } +} + +void ifoFree_VOBU_ADMAP(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + ifoFree_VOBU_ADMAP_internal(ifofile->menu_vobu_admap); + ifofile->menu_vobu_admap = NULL; +} + +void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + ifoFree_VOBU_ADMAP_internal(ifofile->vts_vobu_admap); + ifofile->vts_vobu_admap = NULL; +} + +int ifoRead_PGCIT(ifo_handle_t *ifofile) { + + if(!ifofile) + return 0; + + if(!ifofile->vtsi_mat) + return 0; + + if(ifofile->vtsi_mat->vts_pgcit == 0) /* mandatory */ + return 0; + + ifofile->vts_pgcit = calloc(1, sizeof(pgcit_t)); + if(!ifofile->vts_pgcit) + return 0; + + ifofile->vts_pgcit->ref_count = 1; + if(!ifoRead_PGCIT_internal(ifofile, ifofile->vts_pgcit, + ifofile->vtsi_mat->vts_pgcit * DVD_BLOCK_LEN)) { + free(ifofile->vts_pgcit); + ifofile->vts_pgcit = NULL; + return 0; + } + + return 1; +} + +static int find_dup_pgc(pgci_srp_t *pgci_srp, uint32_t start_byte, int count) { + int i; + + for(i = 0; i < count; i++) { + if(pgci_srp[i].pgc_start_byte == start_byte) { + return i; + } + } + return -1; +} + +static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit, + unsigned int offset) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + int i, info_length; + uint8_t *data, *ptr; + + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + if(!(DVDReadBytes(ifop->file, pgcit, PGCIT_SIZE))) + return 0; + + B2N_16(pgcit->nr_of_pgci_srp); + B2N_32(pgcit->last_byte); + + CHECK_ZERO(pgcit->zero_1); + /* assert(pgcit->nr_of_pgci_srp != 0); + Magic Knight Rayearth Daybreak is mastered very strange and has + Titles with 0 PTTs. */ + CHECK_VALUE(pgcit->nr_of_pgci_srp < 10000); /* ?? seen max of 1338 */ + + if (pgcit->nr_of_pgci_srp == 0) { + pgcit->pgci_srp = NULL; + return 1; + } + + info_length = pgcit->nr_of_pgci_srp * PGCI_SRP_SIZE; + data = calloc(1, info_length); + if(!data) + return 0; + + if(info_length && !(DVDReadBytes(ifop->file, data, info_length))) { + free(data); + return 0; + } + + pgcit->pgci_srp = calloc(pgcit->nr_of_pgci_srp, sizeof(pgci_srp_t)); + if(!pgcit->pgci_srp) { + free(data); + return 0; + } + ptr = data; + for(i = 0; i < pgcit->nr_of_pgci_srp; i++) { + memcpy(&pgcit->pgci_srp[i], ptr, PGCI_SRP_SIZE); + ptr += PGCI_SRP_SIZE; + read_pgci_srp(&pgcit->pgci_srp[i]); + CHECK_VALUE(pgcit->pgci_srp[i].zero_1 == 0); + } + free(data); + + for(i = 0; i < pgcit->nr_of_pgci_srp; i++) + CHECK_VALUE(pgcit->pgci_srp[i].pgc_start_byte + PGC_SIZE <= pgcit->last_byte+1); + + for(i = 0; i < pgcit->nr_of_pgci_srp; i++) { + int dup; + if((dup = find_dup_pgc(pgcit->pgci_srp, pgcit->pgci_srp[i].pgc_start_byte, i)) >= 0) { + pgcit->pgci_srp[i].pgc = pgcit->pgci_srp[dup].pgc; + pgcit->pgci_srp[i].pgc->ref_count++; + continue; + } + pgcit->pgci_srp[i].pgc = calloc(1, sizeof(pgc_t)); + if(!pgcit->pgci_srp[i].pgc) { + int j; + for(j = 0; j < i; j++) { + ifoFree_PGC(&pgcit->pgci_srp[j].pgc); + } + goto fail; + } + pgcit->pgci_srp[i].pgc->ref_count = 1; + if(!ifoRead_PGC(ifofile, pgcit->pgci_srp[i].pgc, + offset + pgcit->pgci_srp[i].pgc_start_byte)) { + Log0(ifop->ctx, "Unable to read invalid PCG"); + //E-One releases provide bogus PGC, ie: out of bound start_byte + free(pgcit->pgci_srp[i].pgc); + pgcit->pgci_srp[i].pgc = NULL; + } + } + + return 1; +fail: + free(pgcit->pgci_srp); + pgcit->pgci_srp = NULL; + return 0; +} + +static void ifoFree_PGCIT_internal(pgcit_t **pgcit) { + if(pgcit && *pgcit && (--(*pgcit)->ref_count <= 0)) { + int i; + for(i = 0; i < (*pgcit)->nr_of_pgci_srp; i++) + { + ifoFree_PGC(&(*pgcit)->pgci_srp[i].pgc); + } + free((*pgcit)->pgci_srp); + free(*pgcit); + } + if (pgcit) + *pgcit = NULL; +} + +void ifoFree_PGCIT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->vts_pgcit) { + ifoFree_PGCIT_internal(&ifofile->vts_pgcit); + } +} + +static int find_dup_lut(pgci_lu_t *lu, uint32_t start_byte, int count) { + int i; + + for(i = 0; i < count; i++) { + if(lu[i].lang_start_byte == start_byte) { + return i; + } + } + return -1; +} + +int ifoRead_PGCI_UT(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + pgci_ut_t *pgci_ut; + unsigned int sector; + unsigned int i; + int info_length; + uint8_t *data, *ptr; + + if(!ifofile) + return 0; + + if(ifofile->vmgi_mat) { + if(ifofile->vmgi_mat->vmgm_pgci_ut == 0) + return 1; + sector = ifofile->vmgi_mat->vmgm_pgci_ut; + } else if(ifofile->vtsi_mat) { + if(ifofile->vtsi_mat->vtsm_pgci_ut == 0) + return 1; + sector = ifofile->vtsi_mat->vtsm_pgci_ut; + } else { + return 0; + } + + ifofile->pgci_ut = calloc(1, sizeof(pgci_ut_t)); + if(!ifofile->pgci_ut) + return 0; + + if(!DVDFileSeek_(ifop->file, sector * DVD_BLOCK_LEN)) { + free(ifofile->pgci_ut); + ifofile->pgci_ut = NULL; + return 0; + } + + if(!(DVDReadBytes(ifop->file, ifofile->pgci_ut, PGCI_UT_SIZE))) { + free(ifofile->pgci_ut); + ifofile->pgci_ut = NULL; + return 0; + } + + pgci_ut = ifofile->pgci_ut; + + B2N_16(pgci_ut->nr_of_lus); + B2N_32(pgci_ut->last_byte); + + CHECK_ZERO(pgci_ut->zero_1); + CHECK_VALUE(pgci_ut->nr_of_lus != 0); + CHECK_VALUE(pgci_ut->nr_of_lus < 100); /* ?? 3-4 ? */ + CHECK_VALUE((uint32_t)pgci_ut->nr_of_lus * PGCI_LU_SIZE < pgci_ut->last_byte); + + info_length = pgci_ut->nr_of_lus * PGCI_LU_SIZE; + data = calloc(1, info_length); + if(!data) { + free(pgci_ut); + ifofile->pgci_ut = NULL; + return 0; + } + if(!(DVDReadBytes(ifop->file, data, info_length))) { + free(data); + free(pgci_ut); + ifofile->pgci_ut = NULL; + return 0; + } + + pgci_ut->lu = calloc(pgci_ut->nr_of_lus, sizeof(pgci_lu_t)); + if(!pgci_ut->lu) { + free(data); + free(pgci_ut); + ifofile->pgci_ut = NULL; + return 0; + } + ptr = data; + for(i = 0; i < pgci_ut->nr_of_lus; i++) { + memcpy(&pgci_ut->lu[i], ptr, PGCI_LU_SIZE); + ptr += PGCI_LU_SIZE; + B2N_16(pgci_ut->lu[i].lang_code); + B2N_32(pgci_ut->lu[i].lang_start_byte); + } + free(data); + + for(i = 0; i < pgci_ut->nr_of_lus; i++) { + /* Maybe this is only defined for v1.1 and later titles? */ + /* If the bits in 'lu[i].exists' are enumerated abcd efgh then: + VTS_x_yy.IFO VIDEO_TS.IFO + a == 0x83 "Root" 0x82 "Title" + b == 0x84 "Subpicture" + c == 0x85 "Audio" + d == 0x86 "Angle" + e == 0x87 "PTT" + */ + CHECK_VALUE((pgci_ut->lu[i].exists & 0x07) == 0); + } + + for(i = 0; i < pgci_ut->nr_of_lus; i++) { + int dup; + if((dup = find_dup_lut(pgci_ut->lu, pgci_ut->lu[i].lang_start_byte, i)) >= 0) { + pgci_ut->lu[i].pgcit = pgci_ut->lu[dup].pgcit; + pgci_ut->lu[i].pgcit->ref_count++; + continue; + } + pgci_ut->lu[i].pgcit = calloc(1, sizeof(pgcit_t)); + if(!pgci_ut->lu[i].pgcit) { + unsigned int j; + for(j = 0; j < i; j++) { + ifoFree_PGCIT_internal(&pgci_ut->lu[j].pgcit); + } + free(pgci_ut->lu); + free(pgci_ut); + ifofile->pgci_ut = NULL; + return 0; + } + pgci_ut->lu[i].pgcit->ref_count = 1; + if(!ifoRead_PGCIT_internal(ifofile, pgci_ut->lu[i].pgcit, + sector * DVD_BLOCK_LEN + + pgci_ut->lu[i].lang_start_byte)) { + unsigned int j; + for(j = 0; j <= i; j++) { + ifoFree_PGCIT_internal(&pgci_ut->lu[j].pgcit); + } + free(pgci_ut->lu); + free(pgci_ut); + ifofile->pgci_ut = NULL; + return 0; + } + /* FIXME: Iterate and verify that all menus that should exists accordingly + * to pgci_ut->lu[i].exists really do? */ + } + + return 1; +} + + +void ifoFree_PGCI_UT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->pgci_ut) { + unsigned int i; + + for(i = 0; i < ifofile->pgci_ut->nr_of_lus; i++) { + ifoFree_PGCIT_internal(&ifofile->pgci_ut->lu[i].pgcit); + } + free(ifofile->pgci_ut->lu); + free(ifofile->pgci_ut); + ifofile->pgci_ut = NULL; + } +} + +static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile, + vts_attributes_t *vts_attributes, + unsigned int offset) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + unsigned int i; + + if(!DVDFileSeek_(ifop->file, offset)) + return 0; + + if(!(DVDReadBytes(ifop->file, vts_attributes, sizeof(vts_attributes_t)))) + return 0; + + read_video_attr(&vts_attributes->vtsm_vobs_attr); + read_video_attr(&vts_attributes->vtstt_vobs_video_attr); + read_audio_attr(&vts_attributes->vtsm_audio_attr); + for(i=0; i<8; i++) + read_audio_attr(&vts_attributes->vtstt_audio_attr[i]); + read_subp_attr(&vts_attributes->vtsm_subp_attr); + for(i=0; i<32; i++) + read_subp_attr(&vts_attributes->vtstt_subp_attr[i]); + B2N_32(vts_attributes->last_byte); + B2N_32(vts_attributes->vts_cat); + + CHECK_ZERO(vts_attributes->zero_1); + CHECK_ZERO(vts_attributes->zero_2); + CHECK_ZERO(vts_attributes->zero_3); + CHECK_ZERO(vts_attributes->zero_4); + CHECK_ZERO(vts_attributes->zero_5); + CHECK_ZERO(vts_attributes->zero_6); + CHECK_ZERO(vts_attributes->zero_7); + CHECK_VALUE(vts_attributes->nr_of_vtsm_audio_streams <= 1); + CHECK_VALUE(vts_attributes->nr_of_vtsm_subp_streams <= 1); + CHECK_VALUE(vts_attributes->nr_of_vtstt_audio_streams <= 8); + for(i = vts_attributes->nr_of_vtstt_audio_streams; i < 8; i++) + CHECK_ZERO(vts_attributes->vtstt_audio_attr[i]); + CHECK_VALUE(vts_attributes->nr_of_vtstt_subp_streams <= 32); + { + unsigned int nr_coded; + CHECK_VALUE(vts_attributes->last_byte + 1 >= VTS_ATTRIBUTES_MIN_SIZE); + nr_coded = (vts_attributes->last_byte + 1 - VTS_ATTRIBUTES_MIN_SIZE)/6; + /* This is often nr_coded = 70, how do you know how many there really are? */ + if(nr_coded > 32) { /* We haven't read more from disk/file anyway */ + nr_coded = 32; + } + CHECK_VALUE(vts_attributes->nr_of_vtstt_subp_streams <= nr_coded); + for(i = vts_attributes->nr_of_vtstt_subp_streams; i < nr_coded; i++) + CHECK_ZERO(vts_attributes->vtstt_subp_attr[i]); + } + + return 1; +} + + + +int ifoRead_VTS_ATRT(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + vts_atrt_t *vts_atrt; + unsigned int i, info_length, sector; + uint32_t *data; + + if(!ifofile) + return 0; + + if(!ifofile->vmgi_mat) + return 0; + + if(ifofile->vmgi_mat->vts_atrt == 0) /* mandatory */ + return 0; + + sector = ifofile->vmgi_mat->vts_atrt; + if(!DVDFileSeek_(ifop->file, sector * DVD_BLOCK_LEN)) + return 0; + + vts_atrt = calloc(1, sizeof(vts_atrt_t)); + if(!vts_atrt) + return 0; + + ifofile->vts_atrt = vts_atrt; + + if(!(DVDReadBytes(ifop->file, vts_atrt, VTS_ATRT_SIZE))) { + free(vts_atrt); + ifofile->vts_atrt = NULL; + return 0; + } + + B2N_16(vts_atrt->nr_of_vtss); + B2N_32(vts_atrt->last_byte); + + CHECK_ZERO(vts_atrt->zero_1); + CHECK_VALUE(vts_atrt->nr_of_vtss != 0); + CHECK_VALUE(vts_atrt->nr_of_vtss < 100); /* ?? */ + CHECK_VALUE((uint32_t)vts_atrt->nr_of_vtss * (4 + VTS_ATTRIBUTES_MIN_SIZE) + + VTS_ATRT_SIZE < vts_atrt->last_byte + 1); + + info_length = vts_atrt->nr_of_vtss * sizeof(uint32_t); + data = calloc(1, info_length); + if(!data) { + free(vts_atrt); + ifofile->vts_atrt = NULL; + return 0; + } + + vts_atrt->vts_atrt_offsets = data; + + if(!(DVDReadBytes(ifop->file, data, info_length))) { + free(data); + free(vts_atrt); + ifofile->vts_atrt = NULL; + return 0; + } + + for(i = 0; i < vts_atrt->nr_of_vtss; i++) { + B2N_32(data[i]); + CHECK_VALUE(data[i] + VTS_ATTRIBUTES_MIN_SIZE < vts_atrt->last_byte + 1); + } + + info_length = vts_atrt->nr_of_vtss * sizeof(vts_attributes_t); + vts_atrt->vts = calloc(1, info_length); + if(!vts_atrt->vts) { + free(data); + free(vts_atrt); + ifofile->vts_atrt = NULL; + return 0; + } + for(i = 0; i < vts_atrt->nr_of_vtss; i++) { + unsigned int offset = data[i]; + if(!ifoRead_VTS_ATTRIBUTES(ifofile, &(vts_atrt->vts[i]), + (sector * DVD_BLOCK_LEN) + offset)) { + free(data); + free(vts_atrt); + ifofile->vts_atrt = NULL; + return 0; + } + + /* This assert can't be in ifoRead_VTS_ATTRIBUTES */ + CHECK_VALUE(offset + vts_atrt->vts[i].last_byte <= vts_atrt->last_byte + 1); + /* Is this check correct? */ + } + + return 1; +} + + +void ifoFree_VTS_ATRT(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->vts_atrt) { + free(ifofile->vts_atrt->vts); + free(ifofile->vts_atrt->vts_atrt_offsets); + free(ifofile->vts_atrt); + ifofile->vts_atrt = NULL; + } +} + + +int ifoRead_TXTDT_MGI(ifo_handle_t *ifofile) { + struct ifo_handle_private_s *ifop = PRIV(ifofile); + txtdt_mgi_t *txtdt_mgi; + + if(!ifofile) + return 0; + + if(!ifofile->vmgi_mat) + return 0; + + /* Return successfully if there is nothing to read. */ + if(ifofile->vmgi_mat->txtdt_mgi == 0) + return 1; + + if(!DVDFileSeek_(ifop->file, + ifofile->vmgi_mat->txtdt_mgi * DVD_BLOCK_LEN)) + return 0; + + txtdt_mgi = calloc(1, sizeof(txtdt_mgi_t)); + if(!txtdt_mgi) { + return 0; + } + ifofile->txtdt_mgi = txtdt_mgi; + + if(!(DVDReadBytes(ifop->file, txtdt_mgi, TXTDT_MGI_SIZE))) { + Log0(ifop->ctx, "Unable to read TXTDT_MGI."); + free(txtdt_mgi); + ifofile->txtdt_mgi = NULL; + return 0; + } + + /* Log1(ifop->ctx, "-- Not done yet --\n"); */ + return 1; +} + +void ifoFree_TXTDT_MGI(ifo_handle_t *ifofile) { + if(!ifofile) + return; + + if(ifofile->txtdt_mgi) { + free(ifofile->txtdt_mgi); + ifofile->txtdt_mgi = NULL; + } +} diff --git a/libdvdread-embedded/src/logger.c b/libdvdread-embedded/src/logger.c new file mode 100644 index 0000000..c8a45f2 --- /dev/null +++ b/libdvdread-embedded/src/logger.c @@ -0,0 +1,41 @@ +/* + * This file is part of libdvdread. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. + */ + +#include "config.h" +#include <stdio.h> +#include <stdarg.h> + +#include "dvdread/dvd_reader.h" +#include "logger.h" + +void DVDReadLog( void *priv, const dvd_logger_cb *logcb, + dvd_logger_level_t level, const char *fmt, ... ) +{ + va_list list; + va_start(list, fmt); + if(logcb && logcb->pf_log) + logcb->pf_log(priv, level, fmt, list); + else + { + FILE *stream = (level == DVD_LOGGER_LEVEL_ERROR) ? stderr : stdout; + fprintf(stream, "libdvdread: "); + vfprintf(stream, fmt, list); + fprintf(stream, "\n"); + } + va_end(list); +} diff --git a/libdvdread-embedded/src/logger.h b/libdvdread-embedded/src/logger.h new file mode 100644 index 0000000..ea3245c --- /dev/null +++ b/libdvdread-embedded/src/logger.h @@ -0,0 +1,32 @@ +/* + * This file is part of libdvdread. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. + */ + +#ifndef LIBDVDREAD_LOGGER_H +#define LIBDVDREAD_LOGGER_H + +void DVDReadLog( void *priv, const dvd_logger_cb *logcb, + dvd_logger_level_t level, const char *fmt, ... ); + +#define LOG(ctx, level, ...) \ + DVDReadLog(ctx->priv, &ctx->logcb, level, __VA_ARGS__) +#define Log0(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_ERROR, __VA_ARGS__) +#define Log1(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_WARN, __VA_ARGS__) +#define Log2(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_INFO, __VA_ARGS__) +#define Log3(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_DEBUG, __VA_ARGS__) + +#endif diff --git a/libdvdread-embedded/src/md5.c b/libdvdread-embedded/src/md5.c new file mode 100644 index 0000000..54f4ed0 --- /dev/null +++ b/libdvdread-embedded/src/md5.c @@ -0,0 +1,346 @@ +/***************************************************************************** + * md5.c: not so strong MD5 hashing + ***************************************************************************** + * Copyright (C) 1995,1996,1998,1999,2001,2002, + * 2003 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. + *****************************************************************************/ + +/* md5.c - MD5 Message-Digest Algorithm + * + * According to the definition of MD5 in RFC 1321 from April 1992. + * NOTE: This is *not* the same file as the one from glibc. + * Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. + * heavily modified for GnuPG by Werner Koch <wk@gnupg.org> + */ + +/* Test values: + * "" D4 1D 8C D9 8F 00 B2 04 E9 80 09 98 EC F8 42 7E + * "a" 0C C1 75 B9 C0 F1 B6 A8 31 C3 99 E2 69 77 26 61 + * "abc 90 01 50 98 3C D2 4F B0 D6 96 3F 7D 28 E1 7F 72 + * "message digest" F9 6B 69 7D 7C B7 93 8D 52 5A 2F 31 AA F1 61 D0 + */ + +#include "config.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "md5.h" + +typedef uint32_t u32; +typedef uint8_t byte; +#define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) ) + +typedef struct md5_s MD5_CONTEXT; + + +static void +md5_init( void *context ) +{ + MD5_CONTEXT *ctx = context; + + ctx->A = 0x67452301; + ctx->B = 0xefcdab89; + ctx->C = 0x98badcfe; + ctx->D = 0x10325476; + + ctx->nblocks = 0; + ctx->count = 0; +} + + +/* These are the four functions used in the four steps of the MD5 algorithm + and defined in the RFC 1321. The first function is a little bit optimized + (as found in Colin Plumbs public domain implementation). */ +/* #define FF(b, c, d) ((b & c) | (~b & d)) */ +#define FF(b, c, d) (d ^ (b & (c ^ d))) +#define FG(b, c, d) FF (d, b, c) +#define FH(b, c, d) (b ^ c ^ d) +#define FI(b, c, d) (c ^ (b | ~d)) + + +/**************** + * transform n*64 bytes + */ +static void +transform ( MD5_CONTEXT *ctx, const unsigned char *data ) +{ + u32 correct_words[16]; + register u32 A = ctx->A; + register u32 B = ctx->B; + register u32 C = ctx->C; + register u32 D = ctx->D; + u32 *cwp = correct_words; + +#ifdef WORDS_BIGENDIAN + { + int i; + byte *p2, *p1; + for(i=0, p1=data, p2=(byte*)correct_words; i < 16; i++, p2 += 4 ) + { + p2[3] = *p1++; + p2[2] = *p1++; + p2[1] = *p1++; + p2[0] = *p1++; + } + } +#else + memcpy( correct_words, data, 64 ); +#endif + + +#define OP(a, b, c, d, s, T) \ + do \ + { \ + a += FF (b, c, d) + (*cwp++) + T; \ + a = rol(a, s); \ + a += b; \ + } \ + while (0) + + /* Before we start, one word about the strange constants. + They are defined in RFC 1321 as + + T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64 + */ + + /* Round 1. */ + OP (A, B, C, D, 7, 0xd76aa478); + OP (D, A, B, C, 12, 0xe8c7b756); + OP (C, D, A, B, 17, 0x242070db); + OP (B, C, D, A, 22, 0xc1bdceee); + OP (A, B, C, D, 7, 0xf57c0faf); + OP (D, A, B, C, 12, 0x4787c62a); + OP (C, D, A, B, 17, 0xa8304613); + OP (B, C, D, A, 22, 0xfd469501); + OP (A, B, C, D, 7, 0x698098d8); + OP (D, A, B, C, 12, 0x8b44f7af); + OP (C, D, A, B, 17, 0xffff5bb1); + OP (B, C, D, A, 22, 0x895cd7be); + OP (A, B, C, D, 7, 0x6b901122); + OP (D, A, B, C, 12, 0xfd987193); + OP (C, D, A, B, 17, 0xa679438e); + OP (B, C, D, A, 22, 0x49b40821); + +#undef OP +#define OP(f, a, b, c, d, k, s, T) \ + do \ + { \ + a += f (b, c, d) + correct_words[k] + T; \ + a = rol(a, s); \ + a += b; \ + } \ + while (0) + + /* Round 2. */ + OP (FG, A, B, C, D, 1, 5, 0xf61e2562); + OP (FG, D, A, B, C, 6, 9, 0xc040b340); + OP (FG, C, D, A, B, 11, 14, 0x265e5a51); + OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa); + OP (FG, A, B, C, D, 5, 5, 0xd62f105d); + OP (FG, D, A, B, C, 10, 9, 0x02441453); + OP (FG, C, D, A, B, 15, 14, 0xd8a1e681); + OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8); + OP (FG, A, B, C, D, 9, 5, 0x21e1cde6); + OP (FG, D, A, B, C, 14, 9, 0xc33707d6); + OP (FG, C, D, A, B, 3, 14, 0xf4d50d87); + OP (FG, B, C, D, A, 8, 20, 0x455a14ed); + OP (FG, A, B, C, D, 13, 5, 0xa9e3e905); + OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8); + OP (FG, C, D, A, B, 7, 14, 0x676f02d9); + OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a); + + /* Round 3. */ + OP (FH, A, B, C, D, 5, 4, 0xfffa3942); + OP (FH, D, A, B, C, 8, 11, 0x8771f681); + OP (FH, C, D, A, B, 11, 16, 0x6d9d6122); + OP (FH, B, C, D, A, 14, 23, 0xfde5380c); + OP (FH, A, B, C, D, 1, 4, 0xa4beea44); + OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9); + OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60); + OP (FH, B, C, D, A, 10, 23, 0xbebfbc70); + OP (FH, A, B, C, D, 13, 4, 0x289b7ec6); + OP (FH, D, A, B, C, 0, 11, 0xeaa127fa); + OP (FH, C, D, A, B, 3, 16, 0xd4ef3085); + OP (FH, B, C, D, A, 6, 23, 0x04881d05); + OP (FH, A, B, C, D, 9, 4, 0xd9d4d039); + OP (FH, D, A, B, C, 12, 11, 0xe6db99e5); + OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8); + OP (FH, B, C, D, A, 2, 23, 0xc4ac5665); + + /* Round 4. */ + OP (FI, A, B, C, D, 0, 6, 0xf4292244); + OP (FI, D, A, B, C, 7, 10, 0x432aff97); + OP (FI, C, D, A, B, 14, 15, 0xab9423a7); + OP (FI, B, C, D, A, 5, 21, 0xfc93a039); + OP (FI, A, B, C, D, 12, 6, 0x655b59c3); + OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92); + OP (FI, C, D, A, B, 10, 15, 0xffeff47d); + OP (FI, B, C, D, A, 1, 21, 0x85845dd1); + OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f); + OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0); + OP (FI, C, D, A, B, 6, 15, 0xa3014314); + OP (FI, B, C, D, A, 13, 21, 0x4e0811a1); + OP (FI, A, B, C, D, 4, 6, 0xf7537e82); + OP (FI, D, A, B, C, 11, 10, 0xbd3af235); + OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb); + OP (FI, B, C, D, A, 9, 21, 0xeb86d391); + + /* Put checksum in context given as argument. */ + ctx->A += A; + ctx->B += B; + ctx->C += C; + ctx->D += D; +} + + + +/* The routine updates the message-digest context to + * account for the presence of each of the characters inBuf[0..inLen-1] + * in the message whose digest is being computed. + */ +static void +md5_write( void *context, const void *inbuf_arg , size_t inlen) +{ + const unsigned char *inbuf = inbuf_arg; + MD5_CONTEXT *hd = context; + + if( hd->count == 64 ) /* flush the buffer */ + { + transform( hd, hd->buf ); + hd->count = 0; + hd->nblocks++; + } + if( !inbuf ) + return; + + if( hd->count ) + { + for( ; inlen && hd->count < 64; inlen-- ) + hd->buf[hd->count++] = *inbuf++; + md5_write( hd, NULL, 0 ); + if( !inlen ) + return; + } + + while( inlen >= 64 ) + { + transform( hd, inbuf ); + hd->count = 0; + hd->nblocks++; + inlen -= 64; + inbuf += 64; + } + for( ; inlen && hd->count < 64; inlen-- ) + hd->buf[hd->count++] = *inbuf++; + +} + + + +/* The routine final terminates the message-digest computation and + * ends with the desired message digest in mdContext->digest[0...15]. + * The handle is prepared for a new MD5 cycle. + * Returns 16 bytes representing the digest. + */ + +static void +md5_final( void *context) +{ + MD5_CONTEXT *hd = context; + u32 t, msb, lsb; + byte *p; + + md5_write(hd, NULL, 0); /* flush */; + + t = hd->nblocks; + /* multiply by 64 to make a byte count */ + lsb = t << 6; + msb = t >> 26; + /* add the count */ + t = lsb; + if( (lsb += hd->count) < t ) + msb++; + /* multiply by 8 to make a bit count */ + t = lsb; + lsb <<= 3; + msb <<= 3; + msb |= t >> 29; + + if( hd->count < 56 ) /* enough room */ + { + hd->buf[hd->count++] = 0x80; /* pad */ + while( hd->count < 56 ) + hd->buf[hd->count++] = 0; /* pad */ + } + else /* need one extra block */ + { + hd->buf[hd->count++] = 0x80; /* pad character */ + while( hd->count < 64 ) + hd->buf[hd->count++] = 0; + md5_write(hd, NULL, 0); /* flush */; + memset(hd->buf, 0, 56 ); /* fill next block with zeroes */ + } + /* append the 64 bit count */ + hd->buf[56] = lsb ; + hd->buf[57] = lsb >> 8; + hd->buf[58] = lsb >> 16; + hd->buf[59] = lsb >> 24; + hd->buf[60] = msb ; + hd->buf[61] = msb >> 8; + hd->buf[62] = msb >> 16; + hd->buf[63] = msb >> 24; + transform( hd, hd->buf ); + + p = hd->buf; +#ifdef WORDS_BIGENDIAN +#define X(a) do { *p++ = hd->a ; *p++ = hd->a >> 8; \ + *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0) +#else /* little endian */ +#define X(a) do { *(u32*)p = (*hd).a ; p += 4; } while(0) +#endif + X(A); + X(B); + X(C); + X(D); +#undef X + +} + +#if 0 +static byte * +md5_read( void *context ) +{ + MD5_CONTEXT *hd = (MD5_CONTEXT *) context; + return hd->buf; +} +#endif + +void InitMD5( struct md5_s *h ) +{ + md5_init( h ); +} + +void AddMD5( struct md5_s *h, const void *data, size_t len ) +{ + md5_write( h, data, len ); +} + +void EndMD5( struct md5_s *h ) +{ + md5_final( h ); +} diff --git a/libdvdread-embedded/src/md5.h b/libdvdread-embedded/src/md5.h new file mode 100644 index 0000000..50ce88c --- /dev/null +++ b/libdvdread-embedded/src/md5.h @@ -0,0 +1,46 @@ +/***************************************************************************** + * md5.h: MD5 hash + ***************************************************************************** + * Copyright © 2004-2011 VLC authors and VideoLAN + * + * Authors: Rémi Denis-Courmont + * Rafaël Carré + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. + *****************************************************************************/ + +#ifndef LIBDVDREAD_MD5_H +#define LIBDVDREAD_MD5_H + +#include <stdint.h> + +/** + * \file + * This file defines functions and structures to compute MD5 digests + */ + +struct md5_s +{ + uint32_t A, B, C, D; /* chaining variables */ + uint32_t nblocks; + uint8_t buf[64]; + int count; +}; + +void InitMD5( struct md5_s * ); +void AddMD5( struct md5_s *, const void *, size_t ); +void EndMD5( struct md5_s * ); + +#endif diff --git a/libdvdread-embedded/src/nav_print.c b/libdvdread-embedded/src/nav_print.c new file mode 100644 index 0000000..d8f7b27 --- /dev/null +++ b/libdvdread-embedded/src/nav_print.c @@ -0,0 +1,248 @@ +/* + * Copyright (C) 2000, 2001, 2002, 2003 Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * Much of the contents in this file is based on VOBDUMP. + * + * VOBDUMP: a program for examining DVD .VOB files + * + * Copyright 1998, 1999 Eric Smith <eric@brouhaha.com> + * + * VOBDUMP is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 or version 3 as + * published by the Free Software Foundation. Note that I am not + * granting permission to redistribute or modify VOBDUMP under the + * terms of any later version of the General Public License. + * + * This program is distributed in the hope that it will be useful (or + * at least amusing), but WITHOUT ANY WARRANTY; without even the + * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include <stdio.h> +#include <inttypes.h> + +#include "dvdread/nav_types.h" +#include "dvdread/nav_print.h" +#include "dvdread/ifo_print.h" + +static void navPrint_PCI_GI(pci_gi_t *pci_gi) { + int i; + + printf("pci_gi:\n"); + printf("nv_pck_lbn 0x%08x\n", pci_gi->nv_pck_lbn); + printf("vobu_cat 0x%04x\n", pci_gi->vobu_cat); + printf("vobu_s_ptm 0x%08x\n", pci_gi->vobu_s_ptm); + printf("vobu_e_ptm 0x%08x\n", pci_gi->vobu_e_ptm); + printf("vobu_se_e_ptm 0x%08x\n", pci_gi->vobu_se_e_ptm); + printf("e_eltm "); + dvdread_print_time(&pci_gi->e_eltm); + printf("\n"); + + printf("vobu_isrc \""); + for(i = 0; i < 32; i++) { + char c = pci_gi->vobu_isrc[i]; + if((c >= ' ') && (c <= '~')) + printf("%c", c); + else + printf("."); + } + printf("\"\n"); +} + +static void navPrint_NSML_AGLI(nsml_agli_t *nsml_agli) { + int i, j = 0; + + for(i = 0; i < 9; i++) + j |= nsml_agli->nsml_agl_dsta[i]; + if(j == 0) + return; + + printf("nsml_agli:\n"); + for(i = 0; i < 9; i++) + if(nsml_agli->nsml_agl_dsta[i]) + printf("nsml_agl_c%d_dsta 0x%08x\n", i + 1, + nsml_agli->nsml_agl_dsta[i]); +} + +static void navPrint_HL_GI(hl_gi_t *hl_gi, int *btngr_ns, int *btn_ns) { + + if((hl_gi->hli_ss & 0x03) == 0) + return; + + printf("hl_gi:\n"); + printf("hli_ss 0x%01x\n", hl_gi->hli_ss & 0x03); + printf("hli_s_ptm 0x%08x\n", hl_gi->hli_s_ptm); + printf("hli_e_ptm 0x%08x\n", hl_gi->hli_e_ptm); + printf("btn_se_e_ptm 0x%08x\n", hl_gi->btn_se_e_ptm); + + *btngr_ns = hl_gi->btngr_ns; + printf("btngr_ns %u\n", hl_gi->btngr_ns); + printf("btngr%d_dsp_ty 0x%02x\n", 1, hl_gi->btngr1_dsp_ty); + printf("btngr%d_dsp_ty 0x%02x\n", 2, hl_gi->btngr2_dsp_ty); + printf("btngr%d_dsp_ty 0x%02x\n", 3, hl_gi->btngr3_dsp_ty); + + printf("btn_ofn %d\n", hl_gi->btn_ofn); + *btn_ns = hl_gi->btn_ns; + printf("btn_ns %d\n", hl_gi->btn_ns); + printf("nsl_btn_ns %d\n", hl_gi->nsl_btn_ns); + printf("fosl_btnn %d\n", hl_gi->fosl_btnn); + printf("foac_btnn %d\n", hl_gi->foac_btnn); +} + +static void navPrint_BTN_COLIT(btn_colit_t *btn_colit) { + int i, j; + + j = 0; + for(i = 0; i < 6; i++) + j |= btn_colit->btn_coli[i/2][i&1]; + if(j == 0) + return; + + printf("btn_colit:\n"); + for(i = 0; i < 3; i++) + for(j = 0; j < 2; j++) + printf("btn_cqoli %d %s_coli: %08x\n", + i, (j == 0) ? "sl" : "ac", + btn_colit->btn_coli[i][j]); +} + +static void navPrint_BTNIT(btni_t *btni_table, int btngr_ns, int btn_ns) { + int i, j; + + printf("btnit:\n"); + printf("btngr_ns: %i\n", btngr_ns); + printf("btn_ns: %i\n", btn_ns); + + if(btngr_ns == 0) + return; + + for(i = 0; i < btngr_ns; i++) { + for(j = 0; j < (36 / btngr_ns); j++) { + if(j < btn_ns) { + btni_t *btni = &btni_table[(36 / btngr_ns) * i + j]; + + printf("group %d btni %d: ", i+1, j+1); + printf("btn_coln %u, auto_action_mode %u\n", + btni->btn_coln, btni->auto_action_mode); + printf("coords (%u, %u) .. (%u, %u)\n", + btni->x_start, btni->y_start, btni->x_end, btni->y_end); + + printf("up %u, ", btni->up); + printf("down %u, ", btni->down); + printf("left %u, ", btni->left); + printf("right %u\n", btni->right); + + /* ifoPrint_COMMAND(&btni->cmd); */ + printf("\n"); + } + } + } +} + +static void navPrint_HLI(hli_t *hli) { + int btngr_ns = 0, btn_ns = 0; + + printf("hli:\n"); + navPrint_HL_GI(&hli->hl_gi, & btngr_ns, & btn_ns); + navPrint_BTN_COLIT(&hli->btn_colit); + navPrint_BTNIT(hli->btnit, btngr_ns, btn_ns); +} + +void navPrint_PCI(pci_t *pci) { + printf("pci packet:\n"); + navPrint_PCI_GI(&pci->pci_gi); + navPrint_NSML_AGLI(&pci->nsml_agli); + navPrint_HLI(&pci->hli); +} + +static void navPrint_DSI_GI(dsi_gi_t *dsi_gi) { + printf("dsi_gi:\n"); + printf("nv_pck_scr 0x%08x\n", dsi_gi->nv_pck_scr); + printf("nv_pck_lbn 0x%08x\n", dsi_gi->nv_pck_lbn ); + printf("vobu_ea 0x%08x\n", dsi_gi->vobu_ea); + printf("vobu_1stref_ea 0x%08x\n", dsi_gi->vobu_1stref_ea); + printf("vobu_2ndref_ea 0x%08x\n", dsi_gi->vobu_2ndref_ea); + printf("vobu_3rdref_ea 0x%08x\n", dsi_gi->vobu_3rdref_ea); + printf("vobu_vob_idn 0x%04x\n", dsi_gi->vobu_vob_idn); + printf("vobu_c_idn 0x%02x\n", dsi_gi->vobu_c_idn); + printf("c_eltm "); + dvdread_print_time(&dsi_gi->c_eltm); + printf("\n"); +} + +static void navPrint_SML_PBI(sml_pbi_t *sml_pbi) { + printf("sml_pbi:\n"); + printf("category 0x%04x\n", sml_pbi->category); + if(sml_pbi->category & 0x8000) + printf("VOBU is in preunit\n"); + if(sml_pbi->category & 0x4000) + printf("VOBU is in ILVU\n"); + if(sml_pbi->category & 0x2000) + printf("VOBU at the beginning of ILVU\n"); + if(sml_pbi->category & 0x1000) + printf("VOBU at end of PREU of ILVU\n"); + + printf("ilvu_ea 0x%08x\n", sml_pbi->ilvu_ea); + printf("nxt_ilvu_sa 0x%08x\n", sml_pbi->ilvu_sa); + printf("nxt_ilvu_size 0x%04x\n", sml_pbi->size); + + printf("vob_v_s_s_ptm 0x%08x\n", sml_pbi->vob_v_s_s_ptm); + printf("vob_v_e_e_ptm 0x%08x\n", sml_pbi->vob_v_e_e_ptm); + + /* $$$ more code needed here */ +} + +static void navPrint_SML_AGLI(sml_agli_t *sml_agli) { + int i; + printf("sml_agli:\n"); + for(i = 0; i < 9; i++) { + printf("agl_c%d address: 0x%08x size 0x%04x\n", i, + sml_agli->data[i].address, sml_agli->data[i].size); + } +} + +static void navPrint_VOBU_SRI(vobu_sri_t *vobu_sri) { + int i; + int stime[19] = { 240, 120, 60, 20, 15, 14, 13, 12, 11, + 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; + printf("vobu_sri:\n"); + printf("Next VOBU with Video %08x\n", vobu_sri->next_video); + for(i = 0; i < 19; i++) { + printf("%3.1f %08x ", stime[i]/2.0, vobu_sri->fwda[i]); + } + printf("\n"); + printf("Next VOBU %08x\n", vobu_sri->next_vobu); + printf("--\n"); + printf("Prev VOBU %08x\n", vobu_sri->prev_vobu); + for(i = 0; i < 19; i++) { + printf("%3.1f %08x ", stime[18 - i]/2.0, vobu_sri->bwda[i]); + } + printf("\n"); + printf("Prev VOBU with Video %08x\n", vobu_sri->prev_video); +} + +static void navPrint_SYNCI(synci_t *synci) { + int i; + + printf("synci:\n"); + /* $$$ more code needed here */ + for(i = 0; i < 8; i++) + printf("%04x ", synci->a_synca[i]); + for(i = 0; i < 32; i++) + printf("%08x ", synci->sp_synca[i]); +} + +void navPrint_DSI(dsi_t *dsi) { + printf("dsi packet:\n"); + navPrint_DSI_GI(&dsi->dsi_gi); + navPrint_SML_PBI(&dsi->sml_pbi); + navPrint_SML_AGLI(&dsi->sml_agli); + navPrint_VOBU_SRI(&dsi->vobu_sri); + navPrint_SYNCI(&dsi->synci); +} diff --git a/libdvdread-embedded/src/nav_read.c b/libdvdread-embedded/src/nav_read.c new file mode 100644 index 0000000..bb781cf --- /dev/null +++ b/libdvdread-embedded/src/nav_read.c @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2000, 2001, 2002, 2003 Håkan Hjort <d95hjort@dtek.chalmers.se> + * + * This file is part of libdvdread. + * + * libdvdread is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * libdvdread is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with libdvdread; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <inttypes.h> + +#include "bswap.h" +#include "dvdread/nav_types.h" +#include "dvdread/nav_read.h" +#include "dvdread_internal.h" +#include "dvdread/bitreader.h" + +#define getbits_init dvdread_getbits_init +#define getbits dvdread_getbits + +#define CHECK_VALUE(arg)\ + if(!(arg)) {\ + DVDReadLog(NULL, NULL, DVD_LOGGER_LEVEL_WARN,\ + "CHECK_VALUE failed in %s:%i for %s",\ + __FILE__, __LINE__, # arg );\ + } + +void navRead_PCI(pci_t *pci, unsigned char *buffer) { + int32_t i, j; + getbits_state_t state; + if (!getbits_init(&state, buffer)) abort(); /* Passed NULL pointers */ + + /* pci pci_gi */ + pci->pci_gi.nv_pck_lbn = getbits(&state, 32 ); + pci->pci_gi.vobu_cat = getbits(&state, 16 ); + pci->pci_gi.zero1 = getbits(&state, 16 ); + pci->pci_gi.vobu_uop_ctl.zero = getbits(&state, 7 ); + pci->pci_gi.vobu_uop_ctl.video_pres_mode_change = getbits(&state, 1 ); + + pci->pci_gi.vobu_uop_ctl.karaoke_audio_pres_mode_change = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.angle_change = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.subpic_stream_change = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.audio_stream_change = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.pause_on = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.still_off = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.button_select_or_activate = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.resume = getbits(&state, 1 ); + + pci->pci_gi.vobu_uop_ctl.chapter_menu_call = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.angle_menu_call = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.audio_menu_call = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.subpic_menu_call = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.root_menu_call = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.title_menu_call = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.backward_scan = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.forward_scan = getbits(&state, 1 ); + + pci->pci_gi.vobu_uop_ctl.next_pg_search = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.prev_or_top_pg_search = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.time_or_chapter_search = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.go_up = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.stop = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.title_play = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.chapter_search_or_play = getbits(&state, 1 ); + pci->pci_gi.vobu_uop_ctl.title_or_time_play = getbits(&state, 1 ); + pci->pci_gi.vobu_s_ptm = getbits(&state, 32 ); + pci->pci_gi.vobu_e_ptm = getbits(&state, 32 ); + pci->pci_gi.vobu_se_e_ptm = getbits(&state, 32 ); + pci->pci_gi.e_eltm.hour = getbits(&state, 8 ); + pci->pci_gi.e_eltm.minute = getbits(&state, 8 ); + pci->pci_gi.e_eltm.second = getbits(&state, 8 ); + pci->pci_gi.e_eltm.frame_u = getbits(&state, 8 ); + for(i = 0; i < 32; i++) + pci->pci_gi.vobu_isrc[i] = getbits(&state, 8 ); + + /* pci nsml_agli */ + for(i = 0; i < 9; i++) + pci->nsml_agli.nsml_agl_dsta[i] = getbits(&state, 32 ); + + /* pci hli hli_gi */ + pci->hli.hl_gi.hli_ss = getbits(&state, 16 ); + pci->hli.hl_gi.hli_s_ptm = getbits(&state, 32 ); + pci->hli.hl_gi.hli_e_ptm = getbits(&state, 32 ); + pci->hli.hl_gi.btn_se_e_ptm = getbits(&state, 32 ); + pci->hli.hl_gi.zero1 = getbits(&state, 2 ); + pci->hli.hl_gi.btngr_ns = getbits(&state, 2 ); + pci->hli.hl_gi.zero2 = getbits(&state, 1 ); + pci->hli.hl_gi.btngr1_dsp_ty = getbits(&state, 3 ); + pci->hli.hl_gi.zero3 = getbits(&state, 1 ); + pci->hli.hl_gi.btngr2_dsp_ty = getbits(&state, 3 ); + pci->hli.hl_gi.zero4 = getbits(&state, 1 ); + pci->hli.hl_gi.btngr3_dsp_ty = getbits(&state, 3 ); + pci->hli.hl_gi.btn_ofn = getbits(&state, 8 ); + pci->hli.hl_gi.btn_ns = getbits(&state, 8 ); + pci->hli.hl_gi.nsl_btn_ns = getbits(&state, 8 ); + pci->hli.hl_gi.zero5 = getbits(&state, 8 ); + pci->hli.hl_gi.fosl_btnn = getbits(&state, 8 ); + pci->hli.hl_gi.foac_btnn = getbits(&state, 8 ); + + /* pci hli btn_colit */ + for(i = 0; i < 3; i++) + for(j = 0; j < 2; j++) + pci->hli.btn_colit.btn_coli[i][j] = getbits(&state, 32 ); + + /* NOTE: I've had to change the structure from the disk layout to get + * the packing to work with Sun's Forte C compiler. */ + + /* pci hli btni */ + for(i = 0; i < 36; i++) { + pci->hli.btnit[i].btn_coln = getbits(&state, 2 ); + pci->hli.btnit[i].x_start = getbits(&state, 10 ); + pci->hli.btnit[i].zero1 = getbits(&state, 2 ); + pci->hli.btnit[i].x_end = getbits(&state, 10 ); + + pci->hli.btnit[i].auto_action_mode = getbits(&state, 2 ); + pci->hli.btnit[i].y_start = getbits(&state, 10 ); + pci->hli.btnit[i].zero2 = getbits(&state, 2 ); + pci->hli.btnit[i].y_end = getbits(&state, 10 ); + + pci->hli.btnit[i].zero3 = getbits(&state, 2 ); + pci->hli.btnit[i].up = getbits(&state, 6 ); + pci->hli.btnit[i].zero4 = getbits(&state, 2 ); + pci->hli.btnit[i].down = getbits(&state, 6 ); + pci->hli.btnit[i].zero5 = getbits(&state, 2 ); + pci->hli.btnit[i].left = getbits(&state, 6 ); + pci->hli.btnit[i].zero6 = getbits(&state, 2 ); + pci->hli.btnit[i].right = getbits(&state, 6 ); + /* pci vm_cmd */ + for(j = 0; j < 8; j++) + pci->hli.btnit[i].cmd.bytes[j] = getbits(&state, 8 ); + } + + +#ifndef NDEBUG + /* Asserts */ + + /* pci pci gi */ + CHECK_VALUE(pci->pci_gi.zero1 == 0); + + /* pci hli hli_gi */ + CHECK_VALUE(pci->hli.hl_gi.zero1 == 0); + CHECK_VALUE(pci->hli.hl_gi.zero2 == 0); + CHECK_VALUE(pci->hli.hl_gi.zero3 == 0); + CHECK_VALUE(pci->hli.hl_gi.zero4 == 0); + CHECK_VALUE(pci->hli.hl_gi.zero5 == 0); + + /* Are there buttons defined here? */ + if((pci->hli.hl_gi.hli_ss & 0x03) != 0) { + CHECK_VALUE(pci->hli.hl_gi.btn_ns != 0); + CHECK_VALUE(pci->hli.hl_gi.btngr_ns != 0); + } else { + CHECK_VALUE((pci->hli.hl_gi.btn_ns != 0 && pci->hli.hl_gi.btngr_ns != 0) + || (pci->hli.hl_gi.btn_ns == 0 && pci->hli.hl_gi.btngr_ns == 0)); + } + + /* pci hli btnit */ + for(i = 0; i < pci->hli.hl_gi.btngr_ns; i++) { + for(j = 0; j < (36 / pci->hli.hl_gi.btngr_ns); j++) { + int n = (36 / pci->hli.hl_gi.btngr_ns) * i + j; + CHECK_VALUE(pci->hli.btnit[n].zero1 == 0); + CHECK_VALUE(pci->hli.btnit[n].zero2 == 0); + CHECK_VALUE(pci->hli.btnit[n].zero3 == 0); + CHECK_VALUE(pci->hli.btnit[n].zero4 == 0); + CHECK_VALUE(pci->hli.btnit[n].zero5 == 0); + CHECK_VALUE(pci->hli.btnit[n].zero6 == 0); + + if (j < pci->hli.hl_gi.btn_ns) { + CHECK_VALUE(pci->hli.btnit[n].x_start <= pci->hli.btnit[n].x_end); + CHECK_VALUE(pci->hli.btnit[n].y_start <= pci->hli.btnit[n].y_end); + CHECK_VALUE(pci->hli.btnit[n].up <= pci->hli.hl_gi.btn_ns); + CHECK_VALUE(pci->hli.btnit[n].down <= pci->hli.hl_gi.btn_ns); + CHECK_VALUE(pci->hli.btnit[n].left <= pci->hli.hl_gi.btn_ns); + CHECK_VALUE(pci->hli.btnit[n].right <= pci->hli.hl_gi.btn_ns); + /* vmcmd_verify(pci->hli.btnit[n].cmd); */ + } else { + int k; + CHECK_VALUE(pci->hli.btnit[n].btn_coln == 0); + CHECK_VALUE(pci->hli.btnit[n].auto_action_mode == 0); + CHECK_VALUE(pci->hli.btnit[n].x_start == 0); + CHECK_VALUE(pci->hli.btnit[n].y_start == 0); + CHECK_VALUE(pci->hli.btnit[n].x_end == 0); + CHECK_VALUE(pci->hli.btnit[n].y_end == 0); + CHECK_VALUE(pci->hli.btnit[n].up == 0); + CHECK_VALUE(pci->hli.btnit[n].down == 0); + CHECK_VALUE(pci->hli.btnit[n].left == 0); + CHECK_VALUE(pci->hli.btnit[n].right == 0); + for (k = 0; k < 8; k++) + CHECK_VALUE(pci->hli.btnit[n].cmd.bytes[k] == 0); /* CHECK_ZERO? */ + } + } + } +#endif /* !NDEBUG */ +} + +void navRead_DSI(dsi_t *dsi, unsigned char *buffer) { + int i; + getbits_state_t state; + if (!getbits_init(&state, buffer)) abort(); /* Passed NULL pointers */ + + /* dsi dsi gi */ + dsi->dsi_gi.nv_pck_scr = getbits(&state, 32 ); + dsi->dsi_gi.nv_pck_lbn = getbits(&state, 32 ); + dsi->dsi_gi.vobu_ea = getbits(&state, 32 ); + dsi->dsi_gi.vobu_1stref_ea = getbits(&state, 32 ); + dsi->dsi_gi.vobu_2ndref_ea = getbits(&state, 32 ); + dsi->dsi_gi.vobu_3rdref_ea = getbits(&state, 32 ); + dsi->dsi_gi.vobu_vob_idn = getbits(&state, 16 ); + dsi->dsi_gi.zero1 = getbits(&state, 8 ); + dsi->dsi_gi.vobu_c_idn = getbits(&state, 8 ); + dsi->dsi_gi.c_eltm.hour = getbits(&state, 8 ); + dsi->dsi_gi.c_eltm.minute = getbits(&state, 8 ); + dsi->dsi_gi.c_eltm.second = getbits(&state, 8 ); + dsi->dsi_gi.c_eltm.frame_u = getbits(&state, 8 ); + + /* dsi sml pbi */ + dsi->sml_pbi.category = getbits(&state, 16 ); + dsi->sml_pbi.ilvu_ea = getbits(&state, 32 ); + dsi->sml_pbi.ilvu_sa = getbits(&state, 32 ); + dsi->sml_pbi.size = getbits(&state, 16 ); + dsi->sml_pbi.vob_v_s_s_ptm = getbits(&state, 32 ); + dsi->sml_pbi.vob_v_e_e_ptm = getbits(&state, 32 ); + for(i = 0; i < 8; i++) { + dsi->sml_pbi.vob_a[i].stp_ptm1 = getbits(&state, 32 ); + dsi->sml_pbi.vob_a[i].stp_ptm2 = getbits(&state, 32 ); + dsi->sml_pbi.vob_a[i].gap_len1 = getbits(&state, 32 ); + dsi->sml_pbi.vob_a[i].gap_len2 = getbits(&state, 32 ); + } + + /* dsi sml agli */ + for(i = 0; i < 9; i++) { + dsi->sml_agli.data[ i ].address = getbits(&state, 32 ); + dsi->sml_agli.data[ i ].size = getbits(&state, 16 ); + } + + /* dsi vobu sri */ + dsi->vobu_sri.next_video = getbits(&state, 32 ); + for(i = 0; i < 19; i++) + dsi->vobu_sri.fwda[i] = getbits(&state, 32 ); + dsi->vobu_sri.next_vobu = getbits(&state, 32 ); + dsi->vobu_sri.prev_vobu = getbits(&state, 32 ); + for(i = 0; i < 19; i++) + dsi->vobu_sri.bwda[i] = getbits(&state, 32 ); + dsi->vobu_sri.prev_video = getbits(&state, 32 ); + + /* dsi synci */ + for(i = 0; i < 8; i++) + dsi->synci.a_synca[i] = getbits(&state, 16 ); + for(i = 0; i < 32; i++) + dsi->synci.sp_synca[i] = getbits(&state, 32 ); + + + /* Asserts */ + + /* dsi dsi gi */ + CHECK_VALUE(dsi->dsi_gi.zero1 == 0); +} |