Fix a bunch of warnings and errors
[vlc.git] / modules / access_filter / timeshift.c
1 /*****************************************************************************
2  * timeshift.c: access filter implementing timeshifting capabilities
3  *****************************************************************************
4  * Copyright (C) 2005 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>
29
30 #include <errno.h>
31
32 #include <vlc/vlc.h>
33 #include <vlc/input.h>
34 #include "charset.h"
35
36 #include <unistd.h>
37
38 /*****************************************************************************
39  * Module descriptor
40  *****************************************************************************/
41 static int  Open ( vlc_object_t * );
42 static void Close( vlc_object_t * );
43
44 #define GRANULARITY_TEXT N_("Timeshift granularity")
45 /// \bug [String] typo
46 #define GRANULARITY_LONGTEXT N_( "This is the size of the temporary files " \
47   "tha will be used to store the timeshifted streams." )
48 #define DIR_TEXT N_("Timeshift directory")
49 #define DIR_LONGTEXT N_( "Directory used to store the timeshift temporary " \
50   "files." )
51 #define FORCE_TEXT N_("Force use of the timeshift module")
52 #define FORCE_LONGTEXT N_("Force use of the timeshift module even if the " \
53   "access declares that it can control pace or pause." )
54
55 vlc_module_begin();
56     set_shortname( _("Timeshift") );
57     set_description( _("Timeshift") );
58     set_category( CAT_INPUT );
59     set_subcategory( SUBCAT_INPUT_ACCESS_FILTER );
60     set_capability( "access_filter", 0 );
61     add_shortcut( "timeshift" );
62     set_callbacks( Open, Close );
63
64     add_integer( "timeshift-granularity", 50, NULL, GRANULARITY_TEXT,
65                  GRANULARITY_LONGTEXT, VLC_TRUE );
66     add_directory( "timeshift-dir", 0, 0, DIR_TEXT, DIR_LONGTEXT, VLC_FALSE );
67     add_bool( "timeshift-force", VLC_FALSE, NULL, FORCE_TEXT, FORCE_LONGTEXT,
68               VLC_FALSE );
69 vlc_module_end();
70
71 /*****************************************************************************
72  * Local prototypes
73  *****************************************************************************/
74
75 static int      Seek( access_t *, int64_t );
76 static block_t *Block  ( access_t *p_access );
77 static int      Control( access_t *, int i_query, va_list args );
78 static void     Thread ( access_t *p_access );
79 static int      WriteBlockToFile( access_t *p_access, block_t *p_block );
80 static block_t *ReadBlockFromFile( access_t *p_access );
81 static char    *GetTmpFilePath( access_t *p_access );
82
83 #define TIMESHIFT_FIFO_MAX (10*1024*1024)
84 #define TIMESHIFT_FIFO_MIN (TIMESHIFT_FIFO_MAX/4)
85 #define TMP_FILE_MAX 256
86
87 typedef struct ts_entry_t
88 {
89     FILE *file;
90     struct ts_entry_t *p_next;
91
92 } ts_entry_t;
93
94 struct access_sys_t
95 {
96     block_fifo_t *p_fifo;
97
98     int  i_files;
99     int  i_file_size;
100     int  i_write_size;
101
102     ts_entry_t *p_read_list;
103     ts_entry_t **pp_read_last;
104     ts_entry_t *p_write_list;
105     ts_entry_t **pp_write_last;
106
107     char *psz_filename_base;
108     char *psz_filename;
109 };
110
111 /*****************************************************************************
112  * Open:
113  *****************************************************************************/
114 static int Open( vlc_object_t *p_this )
115 {
116     access_t *p_access = (access_t*)p_this;
117     access_t *p_src = p_access->p_source;
118     access_sys_t *p_sys;
119     vlc_bool_t b_bool;
120
121     var_Create( p_access, "timeshift-force",
122                 VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
123     if( var_GetBool( p_access, "timeshift-force" ) == VLC_TRUE )
124     {
125         msg_Dbg( p_access, "Forcing use of timeshift even if access can control pace or pause" );
126     }
127     else
128     {
129         /* Only work with not pace controled access */
130         if( access2_Control( p_src, ACCESS_CAN_CONTROL_PACE, &b_bool )
131             || b_bool )
132         {
133             msg_Dbg( p_src, "ACCESS_CAN_CONTROL_PACE: timeshift useless" );
134             return VLC_EGENERIC;
135         }
136         /* Refuse access that can be paused */
137         if( access2_Control( p_src, ACCESS_CAN_PAUSE, &b_bool ) || b_bool )
138         {
139             msg_Dbg( p_src, "ACCESS_CAN_PAUSE: timeshift useless" );
140             return VLC_EGENERIC;
141         }
142     }
143
144     /* */
145     p_access->pf_read = NULL;
146     p_access->pf_block = Block;
147     p_access->pf_seek = Seek;
148     p_access->pf_control = Control;
149     p_access->info = p_src->info;
150
151     p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
152
153     /* */
154     p_sys->p_fifo = block_FifoNew( p_access );
155     p_sys->i_write_size = 0;
156     p_sys->i_files = 0;
157
158     p_sys->p_read_list = NULL;
159     p_sys->pp_read_last = &p_sys->p_read_list;
160     p_sys->p_write_list = NULL;
161     p_sys->pp_write_last = &p_sys->p_write_list;
162
163     var_Create( p_access, "timeshift-dir",
164                 VLC_VAR_DIRECTORY | VLC_VAR_DOINHERIT );
165     var_Create( p_access, "timeshift-granularity",
166                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
167     p_sys->i_file_size = var_GetInteger( p_access, "timeshift-granularity" );
168     if( p_sys->i_file_size < 1 ) p_sys->i_file_size = 1;
169     p_sys->i_file_size *= 1024 * 1024; /* In MBytes */
170
171     p_sys->psz_filename_base = GetTmpFilePath( p_access );
172     p_sys->psz_filename = malloc( strlen( p_sys->psz_filename_base ) + 1000 );
173
174     if( vlc_thread_create( p_access, "timeshift thread", Thread,
175                            VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
176     {
177         msg_Err( p_access, "cannot spawn timeshift access thread" );
178         return VLC_EGENERIC;
179     }
180
181     return VLC_SUCCESS;
182 }
183
184 /*****************************************************************************
185  * Close:
186  *****************************************************************************/
187 static void Close( vlc_object_t *p_this )
188 {
189     access_t     *p_access = (access_t*)p_this;
190     access_sys_t *p_sys = p_access->p_sys;
191     ts_entry_t *p_entry;
192     int i;
193
194     msg_Dbg( p_access, "timeshift close called" );
195     vlc_thread_join( p_access );
196
197     for( p_entry = p_sys->p_write_list; p_entry; )
198     {
199         ts_entry_t *p_next = p_entry->p_next;
200         fclose( p_entry->file );
201         free( p_entry );
202         p_entry = p_next;
203     }
204     for( p_entry = p_sys->p_read_list; p_entry; )
205     {
206         ts_entry_t *p_next = p_entry->p_next;
207         fclose( p_entry->file );
208         free( p_entry );
209         p_entry = p_next;
210     }
211     for( i = 0; i < p_sys->i_files; i++ )
212     {
213         sprintf( p_sys->psz_filename, "%s%i.dat",
214                  p_sys->psz_filename_base, i );
215         unlink( p_sys->psz_filename );
216     }
217
218     free( p_sys->psz_filename );
219     free( p_sys->psz_filename_base );
220     block_FifoRelease( p_sys->p_fifo );
221     free( p_sys );
222 }
223
224 /*****************************************************************************
225  *
226  *****************************************************************************/
227 static block_t *Block( access_t *p_access )
228 {
229     access_sys_t *p_sys = p_access->p_sys;
230     block_t *p_block;
231
232     if( p_access->b_die )
233     {
234         p_access->info.b_eof = VLC_TRUE;
235         return NULL;
236     }
237
238     p_block = block_FifoGet( p_sys->p_fifo );
239     //p_access->info.i_size -= p_block->i_buffer;
240     return p_block;
241 }
242
243 /*****************************************************************************
244  *
245  *****************************************************************************/
246 static void Thread( access_t *p_access )
247 {
248     access_sys_t *p_sys = p_access->p_sys;
249     access_t     *p_src = p_access->p_source;
250     int i;
251
252     while( !p_access->b_die )
253     {
254         block_t *p_block;
255
256         /* Get a new block from the source */
257         if( p_src->pf_block )
258         {
259             p_block = p_src->pf_block( p_src );
260
261             if( p_block == NULL )
262             {
263                 if( p_src->info.b_eof ) break;
264                 msleep( 1000 );
265                 continue;
266             }
267         }
268         else
269         {
270             if( ( p_block = block_New( p_access, 2048 ) ) == NULL ) break;
271
272             p_block->i_buffer =
273                 p_src->pf_read( p_src, p_block->p_buffer, 2048 );
274
275             if( p_block->i_buffer < 0 )
276             {
277                 block_Release( p_block );
278                 if( p_block->i_buffer == 0 ) break;
279                 msleep( 1000 );
280                 continue;
281             }
282         }
283
284         /* Write block */
285         if( !p_sys->p_write_list && !p_sys->p_read_list &&
286             p_sys->p_fifo->i_size < TIMESHIFT_FIFO_MAX )
287         {
288             /* If there isn't too much timeshifted data,
289              * write directly to FIFO */
290             block_FifoPut( p_sys->p_fifo, p_block );
291
292             //p_access->info.i_size += p_block->i_buffer;
293             //p_access->info.i_update |= INPUT_UPDATE_SIZE;
294
295             /* Nothing else to do */
296             continue;
297         }
298
299         WriteBlockToFile( p_access, p_block );
300         block_Release( p_block );
301
302         /* Read from file to fill up the fifo */
303         while( p_sys->p_fifo->i_size < TIMESHIFT_FIFO_MIN &&
304                !p_access->b_die )
305         {
306             p_block = ReadBlockFromFile( p_access );
307             if( !p_block ) break;
308             block_FifoPut( p_sys->p_fifo, p_block );
309         }
310     }
311
312     msg_Dbg( p_access, "timeshift: EOF" );
313
314     /* Send dummy packet to avoid deadlock in TShiftBlock */
315     for( i = 0; i < 2; i++ )
316     {
317         block_t *p_dummy = block_New( p_access, 128 );
318         p_dummy->i_flags |= BLOCK_FLAG_DISCONTINUITY;
319         memset( p_dummy->p_buffer, 0, p_dummy->i_buffer );
320         block_FifoPut( p_sys->p_fifo, p_dummy );
321     }
322 }
323
324 /*****************************************************************************
325  * NextFileWrite:
326  *****************************************************************************/
327 static void NextFileWrite( access_t *p_access )
328 {
329     access_sys_t *p_sys = p_access->p_sys;
330     ts_entry_t   *p_next;
331
332     if( !p_sys->p_write_list )
333     {
334         p_sys->i_write_size = 0;
335         return;
336     }
337
338     p_next = p_sys->p_write_list->p_next;
339
340     /* Put written file in read list */
341     if( p_sys->i_write_size < p_sys->i_file_size )
342         ftruncate( fileno( p_sys->p_write_list->file ), p_sys->i_write_size );
343
344     fseek( p_sys->p_write_list->file, 0, SEEK_SET );
345     *p_sys->pp_read_last = p_sys->p_write_list;
346     p_sys->pp_read_last = &p_sys->p_write_list->p_next;
347     p_sys->p_write_list->p_next = 0;
348
349     /* Switch to next file to write */
350     p_sys->p_write_list = p_next;
351     if( !p_sys->p_write_list ) p_sys->pp_write_last = &p_sys->p_write_list;
352
353     p_sys->i_write_size = 0;
354 }
355
356 /*****************************************************************************
357  * NextFileRead:
358  *****************************************************************************/
359 static void NextFileRead( access_t *p_access )
360 {
361     access_sys_t *p_sys = p_access->p_sys;
362     ts_entry_t   *p_next;
363
364     if( !p_sys->p_read_list ) return;
365
366     p_next = p_sys->p_read_list->p_next;
367
368     /* Put read file in write list */
369     fseek( p_sys->p_read_list->file, 0, SEEK_SET );
370     *p_sys->pp_write_last = p_sys->p_read_list;
371     p_sys->pp_write_last = &p_sys->p_read_list->p_next;
372     p_sys->p_read_list->p_next = 0;
373
374     /* Switch to next file to read */
375     p_sys->p_read_list = p_next;
376     if( !p_sys->p_read_list ) p_sys->pp_read_last = &p_sys->p_read_list;
377 }
378
379 /*****************************************************************************
380  * WriteBlockToFile:
381  *****************************************************************************/
382 static int WriteBlockToFile( access_t *p_access, block_t *p_block )
383 {
384     access_sys_t *p_sys = p_access->p_sys;
385     int i_write, i_buffer;
386
387     if( p_sys->i_write_size == p_sys->i_file_size ) NextFileWrite( p_access );
388
389     /* Open new file if necessary */
390     if( !p_sys->p_write_list )
391     {
392         FILE *file;
393
394         sprintf( p_sys->psz_filename, "%s%i.dat",
395                  p_sys->psz_filename_base, p_sys->i_files );
396         file = utf8_fopen( p_sys->psz_filename, "w+b" );
397
398         if( !file && p_sys->i_files < 2 )
399         {
400             /* We just can't work with less than 2 buffer files */
401             msg_Err( p_access, "cannot open temporary file '%s' (%s)",
402                      p_sys->psz_filename, strerror(errno) );
403             return VLC_EGENERIC;
404         }
405         else if( !file ) return VLC_EGENERIC;
406
407         p_sys->p_write_list = malloc( sizeof(ts_entry_t) );
408         p_sys->p_write_list->p_next = 0;
409         p_sys->p_write_list->file = file;
410         p_sys->pp_write_last = &p_sys->p_write_list->p_next;
411
412         p_sys->i_files++;
413     }
414
415     /* Write to file */
416     i_buffer = __MIN( p_block->i_buffer,
417                       p_sys->i_file_size - p_sys->i_write_size );
418
419     i_write = fwrite( p_block->p_buffer, 1, i_buffer,
420                       p_sys->p_write_list->file );
421
422     if( i_write > 0 ) p_sys->i_write_size += i_write;
423
424     //p_access->info.i_size += i_write;
425     //p_access->info.i_update |= INPUT_UPDATE_SIZE;
426
427     if( i_write < i_buffer )
428     {
429         /* Looks like we're short of space */
430
431         if( !p_sys->p_write_list->p_next )
432         {
433             msg_Warn( p_access, "no more space, overwritting old data" );
434             NextFileRead( p_access );
435             NextFileRead( p_access );
436         }
437
438         /* Make sure we switch to next file in write list */
439         p_sys->i_write_size = p_sys->i_file_size;
440     }
441
442     p_block->p_buffer += i_write;
443     p_block->i_buffer -= i_write;
444
445     /* Check if we have some data left */
446     if( p_block->i_buffer ) return WriteBlockToFile( p_access, p_block );
447
448     return VLC_SUCCESS;
449 }
450
451 /*****************************************************************************
452  * ReadBlockFromFile:
453  *****************************************************************************/
454 static block_t *ReadBlockFromFile( access_t *p_access )
455 {
456     access_sys_t *p_sys = p_access->p_sys;
457     block_t *p_block;
458
459     if( !p_sys->p_read_list && p_sys->p_write_list )
460     {
461         /* Force switching to next write file, that should
462          * give us something to read */
463         NextFileWrite( p_access );
464     }
465
466     if( !p_sys->p_read_list ) return 0;
467
468     p_block = block_New( p_access, 4096 );
469     p_block->i_buffer = fread( p_block->p_buffer, 1, 4096,
470                                p_sys->p_read_list->file );
471
472     if( p_block->i_buffer == 0 ) NextFileRead( p_access );
473
474     //p_access->info.i_size -= p_block->i_buffer;
475     //p_access->info.i_update |= INPUT_UPDATE_SIZE;
476
477     return p_block;
478 }
479
480 /*****************************************************************************
481  * Seek: seek to a specific location in a file
482  *****************************************************************************/
483 static int Seek( access_t *p_access, int64_t i_pos )
484 {
485     //access_sys_t *p_sys = p_access->p_sys;
486     return VLC_SUCCESS;
487 }
488
489 /*****************************************************************************
490  *
491  *****************************************************************************/
492 static int Control( access_t *p_access, int i_query, va_list args )
493 {
494     access_t     *p_src = p_access->p_source;
495
496     vlc_bool_t   *pb_bool;
497     int          *pi_int;
498     int64_t      *pi_64;
499
500     switch( i_query )
501     {
502         case ACCESS_CAN_SEEK:
503         case ACCESS_CAN_FASTSEEK:
504             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
505             *pb_bool = VLC_TRUE;
506             break;
507
508         case ACCESS_CAN_CONTROL_PACE:   /* Not really true */
509         case ACCESS_CAN_PAUSE:
510             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
511             *pb_bool = VLC_TRUE;
512             break;
513
514         case ACCESS_GET_MTU:
515             pi_int = (int*)va_arg( args, int * );
516             *pi_int = 0;
517             break;
518
519         case ACCESS_GET_PTS_DELAY:
520             pi_64 = (int64_t*)va_arg( args, int64_t * );
521             return access2_Control( p_src, ACCESS_GET_PTS_DELAY, pi_64 );
522
523         case ACCESS_SET_PAUSE_STATE:
524             return VLC_SUCCESS;
525
526         case ACCESS_GET_TITLE_INFO:
527         case ACCESS_SET_TITLE:
528         case ACCESS_SET_SEEKPOINT:
529         case ACCESS_GET_META:
530             return VLC_EGENERIC;
531
532         case ACCESS_SET_PRIVATE_ID_STATE:
533         case ACCESS_GET_PRIVATE_ID_STATE:
534         case ACCESS_SET_PRIVATE_ID_CA:
535             return access2_vaControl( p_src, i_query, args );
536
537         default:
538             msg_Warn( p_access, "unimplemented query in control" );
539             return VLC_EGENERIC;
540
541     }
542     return VLC_SUCCESS;
543 }
544
545 /*****************************************************************************
546  * GetTmpFilePath:
547  *****************************************************************************/
548 #ifdef WIN32
549 #define getpid() GetCurrentProcessId()
550 #endif
551 static char *GetTmpFilePath( access_t *p_access )
552 {
553     char *psz_dir = var_GetString( p_access, "timeshift-dir" );
554     char *psz_filename_base;
555
556     if( ( psz_dir != NULL ) && ( psz_dir[0] == '\0' ) )
557     {
558         free( psz_dir );
559         psz_dir = NULL;
560     }
561
562     if( psz_dir == NULL )
563     {
564 #ifdef WIN32
565         char psz_local_dir[MAX_PATH];
566         int i_size;
567
568         i_size = GetTempPath( MAX_PATH, psz_local_dir );
569         if( i_size <= 0 || i_size > MAX_PATH )
570         {
571             if( !getcwd( psz_local_dir, MAX_PATH ) )
572                 strcpy( psz_local_dir, "C:" );
573         }
574
575         psz_dir = FromLocaleDup( psz_local_dir );
576
577         /* remove last \\ if any */
578         if( psz_dir[strlen(psz_dir)-1] == '\\' )
579             psz_dir[strlen(psz_dir)-1] = '\0';
580 #else
581         psz_dir = strdup( "/tmp" );
582 #endif
583     }
584
585     asprintf( &psz_filename_base, "%s/vlc-timeshift-%d-%d-",
586               psz_dir, getpid(), p_access->i_object_id );
587     free( psz_dir );
588
589     return psz_filename_base;
590 }