dialog: use new API
[vlc.git] / modules / access / vdr.c
1 /*****************************************************************************
2  * vdr.c: VDR recordings access plugin
3  *****************************************************************************
4  * Copyright (C) 2010 Tobias G√ľntner
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as published by
8  * the Free Software Foundation; either version 2.1 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
19  *****************************************************************************/
20
21 /***
22 VDR splits recordings into multiple files and stores each recording in a
23 separate directory. If VLC opens a normal directory, the filesystem module
24 will add all files to the playlist. If, however, VLC opens a VDR recording,
25 this module will join all files within that directory and provide a single
26 continuous stream instead.
27
28 VDR recordings have either of two directory layouts:
29     1) PES format:
30         /path/to/0000-00-00.00.00.00.00.rec/
31             001.vdr, 002.vdr, 003.vdr, ...
32             index.vdr, info.vdr, marks.vdr, ...
33     2) TS format:
34         /path/to/0000-00-00.00.00.0-0.rec/
35             00001.ts, 00002.ts, 00003.ts, ...
36             index, info, marks, ...
37 See http://www.vdr-wiki.de/ and http://www.tvdr.de/ for more information.
38 ***/
39
40 /*****************************************************************************
41  * Preamble
42  *****************************************************************************/
43
44 #ifdef HAVE_CONFIG_H
45 # include "config.h"
46 #endif
47
48 #include <sys/types.h>
49 #include <sys/stat.h>
50 #include <fcntl.h>
51 #include <unistd.h>
52
53 #include <ctype.h>
54 #include <time.h>
55 #include <errno.h>
56
57 #include <vlc_common.h>
58 #include <vlc_plugin.h>
59 #include <vlc_access.h>
60 #include <vlc_input.h>
61 #include <vlc_fs.h>
62 #include <vlc_charset.h>
63 #include <vlc_dialog.h>
64 #include <vlc_configuration.h>
65
66 /*****************************************************************************
67  * Module descriptor
68  *****************************************************************************/
69 static int  Open ( vlc_object_t * );
70 static void Close( vlc_object_t * );
71
72 #define HELP_TEXT N_("Support for VDR recordings (http://www.tvdr.de/).")
73
74 #define CHAPTER_OFFSET_TEXT N_("Chapter offset in ms")
75 #define CHAPTER_OFFSET_LONGTEXT N_( \
76     "Move all chapters. This value should be set in milliseconds." )
77
78 #define FPS_TEXT N_("Frame rate")
79 #define FPS_LONGTEXT N_( \
80     "Default frame rate for chapter import." )
81
82 vlc_module_begin ()
83     set_category( CAT_INPUT )
84     set_shortname( N_("VDR") )
85     set_help( HELP_TEXT )
86     set_subcategory( SUBCAT_INPUT_ACCESS )
87     set_description( N_("VDR recordings") )
88     add_integer( "vdr-chapter-offset", 0,
89         CHAPTER_OFFSET_TEXT, CHAPTER_OFFSET_LONGTEXT, true )
90     add_float_with_range( "vdr-fps", 25, 1, 1000,
91         FPS_TEXT, FPS_LONGTEXT, true )
92     set_capability( "access", 60 )
93     add_shortcut( "vdr" )
94     add_shortcut( "directory" )
95     add_shortcut( "dir" )
96     add_shortcut( "file" )
97     set_callbacks( Open, Close )
98 vlc_module_end ()
99
100 /*****************************************************************************
101  * Local prototypes, constants, structures
102  *****************************************************************************/
103
104 /* minimum chapter size in seconds */
105 #define MIN_CHAPTER_SIZE 5
106
107 TYPEDEF_ARRAY( uint64_t, size_array_t );
108
109 struct access_sys_t
110 {
111     /* file sizes of all parts */
112     size_array_t file_sizes;
113     uint64_t offset;
114     uint64_t size; /* total size */
115
116     /* index and fd of current open file */
117     unsigned i_current_file;
118     int fd;
119
120     /* meta data */
121     vlc_meta_t *p_meta;
122
123     /* cut marks */
124     input_title_t *p_marks;
125     uint64_t *offsets;
126     unsigned cur_seekpoint;
127     float fps;
128
129     /* file format: true=TS, false=PES */
130     bool b_ts_format;
131 };
132
133 #define CURRENT_FILE_SIZE ARRAY_VAL(p_sys->file_sizes, p_sys->i_current_file)
134 #define FILE_SIZE(pos)    ARRAY_VAL(p_sys->file_sizes, pos)
135 #define FILE_COUNT        (unsigned)p_sys->file_sizes.i_size
136
137 static int Control( access_t *, int, va_list );
138 static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len );
139 static int Seek( access_t *p_access, uint64_t i_pos);
140 static void FindSeekpoint( access_t *p_access );
141 static bool ScanDirectory( access_t *p_access );
142 static char *GetFilePath( access_t *p_access, unsigned i_file );
143 static bool ImportNextFile( access_t *p_access );
144 static bool SwitchFile( access_t *p_access, unsigned i_file );
145 static void OptimizeForRead( int fd );
146 static void UpdateFileSize( access_t *p_access );
147 static FILE *OpenRelativeFile( access_t *p_access, const char *psz_file );
148 static bool ReadLine( char **ppsz_line, size_t *pi_size, FILE *p_file );
149 static void ImportMeta( access_t *p_access );
150 static void ImportMarks( access_t *p_access );
151 static bool ReadIndexRecord( FILE *p_file, bool b_ts, int64_t i_frame,
152                             uint64_t *pi_offset, uint16_t *pi_file_num );
153 static int64_t ParseFrameNumber( const char *psz_line, float fps );
154 static const char *BaseName( const char *psz_path );
155
156 /*****************************************************************************
157  * Open a directory
158  *****************************************************************************/
159 static int Open( vlc_object_t *p_this )
160 {
161     access_t *p_access = (access_t*)p_this;
162
163     if( !p_access->psz_filepath )
164         return VLC_EGENERIC;
165
166     /* Some tests can be skipped if this module was explicitly requested.
167      * That way, the user can play "corrupt" recordings if necessary
168      * and we can avoid false positives in the general case. */
169     bool b_strict = strcmp( p_access->psz_access, "vdr" );
170
171     /* Do a quick test based on the directory name to see if this
172      * directory might contain a VDR recording. We can be reasonably
173      * sure if ScanDirectory() actually finds files. */
174     if( b_strict )
175     {
176         char psz_extension[4];
177         int i_length = 0;
178         const char *psz_name = BaseName( p_access->psz_filepath );
179         if( sscanf( psz_name, "%*u-%*u-%*u.%*u.%*u.%*u%*[-.]%*u.%3s%n",
180             psz_extension, &i_length ) != 1 || strcasecmp( psz_extension, "rec" ) ||
181             ( psz_name[i_length] != DIR_SEP_CHAR && psz_name[i_length] != '\0' ) )
182             return VLC_EGENERIC;
183     }
184
185     /* Only directories can be recordings */
186     struct stat st;
187     if( vlc_stat( p_access->psz_filepath, &st ) ||
188         !S_ISDIR( st.st_mode ) )
189         return VLC_EGENERIC;
190
191     access_sys_t *p_sys;
192     STANDARD_READ_ACCESS_INIT;
193     p_sys->fd = -1;
194     p_sys->cur_seekpoint = 0;
195     p_sys->fps = var_InheritFloat( p_access, "vdr-fps" );
196     ARRAY_INIT( p_sys->file_sizes );
197
198     /* Import all files and prepare playback. */
199     if( !ScanDirectory( p_access ) ||
200         !SwitchFile( p_access, 0 ) )
201     {
202         Close( p_this );
203         return VLC_EGENERIC;
204     }
205
206     return VLC_SUCCESS;
207 }
208
209 /*****************************************************************************
210  * Close files and free resources
211  *****************************************************************************/
212 static void Close( vlc_object_t * p_this )
213 {
214     access_t *p_access = (access_t*)p_this;
215     access_sys_t *p_sys = p_access->p_sys;
216
217     if( p_sys->fd != -1 )
218         close( p_sys->fd );
219     ARRAY_RESET( p_sys->file_sizes );
220
221     if( p_sys->p_meta )
222         vlc_meta_Delete( p_sys->p_meta );
223
224     size_t count = p_sys->p_marks->i_seekpoint;
225     TAB_CLEAN( count, p_sys->offsets );
226     vlc_input_title_Delete( p_sys->p_marks );
227     free( p_sys );
228 }
229
230 /*****************************************************************************
231  * Determine format and import files
232  *****************************************************************************/
233 static bool ScanDirectory( access_t *p_access )
234 {
235     access_sys_t *p_sys = p_access->p_sys;
236
237     /* find first part and determine directory format */
238     p_sys->b_ts_format = true;
239     if( !ImportNextFile( p_access ) )
240     {
241         p_sys->b_ts_format = !p_sys->b_ts_format;
242         if( !ImportNextFile( p_access ) )
243             return false;
244     }
245
246     /* get all remaining parts */
247     while( ImportNextFile( p_access ) )
248         continue;
249
250     /* import meta data etc. */
251     ImportMeta( p_access );
252
253     /* cut marks depend on meta data and file sizes */
254     ImportMarks( p_access );
255
256     return true;
257 }
258
259 /*****************************************************************************
260  * Control input stream
261  *****************************************************************************/
262 static int Control( access_t *p_access, int i_query, va_list args )
263 {
264     access_sys_t *p_sys = p_access->p_sys;
265     input_title_t ***ppp_title;
266     int i;
267     int64_t *pi64;
268     vlc_meta_t *p_meta;
269
270     switch( i_query )
271     {
272         case ACCESS_CAN_SEEK:
273         case ACCESS_CAN_FASTSEEK:
274         case ACCESS_CAN_PAUSE:
275         case ACCESS_CAN_CONTROL_PACE:
276             *va_arg( args, bool* ) = true;
277             break;
278
279         case ACCESS_GET_SIZE:
280             *va_arg( args, uint64_t* ) = p_sys->size;
281             break;
282
283         case ACCESS_GET_PTS_DELAY:
284             pi64 = va_arg( args, int64_t * );
285             *pi64 = INT64_C(1000)
286                   * var_InheritInteger( p_access, "file-caching" );
287             break;
288
289         case ACCESS_SET_PAUSE_STATE:
290             /* nothing to do */
291             break;
292
293         case ACCESS_GET_TITLE_INFO:
294             /* return a copy of our seek points */
295             if( !p_sys->p_marks )
296                 return VLC_EGENERIC;
297             ppp_title = va_arg( args, input_title_t*** );
298             *va_arg( args, int* ) = 1;
299             *ppp_title = malloc( sizeof( **ppp_title ) );
300             if( !*ppp_title )
301                 return VLC_ENOMEM;
302             **ppp_title = vlc_input_title_Duplicate( p_sys->p_marks );
303             break;
304
305         case ACCESS_GET_TITLE:
306             *va_arg( args, unsigned * ) = 0;
307             break;
308
309         case ACCESS_GET_SEEKPOINT:
310             *va_arg( args, unsigned * ) = p_sys->cur_seekpoint;
311             break;
312
313         case ACCESS_GET_CONTENT_TYPE:
314             *va_arg( args, char ** ) =
315                 strdup( p_sys->b_ts_format ? "video/MP2T" : "video/MP2P" );
316             break;
317
318         case ACCESS_SET_TITLE:
319             /* ignore - only one title */
320             break;
321
322         case ACCESS_SET_SEEKPOINT:
323             i = va_arg( args, int );
324             return Seek( p_access, p_sys->offsets[i] );
325
326         case ACCESS_GET_META:
327             p_meta = va_arg( args, vlc_meta_t* );
328             vlc_meta_Merge( p_meta, p_sys->p_meta );
329             break;
330
331         default:
332             return VLC_EGENERIC;
333     }
334     return VLC_SUCCESS;
335 }
336
337 /*****************************************************************************
338  * Read and concatenate files
339  *****************************************************************************/
340 static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len )
341 {
342     access_sys_t *p_sys = p_access->p_sys;
343
344     if( p_sys->fd == -1 )
345     {
346         /* no more data */
347         p_access->info.b_eof = true;
348         return 0;
349     }
350
351     ssize_t i_ret = read( p_sys->fd, p_buffer, i_len );
352
353     if( i_ret > 0 )
354     {
355         /* success */
356         p_sys->offset += i_ret;
357         UpdateFileSize( p_access );
358         FindSeekpoint( p_access );
359         return i_ret;
360     }
361     else if( i_ret == 0 )
362     {
363         /* check for new files in case the recording is still active */
364         if( p_sys->i_current_file >= FILE_COUNT - 1 )
365             ImportNextFile( p_access );
366         /* play next file */
367         SwitchFile( p_access, p_sys->i_current_file + 1 );
368         return -1;
369     }
370     else if( errno == EINTR )
371     {
372         /* try again later */
373         return -1;
374     }
375     else
376     {
377         /* abort on read error */
378         msg_Err( p_access, "failed to read (%s)", vlc_strerror_c(errno) );
379         vlc_dialog_display_error( p_access, _("File reading failed"),
380             _("VLC could not read the file (%s)."),
381             vlc_strerror(errno) );
382         SwitchFile( p_access, -1 );
383         return 0;
384     }
385 }
386
387 /*****************************************************************************
388  * Seek to a specific location in a file
389  *****************************************************************************/
390 static int Seek( access_t *p_access, uint64_t i_pos )
391 {
392     access_sys_t *p_sys = p_access->p_sys;
393
394     /* might happen if called by ACCESS_SET_SEEKPOINT */
395     i_pos = __MIN( i_pos, p_sys->size );
396
397     p_sys->offset = i_pos;
398     p_access->info.b_eof = false;
399
400     /* find correct chapter */
401     FindSeekpoint( p_access );
402
403     /* find correct file */
404     unsigned i_file = 0;
405     while( i_file < FILE_COUNT - 1 &&
406            i_pos >= FILE_SIZE( i_file ) )
407     {
408         i_pos -= FILE_SIZE( i_file );
409         i_file++;
410     }
411     if( !SwitchFile( p_access, i_file ) )
412         return VLC_EGENERIC;
413
414     /* adjust position within that file */
415     return lseek( p_sys->fd, i_pos, SEEK_SET ) != -1 ?
416         VLC_SUCCESS : VLC_EGENERIC;
417 }
418
419 /*****************************************************************************
420  * Change the chapter index to match the current position
421  *****************************************************************************/
422 static void FindSeekpoint( access_t *p_access )
423 {
424     access_sys_t *p_sys = p_access->p_sys;
425     if( !p_sys->p_marks )
426         return;
427
428     int new_seekpoint = p_sys->cur_seekpoint;
429     if( p_sys->offset < p_sys->offsets[p_sys->cur_seekpoint] )
430     {
431         /* i_pos moved backwards, start fresh */
432         new_seekpoint = 0;
433     }
434
435     /* only need to check the following seekpoints */
436     while( new_seekpoint + 1 < p_sys->p_marks->i_seekpoint &&
437         p_sys->offset >= p_sys->offsets[new_seekpoint + 1] )
438     {
439         new_seekpoint++;
440     }
441
442     p_sys->cur_seekpoint = new_seekpoint;
443 }
444
445 /*****************************************************************************
446  * Returns the path of a certain part
447  *****************************************************************************/
448 static char *GetFilePath( access_t *p_access, unsigned i_file )
449 {
450     char *psz_path;
451     if( asprintf( &psz_path, p_access->p_sys->b_ts_format ?
452         "%s" DIR_SEP "%05u.ts" : "%s" DIR_SEP "%03u.vdr",
453         p_access->psz_filepath, i_file + 1 ) == -1 )
454         return NULL;
455     else
456         return psz_path;
457 }
458
459 /*****************************************************************************
460  * Check if another part exists and import it
461  *****************************************************************************/
462 static bool ImportNextFile( access_t *p_access )
463 {
464     access_sys_t *p_sys = p_access->p_sys;
465
466     char *psz_path = GetFilePath( p_access, FILE_COUNT );
467     if( !psz_path )
468         return false;
469
470     struct stat st;
471     if( vlc_stat( psz_path, &st ) )
472     {
473         msg_Dbg( p_access, "could not stat %s: %s", psz_path,
474                  vlc_strerror_c(errno) );
475         free( psz_path );
476         return false;
477     }
478     if( !S_ISREG( st.st_mode ) )
479     {
480         msg_Dbg( p_access, "%s is not a regular file", psz_path );
481         free( psz_path );
482         return false;
483     }
484     msg_Dbg( p_access, "%s exists", psz_path );
485     free( psz_path );
486
487     ARRAY_APPEND( p_sys->file_sizes, st.st_size );
488     p_sys->size += st.st_size;
489
490     return true;
491 }
492
493 /*****************************************************************************
494  * Close the current file and open another
495  *****************************************************************************/
496 static bool SwitchFile( access_t *p_access, unsigned i_file )
497 {
498     access_sys_t *p_sys = p_access->p_sys;
499
500     /* requested file already open? */
501     if( p_sys->fd != -1 && p_sys->i_current_file == i_file )
502         return true;
503
504     /* close old file */
505     if( p_sys->fd != -1 )
506     {
507         close( p_sys->fd );
508         p_sys->fd = -1;
509     }
510
511     /* switch */
512     if( i_file >= FILE_COUNT )
513         return false;
514     p_sys->i_current_file = i_file;
515
516     /* open new file */
517     char *psz_path = GetFilePath( p_access, i_file );
518     if( !psz_path )
519         return false;
520     p_sys->fd = vlc_open( psz_path, O_RDONLY );
521
522     if( p_sys->fd == -1 )
523     {
524         msg_Err( p_access, "Failed to open %s: %s", psz_path,
525                  vlc_strerror_c(errno) );
526         goto error;
527     }
528
529     /* cannot handle anything except normal files */
530     struct stat st;
531     if( fstat( p_sys->fd, &st ) || !S_ISREG( st.st_mode ) )
532     {
533         msg_Err( p_access, "%s is not a regular file", psz_path );
534         goto error;
535     }
536
537     OptimizeForRead( p_sys->fd );
538
539     msg_Dbg( p_access, "opened %s", psz_path );
540     free( psz_path );
541     return true;
542
543 error:
544     vlc_dialog_display_error (p_access, _("File reading failed"), _("VLC could not"
545         " open the file \"%s\" (%s)."), psz_path, vlc_strerror(errno) );
546     if( p_sys->fd != -1 )
547     {
548         close( p_sys->fd );
549         p_sys->fd = -1;
550     }
551     free( psz_path );
552     return false;
553 }
554
555 /*****************************************************************************
556  * Some tweaks to speed up read()
557  *****************************************************************************/
558 static void OptimizeForRead( int fd )
559 {
560     /* cf. Open() in file access module */
561     VLC_UNUSED(fd);
562 #ifdef HAVE_POSIX_FADVISE
563     posix_fadvise( fd, 0, 4096, POSIX_FADV_WILLNEED );
564     posix_fadvise( fd, 0, 0, POSIX_FADV_NOREUSE );
565 #endif
566 #ifdef F_RDAHEAD
567     fcntl( fd, F_RDAHEAD, 1 );
568 #endif
569 #ifdef F_NOCACHE
570     fcntl( fd, F_NOCACHE, 0 );
571 #endif
572 }
573
574 /*****************************************************************************
575  * Fix size if the (last) part is still growing
576  *****************************************************************************/
577 static void UpdateFileSize( access_t *p_access )
578 {
579     access_sys_t *p_sys = p_access->p_sys;
580     struct stat st;
581
582     if( p_sys->size >= p_sys->offset )
583         return;
584
585     /* TODO: not sure if this can happen or what to do in this case */
586     if( fstat( p_sys->fd, &st ) )
587         return;
588     if( (uint64_t)st.st_size <= CURRENT_FILE_SIZE )
589         return;
590
591     p_sys->size -= CURRENT_FILE_SIZE;
592     CURRENT_FILE_SIZE = st.st_size;
593     p_sys->size += CURRENT_FILE_SIZE;
594 }
595
596 /*****************************************************************************
597  * Open file relative to base directory for reading.
598  *****************************************************************************/
599 static FILE *OpenRelativeFile( access_t *p_access, const char *psz_file )
600 {
601     /* build path and add extension */
602     char *psz_path;
603     if( asprintf( &psz_path, "%s" DIR_SEP "%s%s",
604         p_access->psz_filepath, psz_file,
605         p_access->p_sys->b_ts_format ? "" : ".vdr" ) == -1 )
606         return NULL;
607
608     FILE *file = vlc_fopen( psz_path, "rb" );
609     if( !file )
610         msg_Warn( p_access, "Failed to open %s: %s", psz_path,
611                   vlc_strerror_c(errno) );
612     free( psz_path );
613
614     return file;
615 }
616
617 /*****************************************************************************
618  * Read a line of text. Returns false on error or EOF.
619  *****************************************************************************/
620 static bool ReadLine( char **ppsz_line, size_t *pi_size, FILE *p_file )
621 {
622     ssize_t read = getline( ppsz_line, pi_size, p_file );
623
624     if( read == -1 )
625     {
626         /* automatically free buffer on eof */
627         free( *ppsz_line );
628         *ppsz_line = NULL;
629         return false;
630     }
631
632     if( read > 0 && (*ppsz_line)[ read - 1 ] == '\n' )
633         (*ppsz_line)[ read - 1 ] = '\0';
634     EnsureUTF8( *ppsz_line );
635
636     return true;
637 }
638
639 /*****************************************************************************
640  * Import meta data
641  *****************************************************************************/
642 static void ImportMeta( access_t *p_access )
643 {
644     access_sys_t *p_sys = p_access->p_sys;
645
646     FILE *infofile = OpenRelativeFile( p_access, "info" );
647     if( !infofile )
648         return;
649
650     vlc_meta_t *p_meta = vlc_meta_New();
651     p_sys->p_meta = p_meta;
652     if( !p_meta )
653     {
654         fclose( infofile );
655         return;
656     }
657
658     char *line = NULL;
659     size_t line_len;
660     char *psz_title = NULL, *psz_smalltext = NULL, *psz_date = NULL;
661
662     while( ReadLine( &line, &line_len, infofile ) )
663     {
664         if( !isalpha( (unsigned char)line[0] ) || line[1] != ' ' )
665             continue;
666
667         char tag = line[0];
668         char *text = line + 2;
669
670         if( tag == 'C' )
671         {
672             char *psz_name = strchr( text, ' ' );
673             if( psz_name )
674             {
675                 *psz_name = '\0';
676                 vlc_meta_AddExtra( p_meta, "Channel", psz_name + 1 );
677             }
678             vlc_meta_AddExtra( p_meta, "Transponder", text );
679         }
680
681         else if( tag == 'E' )
682         {
683             unsigned i_id, i_start, i_length;
684             if( sscanf( text, "%u %u %u", &i_id, &i_start, &i_length ) == 3 )
685             {
686                 char str[50];
687                 struct tm tm;
688                 time_t start = i_start;
689                 localtime_r( &start, &tm );
690
691                 /* TODO: locale */
692                 strftime( str, sizeof(str), "%Y-%m-%d %H:%M", &tm );
693                 vlc_meta_AddExtra( p_meta, "Date", str );
694                 free( psz_date );
695                 psz_date = strdup( str );
696
697                 /* display in minutes */
698                 i_length = ( i_length + 59 ) / 60;
699                 snprintf( str, sizeof(str), "%u:%02u", i_length / 60, i_length % 60 );
700                 vlc_meta_AddExtra( p_meta, "Duration", str );
701             }
702         }
703
704         else if( tag == 'T' )
705         {
706             free( psz_title );
707             psz_title = strdup( text );
708             vlc_meta_AddExtra( p_meta, "Title", text );
709         }
710
711         else if( tag == 'S' )
712         {
713             free( psz_smalltext );
714             psz_smalltext = strdup( text );
715             vlc_meta_AddExtra( p_meta, "Info", text );
716         }
717
718         else if( tag == 'D' )
719         {
720             for( char *p = text; *p; ++p )
721             {
722                 if( *p == '|' )
723                     *p = '\n';
724             }
725             vlc_meta_SetDescription( p_meta, text );
726         }
727
728         /* FPS are required to convert between timestamps and frames */
729         else if( tag == 'F' )
730         {
731             float fps = atof( text );
732             if( fps >= 1 )
733                 p_sys->fps = fps;
734             vlc_meta_AddExtra( p_meta, "Frame Rate", text );
735         }
736
737         else if( tag == 'P' )
738         {
739             vlc_meta_AddExtra( p_meta, "Priority", text );
740         }
741
742         else if( tag == 'L' )
743         {
744             vlc_meta_AddExtra( p_meta, "Lifetime", text );
745         }
746     }
747
748     /* create a meaningful title */
749     int i_len = 10 +
750         ( psz_title ? strlen( psz_title ) : 0 ) +
751         ( psz_smalltext ? strlen( psz_smalltext ) : 0 ) +
752         ( psz_date ? strlen( psz_date ) : 0 );
753     char *psz_display = malloc( i_len );
754
755     if( psz_display )
756     {
757         *psz_display = '\0';
758         if( psz_title )
759             strcat( psz_display, psz_title );
760         if( psz_title && psz_smalltext )
761             strcat( psz_display, " - " );
762         if( psz_smalltext )
763             strcat( psz_display, psz_smalltext );
764         if( ( psz_title || psz_smalltext ) && psz_date )
765         {
766             strcat( psz_display, " (" );
767             strcat( psz_display, psz_date );
768             strcat( psz_display, ")" );
769         }
770         if( *psz_display )
771             vlc_meta_SetTitle( p_meta, psz_display );
772     }
773
774     free( psz_display );
775     free( psz_title );
776     free( psz_smalltext );
777     free( psz_date );
778
779     fclose( infofile );
780 }
781
782 /*****************************************************************************
783  * Import cut marks and convert them to seekpoints (chapters).
784  *****************************************************************************/
785 static void ImportMarks( access_t *p_access )
786 {
787     access_sys_t *p_sys = p_access->p_sys;
788
789     FILE *marksfile = OpenRelativeFile( p_access, "marks" );
790     if( !marksfile )
791         return;
792
793     FILE *indexfile = OpenRelativeFile( p_access, "index" );
794     if( !indexfile )
795     {
796         fclose( marksfile );
797         return;
798     }
799
800     /* get the length of this recording (index stores 8 bytes per frame) */
801     struct stat st;
802     if( fstat( fileno( indexfile ), &st ) )
803     {
804         fclose( marksfile );
805         fclose( indexfile );
806         return;
807     }
808     int64_t i_frame_count = st.st_size / 8;
809
810     /* Put all cut marks in a "dummy" title */
811     input_title_t *p_marks = vlc_input_title_New();
812     if( !p_marks )
813     {
814         fclose( marksfile );
815         fclose( indexfile );
816         return;
817     }
818     p_marks->psz_name = strdup( _("VDR Cut Marks") );
819     p_marks->i_length = i_frame_count * (int64_t)( CLOCK_FREQ / p_sys->fps );
820
821     uint64_t *offsetv = NULL;
822     size_t offsetc = 0;
823
824     /* offset for chapter positions */
825     int i_chapter_offset = p_sys->fps / 1000 *
826         var_InheritInteger( p_access, "vdr-chapter-offset" );
827
828     /* minimum chapter size in frames */
829     int i_min_chapter_size = p_sys->fps * MIN_CHAPTER_SIZE;
830
831     /* the last chapter started at this frame (init to 0 so
832      * we skip useless chapters near the beginning as well) */
833     int64_t i_prev_chapter = 0;
834
835     /* parse lines of the form "0:00:00.00 foobar" */
836     char *line = NULL;
837     size_t line_len;
838     while( ReadLine( &line, &line_len, marksfile ) )
839     {
840         int64_t i_frame = ParseFrameNumber( line, p_sys->fps );
841
842         /* skip chapters which are near the end or too close to each other */
843         if( i_frame - i_prev_chapter < i_min_chapter_size ||
844             i_frame >= i_frame_count - i_min_chapter_size )
845             continue;
846         i_prev_chapter = i_frame;
847
848         /* move chapters (simple workaround for inaccurate cut marks) */
849         if( i_frame > -i_chapter_offset )
850             i_frame += i_chapter_offset;
851         else
852             i_frame = 0;
853
854         uint64_t i_offset;
855         uint16_t i_file_number;
856         if( !ReadIndexRecord( indexfile, p_sys->b_ts_format,
857             i_frame, &i_offset, &i_file_number ) )
858             continue;
859         if( i_file_number < 1 || i_file_number > FILE_COUNT )
860             continue;
861
862         /* add file sizes to get the "global" offset */
863         seekpoint_t *sp = vlc_seekpoint_New();
864         if( !sp )
865             continue;
866         sp->i_time_offset = i_frame * (int64_t)( CLOCK_FREQ / p_sys->fps );
867         sp->psz_name = strdup( line );
868
869         TAB_APPEND( p_marks->i_seekpoint, p_marks->seekpoint, sp );
870         TAB_APPEND( offsetc, offsetv, i_offset );
871
872         for( int i = 0; i + 1 < i_file_number; ++i )
873             offsetv[offsetc - 1] += FILE_SIZE( i );
874     }
875
876     /* add a chapter at the beginning if missing */
877     if( p_marks->i_seekpoint > 0 && offsetv[0] > 0 )
878     {
879         seekpoint_t *sp = vlc_seekpoint_New();
880         if( sp )
881         {
882             sp->i_time_offset = 0;
883             sp->psz_name = strdup( _("Start") );
884             TAB_INSERT( p_marks->i_seekpoint, p_marks->seekpoint, sp, 0 );
885             TAB_INSERT( offsetc, offsetv, UINT64_C(0), 0 );
886         }
887     }
888
889     if( p_marks->i_seekpoint > 0 )
890     {
891         p_sys->p_marks = p_marks;
892         p_sys->offsets = offsetv;
893     }
894     else
895     {
896         vlc_input_title_Delete( p_marks );
897         TAB_CLEAN( offsetc, offsetv );
898     }
899
900     fclose( marksfile );
901     fclose( indexfile );
902 }
903
904 /*****************************************************************************
905  * Lookup frame offset in index file
906  *****************************************************************************/
907 static bool ReadIndexRecord( FILE *p_file, bool b_ts, int64_t i_frame,
908                             uint64_t *pi_offset, uint16_t *pi_file_num )
909 {
910     uint8_t index_record[8];
911     if( fseek( p_file, sizeof(index_record) * i_frame, SEEK_SET ) != 0 )
912         return false;
913     if( fread( &index_record, sizeof(index_record), 1, p_file ) < 1 )
914         return false;
915
916     /* VDR usually (only?) runs on little endian machines, but VLC has a
917      * broader audience. See recording.* in VDR source for data layout. */
918     if( b_ts )
919     {
920         uint64_t i_index_entry = GetQWLE( &index_record );
921         *pi_offset = i_index_entry & UINT64_C(0xFFFFFFFFFF);
922         *pi_file_num = i_index_entry >> 48;
923     }
924     else
925     {
926         *pi_offset = GetDWLE( &index_record );
927         *pi_file_num = index_record[5];
928     }
929
930     return true;
931 }
932
933 /*****************************************************************************
934  * Convert time stamp from file to frame number
935  *****************************************************************************/
936 static int64_t ParseFrameNumber( const char *psz_line, float fps )
937 {
938     unsigned h, m, s, f, n;
939
940     /* hour:min:sec.frame (frame is optional) */
941     n = sscanf( psz_line, "%u:%u:%u.%u", &h, &m, &s, &f );
942     if( n >= 3 )
943     {
944         if( n < 4 )
945             f = 1;
946         int64_t i_seconds = (int64_t)h * 3600 + (int64_t)m * 60 + s;
947         return (int64_t)( i_seconds * (double)fps ) + __MAX(1, f) - 1;
948     }
949
950     /* only a frame number */
951     int64_t i_frame = strtoll( psz_line, NULL, 10 );
952     return __MAX(1, i_frame) - 1;
953 }
954
955 /*****************************************************************************
956  * Return the last path component (including trailing separators)
957  *****************************************************************************/
958 static const char *BaseName( const char *psz_path )
959 {
960     const char *psz_name = psz_path + strlen( psz_path );
961
962     /* skip superfluous separators at the end */
963     while( psz_name > psz_path && psz_name[-1] == DIR_SEP_CHAR )
964         --psz_name;
965
966     /* skip last component */
967     while( psz_name > psz_path && psz_name[-1] != DIR_SEP_CHAR )
968         --psz_name;
969
970     return psz_name;
971 }