API tools faq
paste
Guest User

dvd-vr 2010

a guest
Aug 29th, 2024
5
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 59.71 KB | Source Code | 0 0
raw download clone embed print report
  1. //vim:fileencoding=utf8
  2. /*
  3.  dvd-vr.c     Identify and optionally copy the individual programs
  4.               from a DVD-VR format disc
  5.  
  6.  Copyright © 2007-2010 Pádraig Brady <P@draigBrady.com>
  7.  
  8.  This program is free software; you can redistribute it and/or modify
  9.  it under the terms of the GNU General Public License as published by
  10.  the Free Software Foundation; either version 2 of the License, or
  11.  (at your option) any later version.
  12.  
  13.  This program is distributed in the hope that it will be useful,
  14.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  GNU General Public License for more details.
  17.  
  18.  You should have received a copy of the GNU General Public License
  19.  along with this program; if not, write to the Free Software
  20.  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  21. */
  22.  
  23. /*
  24.  
  25. Notes:
  26.  
  27.     Individual recordings (programs) are extracted,
  28.     honouring any splits and/or deletes.
  29.     Merged programs are not handled yet though as
  30.     I would need to fully parse the higher level program set info.
  31.     Note the VOBs output from this program can be trivially
  32.     concatenated with the unix cat command for example
  33.     (note there will be timestamp jumps which may be problematic).
  34.  
  35.     While extracting the DVD data, this program instructs the system
  36.     to not cache the data so that existing cached data is not affected.
  37.  
  38.     We output the data from this program rather than just outputting offsets
  39.     for use with dd for example, because we may support disjoint VOBUs
  40.     (merged programs) in future. Also in future we may transform the NAV info
  41.     slightly in the VOBs? Anyway it gives us greater control over the system cache
  42.     as described above.
  43.  
  44.     It might be useful to provide a FUSE module using this logic,
  45.     to present the logical structure of a DVD-VR, maybe even present as DVD-Video?
  46.  
  47.     Doesn't parse play list index
  48.     Doesn't parse still image info
  49.     Doesn't parse chapters
  50.     Doesn't fixup MPEG time data
  51.  
  52.  
  53. Requirements:
  54.  
  55.     gcc >= 2.95
  56.     glibc >= 2.3.3 on linux
  57.     Tested on linux, CYGWIN and Mac OS X
  58. */
  59.  
  60. #define _GNU_SOURCE           /* for posix_fadvise(), futimes() */
  61. #define _FILE_OFFSET_BITS 64  /* for implicit large file support */
  62.  
  63. #include <inttypes.h>
  64. #include <stdbool.h>
  65.  
  66. #include <stdio.h>
  67. #include <stdlib.h>
  68. #include <string.h>
  69. #include <wchar.h>
  70. #include <unistd.h>
  71. #include <fcntl.h>
  72. #include <time.h>
  73. #include <locale.h>
  74. #include <getopt.h>
  75.  
  76. #include <sys/types.h>
  77. #include <sys/stat.h>
  78. #include <sys/mman.h>
  79. #include <sys/time.h>
  80. #include <errno.h>
  81. #include <limits.h>
  82.  
  83. #if !defined(MB_LEN_MAX) || MB_LEN_MAX<16
  84. /* 1 char could be converted to 2 multibyte chars
  85.  * (for example combining accents), with each taking up to
  86.  * 6 bytes in UTF-8 for example */
  87. # undef MB_LEN_MAX
  88. # define MB_LEN_MAX 16
  89. #endif
  90.  
  91. #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
  92. #define TYPE_MAX(t) \
  93.   ((t) (! TYPE_SIGNED (t) \
  94.         ? (t) -1 \
  95.         : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
  96. #define OFF_T_MAX TYPE_MAX(off_t)
  97.  
  98. #define STREQ(x,y) (strcmp(x,y)==0)
  99. #ifndef MAX
  100. # define MAX(a, b) ((a) > (b) ? (a) : (b))
  101. #endif
  102. #ifndef MIN
  103. # define MIN(a,b) (((a) < (b)) ? (a) : (b))
  104. #endif
  105.  
  106. /* For a discussion of this macro see:
  107.  * http://www.pixelbeat.org/programming/gcc/static_assert.html */
  108. #define ASSERT_CONCAT_(a, b) a##b
  109. #define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b)
  110. #define STATIC_ASSERT(e,m) enum { ASSERT_CONCAT(assert_line_, __LINE__) = 1/(!!(e)) }
  111.  
  112. #if defined(__CYGWIN__) || defined(_WIN32) /* windos doesn't like : in filenames */
  113. #define TIMESTAMP_FMT "%F_%H-%M-%S"
  114. #else
  115. #define TIMESTAMP_FMT "%F_%T" /* keep : in filenames for backward compat */
  116. #endif
  117. const char* base_name = TIMESTAMP_FMT;
  118.  
  119. FILE* stdinfo; /* Where we write disc info */
  120.  
  121. #include <langinfo.h>
  122. #ifdef HAVE_ICONV
  123. #include <iconv.h>
  124. #endif
  125. const char* disc_charset;
  126. const char* sys_charset;
  127.  
  128. /*********************************************************************************
  129.  *                          support routines
  130.  *********************************************************************************/
  131. static size_t my_strnlen(const char* s, size_t n)
  132. {
  133.     size_t len = 0;
  134.     while (n-- && *s++) len++;
  135.     return len;
  136. }
  137.  
  138. /* Mac OS X doesn't provide strndup :( */
  139. static char* my_strndup(const char *s, size_t n)
  140. {
  141.     size_t len = my_strnlen(s, n);
  142.     char* ret = malloc(len+1);
  143.     if (ret) {
  144.         memcpy(ret, s, len);
  145.         ret[len] = '\0';
  146.     }
  147.     return ret;
  148. }
  149.  
  150. #ifndef NDEBUG
  151. void hexdump(const void* data, int len)
  152. {
  153.     int i;
  154.     const unsigned char* bytes=data;
  155.     for (i=0; i<len; i++) {
  156.         printf("%02X ",bytes[i]);
  157.         if ((i+1)%16 == 0) printf("\n");
  158.     }
  159.     if (len%16) putchar('\n');
  160. }
  161.  
  162. #endif//NDEBUG
  163.  
  164. typedef enum {
  165.     PERCENT_START,
  166.     PERCENT_UPDATE,
  167.     PERCENT_END
  168. } percent_control_t;
  169.  
  170. /* Only use display_char!=0 to set non default progress chars like errors etc. */
  171. static
  172. void percent_display(percent_control_t percent_control, unsigned int percent, int display_char)
  173. {
  174.     static int point;
  175.     #define POINTS 20
  176.     #define DEFAULT_PROGRESS_CHAR '.'
  177.     static char chars[POINTS+1];
  178.  
  179.     switch (percent_control) {
  180.     case PERCENT_START: {
  181.         point=0;
  182.         fprintf(stderr, "[%*s]\r",POINTS,"");
  183.         memset(chars, ' ', POINTS);
  184.         *(chars+POINTS)='\0';
  185.         break;
  186.     }
  187.     case PERCENT_UPDATE: {
  188.         int newpoint=percent/(100/POINTS);
  189.         int i;
  190.         if (display_char && (display_char != DEFAULT_PROGRESS_CHAR))
  191.             for (i=point; i<=newpoint && i<POINTS; i++)
  192.                 chars[i]=display_char;
  193.         for (i=0; i<newpoint; i++)
  194.             if (chars[i] == ' ')
  195.                 chars[i] = DEFAULT_PROGRESS_CHAR;
  196.         fprintf(stderr, "\r[%s]",chars);
  197.         point=newpoint;
  198.         break;
  199.     }
  200.     case PERCENT_END: {
  201.         fprintf(stderr, "\r %*s \r",POINTS,"");
  202.         break;
  203.     }
  204.     }
  205.     fflush(stderr);
  206. }
  207.  
  208. /* Set access and modfied times of filename
  209.    to the specified broken down time */
  210. static int touch(const char* filename, struct tm* tm)
  211. {
  212.     time_t ut = mktime(tm);
  213.     struct timeval tv[2]={ {.tv_sec=ut, .tv_usec=0}, {.tv_sec=ut, .tv_usec=0} };
  214.     return utimes(filename, tv);
  215. }
  216.  
  217. typedef void (*process_func_t)(uint8_t* buf, unsigned int bs, void* context);
  218.  
  219. /*
  220.   Copy data between file descriptors while not
  221.   putting more than blocks*block_size in the system cache.
  222.   Therefore you will probably want to call this function repeatedly.
  223.  
  224.   I tested 3 methods for streaming large amounts of data to/from disk.
  225.   All 3 took the same time as the bottleneck is the reading and writing to disk.
  226.   On x86 at least there is no significant difference between the AUTO and ALLOC_ALIGN
  227.   methods, the latter of which allocates the userspace buffer aligned on a page.
  228.   There was a noticeable reduction in CPU usage when MMAP_WRITE was used,
  229.   but the CPU usage is insignificant anyway due to the disc speeds we will
  230.   generally be dealing with. I also noticed that the MMAP method was more stable
  231.   giving consistent timings in all benchmark runs. However to ease portability worries
  232.   I use the AUTO method below, which will also allow us to modify the MPEG frames if
  233.   required. For reference the timings for extracting a 338 MiB VOB
  234.   from a VRO on the same hard disk were:
  235.  
  236.       MMAP_WRITE
  237.         real    0m30.650s
  238.         user    0m0.007s
  239.         sys     0m1.130s
  240.       AUTO/ALLOC_ALIGN
  241.         real    0m31.776s
  242.         user    0m0.075s
  243.         sys     0m1.803s
  244.  */
  245.  
  246. static int stream_data(int src_fd, int dst_fd, uint32_t blocks, uint16_t block_size,
  247.                        process_func_t process_func, void* process_context)
  248. {
  249. #define AUTO
  250. #define BLOCKS_PER_OP 1
  251.  
  252. #if defined AUTO
  253.     uint8_t buf[block_size*BLOCKS_PER_OP];  /* Not page aligned by default */
  254. #elif defined ALLOC_ALIGN
  255.     /* There are portability issue with this.
  256.      * One may need to use MAP_ANONYMOUS rather than MAP_ANON.
  257.      * Also one may need to use MAP_FILE and operate on /dev/zero instead.
  258.      *
  259.      * Also see posix_memalign().
  260.      * Also see pagealign_alloc in gnulib.
  261.      */
  262.     static int8_t* buf;
  263.     if (!buf) {
  264.         buf = mmap(NULL,block_size*BLOCKS_PER_OP,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
  265.     }
  266.     if (buf == MAP_FAILED) {
  267.         fprintf(stderr, "Error: Failed allocating mmap aligned buf [%s]\n", strerror(errno));
  268.         exit(EXIT_FAILURE);
  269.     }
  270.     if ((size_t)buf & (sysconf(_SC_PAGE_SIZE)-1)) {
  271.         fprintf(stderr, "Warning: mmap buffer not aligned\n");
  272.     }
  273. #endif
  274.  
  275.  
  276.     unsigned int block;
  277.     for (block=0; block<blocks; block+=BLOCKS_PER_OP) {
  278.         int trans_blocks = MIN(blocks-block, BLOCKS_PER_OP);
  279.         int trans_size = trans_blocks * block_size;
  280.  
  281.         int bytes_read = read(src_fd, buf, trans_size);
  282.         if (bytes_read != trans_size) {
  283. #ifndef NDEBUG
  284.             if (bytes_read<0) /* otherwise file truncated */
  285.                 fprintf(stderr, "Error reading from SRC [%s]\n", strerror(errno));
  286. #endif //NDEBUG
  287.             return -1;
  288.         }
  289.         if (process_func) {
  290.             int pblock;
  291.             for (pblock=0; pblock<trans_blocks; pblock++) {
  292.                 process_func(buf+(pblock*block_size), block_size, process_context);
  293.             }
  294.         }
  295.         if (write(dst_fd, buf, trans_size) != trans_size) {
  296.             fprintf(stderr, "Error writing to DST [%s]\n", strerror(errno));
  297.             return -2;
  298.         }
  299.     }
  300.  
  301. #ifdef POSIX_FADV_DONTNEED
  302.     /* Don't fill cache with SRC.
  303.     Note be careful to invalidate only what we've written
  304.     so that we don't dump any readahead cache. */
  305.     uint32_t bytes = blocks * block_size;
  306.     off_t offset = lseek(src_fd, 0, SEEK_CUR);
  307.     /* Note src is already guaranteed seekable, but offset may
  308.      * be 0 for example if /dev/zero is specified for testing. */
  309.     if (offset >= bytes) {
  310.         int ret = posix_fadvise(src_fd, offset-bytes, bytes, POSIX_FADV_DONTNEED);
  311.         if (ret) {
  312.             fprintf(stderr, "Warning: posix_fadvise failed [%s]\n", strerror(ret));
  313.         }
  314.     }
  315.  
  316.     /* Don't fill cache with DST.
  317.     Note this slows the operation down by 20% when both source
  318.     and dest are on the same hard disk at least. I guess
  319.     this is due to implicit syncing in posix_fadvise()? */
  320.     offset = lseek(dst_fd, 0, SEEK_CUR);
  321.     if (offset != (off_t)-1) { /* seekable */
  322.         int ret = posix_fadvise(dst_fd, 0, 0, POSIX_FADV_DONTNEED);
  323.         if (ret) {
  324.             fprintf(stderr, "Warning: posix_fadvise failed [%s]\n", strerror(ret));
  325.         }
  326.     }
  327. #endif //POSIX_FADV_DONTNEED
  328.  
  329.    return 0;
  330. }
  331.  
  332. #ifdef MMAP_WRITE
  333. static int stream_data(int src_fd, int dst_fd, uint32_t blocks, uint16_t block_size)
  334. {
  335.     int8_t* buf;
  336.     off_t offset = lseek(src_fd, 0, SEEK_CUR);
  337.     off_t pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1); /* 4097 -> 4096 */
  338.     off_t offset_align = offset - pa_offset;;
  339.     buf = mmap(NULL, block_size*blocks+offset_align,
  340.                PROT_READ, MAP_PRIVATE, src_fd, pa_offset);
  341.     if (buf == MAP_FAILED) {
  342.         fprintf(stderr, "Error mmaping file [%s]\n", strerror(errno));
  343.         exit(EXIT_FAILURE);
  344.     }
  345. #ifdef MADV_SEQUENTIAL
  346.     if (madvise(buf, block_size*blocks+offset_align, MADV_SEQUENTIAL)) {
  347.         fprintf(stderr, "Warning: madvise failed [%s]\n", strerror(errno));
  348.     }
  349. #endif
  350.  
  351.     if (write(dst_fd,buf+offset_align,blocks*block_size) != blocks*block_size) {
  352.         fprintf(stderr, "Error writing to DST [%s]\n", strerror(errno));
  353.         return -2;
  354.     }
  355.     offset = lseek(src_fd, blocks*block_size, SEEK_CUR); /* This won't seek head I presume */
  356.     if (offset == (off_t)-1) {
  357.         fprintf(stderr, "Error seeking in src [%s]\n", strerror(errno));
  358.         exit(EXIT_FAILURE);
  359.     }
  360.  
  361. #ifdef MADV_DONTNEED
  362.     if (madvise(buf, blocks*block_size, MADV_DONTNEED)) {
  363.         fprintf(stderr, "Warning: madvise failed [%s]\n", strerror(errno));
  364.     }
  365. #endif
  366.  
  367.     return 0;
  368. }
  369. #endif //MMAP_WRITE
  370.  
  371. static const char* get_charset(void)
  372. {
  373.     const char* codeset = nl_langinfo(CODESET);
  374. #ifdef __CYGWIN__
  375.     /* Cygwin 1.5 does not support locales and nl_langinfo (CODESET)
  376.        always returns "US-ASCII". This is fixed in v1.7 I think?  */
  377.     if (codeset && STREQ(codeset, "US-ASCII")) {
  378.  
  379.         /* parse LANG=ja_JP.SJIS -> SJIS */
  380.         const char* locale = getenv ("LANG");
  381.         if (locale && *locale) {
  382.             const char *dot = strchr (locale, '.');
  383.  
  384.             if (dot) {
  385.                 const char *modifier;
  386.  
  387.                 dot++;
  388.                 if (!(modifier = strchr (dot, '@'))) {
  389.                     return dot;
  390.                 } else {
  391.                     static char buf[32];
  392.                     size_t len = modifier - dot;
  393.                     if (len < sizeof (buf)) {
  394.                         memcpy (buf, dot, len);
  395.                         *(buf+len) = '\0';
  396.                         return buf;
  397.                     }
  398.                 }
  399.             }
  400.         }
  401.         return "UTF-8";
  402.     }
  403. #endif
  404.     return codeset;
  405. }
  406.  
  407. static bool text_convert(const char *src, size_t srclen, char *dst, size_t dstlen)
  408. {
  409.     bool ret=false;
  410. #ifdef HAVE_ICONV
  411.     iconv_t cd = iconv_open (sys_charset, disc_charset);
  412.     if (cd != (iconv_t)-1) {
  413.         if (iconv (cd, (ICONV_CONST char**)&src, &srclen, &dst, &dstlen) != (size_t)-1) {
  414.             if (iconv (cd, NULL, NULL, &dst, &dstlen) != (size_t)-1) { /* terminate string */
  415.                 ret=true;
  416.             }
  417.         } else {
  418.             fprintf(stderr, "Error converting text from %s to %s\n",
  419.                     disc_charset, sys_charset);
  420.         }
  421.         iconv_close (cd);
  422.     } else {
  423.         fprintf(stderr, "Error converting text from %s to %s. Not supported\n",
  424.                 disc_charset, sys_charset);
  425.     }
  426. #else
  427.     /* avoid warnings (__attribute__ ((unused)) is too verbose/non standard) */
  428.     (void)src; (void)dst; (void)srclen; (void)dstlen;
  429.     fprintf(stderr, "Error converting text. libiconv missing\n");
  430. #endif
  431.     return ret;
  432. }
  433.  
  434. /*********************************************************************************
  435.  *                          Internal structures
  436.  *********************************************************************************/
  437.  
  438. typedef struct {
  439.     int aspect;
  440.     int width;
  441.     int height;
  442. } p_video_attr_t;
  443. p_video_attr_t* ifo_video_attrs;
  444.  
  445. typedef enum {
  446.     SCRAMBLED_UNSET=-1,
  447.     UNSCRAMBLED=0,
  448.     SCRAMBLED=1,
  449.     PARTIALLY_SCRAMBLED=2
  450. } scrambled_t;
  451.  
  452. typedef struct {
  453.     int video_attr;
  454.     scrambled_t scrambled;
  455. } p_program_attr_t;
  456. p_program_attr_t* ifo_program_attrs;
  457.  
  458. /*********************************************************************************
  459.  *                          The DVD-VR structures
  460.  *********************************************************************************/
  461.  
  462. #undef PACKED
  463. #if defined(__GNUC__)
  464. # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
  465. #  define PACKED __attribute__ ((packed))
  466. # endif
  467. #endif
  468. #if !defined(PACKED)
  469. # error "Your compiler doesn't support __attribute__ ((packed))"
  470. #endif
  471.  
  472. /* DVD structures are in network byte order (big endian) */
  473. #include <netinet/in.h>
  474. #undef NTOHS
  475. #undef NTOHL
  476. #define NTOHS(x) x=ntohs(x) /* 16 bit */
  477. #define NTOHL(x) x=ntohl(x) /* 32 bit */
  478.  
  479. #define DVD_SECTOR_SIZE 2048
  480.  
  481. typedef struct {
  482.     struct {
  483.         /* Suffix numbers are decimal offsets */
  484.         /* 0 */
  485.         char     id[12];
  486.         uint32_t vmg_ea;         /* end address */
  487.         uint8_t  zero_16[12];
  488.         uint32_t vmgi_ea;        /* includes playlist info after this structure */
  489.         uint16_t version;        /* specification version */
  490.         /* 34 */                 /* Different from DVD-Video from here */
  491.         uint8_t  zero_34[30];
  492.         uint8_t  data_64[3];
  493.         uint8_t  txt_encoding;   /* as per VideoTextDataUsage.pdf */
  494.         uint8_t  data_68[30];
  495.         /* 98 */
  496.         char     disc_info1[64]; /* format name, or copy of disc_info2. */
  497.         char     disc_info2[64]; /* format name, time or user label.. */
  498.         uint8_t  zero_226[30];
  499.         /* 256 */
  500.         uint32_t pgit_sa;        /* program info table start address */
  501.         uint32_t info_260_sa;    /* ? start address */
  502.         uint8_t  zero_264[3];
  503.         struct {
  504.             uint8_t supported;   /* Encrypted Title Key Status */
  505.             uint8_t title_key[8];/* This needs to be decrypted using media key */
  506.         } cprm;
  507.         uint8_t  zero_276[28];
  508.         /* 304 */
  509.         uint32_t def_psi_sa;     /* default program set info start address */
  510.         uint32_t info_308_sa;    /* ? start address */
  511.         uint32_t info_312_sa;    /* user defined program set info start address? */
  512.         uint32_t info_316_sa;    /* ? start address */
  513.         uint8_t  zero_320[32];
  514.         uint32_t txt_attr_sa;    /* extra attributes for programs (chan id etc.) */
  515.         uint32_t info_356_sa;    /* ? start address */
  516.         uint8_t  zero_360[152];
  517.     } PACKED mat;
  518. } PACKED rtav_vmgi_t; /*Real Time AV (from DVD_RTAV dir)*/
  519. STATIC_ASSERT(sizeof(rtav_vmgi_t) == 512,""); /* catch any miscounting above */
  520.  
  521. typedef struct {
  522.     uint8_t audio_attr[3];
  523. } PACKED audio_attr_t;
  524.  
  525. typedef struct {
  526.     uint8_t pgtm[5];
  527. } PACKED pgtm_t;
  528.  
  529. typedef struct {
  530.     uint32_t ptm;
  531.     uint16_t ptm_extra; /* extra to DSI pkts */
  532. } PACKED ptm_t;
  533.  
  534. typedef struct {
  535.     uint16_t vob_attr;
  536.     pgtm_t   vob_timestamp;
  537.     uint8_t  data1;
  538.     uint8_t  vob_format_id;
  539.     ptm_t    vob_v_s_ptm;
  540.     ptm_t    vob_v_e_ptm;
  541. } PACKED vvob_t; /* Virtual VOB */
  542. typedef struct {
  543.     uint8_t  data[12];
  544. } PACKED adj_vob_t;
  545. typedef struct {
  546.     uint16_t nr_of_time_info;
  547.     uint16_t nr_of_vobu_info;
  548.     uint16_t time_offset;
  549.     uint32_t vob_offset;
  550. } PACKED vobu_map_t;
  551. typedef struct {
  552.     uint8_t  data[7];
  553. } PACKED time_info_t;
  554. typedef struct {
  555.     uint8_t vobu_info[3];
  556. } PACKED vobu_info_t;
  557.  
  558. typedef struct {
  559.     uint16_t zero1;
  560.     uint8_t  nr_of_pgi;
  561.     uint8_t  nr_of_vob_formats;
  562.     uint32_t pgit_ea;
  563. } PACKED pgiti_t; /* info for ProGram Info Table */
  564.  
  565. typedef struct {
  566.     uint16_t video_attr;
  567.     uint8_t  nr_of_audio_streams;
  568.     uint8_t  data1;
  569.     audio_attr_t  audio_attr0;
  570.     audio_attr_t  audio_attr1;
  571.     uint8_t  data2[50];
  572. } PACKED vob_format_t;
  573.  
  574. typedef struct {
  575.     uint16_t nr_of_programs;
  576. } PACKED pgi_gi_t; /* global info for ProGram Info */
  577.  
  578. typedef struct  {
  579.     uint8_t  data1;
  580.     uint8_t  nr_of_psi;
  581.     uint16_t nr_of_programs;  /* Num programs on disc */
  582. } PACKED psi_gi_t; /* global info for Program Set Info */
  583.  
  584. typedef struct  {
  585.     uint8_t  data1;
  586.     uint8_t  data2;
  587.     uint16_t nr_of_programs;  /* Num programs in program set */
  588.     char     label[64];       /* ASCII. Might not be NUL terminated */
  589.     char     title[64];       /* Could be same as label, NUL, or another charset */
  590.     uint16_t prog_set_id;     /* On LG V1.1 discs this is program set ID */
  591.     uint16_t first_prog_id;   /* ID of first program in this program set */
  592.     char     data3[6];
  593. } PACKED psi_t;
  594.  
  595. static const char* parse_txt_encoding(uint8_t txt_encoding)
  596. {
  597. /* from the VideoTextDataUsage.pdf available at dvdforum.org we have:
  598.      01h : ISO 646
  599.      10h : JIS Roman[14]*and JIS Kanji1990[168]*
  600.      11h : ISO 8859-1
  601.      12h : JIS Roman[14]*and JIS Katakana[13]*including Shift JIS Kanji
  602.    Also Nero generates discs with 00h, so I'll assume this is ASCII.
  603. */
  604.  
  605.     const char* charset="Unknown";
  606.  
  607.     switch (txt_encoding) {
  608.     case 0x00: charset="ASCII"; break;
  609.     case 0x01: charset="ISO646-JP"; break; /* ?? */
  610.     case 0x10: charset="JIS_C6220-1969-RO"; break; /* ?? */
  611.     case 0x11: charset="ISO_8859-1"; break;
  612.     case 0x12: charset="SHIFT_JIS"; break;
  613.     }
  614.  
  615.     if (STREQ("Unknown", charset)) {
  616.         fprintf(stdinfo, "text encoding: %s", charset);
  617.         fprintf(stdinfo, ". (%02X). Please report this number and actual text encoding.\n", txt_encoding );
  618.         charset="ISO_8859-15"; /* Shouldn't give an error at least */
  619.     }
  620.  
  621.     return charset;
  622. }
  623.  
  624.  
  625. static bool parse_audio_attr(audio_attr_t audio_attr0)
  626. {
  627.     int coding   = (audio_attr0.audio_attr[0] & 0xE0)>>5;
  628.     int channels = (audio_attr0.audio_attr[1] & 0x0F);
  629.     /* audio_attr0.audio_attr[2] = 7 for my camcorder. Is this 192Kbit? */
  630.     /* audio_attr0.audio_attr[2] = 9 for Masato Nunokawa's disc? */
  631.  
  632.     if (channels < 8) {
  633.         fprintf(stdinfo, "audio_channs: %d\n",channels+1);
  634.     } else if (channels == 9) {
  635.         /* According to Masato Nunokawa's disc */
  636.         fprintf(stdinfo, "audio_channs: 2 (mono)\n");
  637.     } else {
  638.         return false;
  639.     }
  640.  
  641.     const char* coding_name="Unknown";
  642.     switch (coding) {
  643.     case 0: coding_name="Dolby AC-3"; break;
  644.     case 2: coding_name="MPEG-1"; break;
  645.     case 3: coding_name="MPEG-2ext"; break;
  646.     case 4: coding_name="Linear PCM"; break;
  647.     }
  648.     fprintf(stdinfo, "audio_coding: %s",coding_name);
  649.     if (STREQ("Unknown", coding_name)) {
  650.         fprintf(stdinfo, ". (%d). Please report this number and actual audio encoding.\n", coding );
  651.     } else {
  652.         putc('\n', stdinfo);
  653.     }
  654.  
  655.     return true;
  656. }
  657.  
  658. static bool parse_video_attr(uint16_t video_attr, p_video_attr_t* p_video_attr)
  659. {
  660.     int resolution  = (video_attr & 0x0038) >>  3;
  661.     int aspect      = (video_attr & 0x0C00) >> 10;
  662.     int tv_sys      = (video_attr & 0x3000) >> 12;
  663.     int compression = (video_attr & 0xC000) >> 14;
  664.  
  665.     p_video_attr->aspect = p_video_attr->width = p_video_attr->height = -1;
  666.  
  667.     int vert_resolution  = 0;
  668.     int horiz_resolution = 0;
  669.     const char* tv_system = "Unknown";
  670.     switch (tv_sys) {
  671.     case 0:
  672.         tv_system = "NTSC";
  673.         vert_resolution=480;
  674.         break;
  675.     case 1:
  676.         tv_system = "PAL";
  677.         vert_resolution=576;
  678.         break;
  679.     }
  680.     fprintf(stdinfo, "tv_system   : %s", tv_system);
  681.     if (STREQ("Unknown", tv_system)) {
  682.         fprintf(stdinfo, ". (%d). Please report this number and actual TV system.\n", tv_sys );
  683.     } else {
  684.         putc('\n', stdinfo);
  685.     }
  686.  
  687.     switch (resolution) {
  688.     case 0: horiz_resolution=720; break;
  689.     case 1: horiz_resolution=704; break;
  690.     case 2: horiz_resolution=352; break;
  691.     case 3: horiz_resolution=352; vert_resolution/=2; break;
  692.     case 4: horiz_resolution=544; break; /* this is a google inspired guess. */
  693.     case 5: horiz_resolution=480; break; /* from Aaron Binns' disc */
  694.     }
  695.     if (horiz_resolution && vert_resolution) {
  696.         fprintf(stdinfo, "resolution  : %dx%d\n", horiz_resolution, vert_resolution);
  697.         p_video_attr->width = horiz_resolution;
  698.         p_video_attr->height = vert_resolution;
  699.     } else if (!horiz_resolution) {
  700.         fprintf(stdinfo, "resolution  : Unknown (%d). Please report this number and actual resolution.\n", resolution );
  701.     }
  702.  
  703.     const char* aspect_ratio = "Unknown";
  704.     switch (aspect) {
  705.     case 0: aspect_ratio="4:3"; break;
  706.     case 1: aspect_ratio="16:9"; break;
  707.     }
  708.     fprintf(stdinfo, "aspect_ratio: %s", aspect_ratio );
  709.     if (STREQ("Unknown", aspect_ratio)) {
  710.         fprintf(stdinfo, ". (%d). Please report this number and actual aspect ratio.\n", aspect );
  711.     } else {
  712.         putc('\n', stdinfo);
  713.         p_video_attr->aspect = aspect + 2; /* DVD-Video aspect encoding */
  714.     }
  715.  
  716.     const char* mode = "Unknown";
  717.     switch (compression) {
  718.     case 0: mode="MPEG1"; break;
  719.     case 1: mode="MPEG2"; break;
  720.     }
  721.     fprintf(stdinfo, "video_format: %s", mode );
  722.     if (STREQ("Unknown", mode)) {
  723.         p_video_attr->aspect = -1; /* Don't adjust aspect later for unknown formats */
  724.         fprintf(stdinfo, ". (%d). Please report this number and actual compression format.\n", compression );
  725.     } else {
  726.         putc('\n', stdinfo);
  727.     }
  728.  
  729.     return true;
  730. }
  731.  
  732. static bool parse_pgtm(pgtm_t pgtm, struct tm* tm)
  733. {
  734.     bool ret=false;
  735.  
  736.     uint16_t year  = ((pgtm.pgtm[0]       ) <<8 | (pgtm.pgtm[1]     )) >> 2;
  737.     uint8_t  month =  (pgtm.pgtm[1] & 0x03) <<2 | (pgtm.pgtm[2] >> 6);
  738.     uint8_t  day   =  (pgtm.pgtm[2] & 0x3E) >>1;
  739.     uint8_t  hour  =  (pgtm.pgtm[2] & 0x01) <<4 | (pgtm.pgtm[3] >> 4);
  740.     uint8_t  min   =  (pgtm.pgtm[3] & 0x0F) <<2 | (pgtm.pgtm[4] >> 6);
  741.     uint8_t  sec   =  (pgtm.pgtm[4] & 0x3F);
  742.     if (year) {
  743.         tm->tm_year=year-1900;
  744.         tm->tm_mon=month-1;
  745.         tm->tm_mday=day;
  746.         tm->tm_hour=hour;
  747.         tm->tm_min=min;
  748.         tm->tm_sec=sec;
  749.         tm->tm_isdst=-1; /*Auto calc DST offset.*/
  750.  
  751.         char date_str[32];
  752.         strftime(date_str,sizeof(date_str),"%F %T",tm); //locale = %x %X
  753.         fprintf(stdinfo, "date : %s\n",date_str);
  754.         ret=true;
  755.     } else {
  756.         fprintf(stdinfo, "date : not set\n");
  757.     }
  758.     return ret;
  759. }
  760.  
  761. #ifndef NDEBUG
  762. /* This is basically a simplification of find_program_text_info() */
  763. static void print_psi(psi_gi_t* psi_gi)
  764. {
  765.     putc('\n', stdinfo);
  766.     int ps;
  767.     uint16_t program_count = 0;
  768.     for (ps=0; ps<psi_gi->nr_of_psi; ps++) {
  769.         psi_t *psi = (psi_t*)(((char*)(psi_gi+1)) + (ps * sizeof(psi_t)));
  770.  
  771.         uint16_t first_prog_num = ntohs(psi->first_prog_id); /* assuming this is first to play? */
  772.         uint16_t start_prog_num = program_count+1;
  773.         uint16_t num_progs_in_set = ntohs(psi->nr_of_programs);
  774.         program_count += num_progs_in_set;
  775.         fprintf(stdinfo, "Programs in Program set %d:", ps+1);
  776.         int program_id;
  777.         for (program_id = start_prog_num;
  778.              program_id < start_prog_num+num_progs_in_set;
  779.              program_id++) {
  780.             const char* fmt = (program_id==first_prog_num ? " (%d)" : " %d");
  781.             fprintf(stdinfo, fmt, program_id);
  782.         }
  783.         putc('\n', stdinfo);
  784.     }
  785.     putc('\n', stdinfo);
  786. }
  787. #endif//NDEBUG
  788.  
  789. /*
  790.  * FIXME: This assumes the programs occur linearly within
  791.  * the default program sets. This has been accurate for all
  792.  * discs I've seen so far at least. Note I've noticed a
  793.  * couple of "SONY_MOBILE" discs with no labels at all.
  794.  */
  795. static psi_t* find_program_text_info(psi_gi_t* psi_gi, int program)
  796. {
  797.     int ps;
  798.     uint16_t program_count = 0;
  799.     for (ps=0; ps<psi_gi->nr_of_psi; ps++) {
  800.         psi_t *psi = (psi_t*)(((char*)(psi_gi+1)) + (ps * sizeof(psi_t)));
  801.         uint16_t start_prog_num;
  802.         /*
  803.         start_prog_num = ntohs(psi->first_prog_id);
  804.  
  805.         We need to maintain program count as first_prog_id is often not stored,
  806.         as is the case for LG and "CIRRUS LOGIC" V1.1 discs for example (it's 0 or 0xFFFF).
  807.         Also I noticed a Sony disc that had programs sets with 2 programs in them, which
  808.         sometimes set the first_prog_id to the second program in the set.  Perhaps
  809.         this field identifies the prog to start playing, as the first program in those
  810.         sets was a single VOBU that was generated due to a split.
  811.         Perhaps I should name the programs label.ps_id(001) when > 1 ps. */
  812.         start_prog_num = program_count+1;
  813.         uint16_t num_progs_in_set = ntohs(psi->nr_of_programs);
  814.         /* TODO: Perhaps have an option to merge all programs
  815.            in a program set to a vob using this info. That would assume
  816.            though that the programs were adjacent. */
  817.         program_count += num_progs_in_set;
  818.         uint16_t end_prog_num = start_prog_num + num_progs_in_set - 1;
  819.         if ((program >= start_prog_num) && (program <= end_prog_num)) {
  820.             return psi;
  821.         }
  822.     }
  823.     return (psi_t*)NULL;
  824. }
  825.  
  826. /*
  827.  * This function controls the storage used by the actual
  828.  * encoding conversion routines. Note a len must be passed
  829.  * since the text fields are sometimes not NUL terminated.
  830.  *
  831.  * A string in the local encoding is returned which must be free()
  832.  */
  833. static char* text_field_convert(const char* field, unsigned int len)
  834. {
  835.     unsigned int conv_max_len=len*MB_LEN_MAX+1/*NUL*/;
  836.     char* field_local=malloc(conv_max_len);
  837.     if (!field_local) {
  838.         fprintf(stderr, "Error allocating space for text conversion\n");
  839.         return NULL;
  840.     }
  841.     if (*field) {
  842.         char field_copy[len+1]; /* Copy as may not be NUL terminated */
  843.         field_copy[len] = '\0';
  844.         (void) strncpy(field_copy, field, len);
  845.         size_t srclen = strlen(field_copy) + 1; /* convert NUL also */
  846.         if (!text_convert(field_copy, srclen, field_local, conv_max_len)) {
  847.             free(field_local);
  848.             field_local=NULL;
  849.         }
  850.     } else {
  851.         *field_local='\0';
  852.     }
  853.  
  854.     return field_local;
  855. }
  856.  
  857. /* Filter redundant info */
  858. static bool disc_info_redundant(const char* info)
  859. {
  860.     const char* info_exclude_list[] = {
  861.         "DVD VR",
  862.         "DVD-VR",
  863.         " ",
  864.         "" /* must be last */
  865.     };
  866.     const char** info_to_exclude = info_exclude_list;
  867.     while (**info_to_exclude) {
  868.         if (STREQ(info, *info_to_exclude)) {
  869.             return true;
  870.         }
  871.         info_to_exclude++;
  872.     }
  873.     return false;
  874. }
  875.  
  876. static void print_disc_info(rtav_vmgi_t* rtav_vmgi_ptr)
  877. {
  878.     char* txt_local;
  879.  
  880.     txt_local = text_field_convert(rtav_vmgi_ptr->mat.disc_info2,
  881.                                    sizeof(rtav_vmgi_ptr->mat.disc_info2));
  882.     if (txt_local && *txt_local && !disc_info_redundant(txt_local)) {
  883.         fprintf(stdinfo, "info  : %s\n", txt_local);
  884.     }
  885.     free(txt_local);
  886.  
  887.     if (strncmp(rtav_vmgi_ptr->mat.disc_info1,
  888.                 rtav_vmgi_ptr->mat.disc_info2,
  889.                 sizeof(rtav_vmgi_ptr->mat.disc_info1))) {
  890.         /* If there is a unique disc_info1 here, then there is
  891.          * no disc_info2 above on the discs I've seen so far */
  892.         txt_local = text_field_convert(rtav_vmgi_ptr->mat.disc_info1,
  893.                                     sizeof(rtav_vmgi_ptr->mat.disc_info1));
  894.         if (txt_local && *txt_local && !disc_info_redundant(txt_local)) {
  895.             fprintf(stdinfo, "info  : %s\n", txt_local);
  896.         }
  897.         free(txt_local);
  898.     }
  899. }
  900.  
  901. static char* mb_clean_name(const char* src)
  902. {
  903.     size_t src_size = strlen (src) + 1;
  904.     wchar_t *str_wc = NULL;
  905.     size_t src_chars = mbstowcs (NULL, src, 0);
  906.     if (src_chars == (size_t) -1)
  907.         return NULL;
  908.     src_chars += 1; /* make space for NUL */
  909.     str_wc = malloc (src_chars * sizeof (wchar_t));
  910.     if (str_wc == NULL)
  911.         return NULL;
  912.     if (mbstowcs (str_wc, src, src_chars) <= 0) {
  913.         free(str_wc);
  914.         return NULL;
  915.     }
  916.     str_wc[src_chars - 1] = L'\0';
  917.  
  918.     wchar_t* wc = str_wc;
  919.     while (*wc) {
  920.         size_t good = wcscspn(wc, L" /:?\\");
  921.         if (good)
  922.             wc+=good;
  923.         else
  924.             *wc++=L'-';
  925.     }
  926.  
  927.     char* newstr = malloc (src_size);
  928.     if (newstr == NULL) {
  929.         free(str_wc);
  930.         return NULL;
  931.     }
  932.     (void) wcstombs(newstr, str_wc, src_size);
  933.     free(str_wc);
  934.  
  935.     return newstr;
  936. }
  937.  
  938. /* Must pass a string on the heap which may be modified inplace,
  939.  * or may be reallocated. */
  940. static char* clean_name(char* src, bool mb_src)
  941. {
  942.     if (mb_src && (MB_CUR_MAX > 1)) {
  943.         char* cleaned = mb_clean_name(src);
  944.         free(src);
  945.         return cleaned;
  946.     }
  947.  
  948.     char* c = src;
  949.     while (*c) {
  950.         size_t good = strcspn(c, " /:?\\");
  951.         if (good)
  952.             c+=good;
  953.         else
  954.             *c++='-';
  955.     }
  956.     return src;
  957. }
  958.  
  959. static char* get_label_base(const psi_t* psi)
  960. {
  961.     char* title_local = text_field_convert(psi->title, sizeof(psi->title));
  962.     if (title_local && *title_local &&
  963.         strncmp(title_local, psi->label, sizeof(psi->label))) { /* if title != label */
  964.         title_local = clean_name(title_local, true);
  965.         if (!title_local) {
  966.           fprintf(stderr, "Error generating file name from title\n");
  967.           return NULL;
  968.         } else {
  969.           return title_local;
  970.         }
  971.     }
  972.     free(title_local);
  973.  
  974.     const char* label=psi->label; /* ASCII */
  975.     if (*label && !STREQ(label, " ")) {
  976.         char* label_local = my_strndup(label, sizeof(psi->label));
  977.         label_local = clean_name(label_local, false);
  978.         return label_local;
  979.     }
  980.  
  981.     return NULL;
  982. }
  983.  
  984. static void print_label(const psi_t* psi)
  985. {
  986.     const char* label=psi->label; /* ASCII */
  987.  
  988.     char* title_local = text_field_convert(psi->title, sizeof(psi->title));
  989.     if (title_local && *title_local &&
  990.         strncmp(title_local, label, sizeof(psi->label))) { /* if title != label */
  991.         fprintf(stdinfo, "title: %s\n", title_local);
  992.     }
  993.     free(title_local);
  994.  
  995.     if (*label && !STREQ(label, " ")) {
  996.         fprintf(stdinfo, "label: %.*s\n", (int)sizeof(psi->label), label);
  997.     }
  998. }
  999.  
  1000. /*********************************************************************************
  1001.  * MPEG2 processing routines
  1002.  *********************************************************************************/
  1003.  
  1004. /*
  1005. This is to both apply the aspect ratio from the IFO to the sequence header (0xB3)
  1006. and to reset the size of any sequence display extension packets (0xB5) to
  1007. the size of the video, as processing of this is not handled well by players.
  1008.  
  1009. For e.g., for 16:9 recordings my camcorder leaves the aspect in the sequence
  1010. header at 4:3 but sets the pan scan width and height appropriately in the
  1011. sequence display extension. ffmpeg for a short time used this to compute the
  1012. aspect, but because many MPEG streams incorrectly set the pan scan widths and
  1013. heights, it was changed back to ignoring these when determining the aspect ratio.
  1014. See: http://svn.ffmpeg.org/ffmpeg?view=rev&revision=15183
  1015. Specifically for widescreen PAL movies my DVD-VR camcorder set:
  1016.   aspect = 2 (4:3)
  1017.   width x height = 720 x 576
  1018.   pan scan width x height = 540 x 576
  1019. */
  1020.  
  1021. #define MPEG_HEADER_LEN 4
  1022. #define SEQUENCE_ID 0xB3
  1023. #define SEQUENCE_EXTENSION_ID 0xB5
  1024. #define VIDEO_STREAM_0 0xE0 /* I've only seen E0 on dvd-vr discs (E0-F possible) */
  1025. #define SEQUENCE_LEN 4 /* length of data we need to parse from sequence packet */
  1026. #define SEQUENCE_EXTENSION_LEN 5 /* length of data we need to parse from sequence extension packet */
  1027. #define VIDEO_STREAM_LEN 3 /* length of data we need to parse from video stream packet */
  1028.  
  1029. /* Return offset to header or -1 if not found */
  1030. static int find_mpeg_header(const uint8_t* buf, const unsigned int bs, const uint8_t type)
  1031. {
  1032.     unsigned int offset=0;
  1033.     uint32_t header = 0x00000100 + type;
  1034.     NTOHL(header);
  1035.     while (offset <= bs - sizeof (header)) {
  1036.         if (*(uint32_t*)(buf+offset) == header)
  1037.             return offset;
  1038.         offset++;
  1039.     }
  1040.     return -1;
  1041. }
  1042.  
  1043. static int sequence_offset;
  1044. static uint8_t sequence_aspect;
  1045.  
  1046. /* reset cached values for each program */
  1047. static void init_mpeg2_cache(void)
  1048. {
  1049.     sequence_offset = -1;
  1050.     sequence_aspect = -1;
  1051. }
  1052.  
  1053. static p_video_attr_t get_sequence_aspect(const uint8_t* buf)
  1054. {
  1055.     p_video_attr_t s_video_attr;
  1056.     s_video_attr.width = s_video_attr.height = -1;
  1057.     uint8_t aspect_byte = *(buf + sequence_offset + MPEG_HEADER_LEN + 3);
  1058.     s_video_attr.aspect = aspect_byte >> 4;
  1059.     return s_video_attr;
  1060. }
  1061.  
  1062. static void set_sequence_aspect(uint8_t* buf, const unsigned int offset, p_video_attr_t s_video_attr)
  1063. {
  1064.     uint8_t aspect_byte = *(buf + offset + MPEG_HEADER_LEN + 3);
  1065.     aspect_byte = (aspect_byte & 0x0F) | ((uint8_t) s_video_attr.aspect) << 4;
  1066.     *(buf + sequence_offset + MPEG_HEADER_LEN + 3) = aspect_byte;
  1067. }
  1068.  
  1069. static p_video_attr_t get_sequence_display_extension_sizes(const uint8_t* buf, const unsigned int offset)
  1070. {
  1071.     p_video_attr_t e_video_attr;
  1072.     e_video_attr.aspect=-1;
  1073.  
  1074.     uint8_t type = *(buf + offset + MPEG_HEADER_LEN);
  1075.     int skip_colour=(type&0x01) ? 3 : 0;
  1076.     const uint8_t* display_size = buf + offset + MPEG_HEADER_LEN + skip_colour + sizeof (type);
  1077.     uint16_t horiz_disp_size  = *(display_size) << 6;
  1078.             horiz_disp_size += *(display_size+1) >> 2;
  1079.     uint16_t vert_disp_size = (*(display_size+1) & 0x01) << 13;
  1080.             vert_disp_size += *(display_size+2) << 5;
  1081.             vert_disp_size += *(display_size+3) >> 3;
  1082.  
  1083.     e_video_attr.width = horiz_disp_size;
  1084.     e_video_attr.height = vert_disp_size;
  1085.  
  1086.     return e_video_attr;
  1087. }
  1088.  
  1089. static void set_sequence_display_extension_sizes(uint8_t* buf, const unsigned int offset, p_video_attr_t e_video_attr)
  1090. {
  1091.     uint16_t horiz_disp_size = e_video_attr.width;
  1092.     uint16_t vert_disp_size = e_video_attr.height;
  1093.  
  1094.     uint8_t type = *(buf + offset + MPEG_HEADER_LEN);
  1095.     int skip_colour=(type&0x01) ? 3 : 0;
  1096.     uint8_t* display_size = buf + offset + MPEG_HEADER_LEN + skip_colour + sizeof (type);
  1097.  
  1098.     /* One could precalc this per program, but frequency is low so not worth the effort */
  1099.     *(uint32_t*)display_size = htonl(0x00020000);
  1100.     *(display_size)   |= (horiz_disp_size >> 6);
  1101.     *(display_size+1) |= (horiz_disp_size << 2);
  1102.     *(display_size+1) |= ((vert_disp_size >> 13) & 0x01);
  1103.     *(display_size+2) |= (vert_disp_size >> 5);
  1104.     *(display_size+3) |= (vert_disp_size << 3);
  1105. }
  1106.  
  1107. static void check_mpeg_encryption(uint8_t* buf, const unsigned int bs, const unsigned int program)
  1108. {
  1109.     /* Note we'll warn below if we've not seen any video stream (E0 doesn't match).
  1110.      * Note also I've only seen AC-3 audio on 0xBD and it has also been
  1111.      * encrypted on discs I've seen.  */
  1112.     if (ifo_program_attrs[program].scrambled != PARTIALLY_SCRAMBLED) {
  1113.         int pes_offset = find_mpeg_header(buf, bs-VIDEO_STREAM_LEN, VIDEO_STREAM_0);
  1114.         if (pes_offset >= 0) {
  1115.             /* extension header is always available for 0xBD and 0xE? types */
  1116.             uint8_t scramble_byte = *(buf + pes_offset + MPEG_HEADER_LEN + 2);
  1117.             bool scrambled;
  1118.             if ((scramble_byte & 0xC0) == 0x80) { /* MPEG2 */
  1119.                 scrambled = scramble_byte & 0x30;
  1120.             } else {
  1121.                 scrambled = false; /* assuming MPEG1 doesn't support encryption */
  1122.             }
  1123.             if (ifo_program_attrs[program].scrambled != SCRAMBLED_UNSET &&
  1124.                 ifo_program_attrs[program].scrambled != scrambled) {
  1125.                 ifo_program_attrs[program].scrambled = PARTIALLY_SCRAMBLED;
  1126.             } else {
  1127.                 ifo_program_attrs[program].scrambled = scrambled;
  1128.             }
  1129.         }
  1130.     }
  1131. }
  1132.  
  1133. static void fix_mpeg2_aspect(uint8_t* buf, const unsigned int bs, const unsigned int program)
  1134. {
  1135.     static int sector;
  1136.     bool found_sequence_header = false;
  1137.     const bool look_harder = false; /* Should never need to be set to true as far as I can see */
  1138.  
  1139.     p_video_attr_t ifo_video_attr = ifo_video_attrs[ifo_program_attrs[program].video_attr];
  1140.     if (ifo_video_attr.aspect < 2) {
  1141.         sector++;
  1142.         return;
  1143.     }
  1144.  
  1145.     p_video_attr_t s_video_attr = { .aspect=ifo_video_attr.aspect, .width=-1, .height=-1 };
  1146.  
  1147.     if (sequence_offset == -1) {
  1148.         if ((sequence_offset = find_mpeg_header(buf, bs-SEQUENCE_LEN, SEQUENCE_ID)) >= 0) {
  1149.             found_sequence_header = true;
  1150. #ifndef NDEBUG
  1151.             fprintf(stdinfo,"Found SH  @ %d+%d\n", sector, sequence_offset);
  1152. #endif
  1153.             sequence_aspect = get_sequence_aspect(buf).aspect;
  1154.             if (sequence_aspect != ifo_video_attr.aspect) {
  1155.                 set_sequence_aspect(buf, sequence_offset, s_video_attr);
  1156.             }
  1157.         }
  1158.     } else {
  1159.         if (find_mpeg_header(buf+sequence_offset, MPEG_HEADER_LEN, SEQUENCE_ID)==0) {
  1160.             found_sequence_header = true;
  1161. #ifndef NDEBUG
  1162.             fprintf(stdinfo,"Found SH  @ %d+%d\n", sector, sequence_offset);
  1163. #endif
  1164.             if (sequence_aspect!=ifo_video_attr.aspect)
  1165.                 set_sequence_aspect(buf, sequence_offset, s_video_attr);
  1166.         } else if (look_harder) {
  1167.         /* I can't see why the sequence headers would be at arbitrary offsets in each sector,
  1168.          * and I've analyzed about 10 different VROs and they all have the same offsets.
  1169.          * So I think that doing this will only redundantly scan every byte of sectors
  1170.          * without sequence headers. */
  1171.             int curr_offset = find_mpeg_header(buf, bs-SEQUENCE_LEN, SEQUENCE_ID);
  1172.             if (curr_offset >= 0) {
  1173.                 found_sequence_header = true;
  1174.                 sequence_offset = curr_offset;
  1175. #ifndef NDEBUG
  1176.                 fprintf(stdinfo,"Found SH @ %d+%d\n", sector, sequence_offset);
  1177. #endif
  1178.                 set_sequence_aspect(buf, sequence_offset, s_video_attr);
  1179.             } else {
  1180.             }
  1181.         }
  1182.     }
  1183.  
  1184.     /* As an optimization, only look for sequence display extension, if there
  1185.      * is a sequence header in this sector. */
  1186.     if (found_sequence_header || look_harder) {
  1187.         if (ifo_video_attr.width <= 0 || ifo_video_attr.height <= 0) {
  1188.             sector++;
  1189.             return;
  1190.         }
  1191.         int extension_offset = look_harder ? 0 : sequence_offset + MPEG_HEADER_LEN + SEQUENCE_LEN;
  1192.         int next_offset;
  1193.         while ((next_offset = find_mpeg_header(buf + extension_offset,
  1194.                                                bs - extension_offset - SEQUENCE_EXTENSION_LEN,
  1195.                                                SEQUENCE_EXTENSION_ID)) >= 0) {
  1196.             extension_offset += next_offset;
  1197.             uint8_t type = *(buf + extension_offset + MPEG_HEADER_LEN);
  1198.             if ((type&0xF0) == 0x20) {
  1199.                 p_video_attr_t e_video_attr = get_sequence_display_extension_sizes(buf, extension_offset);
  1200. #ifndef NDEBUG
  1201.                 fprintf(stdinfo, "Found SDE @ %d+%d (%d x %d)\n", sector, extension_offset, e_video_attr.width, e_video_attr.height);
  1202. #endif
  1203.                 e_video_attr.width = ifo_video_attr.width;
  1204.                 e_video_attr.height = ifo_video_attr.height;
  1205.                 set_sequence_display_extension_sizes(buf, extension_offset, e_video_attr);
  1206. #ifndef NDEBUG
  1207.                 e_video_attr = get_sequence_display_extension_sizes(buf, extension_offset);
  1208.                 fprintf(stdinfo, "New   SDE @ %d+%d (%d x %d)\n", sector, extension_offset, e_video_attr.width, e_video_attr.height);
  1209. #endif
  1210.                 break; /* Should be only 1 of these per sector */
  1211.             } else {
  1212. #ifndef NDEBUG
  1213.                 fprintf(stdinfo, "Found SE  @ %d+%d (type=%d)\n", sector, extension_offset, (type&0xF0)>>4);
  1214. #endif
  1215.             }
  1216.             extension_offset++;
  1217.         }
  1218.     }
  1219.  
  1220.     sector++;
  1221. }
  1222.  
  1223. /* Haven't had a request to do this yet:
  1224.    http://forum.doom9.org/archive/index.php/t-102969.html
  1225.    Note code there makes incorrect assumptions about offsets I think.  */
  1226. static void add_mpeg_nav(uint8_t* buf, const unsigned int bs)
  1227. {
  1228.     (void) buf; (void) bs;
  1229. }
  1230.  
  1231. void process_mpeg2(uint8_t* buf, const unsigned int bs, void* program)
  1232. {
  1233.     fix_mpeg2_aspect(buf, bs, *(const unsigned int*)program);
  1234.     add_mpeg_nav(buf, bs);
  1235.     check_mpeg_encryption(buf, bs, *(const unsigned int*)program);
  1236. }
  1237.  
  1238. /*********************************************************************************
  1239.  *
  1240.  *********************************************************************************/
  1241.  
  1242. unsigned long required_program=0; /* process all programs by default */
  1243. const char* ifo_name=NULL;
  1244. const char* vro_name=NULL;
  1245.  
  1246. static void usage(char** argv, int error)
  1247. {
  1248.     FILE* where = error==EXIT_FAILURE ? stderr : stdout;
  1249.  
  1250.     fprintf(where, "Usage: %s [OPTION]... VR_MANGR.IFO [VR_MOVIE.VRO]\n"
  1251.                    "Print info about and optionally extract vob data from DVD-VR files.\n"
  1252.                    "\n"
  1253.                    "If the VRO file is specified, the component programs are\n"
  1254.                    "extracted to the current directory or to stdout.\n"
  1255.                    "\n"
  1256.                    "  -p, --program=NUM  Only process program NUM rather than all programs.\n"
  1257.                    "\n"
  1258.                    "  -n, --name=NAME    Specify a basename to use for extracted vob files\n"
  1259.                    "                     rather than using one based on the timestamp.\n"
  1260.                    "                     If you pass `-' the vob files will be written to stdout.\n"
  1261.                    "                     If you pass `[label]' the names will be based on\n"
  1262.                    "                     a sanitized version of the title or label.\n"
  1263.                    "\n"
  1264.                    "      --help         Display this help and exit.\n"
  1265.                    "      --version      Output version information and exit.\n"
  1266.                    ,argv[0]);
  1267.     exit(error);
  1268. }
  1269.  
  1270. static void get_options(int argc, char** argv)
  1271. {
  1272.     static struct option const longopts[] =
  1273.     {
  1274.         /* I'm using capitals for long options
  1275.          * without a corresponding short option. */
  1276.         {"program", required_argument, NULL, 'p'},
  1277.         {"name", required_argument, NULL, 'n'},
  1278.         {"help", no_argument, NULL, 'H'},
  1279.         {"version", no_argument, NULL, 'V'},
  1280.         {NULL, 0, NULL, 0}
  1281.     };
  1282.  
  1283.     int opt;
  1284.     while ((opt = getopt_long(argc, argv, "p:n:", longopts, NULL)) != -1) {
  1285.         switch (opt) {
  1286.         case 'p': {
  1287.             char* trailing;
  1288.             required_program = strtoul(optarg, &trailing, 10);
  1289.             if (*trailing) {
  1290.                 usage(argv, EXIT_FAILURE);
  1291.             }
  1292.             break;
  1293.         }
  1294.         case 'n':
  1295.             base_name = optarg;
  1296.             break;
  1297.         case 'V':
  1298.             printf("dvd-vr "VERSION);
  1299.             printf("\n\nWritten by Pádraig Brady <P@draigBrady.com>\n");
  1300.             exit(EXIT_SUCCESS);
  1301.             break;
  1302.         case 'H':
  1303.             usage(argv, EXIT_SUCCESS);
  1304.             break;
  1305.         default: /* '?',':' */
  1306.             usage(argv, EXIT_FAILURE);
  1307.             break;
  1308.         }
  1309.     }
  1310.     if (optind >= argc ||   /* no files specified */
  1311.         argc > optind+2) {  /* too many files specified */
  1312.         usage(argv, EXIT_FAILURE);
  1313.     }
  1314.  
  1315.     ifo_name=argv[optind++];
  1316.  
  1317.     if (optind < argc) {
  1318.         vro_name=argv[optind++];
  1319.     }
  1320.  
  1321.     if (!STREQ(base_name, TIMESTAMP_FMT) && !vro_name) {
  1322.         usage(argv, EXIT_FAILURE);
  1323.     }
  1324. }
  1325.  
  1326. int main(int argc, char** argv)
  1327. {
  1328.     setlocale(LC_ALL,"");
  1329.     sys_charset=get_charset();
  1330.  
  1331.     get_options(argc, argv);
  1332.  
  1333.     if (STREQ(base_name, "-")) {
  1334.         stdinfo = stderr;
  1335.     } else {
  1336.         stdinfo = stdout; /* allow users to grep metadata etc. */
  1337.     }
  1338.  
  1339.     int fd=open(ifo_name,O_RDONLY);
  1340.     if (fd == -1) {
  1341.         fprintf(stderr, "Error opening [%s] (%s)\n", ifo_name, strerror(errno));
  1342.         exit(EXIT_FAILURE);
  1343.     }
  1344.  
  1345.     rtav_vmgi_t* rtav_vmgi_ptr=mmap(0,sizeof(rtav_vmgi_t),PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);
  1346.     if (rtav_vmgi_ptr == MAP_FAILED) {
  1347.         fprintf(stderr, "Failed to MMAP ifo file (%s)\n", strerror(errno));
  1348.         exit(EXIT_FAILURE);
  1349.     }
  1350.     if (strncmp("DVD_RTR_VMG0",rtav_vmgi_ptr->mat.id,sizeof(rtav_vmgi_ptr->mat.id))) {
  1351.         fprintf(stderr, "invalid DVD-VR IFO identifier\n");
  1352.         exit(EXIT_FAILURE);
  1353.     }
  1354.  
  1355.     uint32_t vmg_size = NTOHL(rtav_vmgi_ptr->mat.vmg_ea) + 1;
  1356.     if (munmap(rtav_vmgi_ptr, sizeof(rtav_vmgi_t)) !=0) {
  1357.         fprintf(stderr, "Failed to unmap ifo file (%s)\n", strerror(errno));
  1358.         exit(EXIT_FAILURE);
  1359.     }
  1360.     rtav_vmgi_ptr=mmap(0,vmg_size,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);
  1361.     if (rtav_vmgi_ptr == MAP_FAILED) {
  1362.         fprintf(stderr, "Failed to re MMAP ifo file (%s)\n", strerror(errno));
  1363.         exit(EXIT_FAILURE);
  1364.     }
  1365.  
  1366.     int vro_fd=-1;
  1367.     if (vro_name) {
  1368.         vro_fd=open(vro_name,O_RDONLY);
  1369.         if (vro_fd == -1) {
  1370.             fprintf(stderr, "Error opening [%s] (%s)\n", vro_name, strerror(errno));
  1371.             exit(EXIT_FAILURE);
  1372.         }
  1373. #ifdef POSIX_FADV_SEQUENTIAL
  1374.         posix_fadvise(vro_fd, 0, 0, POSIX_FADV_SEQUENTIAL);/* More readahead done */
  1375. #endif //POSIX_FADV_SEQUENTIAL
  1376.     }
  1377.  
  1378.     NTOHS(rtav_vmgi_ptr->mat.version);
  1379.     rtav_vmgi_ptr->mat.version &= 0x00FF;
  1380.     fprintf(stdinfo, "format: DVD-VR V%d.%d\n",
  1381.             rtav_vmgi_ptr->mat.version>>4,rtav_vmgi_ptr->mat.version&0x0F);
  1382.     if (rtav_vmgi_ptr->mat.cprm.supported) {
  1383.         fprintf(stdinfo, "Encryption: CPRM supported\n");
  1384.         /* Note programs may not actually be encrypted.
  1385.          * That's indicated per AV pack in 2 PES scrambling control bits */
  1386.     }
  1387.  
  1388.     disc_charset=parse_txt_encoding(rtav_vmgi_ptr->mat.txt_encoding);
  1389.  
  1390.     print_disc_info(rtav_vmgi_ptr);
  1391.  
  1392.     NTOHL(rtav_vmgi_ptr->mat.pgit_sa);
  1393.     pgiti_t* pgiti = (pgiti_t*) ((char*)rtav_vmgi_ptr + rtav_vmgi_ptr->mat.pgit_sa);
  1394.     NTOHL(pgiti->pgit_ea);
  1395.  
  1396.     NTOHL(rtav_vmgi_ptr->mat.def_psi_sa);
  1397.     psi_gi_t *def_psi_gi = (psi_gi_t*) ((char*)rtav_vmgi_ptr + rtav_vmgi_ptr->mat.def_psi_sa);
  1398.  
  1399. #ifndef NDEBUG
  1400.     NTOHS(def_psi_gi->nr_of_programs);
  1401.     if ((def_psi_gi->nr_of_psi > 1) && (def_psi_gi->nr_of_psi != def_psi_gi->nr_of_programs)) {
  1402.         print_psi(def_psi_gi);
  1403.     }
  1404.     fprintf(stdinfo, "Number of info tables for VRO: %d\n",pgiti->nr_of_pgi);
  1405.     fprintf(stdinfo, "Number of vob formats: %d\n",pgiti->nr_of_vob_formats);
  1406.     fprintf(stdinfo, "pgit_ea: %08"PRIX32"\n",pgiti->pgit_ea);
  1407. #endif//NDEBUG
  1408.  
  1409.     if (pgiti->nr_of_pgi == 0) {
  1410.         fprintf(stderr, "Error: couldn't find info table for VRO\n");
  1411.         exit(EXIT_FAILURE);
  1412.     }
  1413.     if (pgiti->nr_of_pgi > 1) {
  1414.         fprintf(stderr, "Warning: Only processing 1 of the %"PRIu8" VRO info tables\n",
  1415.                 pgiti->nr_of_pgi);
  1416.     }
  1417.  
  1418.     vob_format_t* vob_format = (vob_format_t*) (pgiti+1);
  1419.     int vob_type;
  1420.     int vob_types=pgiti->nr_of_vob_formats;
  1421.     ifo_video_attrs=malloc(vob_types * sizeof(p_video_attr_t));
  1422.     if (!ifo_video_attrs) {
  1423.         fprintf(stderr, "Error allocating space for video type attributes\n");
  1424.         exit(EXIT_FAILURE);
  1425.     }
  1426.     for (vob_type=0; vob_type<vob_types; vob_type++) {
  1427.         putc('\n', stdinfo);
  1428.         if (vob_types>1) {
  1429.             fprintf(stdinfo, "VOB format %d...\n",vob_type+1);
  1430.         }
  1431.         NTOHS(vob_format->video_attr);
  1432.         if (!parse_video_attr(vob_format->video_attr, &ifo_video_attrs[vob_type])) {
  1433.             fprintf(stderr, "Error parsing video_attr\n");
  1434.         }
  1435.         if (!parse_audio_attr(vob_format->audio_attr0)) {
  1436.             fprintf(stderr, "Error parsing audio_attr0\n");
  1437.         }
  1438.         vob_format++;
  1439.     }
  1440.  
  1441.     pgi_gi_t* pgi_gi = (pgi_gi_t*) vob_format;
  1442.     NTOHS(pgi_gi->nr_of_programs);
  1443.     fprintf(stdinfo, "\nNumber of programs: %d\n", pgi_gi->nr_of_programs);
  1444.     if (required_program && required_program>pgi_gi->nr_of_programs) {
  1445.         fprintf(stderr, "Error: couldn't find specified program (%lu)\n", required_program);
  1446.         exit(EXIT_FAILURE);
  1447.     }
  1448.     ifo_program_attrs=malloc(pgi_gi->nr_of_programs * sizeof(p_program_attr_t));
  1449.     if (!ifo_program_attrs) {
  1450.         fprintf(stderr, "Error allocating space for program attributes\n");
  1451.         exit(EXIT_FAILURE);
  1452.     }
  1453.  
  1454.     struct tm now_tm;
  1455.     time_t now=time(0);
  1456.     (void) gmtime_r(&now, &now_tm);//used if no timestamp in program
  1457.     unsigned int program;
  1458.     typedef uint32_t vvobi_sa_t;
  1459.     vvobi_sa_t* vvobi_sa=(vvobi_sa_t*)(pgi_gi+1);
  1460.     for (program=0; program<pgi_gi->nr_of_programs; program++) {
  1461.  
  1462.         if (required_program && program+1!=required_program) {
  1463.             vvobi_sa++;
  1464.             continue;
  1465.         }
  1466.  
  1467.         NTOHL(*vvobi_sa);
  1468.  
  1469.         putc('\n', stdinfo);
  1470.         fprintf(stdinfo, "num  : %d\n", program+1);
  1471.  
  1472.         psi_t* psi=find_program_text_info(def_psi_gi, program+1);
  1473.         if (psi) {
  1474.             print_label(psi);
  1475.         } else {
  1476.             fprintf(stdinfo, "label: Couldn't find. Please report.\n");
  1477.         }
  1478.  
  1479. #ifndef NDEBUG
  1480.         fprintf(stdinfo, "VVOB info (%d) address: %"PRIu32"\n",program+1,*vvobi_sa);
  1481. #endif//NDEBUG
  1482.         vvob_t* vvob = (vvob_t*) (((uint8_t*)pgiti) + *vvobi_sa);
  1483.         struct tm tm;
  1484.         bool ts_ok = parse_pgtm(vvob->vob_timestamp,&tm);
  1485.         char vob_base[(sizeof(psi->title)*MB_LEN_MAX)+4/*#123*/+1/*NUL*/];
  1486.         if (STREQ(base_name, TIMESTAMP_FMT)) { //use timestamp to give unique filename
  1487.             if (ts_ok) {
  1488.                 strftime(vob_base,sizeof(vob_base),TIMESTAMP_FMT,&tm);
  1489.             } else { //use now + program num to give unique name
  1490.                 strftime(vob_base,sizeof(vob_base),TIMESTAMP_FMT,&now_tm);
  1491.                 int datelen=strlen(vob_base);
  1492.                 (void) snprintf(vob_base+datelen, sizeof(vob_base)-datelen, "#%03d", program+1);
  1493.             }
  1494.         } else if (STREQ(base_name, "[label]")) { //use the label to generate filename
  1495.             if (!psi) {
  1496.                 fprintf(stderr, "Error: Couldn't generate name based on label\n");
  1497.                 exit(EXIT_FAILURE);
  1498.             }
  1499.             char* label_base = get_label_base(psi);
  1500.             if (!label_base) {
  1501.                 fprintf(stderr, "Error: Couldn't generate name based on empty label\n");
  1502.                 exit(EXIT_FAILURE);
  1503.             }
  1504.             unsigned int ret = snprintf(vob_base, sizeof(vob_base), "%s#%03d", label_base, program+1);
  1505.             if (ret >= sizeof(vob_base)) { /* Shouldn't happen.  */
  1506.                 fprintf(stderr, "Error: label is too long\n");
  1507.                 exit(EXIT_FAILURE);
  1508.             }
  1509.             free(label_base);
  1510.         } else {
  1511.             unsigned int ret = snprintf(vob_base, sizeof(vob_base), "%s#%03d", base_name, program+1);
  1512.             if (ret >= sizeof(vob_base)) {
  1513.                 fprintf(stderr, "Error: Specified basename is too long (>%zu)\n", sizeof(vob_base)-4);
  1514.                 exit(EXIT_FAILURE);
  1515.             }
  1516.         }
  1517.  
  1518.         int vob_fd=-1;
  1519.         char vob_name[sizeof(vob_base)+4];
  1520.         if (vro_fd!=-1) {
  1521.             if (STREQ(base_name, "-")) {
  1522.                 vob_fd=fileno(stdout);
  1523.             } else {
  1524.                 (void) snprintf(vob_name,sizeof(vob_name),"%s.vob",vob_base);
  1525.                 vob_fd=open(vob_name,O_WRONLY|O_CREAT|O_EXCL,0666);
  1526.                 if (vob_fd == -1 && errno == EEXIST && STREQ(base_name, TIMESTAMP_FMT)) {
  1527.                     /* JVC DVD recorder can generate duplicate timestamps at least :( */
  1528.                     /* FIXME: The second time ripping a disc will duplicate the first VOB with duplicate timestamp.
  1529.                     * Would need to scan all program info first and change format if any duplicate timestamps. */
  1530.                     (void) snprintf(vob_name,sizeof(vob_name),"%s#%03d.vob",vob_base, program+1);
  1531.                     vob_fd=open(vob_name,O_WRONLY|O_CREAT|O_EXCL,0666);
  1532.                 }
  1533.             }
  1534.             if (vob_fd == -1) {
  1535.                 fprintf(stderr, "Error opening [%s] (%s)\n", vob_name, strerror(errno));
  1536.                 vvobi_sa++;
  1537.                 continue;
  1538.             }
  1539.         }
  1540.  
  1541.         if (vob_types>1) {
  1542.             fprintf(stdinfo, "vob format: %d\n", vvob->vob_format_id);
  1543.         }
  1544.         ifo_program_attrs[program].video_attr = vvob->vob_format_id-1;
  1545.         ifo_program_attrs[program].scrambled = SCRAMBLED_UNSET;
  1546.  
  1547.         NTOHS(vvob->vob_attr);
  1548.         int skip=0;
  1549.         if (vvob->vob_attr & 0x80) {
  1550.             skip+=sizeof(adj_vob_t);
  1551. #ifndef NDEBUG
  1552.             fprintf(stdinfo, "skipping adjacent VOB info\n");
  1553. #endif//NDEBUG
  1554.         }
  1555.         skip+=sizeof(uint16_t); /* ?? */
  1556.         vobu_map_t* vobu_map = (vobu_map_t*) (((uint8_t*)(vvob+1)) + skip);
  1557.         NTOHS(vobu_map->nr_of_time_info);
  1558.         NTOHS(vobu_map->nr_of_vobu_info);
  1559.         NTOHS(vobu_map->time_offset);
  1560.         NTOHL(vobu_map->vob_offset);
  1561. #ifndef NDEBUG
  1562.         fprintf(stdinfo, "num time infos:   %"PRIu16"\n",vobu_map->nr_of_time_info);
  1563.         fprintf(stdinfo, "num VOBUs: %"PRIu16"\n",vobu_map->nr_of_vobu_info);
  1564.         fprintf(stdinfo, "time offset:      %"PRIu16"\n",vobu_map->time_offset); /* What units? */
  1565.         fprintf(stdinfo, "vob offset:     %"PRIu32"*%d\n",vobu_map->vob_offset,DVD_SECTOR_SIZE);  /* offset in the VRO file of the VOB */
  1566. #endif//NDEBUG
  1567.         off_t vob_offset = vobu_map->vob_offset;
  1568.         if (vob_offset > OFF_T_MAX / DVD_SECTOR_SIZE)
  1569.         {
  1570.             fprintf(stderr, "Overflow in extracting VOB at offset %"PRIu32"*%d\n",vobu_map->vob_offset,DVD_SECTOR_SIZE);
  1571.             exit(EXIT_FAILURE);
  1572.         }
  1573.         vob_offset *= DVD_SECTOR_SIZE;
  1574.         if (vro_fd!=-1) {
  1575.             if (lseek(vro_fd, vob_offset, SEEK_SET)==(off_t)-1) {
  1576.                 fprintf(stderr, "Error seeking within VRO [%s]\n", strerror(errno));
  1577.                 exit(EXIT_FAILURE);
  1578.             }
  1579.         }
  1580.         vobu_info_t* vobu_info = (vobu_info_t*) (((uint8_t*)(vobu_map+1)) + vobu_map->nr_of_time_info*sizeof(time_info_t));
  1581.         int vobus;
  1582.         uint64_t tot=0;
  1583.         int display_char;
  1584.         bool processed_some_video = false;
  1585.         int error=0;
  1586.         if (vro_fd != -1) {
  1587.             percent_display(PERCENT_START, 0, 0);
  1588.             init_mpeg2_cache();
  1589.         }
  1590.         for (vobus=0; vobus<vobu_map->nr_of_vobu_info; vobus++) {
  1591.             uint16_t vobu_size = *(uint16_t*)(&vobu_info->vobu_info[1]);
  1592.             NTOHS(vobu_size); vobu_size&=0x03FF;
  1593.             if (vro_fd != -1) {
  1594.                 off_t curr_offset = lseek(vro_fd, 0, SEEK_CUR);
  1595.                 if (curr_offset == (off_t)-1) {
  1596.                     fprintf(stderr, "Error determining VRO offset [%s]\n", strerror(errno));
  1597.                     exit(EXIT_FAILURE);
  1598.                 }
  1599.                 int ret = stream_data(vro_fd, vob_fd, vobu_size, DVD_SECTOR_SIZE, process_mpeg2, &program);
  1600.                 if (ret == -2) { /* write error */
  1601.                     exit(EXIT_FAILURE);
  1602.                 } else if (ret == -1) { /* read error */
  1603.                     display_char='X';
  1604.                     error=1;
  1605.                     off_t new_offset = lseek(vro_fd, 0, SEEK_CUR);
  1606.                     if (new_offset == (off_t)-1) {
  1607.                         fprintf(stderr, "Error determining VRO offset [%s]\n", strerror(errno));
  1608.                         exit(EXIT_FAILURE);
  1609.                     }
  1610.                     off_t skip_len = (curr_offset + vobu_size*DVD_SECTOR_SIZE) - new_offset;
  1611.                     if (skip_len) {
  1612. #ifndef NDEBUG
  1613.                         fprintf(stderr, "Warning: Skipping %"PRIdMAX" bytes\n", skip_len);
  1614.                         /* Note we mark the whole VOBU as bad not just this skip len */
  1615. #endif//NDEBUG
  1616.                         if (lseek(vro_fd, skip_len, SEEK_CUR) == (off_t)-1) {
  1617.                             fprintf(stderr, "Error skipping in VRO [%s]\n", strerror(errno));
  1618.                             exit(EXIT_FAILURE);
  1619.                         }
  1620.                     }
  1621.                 } else if (ifo_program_attrs[program].scrambled == SCRAMBLED ||
  1622.                            ifo_program_attrs[program].scrambled == PARTIALLY_SCRAMBLED) {
  1623.                     display_char='E';
  1624.                     processed_some_video = true;
  1625.                 } else {
  1626.                     display_char=0; /* default */
  1627.                     processed_some_video = true;
  1628.                 }
  1629.  
  1630.                 int percent=((vobus+1)*100)/vobu_map->nr_of_vobu_info;
  1631.                 percent_display(PERCENT_UPDATE, percent, display_char);
  1632.             }
  1633.             tot+=vobu_size;
  1634.             vobu_info++;
  1635.         }
  1636.         if (vro_fd != -1) {
  1637.             if (!error) {
  1638.                 percent_display(PERCENT_END, 0, 0);
  1639.             } else {
  1640.                 /* Leave the percent display showing read errors */
  1641.                 putc('\n', stderr);
  1642.             }
  1643.             if (vob_fd != fileno(stdout)) {
  1644.                 close(vob_fd);
  1645.                 touch(vob_name, &tm);
  1646.             }
  1647.         }
  1648.  
  1649.         fprintf(stdinfo, "size : %'"PRIu64"\n",tot*DVD_SECTOR_SIZE);
  1650.  
  1651.         if (ifo_program_attrs[program].scrambled == SCRAMBLED) {
  1652.             fprintf(stderr, "Warning: program is encrypted\n");
  1653.         } else if (ifo_program_attrs[program].scrambled == PARTIALLY_SCRAMBLED) {
  1654.             fprintf(stderr, "Warning: program is partially encrypted\n");
  1655.         } else if (ifo_program_attrs[program].scrambled == SCRAMBLED_UNSET && processed_some_video) {
  1656.             fprintf(stderr, "Warning: didn't detect a video stream, please report\n");
  1657.             fprintf(stderr, "  (preferably with a sample vob file)\n");
  1658.         }
  1659.  
  1660.         vvobi_sa++;
  1661.     }
  1662.  
  1663.     free(ifo_program_attrs);
  1664.     free(ifo_video_attrs);
  1665.     munmap(rtav_vmgi_ptr, vmg_size);
  1666.     close(fd);
  1667.     if (vro_fd != -1)
  1668.         close(vro_fd);
  1669.  
  1670.     return EXIT_SUCCESS;
  1671. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!