Skip to content

V
vlc-2-2
Commit 24c93ade authored by Laurent Aimar's avatar Laurent Aimar
Browse files
Options

* ps.* : new PS demuxer (still incomplete) 

 * dvdnav.c: begin of a dvdnav plugin. It's more to test that to be a real
 plugin for now. (a lot of design problems are raised with it).
parent 7b180e00
Show whitespace changes
Inline Side-by-side
Showing with 1536 additions and 0 deletions
modules/demux/dvdnav.c 0 → 100644
View file @ 24c93ade
/*****************************************************************************
* dvdnav.c:
*****************************************************************************
* Copyright (C) 2004 VideoLAN
* $Id: dvdnav.c,v 1.1 2004/01/17 22:32:50 fenrir Exp $
*
* Authors: 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 "vlc_keys.h"
#include "iso_lang.h"
#include <dvdnav/dvdnav.h>
#include "ps.h"
/*****************************************************************************
* Module descriptor
*****************************************************************************/
#define CACHING_TEXT N_("caching value in ms")
#define CACHING_LONGTEXT N_( \
"Allows you to modify the default caching value for dvdnav streams. This " \
"value should be set in miliseconds units." )
static int AccessOpen ( vlc_object_t * );
static void AccessClose( vlc_object_t * );
static int DemuxOpen ( vlc_object_t * );
static void DemuxClose( vlc_object_t * );
vlc_module_begin();
set_description( "DVDnav Input" );
add_category_hint( N_("DVD"), NULL , VLC_TRUE );
add_integer( "dvdnav-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
set_capability( "access", 0 );
add_shortcut( "dvdnav" );
set_callbacks( AccessOpen, AccessClose );
add_submodule();
set_description( "DVDnav Input (demux)" );
set_capability( "demux2", 1 );
add_shortcut( "dvdnav" );
set_callbacks( DemuxOpen, DemuxClose );
vlc_module_end();
/* TODO
* - use dvdnav_get_next_cache_block/dvdnav_free_cache_block
* - all
* - once done the new input API remove the pseudo access
* - ...
*/
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static ssize_t AccessRead ( input_thread_t *, byte_t *, size_t ); /* dummy */
typedef struct
{
VLC_COMMON_MEMBERS
demux_t *p_demux;
vlc_mutex_t lock;
vlc_bool_t b_moved;
vlc_bool_t b_clicked;
vlc_bool_t b_key;
vlc_bool_t b_still;
int64_t i_still_end;
} event_thread_t;
static int EventThread( vlc_object_t * );
struct demux_sys_t
{
dvdnav_t *dvdnav;
/* track */
int i_spu;
int i_audio;
ps_track_t tk[PS_TK_COUNT];
/* for spu variables */
input_thread_t *p_input;
/* event */
event_thread_t *p_ev;
/* FIXME */
uint8_t alpha[4];
/* */
int i_aspect;
/* */
vlc_bool_t b_es_out_ok;
};
static int DemuxControl( demux_t *, int, va_list );
static int DemuxDemux ( demux_t * );
static int DemuxBlock ( demux_t *, uint8_t *pkt, int i_pkt );
enum
{
AR_SQUARE_PICTURE = 1, /* square pixels */
AR_3_4_PICTURE = 2, /* 3:4 picture (TV) */
AR_16_9_PICTURE = 3, /* 16:9 picture (wide screen) */
AR_221_1_PICTURE = 4, /* 2.21:1 picture (movie) */
};
/*****************************************************************************
* Open: see if dvdnav can handle the input and if so force dvdnav demux
*****************************************************************************
* For now it has to be like that (ie open dvdnav twice) but will be fixed
* when a demux could work without access
*****************************************************************************/
static int AccessOpen( vlc_object_t *p_this )
{
input_thread_t *p_input = (input_thread_t *)p_this;
dvdnav_t *dvdnav;
vlc_value_t val;
/* We try only if we are forced */
if( p_input->psz_demux &&
*p_input->psz_demux &&
strcmp( p_input->psz_demux, "dvdnav" ) )
{
msg_Warn( p_input, "dvdnav access discarded (demuxer forced)" );
return VLC_EGENERIC;
}
/* Test dvdnav */
if( dvdnav_open( &dvdnav, p_input->psz_name ) != DVDNAV_STATUS_OK )
{
msg_Warn( p_input, "cannot open dvdnav" );
return VLC_EGENERIC;
}
dvdnav_close( dvdnav );
/* Fill p_input fields */
p_input->pf_read = AccessRead;
p_input->pf_set_program = input_SetProgram;
p_input->pf_set_area = NULL;
p_input->pf_seek = NULL;
vlc_mutex_lock( &p_input->stream.stream_lock );
p_input->stream.b_pace_control = VLC_TRUE;
p_input->stream.b_seekable = VLC_TRUE;
p_input->stream.p_selected_area->i_tell = 0;
p_input->stream.p_selected_area->i_size = 1000;
p_input->stream.i_method = INPUT_METHOD_NETWORK;
vlc_mutex_unlock( &p_input->stream.stream_lock );
p_input->i_mtu = 0;
/* force dvdnav plugin */
p_input->psz_demux = strdup( "dvdnav" );
/* Update default_pts to a suitable value for udp access */
var_Create( p_input, "dvdnav-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_input, "dvdnav-caching", &val );
p_input->i_pts_delay = val.i_int * 1000;
return VLC_SUCCESS;
}
/*****************************************************************************
* Close: free unused data structures
*****************************************************************************/
static void AccessClose( vlc_object_t *p_this )
{
}
/*****************************************************************************
* Read: Should not be called (ie not use by dvdnav demuxer)
*****************************************************************************/
static ssize_t AccessRead( input_thread_t *p_input, byte_t *p_buffer, size_t i_len )
{
memset( p_buffer, 0, i_len );
return i_len;
}
/*****************************************************************************
* DemuxOpen:
*****************************************************************************/
static int DemuxOpen ( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
if( strcmp( p_demux->psz_access, "dvdnav" ) ||
strcmp( p_demux->psz_demux, "dvdnav" ) )
{
msg_Warn( p_demux, "dvdnav module discarded" );
return VLC_EGENERIC;
}
/* Init p_sys */
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
memset( p_sys, 0, sizeof( demux_sys_t ) );
ps_track_init( p_sys->tk );
p_sys->i_audio = 0;
p_sys->i_spu = 0;
p_sys->i_aspect = -1;
p_sys->b_es_out_ok = VLC_FALSE;
/* Open dvdnav */
if( dvdnav_open( &p_sys->dvdnav, p_demux->psz_path ) != DVDNAV_STATUS_OK )
{
msg_Warn( p_demux, "cannot open dvdnav" );
return VLC_EGENERIC;
}
/* Configure dvdnav */
if( dvdnav_set_readahead_flag( p_sys->dvdnav, 1 ) != DVDNAV_STATUS_OK )
{
msg_Warn( p_demux, "cannot set readahead flag" );
}
if( dvdnav_set_PGC_positioning_flag( p_sys->dvdnav, 1 ) != DVDNAV_STATUS_OK )
{
msg_Warn( p_demux, "cannot set PGC positioning flag" );
}
if( dvdnav_menu_language_select( p_sys->dvdnav, "en" ) != DVDNAV_STATUS_OK ||
dvdnav_audio_language_select( p_sys->dvdnav, "en" ) != DVDNAV_STATUS_OK ||
dvdnav_spu_language_select( p_sys->dvdnav, "en" ) != DVDNAV_STATUS_OK )
{
msg_Warn( p_demux, "something failed while setting en language (%s)",
dvdnav_err_to_string( p_sys->dvdnav ) );
}
/* get p_input and create variable */
p_sys->p_input = vlc_object_find( p_demux, VLC_OBJECT_INPUT, FIND_ANYWHERE );
var_Create( p_sys->p_input, "x-start", VLC_VAR_INTEGER );
var_Create( p_sys->p_input, "y-start", VLC_VAR_INTEGER );
var_Create( p_sys->p_input, "x-end", VLC_VAR_INTEGER );
var_Create( p_sys->p_input, "y-end", VLC_VAR_INTEGER );
var_Create( p_sys->p_input, "color", VLC_VAR_ADDRESS );
var_Create( p_sys->p_input, "contrast", VLC_VAR_ADDRESS );
var_Create( p_sys->p_input, "highlight", VLC_VAR_BOOL );
var_Create( p_sys->p_input, "highlight-mutex", VLC_VAR_MUTEX );
/* Now create our event thread catcher */
p_sys->p_ev = vlc_object_create( p_demux, sizeof( event_thread_t ) );
p_sys->p_ev->p_demux = p_demux;
vlc_thread_create( p_sys->p_ev, "dvdnav event thread handler", EventThread, VLC_THREAD_PRIORITY_LOW, VLC_FALSE );
/* fill p_demux field */
p_demux->pf_control = DemuxControl;
p_demux->pf_demux = DemuxDemux;
return VLC_SUCCESS;
}
/*****************************************************************************
* DemuxClose:
*****************************************************************************/
static void DemuxClose( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys = p_demux->p_sys;
/* stop the event handler */
p_sys->p_ev->b_die = VLC_TRUE;
vlc_thread_join( p_sys->p_ev );
var_Destroy( p_sys->p_input, "highlight-mutex" );
var_Destroy( p_sys->p_input, "highlight" );
var_Destroy( p_sys->p_input, "x-start" );
var_Destroy( p_sys->p_input, "x-end" );
var_Destroy( p_sys->p_input, "y-start" );
var_Destroy( p_sys->p_input, "y-end" );
var_Destroy( p_sys->p_input, "color" );
var_Destroy( p_sys->p_input, "contrast" );
vlc_object_release( p_sys->p_input );
dvdnav_close( p_sys->dvdnav );
free( p_sys );
}
/*****************************************************************************
* DemuxControl:
*****************************************************************************/
static int DemuxControl( demux_t *p_demux, int i_query, va_list args )
{
demux_sys_t *p_sys = p_demux->p_sys;
double f, *pf;
switch( i_query )
{
case DEMUX_GET_POSITION:
{
uint32_t pos, len;
pf = (double*) va_arg( args, double* );
if( dvdnav_get_position( p_sys->dvdnav, &pos, &len ) == DVDNAV_STATUS_OK && len > 0 )
{
*pf = (double)pos / (double)len;
}
else
{
*pf = 0.0;
}
return VLC_SUCCESS;
}
case DEMUX_SET_POSITION:
{
uint32_t pos, len;
f = (double) va_arg( args, double );
if( dvdnav_get_position( p_sys->dvdnav, &pos, &len ) == DVDNAV_STATUS_OK && len > 0 )
{
pos = f * len;
if( dvdnav_sector_search( p_sys->dvdnav, pos, SEEK_SET ) == DVDNAV_STATUS_OK )
{
return VLC_SUCCESS;
}
}
return VLC_EGENERIC;
}
/* TODO implement others */
default:
return VLC_EGENERIC;
}
}
/*****************************************************************************
* DemuxDemux:
*****************************************************************************/
static int DemuxDemux( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
uint8_t packet[DVD_VIDEO_LB_LEN];
int i_event;
int i_len;
if( !p_sys->b_es_out_ok )
{
/* We do ourself the selection/unselection
* Problem: bypass --audio-channel and --spu-channel
* Solution: call ourself dvdnav_??set_channel -> TODO
*/
es_out_Control( p_demux->out, ES_OUT_SET_MODE, ES_OUT_MODE_NONE );
p_sys->b_es_out_ok = VLC_TRUE;
}
if( dvdnav_get_next_block( p_sys->dvdnav, packet, &i_event, &i_len ) == DVDNAV_STATUS_ERR )
{
msg_Warn( p_demux, "cannot get next block (%s)",
dvdnav_err_to_string( p_sys->dvdnav ) );
return -1;
}
switch( i_event )
{
case DVDNAV_BLOCK_OK: /* mpeg block */
DemuxBlock( p_demux, packet, i_len );
break;
case DVDNAV_NOP: /* Nothing */
msg_Dbg( p_demux, "DVDNAV_NOP" );
break;
case DVDNAV_STILL_FRAME:
{
dvdnav_still_event_t *event = (dvdnav_still_event_t*)packet;
vlc_mutex_lock( &p_sys->p_ev->lock );
if( !p_sys->p_ev->b_still )
{
msg_Dbg( p_demux, "DVDNAV_STILL_FRAME" );
msg_Dbg( p_demux, " - length=0x%x", event->length );
p_sys->p_ev->b_still = VLC_TRUE;
if( event->length == 0xff )
{
p_sys->p_ev->i_still_end = 0;
}
else
{
p_sys->p_ev->i_still_end = (int64_t)event->length * 1000000 + mdate() + p_sys->p_input->i_pts_delay;
}
}
vlc_mutex_unlock( &p_sys->p_ev->lock );
msleep( 40000 );
break;
}
case DVDNAV_SPU_STREAM_CHANGE:
{
dvdnav_spu_stream_change_event_t *event = (dvdnav_spu_stream_change_event_t*)packet;
msg_Dbg( p_demux, "DVDNAV_SPU_STREAM_CHANGE" );
msg_Dbg( p_demux, " - physical_wide=%d", event->physical_wide );
msg_Dbg( p_demux, " - physical_letterbox=%d", event->physical_letterbox);
msg_Dbg( p_demux, " - physical_pan_scan=%d", event->physical_pan_scan );
break;
}
case DVDNAV_AUDIO_STREAM_CHANGE:
{
dvdnav_audio_stream_change_event_t *event = (dvdnav_audio_stream_change_event_t*)packet;
msg_Dbg( p_demux, "DVDNAV_AUDIO_STREAM_CHANGE" );
msg_Dbg( p_demux, " - physical=%d", event->physical );
break;
}
case DVDNAV_VTS_CHANGE:
{
dvdnav_vts_change_event_t *event = (dvdnav_vts_change_event_t*)packet;
msg_Dbg( p_demux, "DVDNAV_VTS_CHANGE" );
msg_Dbg( p_demux, " - vtsN=%d", event->new_vtsN );
msg_Dbg( p_demux, " - domain=%d", event->new_domain );
/* dvdnav_get_video_aspect / dvdnav_get_video_scale_permission */
/* TODO check if we alsways have VTS and CELL */
p_sys->i_aspect = dvdnav_get_video_aspect( p_sys->dvdnav );
break;
}
case DVDNAV_CELL_CHANGE:
{
int i;
dvdnav_cell_change_event_t *event = (dvdnav_cell_change_event_t*)packet;
msg_Dbg( p_demux, "DVDNAV_CELL_CHANGE" );
msg_Dbg( p_demux, " - cellN=%d", event->cellN );
msg_Dbg( p_demux, " - pgN=%d", event->pgN );
msg_Dbg( p_demux, " - cell_length=%lld", event->cell_length );
msg_Dbg( p_demux, " - pg_length=%lld", event->pg_length );
msg_Dbg( p_demux, " - pgc_length=%lld", event->pgc_length );
msg_Dbg( p_demux, " - cell_start=%lld", event->cell_start );
msg_Dbg( p_demux, " - pg_start=%lld", event->pg_start );
/* Do we need to check for audio/spu stream here ? */
/* reset PCR */
es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
/* Delete all es */
/* XXX we should avoid that sometime */
for( i = 0; i < PS_TK_COUNT; i++ )
{
ps_track_t *tk = &p_sys->tk[i];
if( tk->b_seen && tk->es )
{
es_out_Del( p_demux->out, tk->es );
}
tk->b_seen = VLC_FALSE;
}
p_sys->i_audio = 0;
p_sys->i_spu = 0;
break;
}
case DVDNAV_NAV_PACKET:
{
msg_Dbg( p_demux, "DVDNAV_NAV_PACKET" );
/* A lot of thing to do here :
* - handle packet
* - fetch pts (for time display)
* - ...
*/
DemuxBlock( p_demux, packet, i_len );
break;
}
case DVDNAV_STOP: /* EOF */
msg_Dbg( p_demux, "DVDNAV_STOP" );
return 0;
case DVDNAV_HIGHLIGHT:
{
vlc_value_t val;
uint32_t i_button;
dvdnav_highlight_event_t *event = (dvdnav_highlight_event_t*)packet;
msg_Dbg( p_demux, "DVDNAV_HIGHLIGHT" );
msg_Dbg( p_demux, " - display=%d", event->display );
msg_Dbg( p_demux, " - buttonN=%d", event->buttonN );
/* Can't we just use event->buttonN ? */
dvdnav_get_current_highlight( p_sys->dvdnav, &i_button );
if( var_Get( p_sys->p_input, "highlight-mutex", &val ) == VLC_SUCCESS )
{
vlc_mutex_t *p_mutex = val.p_address;
dvdnav_highlight_area_t hl;
if( i_button > 0 )
{
pci_t *pci = dvdnav_get_current_nav_pci( p_sys->dvdnav );
dvdnav_get_highlight_area( pci, i_button, 1, &hl );
vlc_mutex_lock( p_mutex );
val.i_int = hl.sx; var_Set( p_sys->p_input, "x-start", val );
val.i_int = hl.ex; var_Set( p_sys->p_input, "x-end", val );
val.i_int = hl.sy; var_Set( p_sys->p_input, "y-start", val );
val.i_int = hl.ey; var_Set( p_sys->p_input, "y-end", val );
/* I fear it is plain wrong */
//val.p_address = (void *)&hl.palette;
p_sys->alpha[0] = 0x00;
p_sys->alpha[1] = 0x0f;
p_sys->alpha[2] = 0x0f;
p_sys->alpha[3] = 0x0f;
val.p_address = (void *)p_sys->alpha;
var_Set( p_sys->p_input, "contrast", val );
val.b_bool = VLC_TRUE; var_Set( p_sys->p_input, "highlight", val );
}
else
{
val.b_bool = VLC_FALSE; var_Set( p_sys->p_input, "highlight", val );
}
vlc_mutex_unlock( p_mutex );
}
break;
}
case DVDNAV_SPU_CLUT_CHANGE:
msg_Dbg( p_demux, "DVDNAV_SPU_CLUT_CHANGE" );
/* Update color lookup table (16 *uint32_t in packet) */
break;
case DVDNAV_HOP_CHANNEL:
msg_Dbg( p_demux, "DVDNAV_HOP_CHANNEL" );
/* We should try to flush all our internal buffer */
break;
case DVDNAV_WAIT:
msg_Dbg( p_demux, "DVDNAV_WAIT" );
dvdnav_wait_skip( p_sys->dvdnav );
break;
default:
msg_Warn( p_demux, "Unknown event (0x%x)", i_event );
break;
}
return 1;
}
/*****************************************************************************
* DemuxBlock: demux a given block
*****************************************************************************/
static void DemuxNewES( demux_t *p_demux, int i_id );
static int DemuxBlock( demux_t *p_demux, uint8_t *pkt, int i_pkt )
{
demux_sys_t *p_sys = p_demux->p_sys;
uint8_t *p = pkt;
while( p < &pkt[i_pkt] )
{
int i_size = ps_pkt_size( p, &pkt[i_pkt] - p );
block_t *p_pkt;
if( i_size <= 0 )
{
break;
}
/* Create a block */
p_pkt = block_New( p_demux, i_size );
memcpy( p_pkt->p_buffer, p, i_size);
/* Parse it and send it */
switch( 0x100 | p[3] )
{
case 0x1b9:
case 0x1bb:
case 0x1bc:
if( p[3] == 0xbc )
{
msg_Warn( p_demux, "received a PSM packet" );
}
else if( p[3] == 0xbb )
{
msg_Warn( p_demux, "received a SYSTEM packet" );
}
block_Release( p_pkt );
break;
case 0x1ba:
{
int64_t i_scr;
int i_mux_rate;
if( !ps_pkt_parse_pack( p_pkt, &i_scr, &i_mux_rate ) )
{
es_out_Control( p_demux->out, ES_OUT_SET_PCR, i_scr );
}
block_Release( p_pkt );
break;
}
default:
{
int i_id = ps_pkt_id( p_pkt );
if( i_id >= 0xc0 )
{
ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
if( !tk->b_seen )
{
DemuxNewES( p_demux, i_id );
}
if( tk->b_seen && tk->es && !ps_pkt_parse_pes( p_pkt, tk->i_skip ) )
{
es_out_Send( p_demux->out, tk->es, p_pkt );
}
else
{
block_Release( p_pkt );
}
}
else
{
block_Release( p_pkt );
}
break;
}
}
p += i_size;
}
return VLC_SUCCESS;
}
static char *LangCode2String( uint16_t i_lang )
{
const iso639_lang_t *pl;
char lang[3];
if( i_lang == 0xffff )
{
return NULL;
}
lang[0] = (i_lang >> 8)&0xff;
lang[1] = (i_lang )&0xff;
lang[2] = 0;
pl = GetLang_1( lang );
if( !strcmp( pl->psz_iso639_1, "??" ) )
{
return strdup( lang );
}
else if( *pl->psz_native_name )
{
return strdup( pl->psz_native_name );
}
return strdup( pl->psz_eng_name );
}
static void DemuxNewES( demux_t *p_demux, int i_id )
{
demux_sys_t *p_sys = p_demux->p_sys;
ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
vlc_bool_t b_select = VLC_FALSE;
if( tk->b_seen )
{
return;
}
if( ps_track_fill( tk, i_id ) )
{
msg_Warn( p_demux, "unknown codec for id=0x%x", i_id );
return;
}
/* Add a new ES */
if( tk->fmt.i_cat == VIDEO_ES )
{
if( p_sys->i_aspect >= 0 )
{
tk->fmt.video.i_aspect = p_sys->i_aspect;
}
b_select = VLC_TRUE;
}
else if( tk->fmt.i_cat == AUDIO_ES )
{
tk->fmt.psz_language = LangCode2String( dvdnav_audio_stream_to_lang( p_sys->dvdnav, p_sys->i_audio ) );
if( dvdnav_get_active_audio_stream( p_sys->dvdnav ) == p_sys->i_audio )
{
b_select = VLC_TRUE;
}
p_sys->i_audio++;
}
else if( tk->fmt.i_cat == SPU_ES )
{
tk->fmt.psz_language = LangCode2String( dvdnav_spu_stream_to_lang( p_sys->dvdnav, p_sys->i_spu ) );
if( dvdnav_get_active_spu_stream( p_sys->dvdnav ) == p_sys->i_spu )
{
b_select = VLC_TRUE;
}
p_sys->i_spu++;
}
tk->es = es_out_Add( p_demux->out, &tk->fmt );
if( b_select )
{
//es_out_Control( p_demux->out, ES_OUT_SET_ES, tk->es );
es_out_Control( p_demux->out, ES_OUT_SET_ES_STATE, tk->es, b_select );
}
tk->b_seen = VLC_TRUE;
}
/*****************************************************************************
* Event handler code
*****************************************************************************/
static int EventMouse( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
static int EventKey ( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
static int EventThread( vlc_object_t *p_this )
{
event_thread_t *p_ev = (event_thread_t*)p_this;
demux_sys_t *p_sys = p_ev->p_demux->p_sys;
vlc_object_t *p_vout = NULL;
vlc_mutex_init( p_ev, &p_ev->lock );
p_ev->b_moved = VLC_FALSE;
p_ev->b_clicked = VLC_FALSE;
p_ev->b_key = VLC_FALSE;
p_ev->b_still = VLC_FALSE;
/* catch all key event */
var_AddCallback( p_ev->p_vlc, "key-pressed", EventKey, p_ev );
/* main loop */
while( !p_ev->b_die )
{
vlc_bool_t b_activated = VLC_FALSE;
/* KEY part */
if( p_ev->b_key )
{
pci_t *pci = dvdnav_get_current_nav_pci( p_sys->dvdnav );
vlc_value_t valk;
struct hotkey *p_hotkeys = p_ev->p_vlc->p_hotkeys;
int i, i_action = -1;
vlc_mutex_lock( &p_ev->lock );
var_Get( p_ev->p_vlc, "key-pressed", &valk );
for( i = 0; p_hotkeys[i].psz_action != NULL; i++ )
{
if( p_hotkeys[i].i_key == valk.i_int )
{
i_action = p_hotkeys[i].i_action;
}
}
switch( i_action )
{
case ACTIONID_NAV_LEFT:
dvdnav_left_button_select( p_sys->dvdnav, pci );
break;
case ACTIONID_NAV_RIGHT:
dvdnav_right_button_select( p_sys->dvdnav, pci );
break;
case ACTIONID_NAV_UP:
dvdnav_upper_button_select( p_sys->dvdnav, pci );
break;
case ACTIONID_NAV_DOWN:
dvdnav_lower_button_select( p_sys->dvdnav, pci );
break;
case ACTIONID_NAV_ACTIVATE:
b_activated = VLC_TRUE;
dvdnav_button_activate( p_sys->dvdnav, pci );
break;
default:
break;
}
p_ev->b_key = VLC_FALSE;
vlc_mutex_unlock( &p_ev->lock );
}
/* VOUT part */
if( p_vout && ( p_ev->b_moved || p_ev->b_clicked ) )
{
pci_t *pci = dvdnav_get_current_nav_pci( p_sys->dvdnav );
vlc_value_t valx, valy;
vlc_mutex_lock( &p_ev->lock );
var_Get( p_vout, "mouse-x", &valx );
var_Get( p_vout, "mouse-y", &valy );
if( p_ev->b_moved )
{
dvdnav_mouse_select( p_sys->dvdnav, pci, valx.i_int, valy.i_int );
}
if( p_ev->b_clicked )
{
b_activated = VLC_TRUE;
dvdnav_mouse_activate( p_sys->dvdnav, pci, valx.i_int, valy.i_int );
}
p_ev->b_moved = VLC_FALSE;
p_ev->b_clicked = VLC_FALSE;
vlc_mutex_unlock( &p_ev->lock );
}
if( p_vout && p_vout->b_die )
{
var_DelCallback( p_vout, "mouse-moved", EventMouse, p_ev );
var_DelCallback( p_vout, "mouse-clicked", EventMouse, p_ev );
vlc_object_release( p_vout );
p_vout = NULL;
}
if( p_vout == NULL )
{
p_vout = vlc_object_find( p_sys->p_input, VLC_OBJECT_VOUT, FIND_CHILD );
if( p_vout)
{
var_AddCallback( p_vout, "mouse-moved", EventMouse, p_ev );
var_AddCallback( p_vout, "mouse-clicked", EventMouse, p_ev );
}
}
/* Still part */
vlc_mutex_lock( &p_ev->lock );
if( p_ev->b_still )
{
if( b_activated || ( p_ev->i_still_end > 0 && p_ev->i_still_end < mdate() ))
{
p_ev->b_still = VLC_FALSE;
dvdnav_still_skip( p_sys->dvdnav );
}
}
vlc_mutex_unlock( &p_ev->lock );
/* Wait a bit */
msleep( 10000 );
}
/*release callback */
if( p_vout )
{
var_DelCallback( p_vout, "mouse-moved", EventMouse, p_ev );
var_DelCallback( p_vout, "mouse-clicked", EventMouse, p_ev );
vlc_object_release( p_vout );
}
var_DelCallback( p_ev->p_vlc, "key-pressed", EventKey, p_ev );
vlc_mutex_destroy( &p_ev->lock );
return VLC_SUCCESS;
}
static int EventMouse( vlc_object_t *p_this, char const *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
event_thread_t *p_ev = p_data;
vlc_mutex_lock( &p_ev->lock );
if( psz_var[6] == 'c' )
p_ev->b_clicked = VLC_TRUE;
else if( psz_var[6] == 'm' )
p_ev->b_moved = VLC_TRUE;
vlc_mutex_unlock( &p_ev->lock );
return VLC_SUCCESS;
}
static int EventKey ( vlc_object_t *p_this, char const *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
event_thread_t *p_ev = p_data;
vlc_mutex_lock( &p_ev->lock );
p_ev->b_key = VLC_TRUE;
vlc_mutex_unlock( &p_ev->lock );
return VLC_SUCCESS;
}
modules/demux/ps.c 0 → 100644
View file @ 24c93ade
/*****************************************************************************
* ps.c
*****************************************************************************
* Copyright (C) 2004 VideoLAN
* $Id: ps.c,v 1.1 2004/01/17 22:32:50 fenrir Exp $
*
* Authors: 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> /* malloc(), free() */
#include <vlc/vlc.h>
#include <vlc/input.h>
#include "ps.h"
/* TODO:
* - re-add pre-scanning.
* - ...
*/
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
vlc_module_begin();
set_description( "PS demuxer" );
set_capability( "demux2", 0 );
set_callbacks( Open, Close );
add_shortcut( "ps2" );
vlc_module_end();
/*****************************************************************************
* Local prototypes
*****************************************************************************/
struct demux_sys_t
{
ps_track_t tk[PS_TK_COUNT];
int64_t i_scr;
int i_mux_rate;
};
static int Demux ( demux_t *p_demux );
static int Control( demux_t *p_demux, int i_query, va_list args );
static int ps_pkt_resynch( stream_t *, uint32_t *pi_code );
static block_t *ps_pkt_read ( stream_t *, uint32_t i_code );
/*****************************************************************************
* Open
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
uint8_t *p_peek;
if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 )
{
msg_Err( p_demux, "cannot peek" );
return VLC_EGENERIC;
}
if( p_peek[0] != 0 || p_peek[1] != 0 || p_peek[2] != 1 || p_peek[3] < 0xb9 )
{
msg_Warn( p_demux, "this does not look like an MPEG PS stream, continuing anyway" );
}
/* Fill p_demux field */
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
/* Init p_sys */
p_sys->i_mux_rate = 0;
p_sys->i_scr = -1;
ps_track_init( p_sys->tk );
/* TODO prescanning of ES */
return VLC_SUCCESS;
}
/*****************************************************************************
* Close
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys = p_demux->p_sys;
free( p_sys );
}
/*****************************************************************************
* Demux:
*****************************************************************************/
static int Demux( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
int i_ret;
uint32_t i_code;
block_t *p_pkt;
i_ret = ps_pkt_resynch( p_demux->s, &i_code );
if( i_ret < 0 )
{
return 0;
}
else if( i_ret == 0 )
{
msg_Warn( p_demux, "garbage at input" );
return 1;
}
if( ( p_pkt = ps_pkt_read( p_demux->s, i_code ) ) == NULL )
{
return 0;
}
switch( i_code )
{
case 0x1b9:
block_Release( p_pkt );
break;
case 0x1ba:
{
int i_mux_rate;
if( !ps_pkt_parse_pack( p_pkt, &p_sys->i_scr, &i_mux_rate ) )
{
es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_scr );
if( i_mux_rate > 0 )
{
p_sys->i_mux_rate = i_mux_rate;
}
}
block_Release( p_pkt );
break;
}
case 0x1bb:
if( !ps_pkt_parse_system( p_pkt, p_sys->tk ) )
{
int i;
for( i = 0; i < PS_TK_COUNT; i++ )
{
ps_track_t *tk = &p_sys->tk[i];
if( tk->b_seen && !tk->es && tk->fmt.i_cat != UNKNOWN_ES )
{
tk->es = es_out_Add( p_demux->out, &tk->fmt );
}
}
}
block_Release( p_pkt );
break;
case 0x1bc:
/* TODO PSM */
block_Release( p_pkt );
break;
default:
{
int i_id = ps_pkt_id( p_pkt );
if( i_id >= 0xc0 )
{
ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
if( !tk->b_seen )
{
if( !ps_track_fill( tk, i_id ) )
{
tk->es = es_out_Add( p_demux->out, &tk->fmt );
}
tk->b_seen = VLC_TRUE;
}
if( tk->b_seen && tk->es && !ps_pkt_parse_pes( p_pkt, tk->i_skip ) )
{
es_out_Send( p_demux->out, tk->es, p_pkt );
}
else
{
block_Release( p_pkt );
}
}
else
{
block_Release( p_pkt );
}
break;
}
}
return 1;
}
/*****************************************************************************
* Control:
*****************************************************************************/
static int Control( demux_t *p_demux, int i_query, va_list args )
{
demux_sys_t *p_sys = p_demux->p_sys;
double f, *pf;
int64_t i64, *pi64;
switch( i_query )
{
case DEMUX_GET_POSITION:
pf = (double*) va_arg( args, double* );
i64 = stream_Size( p_demux->s );
if( i64 > 0 )
{
*pf = (double)stream_Tell( p_demux->s ) / (double)i64;
}
else
{
*pf = 0.0;
}
return VLC_SUCCESS;
case DEMUX_SET_POSITION:
f = (double) va_arg( args, double );
i64 = stream_Size( p_demux->s );
es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
return stream_Seek( p_demux->s, (int64_t)(i64 * f) );
case DEMUX_GET_TIME:
pi64 = (int64_t*)va_arg( args, int64_t * );
if( p_sys->i_mux_rate > 0 )
{
*pi64 = (int64_t)1000000 * ( stream_Tell( p_demux->s ) / 50 ) / p_sys->i_mux_rate;
return VLC_SUCCESS;
}
*pi64 = 0;
return VLC_EGENERIC;
case DEMUX_GET_LENGTH:
pi64 = (int64_t*)va_arg( args, int64_t * );
if( p_sys->i_mux_rate > 0 )
{
*pi64 = (int64_t)1000000 * ( stream_Size( p_demux->s ) / 50 ) / p_sys->i_mux_rate;
return VLC_SUCCESS;
}
*pi64 = 0;
return VLC_EGENERIC;
case DEMUX_SET_TIME:
case DEMUX_GET_FPS:
default:
return VLC_EGENERIC;
}
}
/*****************************************************************************
* Divers:
*****************************************************************************/
/* PSResynch: resynch on a systeme starcode
* It doesn't skip more than 512 bytes
* -1 -> error, 0 -> not synch, 1 -> ok
*/
static int ps_pkt_resynch( stream_t *s, uint32_t *pi_code )
{
uint8_t *p_peek;
int i_peek;
int i_skip;
if( stream_Peek( s, &p_peek, 4 ) < 4 )
{
return -1;
}
if( p_peek[0] == 0 && p_peek[1] == 0 && p_peek[2] == 1 && p_peek[3] >= 0xb9 )
{
*pi_code = 0x100 | p_peek[3];
return 1;
}
if( ( i_peek = stream_Peek( s, &p_peek, 512 ) ) < 4 )
{
return -1;
}
i_skip = 0;
for( ;; )
{
if( i_peek < 4 )
{
break;
}
if( p_peek[0] == 0 && p_peek[1] == 0 && p_peek[2] == 1 && p_peek[3] >= 0xb9 )
{
*pi_code = 0x100 | p_peek[3];
return stream_Read( s, NULL, i_skip ) == i_skip ? 1 : -1;
}
p_peek++;
i_peek--;
i_skip++;
}
return stream_Read( s, NULL, i_skip ) == i_skip ? 0 : -1;
}
static block_t *ps_pkt_read( stream_t *s, uint32_t i_code )
{
uint8_t *p_peek;
int i_peek = stream_Peek( s, &p_peek, 14 );
int i_size = ps_pkt_size( p_peek, i_peek );
if( i_size > 0 )
{
return stream_Block( s, i_size );
}
return NULL;
}
modules/demux/ps.h 0 → 100644
View file @ 24c93ade
/*****************************************************************************
* ps.h: Program Stream demuxer helper
*****************************************************************************
* Copyright (C) 2004 VideoLAN
* $Id: ps.h,v 1.1 2004/01/17 22:32:50 fenrir Exp $
*
* Authors: 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.
*****************************************************************************/
#define PS_TK_COUNT (512 - 0xc0)
#define PS_ID_TO_TK( id ) ((id) <= 0xff ? (id) - 0xc0 : ((id)&0xff) + (256 - 0xc0))
typedef struct
{
vlc_bool_t b_seen;
int i_skip;
es_out_id_t *es;
es_format_t fmt;
} ps_track_t;
/* Init a set of track */
static inline void ps_track_init( ps_track_t tk[PS_TK_COUNT] )
{
int i;
for( i = 0; i < PS_TK_COUNT; i++ )
{
tk[i].b_seen = VLC_FALSE;
tk[i].i_skip = 0;
tk[i].es = NULL;
es_format_Init( &tk[i].fmt, UNKNOWN_ES, 0 );
}
}
/* From id fill i_skip and es_format_t */
static inline int ps_track_fill( ps_track_t *tk, int i_id )
{
tk->i_skip = 0;
if( ( i_id&0xff00 ) == 0xbd00 )
{
if( ( i_id&0xf8 ) == 0x88 )
{
es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'd', 't', 's', ' ' ) );
tk->i_skip = 1;
}
else if( ( i_id&0xf0 ) == 0x80 )
{
es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', ' ' ) );
tk->i_skip = 4;
}
else if( ( i_id&0xe0 ) == 0x20 )
{
es_format_Init( &tk->fmt, SPU_ES, VLC_FOURCC( 's', 'p', 'u', ' ' ) );
tk->i_skip = 1;
}
else if( ( i_id&0xf0 ) == 0xa0 )
{
es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'l', 'p', 'c', 'm' ) );
tk->i_skip = 1;
}
else
{
es_format_Init( &tk->fmt, UNKNOWN_ES, 0 );
return VLC_EGENERIC;
}
}
else
{
if( ( i_id&0xf0 ) == 0xe0 )
{
es_format_Init( &tk->fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', 'g', 'v' ) );
}
else if( ( i_id&0xe0 ) == 0xc0 )
{
es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'm', 'p', 'g', 'a' ) );
}
else
{
es_format_Init( &tk->fmt, UNKNOWN_ES, 0 );
return VLC_EGENERIC;
}
}
return VLC_SUCCESS;
}
/* return the id of a PES (should be valid) */
static inline int ps_pkt_id( block_t *p_pkt )
{
if( p_pkt->p_buffer[3] == 0xbd &&
p_pkt->i_buffer >= 9 &&
p_pkt->i_buffer >= 9 + p_pkt->p_buffer[8] )
{
return 0xbd00 | p_pkt->p_buffer[9+p_pkt->p_buffer[8]];
}
return p_pkt->p_buffer[3];
}
/* return the size of the next packet
* XXX you need to give him at least 14 bytes (and it need to start as a
* valid packet) */
static inline int ps_pkt_size( uint8_t *p, int i_peek )
{
if( p[3] == 0xb9 && i_peek >= 4 )
{
return 4;
}
else if( p[3] == 0xba )
{
if( (p[4] >> 6) == 0x01 && i_peek >= 14 )
{
return 14 + (p[13]&0x07);
}
else if( (p[4] >> 4) == 0x02 && i_peek >= 12 )
{
return 12;
}
return -1;
}
else if( i_peek >= 6 )
{
return 6 + ((p[4]<<8) | p[5] );
}
return -1;
}
/* parse a PACK PES */
static inline int ps_pkt_parse_pack( block_t *p_pkt, int64_t *pi_scr, int *pi_mux_rate )
{
uint8_t *p = p_pkt->p_buffer;
if( p_pkt->i_buffer >= 14 && (p[4] >> 6) == 0x01 )
{
*pi_scr =((((int64_t)p[4]&0x38) << 27 )|
(((int64_t)p[4]&0x03) << 28 )|
((int64_t)p[5] << 20 )|
(((int64_t)p[6]&0xf8) << 12 )|
(((int64_t)p[6]&0x03) << 13 )|
((int64_t)p[7] << 5 )|
((int64_t)p[8] >> 3 )) * 100 / 9;
*pi_mux_rate = ( p[10] << 14 )|( p[11] << 6 )|( p[12] >> 2);
}
else if( p_pkt->i_buffer >= 12 && (p[4] >> 4) == 0x02 )
{
*pi_scr =((((int64_t)p[4]&0x0e) << 29 )|
((int64_t)p[5] << 22 )|
(((int64_t)p[6]&0xfe) << 14 )|
((int64_t)p[7] << 7 )|
((int64_t)p[8] >> 1 )) * 100 / 9;
*pi_mux_rate = ( ( p[9]&0x7f )<< 15 )|( p[10] << 7 )|( p[11] >> 1);
}
else
{
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/* Parse a SYSTEM PES */
static inline int ps_pkt_parse_system( block_t *p_pkt, ps_track_t tk[PS_TK_COUNT] )
{
uint8_t *p = &p_pkt->p_buffer[6 + 3 + 1 + 1 + 1];
while( p < &p_pkt->p_buffer[p_pkt->i_buffer] )
{
/* msg_Dbg( p_demux, " SYSTEM_START_CODE: id=0x%x", p[0] ); */
if( p[0] != 0xbd )
{
int i_id = p[0];
int i_tk = PS_ID_TO_TK( i_id );
if( !tk[i_tk].b_seen )
{
if( !ps_track_fill( &tk[i_tk], i_id ) )
{
tk[i_tk].b_seen = VLC_TRUE;
}
}
p += 2;
}
p++;
}
return VLC_SUCCESS;
}
/* Parse a PES (and skip i_skip_extra in the payload) */
static inline int ps_pkt_parse_pes( block_t *p_pes, int i_skip_extra )
{
uint8_t header[30];
int i_skip = 0;
memcpy( header, p_pes->p_buffer, __MIN( p_pes->i_buffer, 30 ) );
switch( header[3] )
{
case 0xBC: /* Program stream map */
case 0xBE: /* Padding */
case 0xBF: /* Private stream 2 */
case 0xB0: /* ECM */
case 0xB1: /* EMM */
case 0xFF: /* Program stream directory */
case 0xF2: /* DSMCC stream */
case 0xF8: /* ITU-T H.222.1 type E stream */
i_skip = 6;
break;
default:
if( ( header[6]&0xC0 ) == 0x80 )
{
/* mpeg2 PES */
i_skip = header[8] + 9;
if( header[7]&0x80 ) /* has pts */
{
p_pes->i_pts = ((mtime_t)(header[ 9]&0x0e ) << 29)|
(mtime_t)(header[10] << 22)|
((mtime_t)(header[11]&0xfe) << 14)|
(mtime_t)(header[12] << 7)|
(mtime_t)(header[12] >> 1);
if( header[7]&0x40 ) /* has dts */
{
p_pes->i_dts = ((mtime_t)(header[13]&0x0e ) << 29)|
(mtime_t)(header[14] << 22)|
((mtime_t)(header[15]&0xfe) << 14)|
(mtime_t)(header[16] << 7)|
(mtime_t)(header[17] >> 1);
}
}
}
else
{
i_skip = 6;
while( i_skip < 23 && header[i_skip] == 0xff )
{
i_skip++;
}
if( i_skip == 23 )
{
/* msg_Err( p_demux, "too much MPEG-1 stuffing" ); */
return VLC_EGENERIC;
}
if( ( header[i_skip] & 0xC0 ) == 0x40 )
{
i_skip += 2;
}
if( header[i_skip]&0x20 )
{
p_pes->i_pts = ((mtime_t)(header[i_skip]&0x0e ) << 29)|
(mtime_t)(header[i_skip+1] << 22)|
((mtime_t)(header[i_skip+2]&0xfe) << 14)|
(mtime_t)(header[i_skip+3] << 7)|
(mtime_t)(header[i_skip+4] >> 1);
if( header[i_skip]&0x10 ) /* has dts */
{
p_pes->i_dts = ((mtime_t)(header[i_skip+5]&0x0e ) << 29)|
(mtime_t)(header[i_skip+6] << 22)|
((mtime_t)(header[i_skip+7]&0xfe) << 14)|
(mtime_t)(header[i_skip+8] << 7)|
(mtime_t)(header[i_skip+9] >> 1);
i_skip += 10;
}
else
{
i_skip += 5;
}
}
else
{
i_skip += 1;
}
}
}
i_skip += i_skip_extra;
if( p_pes->i_buffer <= i_skip )
{
return VLC_EGENERIC;
}
p_pes->p_buffer += i_skip;
p_pes->i_buffer -= i_skip;
p_pes->i_dts = 100 * p_pes->i_dts / 9;
p_pes->i_pts = 100 * p_pes->i_pts / 9;
return VLC_SUCCESS;
}
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