Commit 02d6384d authored by Laurent Aimar's avatar Laurent Aimar

* access.* input/*: added access_filter architecture (same API as a

 standard access_t except that it reads from an access_t).

 * timeshift.c: timeshift access filter. It works with udp/dvb streams (tested
 under linux/windows).
 It allows to pause and to fast/slow forward. To try it, use
 --access-filter timeshift.
parent e80505af
......@@ -81,11 +81,12 @@
#define CAT_INPUT 4
#define SUBCAT_INPUT_ACCESS 401
#define SUBCAT_INPUT_DEMUX 402
#define SUBCAT_INPUT_VCODEC 403
#define SUBCAT_INPUT_ACODEC 404
#define SUBCAT_INPUT_SCODEC 405
#define SUBCAT_INPUT_ADVANCED 406
#define SUBCAT_INPUT_ACCESS_FILTER 402
#define SUBCAT_INPUT_DEMUX 403
#define SUBCAT_INPUT_VCODEC 404
#define SUBCAT_INPUT_ACODEC 405
#define SUBCAT_INPUT_SCODEC 406
#define SUBCAT_INPUT_ADVANCED 407
#define CAT_SOUT 5
#define SUBCAT_SOUT_GENERAL 501
......
......@@ -70,6 +70,8 @@ struct access_t
char *psz_access;
/* Access path/url/filename/.... */
char *psz_path;
/* Access source for access_filter (NULL for regular access) */
access_t *p_source;
/* Access can fill this entry to force a demuxer
* XXX: fill it once you know for sure you will succed
......@@ -107,6 +109,7 @@ struct access_t
#define access2_New( a, b, c, d, e ) __access2_New(VLC_OBJECT(a), b, c, d, e )
VLC_EXPORT( access_t *, __access2_New, ( vlc_object_t *p_obj, char *psz_access, char *psz_demux, char *psz_path, vlc_bool_t b_quick ) );
VLC_EXPORT( access_t *, access2_FilterNew, ( access_t *p_source, char *psz_access_filter ) );
VLC_EXPORT( void, access2_Delete, ( access_t * ) );
static inline int access2_vaControl( access_t *p_access, int i_query, va_list args )
......
......@@ -101,6 +101,10 @@
"Common settings you may want to alter are HTTP proxy or " \
"caching settings." )
#define ACCESS_FILTER_TITLE N_( "Access filter modules" )
#define ACCESS_FILTER_HELP N_( \
"Settings related to the various access filter used by VLC.\n" )
#define DEMUX_TITLE N_("Demuxers")
#define DEMUX_HELP N_( "Demuxers are used to separate audio and video streams" )
......@@ -297,6 +301,7 @@ static struct config_category_t categories_array[] =
{ CAT_INPUT, INPUT_TITLE, INPUT_HELP },
{ SUBCAT_INPUT_ACCESS, ACCESS_TITLE, ACCESS_HELP },
{ SUBCAT_INPUT_ACCESS_FILTER, ACCESS_FILTER_TITLE, ACCESS_FILTER_HELP },
{ SUBCAT_INPUT_DEMUX, DEMUX_TITLE, DEMUX_HELP },
{ SUBCAT_INPUT_VCODEC, VDEC_TITLE, VDEC_HELP },
{ SUBCAT_INPUT_ACODEC, ADEC_TITLE, ADEC_HELP },
......
SOURCES_access_filter_timeshift = timeshift.c
/*****************************************************************************
* timeshift.c
*****************************************************************************
* Copyright (C) 2005 VideoLAN
* $Id: demux.c 7546 2004-04-29 13:53:29Z gbazin $
*
* Author: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <stdlib.h>
#include <vlc/vlc.h>
#include <vlc/input.h>
#include <unistd.h>
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close( vlc_object_t * );
vlc_module_begin();
set_description( _("Timeshift") );
set_category( CAT_INPUT );
set_subcategory( SUBCAT_INPUT_ACCESS_FILTER );
set_capability( "access_filter", 0 );
add_shortcut( "timeshift" );
set_callbacks( Open, Close );
vlc_module_end();
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static block_t *Block ( access_t *p_access );
static int Control( access_t *, int i_query, va_list args );
static void Thread ( access_t * );
#define TIMESHIFT_FIFO_MAX (4*1024*1024)
#define TIMESHIFT_FIFO_MIN (TIMESHIFT_FIFO_MAX/4)
struct access_sys_t
{
block_fifo_t *p_fifo;
vlc_bool_t b_opened;
FILE *t1, *t2;
char *psz_tmp1;
char *psz_tmp2;
FILE *w;
int i_w;
FILE *r;
};
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
access_t *p_src = p_access->p_source;
access_sys_t *p_sys;
vlc_bool_t b_bool;
#ifdef WIN32
char buffer[4096];
int i_size;
#endif
/* Only work with not pace controled access */
if( access2_Control( p_src, ACCESS_CAN_CONTROL_PACE, &b_bool ) || b_bool )
{
msg_Dbg( p_src, "ACCESS_CAN_CONTROL_PACE" );
return VLC_EGENERIC;
}
/* Refuse access that can be paused */
if( access2_Control( p_src, ACCESS_CAN_PAUSE, &b_bool ) || b_bool )
{
msg_Dbg( p_src, "ACCESS_CAN_PAUSE: timeshift useless" );
return VLC_EGENERIC;
}
/* */
p_access->pf_read = NULL;
p_access->pf_block = Block;
p_access->pf_seek = NULL;
p_access->pf_control = Control;
p_access->info = p_src->info;
p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
/* */
p_sys->p_fifo = block_FifoNew( p_access );
p_sys->b_opened = VLC_FALSE;
p_sys->t1 = p_sys->t2 = NULL;
p_sys->w = p_sys->r = NULL;
p_sys->i_w = 0;
#ifdef WIN32
i_size = GetTempPath( 4095, buffer );
if( i_size <= 0 || i_size >= 4095 )
{
if( getcwd( buffer, 4095 ) == NULL )
strcpy( buffer, "c:" );
}
/* remove last \\ if any */
if( buffer[strlen(buffer)-1] == '\\' )
buffer[strlen(buffer)-1] = '\0';
asprintf( &p_sys->psz_tmp1, "%s\\vlc-timeshift-%d-%d-1.dat",
buffer, GetCurrentProcessId(), p_access->i_object_id );
asprintf( &p_sys->psz_tmp2, "%s\\vlc-timeshift-%d-%d-2.dat",
buffer, GetCurrentProcessId(), p_access->i_object_id );
#else
asprintf( &p_sys->psz_tmp1, "/tmp/vlc-timeshift-%d-%d-1.dat",
getpid(), p_access->i_object_id );
asprintf( &p_sys->psz_tmp2, "/tmp/vlc-timeshift-%d-%d-2.dat",
getpid(), p_access->i_object_id );
#endif
if( vlc_thread_create( p_access, "timeshift thread", Thread,
VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
{
msg_Err( p_access, "cannot spawn timeshift access thread" );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
access_sys_t *p_sys = p_access->p_sys;
/* */
msg_Dbg( p_access, "timeshift close called" );
vlc_thread_join( p_access );
if( p_sys->b_opened )
{
if( p_sys->t1 ) fclose( p_sys->t1 );
if( p_sys->t2 ) fclose( p_sys->t2 );
unlink( p_sys->psz_tmp1 );
unlink( p_sys->psz_tmp2 );
}
free( p_sys->psz_tmp1 );
free( p_sys->psz_tmp2 );
block_FifoRelease( p_sys->p_fifo );
free( p_sys );
}
/*****************************************************************************
*
*****************************************************************************/
static block_t *Block( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
if( p_access->b_die )
{
p_access->info.b_eof = VLC_TRUE;
return NULL;
}
return block_FifoGet( p_sys->p_fifo );
}
/*****************************************************************************
*
*****************************************************************************/
static int Control( access_t *p_access, int i_query, va_list args )
{
access_t *p_src = p_access->p_source;
vlc_bool_t *pb_bool;
int *pi_int;
int64_t *pi_64;
switch( i_query )
{
/* */
case ACCESS_CAN_SEEK:
case ACCESS_CAN_FASTSEEK:
pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
*pb_bool = VLC_FALSE;
break;
case ACCESS_CAN_CONTROL_PACE: /* Not really true */
case ACCESS_CAN_PAUSE:
pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
*pb_bool = VLC_TRUE;
break;
/* */
case ACCESS_GET_MTU:
pi_int = (int*)va_arg( args, int * );
*pi_int = 0;
break;
case ACCESS_GET_PTS_DELAY:
pi_64 = (int64_t*)va_arg( args, int64_t * );
return access2_Control( p_src, ACCESS_GET_PTS_DELAY, pi_64 );
/* */
case ACCESS_SET_PAUSE_STATE:
return VLC_SUCCESS;
case ACCESS_GET_TITLE_INFO:
case ACCESS_SET_TITLE:
case ACCESS_SET_SEEKPOINT:
case ACCESS_GET_META:
return VLC_EGENERIC;
case ACCESS_SET_PRIVATE_ID_STATE:
case ACCESS_GET_PRIVATE_ID_STATE:
case ACCESS_SET_PRIVATE_ID_CA:
return access2_vaControl( p_src, i_query, args );
default:
msg_Warn( p_access, "unimplemented query in control" );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
*
*****************************************************************************/
static void Thread( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
access_t *p_src = p_access->p_source;
int i_loop = 0;
while( !p_access->b_die )
{
block_t *p_block;
/* Get a new block */
if( p_src->pf_block )
{
p_block = p_src->pf_block( p_src );
if( p_block == NULL )
{
if( p_src->info.b_eof )
break;
msleep( 1000 );
continue;
}
}
else
{
if( ( p_block = block_New( p_access, 2048 ) ) == NULL )
break;
p_block->i_buffer = p_src->pf_read( p_src, p_block->p_buffer, 2048);
if( p_block->i_buffer < 0 )
{
block_Release( p_block );
if( p_block->i_buffer == 0 )
break;
msleep( 1000 );
continue;
}
}
/* Open dump files if we need them */
if( p_sys->p_fifo->i_size >= TIMESHIFT_FIFO_MAX && !p_sys->b_opened )
{
msg_Dbg( p_access, "opening first temporary files (%s)",
p_sys->psz_tmp1 );
p_sys->b_opened = VLC_TRUE;
p_sys->t1 = p_sys->t2 = NULL;
p_sys->w = p_sys->r = NULL;
p_sys->t1 = fopen( p_sys->psz_tmp1, "w+b" );
if( p_sys->t1 )
{
msg_Dbg( p_access, "opening second temporary files (%s)",
p_sys->psz_tmp2 );
p_sys->t2 = fopen( p_sys->psz_tmp2, "w+b" );
if( p_sys->t2 )
{
p_sys->w = p_sys->t1;
p_sys->i_w = 0;
msg_Dbg( p_access, "start writing into temporary file" );
}
else
{
msg_Err( p_access, "cannot open temporary file '%s' (%s)",
p_sys->psz_tmp2, strerror(errno) );
fclose( p_sys->t1 );
p_sys->t1 = NULL;
}
}
else
{
msg_Err( p_access, "cannot open temporary file '%s' (%s)",
p_sys->psz_tmp1, strerror(errno) );
}
}
if( p_sys->w )
{
int i_write;
/* Dump the block */
i_write = fwrite( p_block->p_buffer, 1, p_block->i_buffer,
p_sys->w );
block_Release( p_block );
if( i_write > 0 )
p_sys->i_w += i_write;
else
msg_Warn( p_access, "cannot write data" );
/* Start reading from a file if fifo isn't at 25% */
if( p_sys->p_fifo->i_size < TIMESHIFT_FIFO_MIN && !p_sys->r )
{
msg_Dbg( p_access, "start reading from temporary file (dumped=%d)", p_sys->i_w );
p_sys->r = p_sys->w;
fseek( p_sys->r, 0, SEEK_SET );
p_sys->w = p_sys->t2;
p_sys->i_w = 0;
}
if( p_sys->r )
{
while( p_sys->p_fifo->i_size < TIMESHIFT_FIFO_MIN )
{
p_block = block_New( p_access, 4096 );
p_block->i_buffer = fread( p_block->p_buffer, 1, 4096,
p_sys->r );
if( p_block->i_buffer > 0 )
{
block_FifoPut( p_sys->p_fifo, p_block );
}
else if( p_sys->i_w > 32*1024)
{
FILE *tmp;
block_Release( p_block );
msg_Dbg( p_access, "switching temporary files (dumped=%d)", p_sys->i_w );
/* Switch read/write */
tmp = p_sys->r;
p_sys->r = p_sys->w;
fseek( p_sys->r, 0, SEEK_SET );
p_sys->w = tmp;
fseek( p_sys->w, 0, SEEK_SET );
ftruncate( fileno(p_sys->w), 0 );
p_sys->i_w = 0;
}
else
{
msg_Dbg( p_access, "removing temporary files" );
/* We will remove the need of tmp files */
if( p_sys->i_w > 0 )
{
msg_Dbg( p_access, "loading temporary file" );
fseek( p_sys->w, 0, SEEK_SET );
for( ;; )
{
p_block = block_New( p_access, 4096 );
p_block->i_buffer = fread( p_block->p_buffer,
1, 4096,
p_sys->w );
if( p_block->i_buffer <= 0 )
{
block_Release( p_block );
break;
}
block_FifoPut( p_sys->p_fifo, p_block );
}
}
p_sys->b_opened = VLC_FALSE;
fclose( p_sys->t1 );
fclose( p_sys->t2 );
p_sys->t1 = p_sys->t2 = NULL;
p_sys->w = p_sys->r = NULL;
unlink( p_sys->psz_tmp1 );
unlink( p_sys->psz_tmp2 );
break;
}
}
}
}
else if( p_sys->p_fifo->i_size < TIMESHIFT_FIFO_MAX )
{
block_FifoPut( p_sys->p_fifo, p_block );
}
else
{
/* We failed to opened files so trash new data */
block_Release( p_block );
}
#if 0
if( (i_loop % 400) == 0 )
msg_Dbg( p_access, "timeshift: buff=%d", p_sys->p_fifo->i_size );
#endif
i_loop++;
}
msg_Warn( p_access, "timeshift: EOF" );
/* Send dummy packet to avoid deadlock in TShiftBlock */
for( i_loop = 0; i_loop < 2; i_loop++ )
{
block_t *p_dummy = block_New( p_access, 128 );
p_dummy->i_flags |= BLOCK_FLAG_DISCONTINUITY;
memset( p_dummy->p_buffer, 0, p_dummy->i_buffer );
block_FifoPut( p_sys->p_fifo, p_dummy );
}
}
......@@ -1482,8 +1482,8 @@ static vlc_bool_t GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
else if( i_diff != 0 )
{
/* FIXME what to do when discontinuity_indicator is set ? */
msg_Warn( p_demux, "discontinuity received 0x%x instead of 0x%x",
i_cc, ( pid->i_cc + 1 )&0x0f );
msg_Warn( p_demux, "discontinuity received 0x%x instead of 0x%x (pid=%d)",
i_cc, ( pid->i_cc + 1 )&0x0f, pid->i_pid );
pid->i_cc = i_cc;
......
......@@ -1456,7 +1456,7 @@ static block_t *TSNew( sout_mux_t *p_mux, ts_stream_t *p_stream,
p_ts->p_buffer[7] = ( 0 )&0xff;
p_ts->p_buffer[8] = ( 0 )&0xff;
p_ts->p_buffer[9] = ( 0 )&0xff;
p_ts->p_buffer[10]= ( 0 )&0x80;
p_ts->p_buffer[10]= ( ( 0 )&0x80 ) | 0x7e;
p_ts->p_buffer[11]= 0;
for( i = 12; i < 12 + i_stuffing; i++ )
......
......@@ -28,11 +28,12 @@
#include "input_internal.h"
/*****************************************************************************
* access2_New:
* access2_InternalNew:
*****************************************************************************/
access_t *__access2_New( vlc_object_t *p_obj,
char *psz_access, char *psz_demux, char *psz_path,
vlc_bool_t b_quick )
static access_t *access2_InternalNew( vlc_object_t *p_obj,
char *psz_access, char *psz_demux, char *psz_path,
access_t *p_source,
vlc_bool_t b_quick )
{
access_t *p_access = vlc_object_create( p_obj, VLC_OBJECT_ACCESS );
......@@ -43,13 +44,21 @@ access_t *__access2_New( vlc_object_t *p_obj,
}
/* Parse URL */
p_access->psz_access = b_quick ? strdup( "file" ) : strdup( psz_access );
p_access->psz_path = strdup( psz_path );
p_access->psz_demux = strdup( "" );
if( !b_quick )
p_access->p_source = p_source;
if( p_source )
{
msg_Dbg( p_obj, "creating access filter '%s'", psz_access );
p_access->psz_access = strdup( p_source->psz_access );
p_access->psz_path = strdup( p_source->psz_path );
}
else if( !b_quick )
{
msg_Dbg( p_obj, "creating access '%s' path='%s'",
p_access->psz_access, p_access->psz_path );
psz_access, psz_path );
p_access->psz_access = b_quick ? strdup( "file" ) : strdup( psz_access );
p_access->psz_path = strdup( psz_path );
}
p_access->psz_demux = strdup( "" );
p_access->pf_read = NULL;
p_access->pf_block = NULL;
......@@ -67,9 +76,17 @@ access_t *__access2_New( vlc_object_t *p_obj,
/* Before module_Need (for var_Create...) */
vlc_object_attach( p_access, p_obj );
p_access->p_module =
module_Need( p_access, "access2", p_access->psz_access,
b_quick ? VLC_TRUE : VLC_FALSE );
if( p_source )
{
p_access->p_module =
module_Need( p_access, "access_filter", psz_access, VLC_FALSE );
}
else
{
p_access->p_module =
module_Need( p_access, "access2",p_access->psz_access,
b_quick ? VLC_TRUE : VLC_FALSE );
}
if( p_access->p_module == NULL )
{
......@@ -85,7 +102,27 @@ access_t *__access2_New( vlc_object_t *p_obj,
}
/*****************************************************************************
* demux2_Delete:
* access2_New:
*****************************************************************************/
access_t *__access2_New( vlc_object_t *p_obj,
char *psz_access, char *psz_demux, char *psz_path,
vlc_bool_t b_quick )
{
return access2_InternalNew( p_obj, psz_access, psz_demux, psz_path, NULL, b_quick );
}
/*****************************************************************************
* access2_FilterNew:
*****************************************************************************/
access_t *access2_FilterNew( access_t *p_source, char *psz_access_filter )
{
return access2_InternalNew( VLC_OBJECT(p_source),
psz_access_filter, NULL, NULL,
p_source, VLC_FALSE );
}
/*****************************************************************************
* access2_Delete:
*****************************************************************************/
void access2_Delete( access_t *p_access )
{
......@@ -96,5 +133,11 @@ void access2_Delete( access_t *p_access )
free( p_access->psz_path );
free( p_access->psz_demux );
if( p_access->p_source )
{
access2_Delete( p_access->p_source );
}
vlc_object_destroy( p_access );
}
......@@ -1912,6 +1912,7 @@ static int InputSourceInit( input_thread_t *p_input,
char *psz_access;
char *psz_demux;
char *psz_path;
char *psz;
vlc_value_t val;
/* Split uri */
......@@ -2021,6 +2022,23 @@ static int InputSourceInit( input_thread_t *p_input,
goto error;
}
/* */
psz = var_GetString( p_input, "access-filter" );
if( *psz )
{
access_t *p_access = in->p_access;
/* TODO support chained access-filter */
in->p_access = access2_FilterNew( in->p_access, psz );
if( in->p_access == NULL )
{
in->p_access = p_access;
msg_Warn( p_input, "failed to insert access filter %s",
psz );
}
}
free( psz );
/* Get infos from access */
if( !b_quick )
{
......
......@@ -439,6 +439,9 @@ void input_ConfigVarInit ( input_thread_t *p_input )
var_Create( p_input, "input-slave", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
/* */
var_Create( p_input, "access-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
/* Meta */
var_Create( p_input, "meta-title", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_input, "meta-author", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
......
......@@ -663,6 +663,10 @@ static char *ppsz_clock_descriptions[] =
#define ACCESS_LONGTEXT N_( \
"This is a legacy entry to let you configure access modules.")
#define ACCESS_FILTER_TEXT N_("Access filter module")
#define ACCESS_FILTER_LONGTEXT N_( \
"This is a legacy entry to let you configure access filter modules.")
#define DEMUX_TEXT N_("Demux module")
#define DEMUX_LONGTEXT N_( \
"This is a legacy entry to let you configure demux modules.")
......@@ -1012,6 +1016,12 @@ vlc_module_begin();
add_category_hint( N_("Input"), INPUT_CAT_LONGTEXT , VLC_FALSE );
add_module( "access", "access2", NULL, NULL, ACCESS_TEXT,
ACCESS_LONGTEXT, VLC_TRUE );
set_subcategory( SUBCAT_INPUT_ACCESS_FILTER );
add_module_list_cat( "access-filter", SUBCAT_INPUT_ACCESS_FILTER, NULL, NULL,
ACCESS_FILTER_TEXT, ACCESS_FILTER_LONGTEXT, VLC_FALSE );
set_subcategory( SUBCAT_INPUT_DEMUX );
add_module( "demux", "demux2", NULL, NULL, DEMUX_TEXT,
DEMUX_LONGTEXT, VLC_TRUE );
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment