static int Playlist(vlc_object_t *obj, char const *cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data)
{
intf_thread_t *intf = (intf_thread_t*)obj;
intf_sys_t *sys = intf->p_sys;
playlist_t *playlist = sys->playlist;
input_thread_t * input = playlist_CurrentInput(playlist);
int state;
if(input) {
state = var_GetInteger(input, "state");
vlc_object_release(input);
} else {
return VLC_EGENERIC;
}
if(strcmp(cmd, "pause") == 0) {
msg_Info(intf, "Pause");
if(state == PLAYING_S)
playlist_Pause(sys->playlist);
} else if(strcmp(cmd, "play") == 0) {
msg_Info(intf, "Play");
if(state != PLAYING_S)
playlist_Play(sys->playlist);
}
}
static void adjust_refresh_rate(vout_display_t *vd, const video_format_t *fmt)
{
vout_display_sys_t *sys = vd->sys;
TV_DISPLAY_STATE_T display_state;
TV_SUPPORTED_MODE_NEW_T supported_modes[VC_TV_MAX_MODE_IDS];
char response[20]; /* answer is hvs_update_fields=%1d */
int num_modes;
double frame_rate = (double)fmt->i_frame_rate / fmt->i_frame_rate_base;
int best_id = -1;
double best_score, score;
int i;
vc_tv_get_display_state(&display_state);
if(display_state.display.hdmi.mode != HDMI_MODE_OFF) {
num_modes = vc_tv_hdmi_get_supported_modes_new(display_state.display.hdmi.group,
supported_modes, VC_TV_MAX_MODE_IDS, NULL, NULL);
for (i = 0; i < num_modes; ++i) {
TV_SUPPORTED_MODE_NEW_T *mode = &supported_modes[i];
if (!sys->native_interlaced) {
if (mode->width != display_state.display.hdmi.width ||
mode->height != display_state.display.hdmi.height ||
mode->scan_mode == HDMI_INTERLACED)
continue;
} else {
if (mode->width != vd->fmt.i_visible_width ||
mode->height != vd->fmt.i_visible_height)
continue;
if (mode->scan_mode != sys->b_progressive ? HDMI_NONINTERLACED : HDMI_INTERLACED)
continue;
}
score = fmod(supported_modes[i].frame_rate, frame_rate);
if((best_id < 0) || (score < best_score)) {
best_id = i;
best_score = score;
}
}
if((best_id >= 0) && (display_state.display.hdmi.mode != supported_modes[best_id].code)) {
msg_Info(vd, "Setting HDMI refresh rate to %"PRIu32,
supported_modes[best_id].frame_rate);
vc_tv_hdmi_power_on_explicit_new(HDMI_MODE_HDMI,
supported_modes[best_id].group,
supported_modes[best_id].code);
}
if (sys->native_interlaced &&
supported_modes[best_id].scan_mode == HDMI_INTERLACED) {
char hvs_mode = sys->b_top_field_first ? '1' : '2';
if (vc_gencmd(response, sizeof(response), "hvs_update_fields %c",
hvs_mode) != 0 || response[18] != hvs_mode)
msg_Warn(vd, "Could not set hvs field mode");
else
msg_Info(vd, "Configured hvs field mode for interlaced %s playback",
sys->b_top_field_first ? "tff" : "bff");
}
}
}
static int EventKey( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
decoder_t *p_dec = p_data;
decoder_sys_t *p_sys = p_dec->p_sys;
VLC_UNUSED(psz_cmd);
VLC_UNUSED(oldval);
VLC_UNUSED( p_this );
/* FIXME: Capture + and - key for subpage browsing */
if( newval.i_int == '-' || newval.i_int == '+' )
{
vlc_mutex_lock( &p_sys->lock );
if( p_sys->i_wanted_subpage == VBI_ANY_SUBNO && newval.i_int == '+' )
p_sys->i_wanted_subpage = vbi_dec2bcd(1);
else if ( newval.i_int == '+' )
p_sys->i_wanted_subpage = vbi_add_bcd( p_sys->i_wanted_subpage, 1);
else if( newval.i_int == '-')
p_sys->i_wanted_subpage = vbi_add_bcd( p_sys->i_wanted_subpage, 0xF9999999); /* BCD complement - 1 */
if ( !vbi_bcd_digits_greater( p_sys->i_wanted_subpage, 0x00 ) || vbi_bcd_digits_greater( p_sys->i_wanted_subpage, 0x99 ) )
p_sys->i_wanted_subpage = VBI_ANY_SUBNO;
else
msg_Info( p_dec, "subpage: %d",
vbi_bcd2dec( p_sys->i_wanted_subpage) );
p_sys->b_update = true;
vlc_mutex_unlock( &p_sys->lock );
}
/* Capture 0-9 for page selection */
if( newval.i_int < '0' || newval.i_int > '9' )
return VLC_SUCCESS;
vlc_mutex_lock( &p_sys->lock );
p_sys->i_key[0] = p_sys->i_key[1];
p_sys->i_key[1] = p_sys->i_key[2];
p_sys->i_key[2] = (int)(newval.i_int - '0');
msg_Info( p_dec, "page: %c%c%c", (char)(p_sys->i_key[0]+'0'),
(char)(p_sys->i_key[1]+'0'), (char)(p_sys->i_key[2]+'0') );
int i_new_page = 0;
if( p_sys->i_key[0] > 0 && p_sys->i_key[0] <= 8 &&
p_sys->i_key[1] >= 0 && p_sys->i_key[1] <= 9 &&
p_sys->i_key[2] >= 0 && p_sys->i_key[2] <= 9 )
{
i_new_page = p_sys->i_key[0]*100 + p_sys->i_key[1]*10 + p_sys->i_key[2];
p_sys->i_key[0] = p_sys->i_key[1] = p_sys->i_key[2] = '*' - '0';
}
vlc_mutex_unlock( &p_sys->lock );
if( i_new_page > 0 )
var_SetInteger( p_dec, "vbi-page", i_new_page );
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: initializes dump structures
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
const char *psz_mode;
vlc_value_t val;
bool b_append;
/* Accept only if forced */
if( !p_demux->b_force )
return VLC_EGENERIC;
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
var_Create( p_demux, "demuxdump-append", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
var_Get( p_demux, "demuxdump-append", &val );
b_append = val.b_bool;
if ( b_append )
psz_mode = "ab";
else
psz_mode = "wb";
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
p_sys->i_write = 0;
p_sys->p_file = NULL;
p_sys->psz_file = var_CreateGetString( p_demux, "demuxdump-file" );
if( *p_sys->psz_file == '\0' )
{
msg_Warn( p_demux, "no dump file name given" );
free( p_sys->psz_file );
free( p_sys );
return VLC_EGENERIC;
}
if( !strcmp( p_sys->psz_file, "-" ) )
{
msg_Info( p_demux, "dumping raw stream to standard output" );
p_sys->p_file = stdout;
}
else if( ( p_sys->p_file = utf8_fopen( p_sys->psz_file, psz_mode ) ) == NULL )
{
msg_Err( p_demux, "cannot create `%s' for writing", p_sys->psz_file );
free( p_sys->psz_file );
free( p_sys );
return VLC_EGENERIC;
}
msg_Info( p_demux, "%s raw stream to file `%s'",
b_append ? "appending" : "dumping", p_sys->psz_file );
return VLC_SUCCESS;
}
static void Run(intf_thread_t *intf)
{
intf_sys_t *sys = intf->p_sys;
int fd;
int canc = vlc_savecancel();
RegisterCallbacks(intf);
while(1) {
msg_Info(intf, "Creating IRC connection...");
fd = net_ConnectTCP(VLC_OBJECT(intf), sys->server, 6667);
if(fd == -1) {
msg_Err(intf, "Error connecting to server");
return;
}
msg_Info(intf, "Connected to server");
/* initialize context */
sys->fd = fd;
sys->line_loc = 0;
SendBufferInit(intf);
SendBufferAppend(intf, "NICK ");
SendBufferAppend(intf, sys->nick);
SendBufferAppend(intf, "\r\n");
SendBufferAppend(intf, "USER ");
SendBufferAppend(intf, sys->nick);
SendBufferAppend(intf, " 8 * vlc\r\n");
sys->playlist = pl_Get(intf);
#ifdef STOP_HACK
playlist_Pause(sys->playlist);
input_thread_t * input = playlist_CurrentInput(sys->playlist);
var_SetFloat(input, "position", 0.0);
#endif
EventLoop(fd, intf);
free(sys->send_buffer->buffer);
sleep(30);
}
free(sys);
vlc_restorecancel(canc);
}
void FilterWin::toBlackoutFrame()
{
#ifdef MSDEBUG1
msg_Info( p_obj, "calling blackoutFrame->load" );
#endif
blackoutFrame->load();
#ifdef MSDEBUG1
msg_Info( p_obj, "done blackoutFrame->load" );
#endif
setCurrentWidget(blackoutFrame);
}
/**
* Finds the value of a variable. If the specified object does not hold a
* variable with the specified name, try the parent object, and iterate until
* the top of the tree. If no match is found, the value is read from the
* configuration.
*/
int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type,
vlc_value_t *p_val )
{
#ifndef NDEBUG
if (p_this != VLC_OBJECT(p_this->p_libvlc)
&& unlikely(p_this->p_parent == NULL))
{
msg_Info (p_this, "%s(%s) on detached object", __func__, psz_name);
//vlc_backtrace ();
}
#endif
i_type &= VLC_VAR_CLASS;
for( vlc_object_t *obj = p_this; obj != NULL; obj = obj->p_parent )
{
if( var_GetChecked( obj, psz_name, i_type, p_val ) == VLC_SUCCESS )
return VLC_SUCCESS;
#ifndef NDEBUG
if (obj != p_this && obj != VLC_OBJECT(p_this->p_libvlc)
&& unlikely(obj->p_parent == NULL))
{
msg_Info (p_this, "%s(%s) on detached tree [%p] %s", __func__,
psz_name, obj, obj->psz_object_type);
//vlc_backtrace ();
}
#endif
}
/* else take value from config */
switch( i_type & VLC_VAR_CLASS )
{
case VLC_VAR_STRING:
p_val->psz_string = config_GetPsz( p_this, psz_name );
if( !p_val->psz_string ) p_val->psz_string = strdup("");
break;
case VLC_VAR_FLOAT:
p_val->f_float = config_GetFloat( p_this, psz_name );
break;
case VLC_VAR_INTEGER:
p_val->i_int = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_BOOL:
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_ADDRESS:
return VLC_ENOOBJ;
default:
msg_Warn( p_this, "Could not inherit value for var %s "
"from config. Invalid Type", psz_name );
return VLC_ENOOBJ;
}
/*msg_Dbg( p_this, "Inherited value for var %s from config", psz_name );*/
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: initialize and create stuff
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
msg_Err( p_intf, "The logger interface no longer exists." );
msg_Info( p_intf, "As of VLC version 0.9.0, use --file-logging to write "
"logs to a file." );
# ifndef _WIN32
msg_Info( p_intf, "Use --syslog to send logs to the system logger." );
# endif
return VLC_EGENERIC;
}
/*****************************************************************************
* Everything else
*****************************************************************************/
static int AddDevice( services_discovery_t *p_sd,
LIBMTP_raw_device_t *p_raw_device )
{
char *psz_name = NULL;
LIBMTP_mtpdevice_t *p_device;
LIBMTP_track_t *p_track, *p_tmp;
if( ( p_device = LIBMTP_Open_Raw_Device( p_raw_device ) ) != NULL )
{
if( !( psz_name = LIBMTP_Get_Friendlyname( p_device ) ) )
if( !( psz_name = LIBMTP_Get_Modelname( p_device ) ) )
if( !( psz_name = strdup( N_( "MTP Device" ) ) ) )
return VLC_ENOMEM;
msg_Info( p_sd, "Found device: %s", psz_name );
p_sd->p_sys->i_bus = p_raw_device->bus_location;
p_sd->p_sys->i_dev = p_raw_device->devnum;
p_sd->p_sys->i_product_id = p_raw_device->device_entry.product_id;
if( ( p_track = LIBMTP_Get_Tracklisting_With_Callback( p_device,
CountTracks, p_sd ) ) == NULL )
{
msg_Warn( p_sd, "No tracks on the device" );
}
else
{
if( !( p_sd->p_sys->pp_items = calloc( p_sd->p_sys->i_tracks_num,
sizeof( input_item_t * ) ) ) )
{
free( psz_name );
return VLC_ENOMEM;
}
p_sd->p_sys->i_count = 0;
while( p_track != NULL )
{
msg_Dbg( p_sd, "Track found: %s - %s", p_track->artist,
p_track->title );
AddTrack( p_sd, p_track );
p_tmp = p_track;
p_track = p_track->next;
LIBMTP_destroy_track_t( p_tmp );
}
}
p_sd->p_sys->psz_name = psz_name;
LIBMTP_Release_Device( p_device );
return VLC_SUCCESS;
}
else
{
msg_Info( p_sd, "The device seems to be mounted, unmount it first" );
return VLC_EGENERIC;
}
}
/*****************************************************************************
* Render: displays previously rendered output
*****************************************************************************/
static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
{
filter_sys_t *p_sys = p_filter->p_sys;
filter_t *p_blend;
if( p_sys->b_done )
return p_pic;
p_blend = vlc_object_create( p_filter, sizeof(filter_t) );
if( !p_blend )
{
picture_Release( p_pic );
return NULL;
}
p_blend->fmt_out.video = p_sys->p_base_image->format;
p_blend->fmt_in.video = p_sys->p_blend_image->format;
p_blend->p_module = module_need( p_blend, "video blending", NULL, false );
if( !p_blend->p_module )
{
picture_Release( p_pic );
vlc_object_delete(p_blend);
return NULL;
}
vlc_tick_t time = vlc_tick_now();
for( int i_iter = 0; i_iter < p_sys->i_loops; ++i_iter )
{
p_blend->pf_video_blend( p_blend,
p_sys->p_base_image, p_sys->p_blend_image,
0, 0, p_sys->i_alpha );
}
time = vlc_tick_now() - time;
msg_Info( p_filter, "Blended %d images in %f sec", p_sys->i_loops,
secf_from_vlc_tick(time) );
msg_Info( p_filter, "Speed is: %f images/second, %f pixels/second",
(float) p_sys->i_loops / time * CLOCK_FREQ,
(float) p_sys->i_loops / time * CLOCK_FREQ *
p_sys->p_blend_image->p[Y_PLANE].i_visible_pitch *
p_sys->p_blend_image->p[Y_PLANE].i_visible_lines );
module_unneed( p_blend, p_blend->p_module );
vlc_object_delete(p_blend);
p_sys->b_done = true;
return p_pic;
}
/*****************************************************************************
* Open: initialize dummy interface
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
vlm_t *mediatheque;
char *psz_address;
vlc_url_t url;
int i_telnetport;
if( !(mediatheque = vlm_New( p_intf )) )
{
msg_Err( p_intf, "cannot start VLM" );
return VLC_EGENERIC;
}
msg_Info( p_intf, "using the VLM interface plugin..." );
i_telnetport = config_GetInt( p_intf, "telnet-port" );
psz_address = config_GetPsz( p_intf, "telnet-host" );
vlc_UrlParse(&url, psz_address, 0);
// There might be two ports given, resolve any potentially
// conflict
url.i_port = getPort(p_intf, url, i_telnetport);
p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
if( ( p_intf->p_sys->pi_fd = net_ListenTCP( p_intf, url.psz_host, url.i_port ) )
== NULL )
{
msg_Err( p_intf, "cannot listen for telnet" );
vlc_UrlClean(&url);
free( psz_address );
free( p_intf->p_sys );
return VLC_EGENERIC;
}
msg_Info( p_intf,
"telnet interface started on interface %s %d",
url.psz_host, url.i_port );
p_intf->p_sys->i_clients = 0;
p_intf->p_sys->clients = NULL;
p_intf->p_sys->mediatheque = mediatheque;
p_intf->pf_run = Run;
vlc_UrlClean(&url);
free( psz_address );
return VLC_SUCCESS;
}
/**
* It creates a Direct3D device manager
*/
static int D3dCreateDeviceManager(vlc_va_dxva2_t *va)
{
HRESULT (WINAPI *CreateDeviceManager9)(UINT *pResetToken,
IDirect3DDeviceManager9 **);
CreateDeviceManager9 =
(void *)GetProcAddress(va->hdxva2_dll,
TEXT("DXVA2CreateDirect3DDeviceManager9"));
if (!CreateDeviceManager9) {
msg_Err(va->log, "cannot load function");
return VLC_EGENERIC;
}
msg_Dbg(va->log, "OurDirect3DCreateDeviceManager9 Success!");
UINT token;
IDirect3DDeviceManager9 *devmng;
if (FAILED(CreateDeviceManager9(&token, &devmng))) {
msg_Err(va->log, " OurDirect3DCreateDeviceManager9 failed");
return VLC_EGENERIC;
}
va->token = token;
va->devmng = devmng;
msg_Info(va->log, "obtained IDirect3DDeviceManager9");
HRESULT hr = IDirect3DDeviceManager9_ResetDevice(devmng, va->d3ddev, token);
if (FAILED(hr)) {
msg_Err(va->log, "IDirect3DDeviceManager9_ResetDevice failed: %08x", (unsigned)hr);
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/**
* Add an interface plugin and run it
*/
int libvlc_InternalAddIntf( libvlc_int_t *p_libvlc, const char *name )
{
int ret;
if( !p_libvlc )
return VLC_EGENERIC;
if( name != NULL )
ret = intf_Create( p_libvlc, name );
else
{ /* Default interface */
char *intf = var_InheritString( p_libvlc, "intf" );
if( intf == NULL ) /* "intf" has not been set */
{
char *pidfile = var_InheritString( p_libvlc, "pidfile" );
if( pidfile != NULL )
free( pidfile );
else
msg_Info( p_libvlc, "%s",
_("Running vlc with the default interface. "
"Use 'cvlc' to use vlc without interface.") );
}
ret = intf_Create( p_libvlc, intf );
name = "default";
}
if( ret )
msg_Err( p_libvlc, "interface \"%s\" initialization failed", name );
return ret;
}
/**
* Load a certain playlist file into the playlist
* This file will replace the contents of the "current" view
*
* \param p_playlist the playlist to which the new items will be added
* \param psz_filename the name of the playlistfile to import
* \return VLC_SUCCESS on success
*/
int playlist_Load( playlist_t * p_playlist, const char *psz_filename )
{
playlist_item_t *p_item;
char *psz_uri;
int i_id;
msg_Info( p_playlist, "clearing playlist");
playlist_Clear( p_playlist );
psz_uri = (char *)malloc(sizeof(char)*strlen(psz_filename) + 17 );
sprintf( psz_uri, "file/playlist://%s", psz_filename);
i_id = playlist_Add( p_playlist, psz_uri, psz_uri,
PLAYLIST_INSERT , PLAYLIST_END);
vlc_mutex_lock( &p_playlist->object_lock );
p_item = playlist_ItemGetById( p_playlist, i_id );
p_item->b_autodeletion = VLC_TRUE;
vlc_mutex_unlock( &p_playlist->object_lock );
playlist_Play(p_playlist);
return VLC_SUCCESS;
}
/*****************************************************************************
* sout_SLDePReg: Unregisters the program from SLP
*****************************************************************************/
int sout_SLPDereg( sout_instance_t *p_sout, char * psz_url,
char * psz_name)
{
#ifdef HAVE_SLP_H
SLPHandle slp_handle;
SLPError slp_res;
char *psz_service= sout_SLPBuildName(psz_url,psz_name);
if( SLPOpen( NULL, SLP_FALSE, &slp_handle ) != SLP_OK)
{
msg_Warn(p_sout,"Unable to initialize SLP");
return -1;
}
msg_Info(p_sout , "Unregistering %s from SLP",
psz_service);
slp_res = SLPDereg ( slp_handle,
psz_service,
sout_SLPReport,
NULL );
if( slp_res != SLP_OK )
{
msg_Warn(p_sout,"Error while registering service: %i", slp_res );
return -1;
}
return 0;
#else /* This function should never be called if this is false */
return -1;
#endif
}
/**
* It creates a Direct3D device manager
*/
static int D3dCreateDeviceManager(vlc_va_t *va)
{
vlc_va_sys_t *sys = va->sys;
directx_sys_t *dx_sys = &va->sys->dx_sys;
HRESULT (WINAPI *CreateDeviceManager9)(UINT *pResetToken,
IDirect3DDeviceManager9 **);
CreateDeviceManager9 =
(void *)GetProcAddress(dx_sys->hdecoder_dll,
"DXVA2CreateDirect3DDeviceManager9");
if (!CreateDeviceManager9) {
msg_Err(va, "cannot load function");
return VLC_EGENERIC;
}
msg_Dbg(va, "OurDirect3DCreateDeviceManager9 Success!");
UINT token;
IDirect3DDeviceManager9 *devmng;
if (FAILED(CreateDeviceManager9(&token, &devmng))) {
msg_Err(va, " OurDirect3DCreateDeviceManager9 failed");
return VLC_EGENERIC;
}
sys->devmng = devmng;
msg_Info(va, "obtained IDirect3DDeviceManager9");
HRESULT hr = IDirect3DDeviceManager9_ResetDevice(devmng, (IDirect3DDevice9*) dx_sys->d3ddev, token);
if (FAILED(hr)) {
msg_Err(va, "IDirect3DDeviceManager9_ResetDevice failed: %08x", (unsigned)hr);
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/**
* Add an interface plugin and run it
*/
int libvlc_InternalAddIntf( libvlc_int_t *p_libvlc, char const *psz_module )
{
if( !p_libvlc )
return VLC_EGENERIC;
if( !psz_module ) /* requesting the default interface */
{
char *psz_interface = var_CreateGetNonEmptyString( p_libvlc, "intf" );
if( !psz_interface ) /* "intf" has not been set */
{
#if !defined( WIN32 ) && !defined( __OS2__ )
if( b_daemon )
/* Daemon mode hack.
* We prefer the dummy interface if none is specified. */
psz_module = "dummy";
else
#endif
msg_Info( p_libvlc, "%s",
_("Running vlc with the default interface. "
"Use 'cvlc' to use vlc without interface.") );
}
free( psz_interface );
var_Destroy( p_libvlc, "intf" );
}
/* Try to create the interface */
int ret = intf_Create( p_libvlc, psz_module ? psz_module : "$intf" );
if( ret )
msg_Err( p_libvlc, "interface \"%s\" initialization failed",
psz_module ? psz_module : "default" );
return ret;
}
void InitialiseGenerator(int argc, char *argv[])
{
if(argc<2) {
cout<<"Usage: ./SingleDecay <PDG_CODE>"<<endl;
THROW(normal_exit,"you didn't specify the decaying particle by PDG code.");
}
small_sherpa_init(argc, argv);
hadrons = new SHERPA::Hadron_Decay_Handler(".", "Fragmentation.dat");
mother_flav = Flavour( (kf_code) abs(ToType<int>(argv[1])) );
mother_flav.SetStable(false);
if(ToType<int>(argv[1])<0) mother_flav=mother_flav.Bar();
if(hadrons->DecayMap()->FindDecay(mother_flav)==NULL)
THROW(fatal_error, "Didn't find "+ToString<Flavour>(mother_flav)+
" in HadronDecays.dat.");
// set all decay channel BR's equal, such that we generate the same amount of
// each decay channel to be tested
PHASIC::Decay_Table* table=hadrons->DecayMap()->FindDecay(mother_flav);
for(size_t i(0);i<table->size();++i)
table->UpdateWidth(table->at(i), 1.0);
rpa->gen.SetEcms(mother_flav.HadMass());
msg_Info()<<"Welcome. I am decaying a "<<mother_flav<<endl;
}
static void print_chunk( stream_t *s, chunk_t *ck )
{
msg_Info( s, "chunk %u type %i: duration is %"PRIu64", stime is %"PRIu64", "\
"size is %i, offset is %"PRIu64", read_pos is %i.",
ck->sequence, ck->type, ck->duration,
ck->start_time, ck->size, ck->offset, ck->read_pos );
}
/**
* Starts an interface plugin.
*/
int libvlc_InternalAddIntf(libvlc_int_t *libvlc, const char *name)
{
playlist_t *playlist = intf_GetPlaylist(libvlc);
int ret;
if (unlikely(playlist == NULL))
ret = VLC_ENOMEM;
else
if (name != NULL)
ret = intf_Create(playlist, name);
else
{ /* Default interface */
char *intf = var_InheritString(libvlc, "intf");
if (intf == NULL) /* "intf" has not been set */
{
char *pidfile = var_InheritString(libvlc, "pidfile");
if (pidfile != NULL)
free(pidfile);
else
msg_Info(libvlc, _("Running vlc with the default interface. "
"Use 'cvlc' to use vlc without interface."));
}
ret = intf_Create(playlist, intf);
name = "default";
}
if (ret != VLC_SUCCESS)
msg_Err(libvlc, "interface \"%s\" initialization failed", name);
return ret;
}
/**
* @brief VLC flush callback
* @param intf
*/
static void y4m_flush(filter_t* intf)
{
filter_sys_t* sys = intf->p_sys;
msg_Info(intf, "flush: enter: buffers=%d:%d:%d",
sys->bufferedIn, sys->bufferedOut, sys->minBuffered);
// flush what we can, there can still be frames outstanding
// after the flush so the counts need to be updated
// block the input thread while flushing its fifo.
// vlc_mutex_lock(&sys->inputMutex);
// picture_t* pic;
// while ((pic = picture_fifo_Pop(sys->inputFifo)))
// {
// picture_Release(pic);
// sys->bufferedIn--;
// sys->bufferedOut -= sys->bufferRatio;
// }
// vlc_mutex_unlock(&sys->inputMutex);
picture_t* pic;
while ((pic = picture_fifo_Pop(sys->outputFifo)))
{
picture_Release(pic);
sys->bufferedOut--;
}
// check our accounting, if it goes below zero there is race somewhere
if (sys->bufferedOut < 0)
{
msg_Err(intf, "flush: race condition on output count");
sys->bufferedOut = 0;
}
if (sys->bufferedIn < 0)
{
msg_Err(intf, "flush: race condition on input count");
sys->bufferedIn = 0;
}
sys->minBuffered = sys->bufferedOut;
sys->lastDate = 0;
msg_Info(intf, "flush: exit: buffers=%d:%d:%d",
sys->bufferedIn, sys->bufferedOut, sys->minBuffered);
}
static void sighandler(struct ev_loop *loop, struct ev_signal *w, int revents)
{
switch (w->signum)
{
case SIGINT:
case SIGTERM:
default:
msg_Info( NULL, "Shutdown was requested." );
ev_break(loop, EVBREAK_ALL);
break;
case SIGHUP:
msg_Info( NULL, "Configuration reload was requested." );
config_ReadFile();
break;
}
}
/* Fires when user clicks position bar. - Restart loaded Filter. */
static MOVIESOAP_CALLBACK(InputCbPosition)
{
#ifdef MSDEBUG3
msg_Info( p_this, "!!! CALLBACK input position !!! : %s ... new: %f ... old: %f", psz_var, (float) newval.f_float, (float) oldval.f_float );
#endif
if (p_loadedFilter) {
mtime_t new_time = newval.f_float * var_GetTime( p_input, "length" );
#ifdef MSDEBUG2
char buffer[12];
strftime(new_time / MOVIESOAP_MOD_TIME_FACTOR, buffer);
msg_Info(p_this, "new time %lld\n%s", new_time, &buffer[0]);
#endif
StopAndStartFilter(new_time);
}
return 0;
}
UpnpInstanceWrapper *UpnpInstanceWrapper::get(vlc_object_t *p_obj, Upnp_FunPtr callback, SD::MediaServerList *opaque)
{
vlc_mutex_locker lock( &s_lock );
if ( s_instance == NULL )
{
UpnpInstanceWrapper* instance = new(std::nothrow) UpnpInstanceWrapper;
if ( unlikely( !instance ) )
return NULL;
#ifdef UPNP_ENABLE_IPV6
char* psz_miface = var_InheritString( p_obj, "miface" );
msg_Info( p_obj, "Initializing libupnp on '%s' interface", psz_miface );
int i_res = UpnpInit2( psz_miface, 0 );
free( psz_miface );
#else
/* If UpnpInit2 isnt available, initialize on first IPv4-capable interface */
int i_res = UpnpInit( 0, 0 );
#endif
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_obj, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) );
delete instance;
return NULL;
}
ixmlRelaxParser( 1 );
/* Register a control point */
i_res = UpnpRegisterClient( Callback, instance, &instance->handle_ );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_obj, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) );
delete instance;
return NULL;
}
/* libupnp does not treat a maximum content length of 0 as unlimited
* until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate
* between versions */
if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS )
{
msg_Err( p_obj, "Failed to set maximum content length: %s",
UpnpGetErrorMessage( i_res ));
delete instance;
return NULL;
}
s_instance = instance;
}
s_instance->refcount_++;
// This assumes a single UPNP SD instance
if (callback && opaque)
{
assert(!s_instance->callback_ && !s_instance->opaque_);
s_instance->opaque_ = opaque;
s_instance->callback_ = callback;
}
return s_instance;
}
/**
* @brief Thread reading frames from the subprocess
*/
static void* outputThread(void* userData)
{
filter_t* intf = (filter_t*)userData;
filter_sys_t* sys = intf->p_sys;
msg_Info(intf, "outputThread: enter");
bool gotHeader = false;
while (true)
{
if (!gotHeader)
{
video_format_Init(&sys->outFormat, VLC_CODEC_I420);
if (1 != readY4mHeader(intf, &sys->outFormat, sys->stdout))
break;
gotHeader = true;
}
picture_t* outPic = picture_NewFromFormat(&sys->outFormat);
if(1 != readY4mFrame(intf, outPic, sys->stdout))
{
picture_Release(outPic);
break;
}
//msg_Info(intf, "outputThread: read picture");
// fixme: deinterlace filter does this, not sure if we need to;
// y4m header contains this information
outPic->b_progressive = true;
outPic->i_nb_fields = 2;
picture_fifo_Push(sys->outputFifo, outPic);
vlc_cond_signal(&sys->outputCond);
}
msg_Info(intf, "outputThread: exit");
sys->threadExit = true;
vlc_cond_signal(&sys->outputCond);
return userData;
}
static int vlclua_msg_info( lua_State *L )
{
int i_top = lua_gettop( L );
vlc_object_t *p_this = vlclua_get_this( L );
int i;
for( i = 1; i <= i_top; i++ )
msg_Info( p_this, "%s", luaL_checkstring( L, i ) );
return 0;
}
/*****************************************************************************
* OpenDemux: initialize the target, ie. parse the command
*****************************************************************************/
int OpenDemux ( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
char * psz_name = p_demux->psz_path;
p_demux->pf_control = DemuxControl;
p_demux->p_sys = NULL;
/* Check for a "vlc://nop" command */
if( !strcasecmp( psz_name, "nop" ) )
{
msg_Info( p_demux, "command `nop'" );
p_demux->pf_demux = DemuxNoOp;
return VLC_SUCCESS;
}
/* Check for a "vlc://quit" command */
if( !strcasecmp( psz_name, "quit" ) )
{
msg_Info( p_demux, "command `quit'" );
p_demux->pf_demux = DemuxNoOp;
libvlc_Quit( p_demux->p_libvlc );
return VLC_SUCCESS;
}
/* Check for a "vlc://pause:***" command */
if( !strncasecmp( psz_name, "pause:", 6 ) )
{
double f = us_atof( psz_name + 6 );
mtime_t end = mdate() + f * (mtime_t)1000000;
msg_Info( p_demux, "command `pause %f'", f );
p_demux->pf_demux = DemuxPause;
p_demux->p_sys = malloc( sizeof( end ) );
if( p_demux->p_sys == NULL )
return VLC_ENOMEM;
memcpy( p_demux->p_sys, &end, sizeof( end ) );
return VLC_SUCCESS;
}
msg_Err( p_demux, "unknown command `%s'", psz_name );
return VLC_EGENERIC;
}
void loadFilterDialogue(QWidget * parent)
{ // Get filepath from user
QString filepath = QFileDialog::getOpenFileName( parent,
QString("Open Moviesoap filter file"),
QString(saveDir().c_str()),
QString(MOVIESOAP_FILECHOOSER_FILTER));
if ( !filepath.isEmpty() ) {
vlc_mutex_lock( &Moviesoap::lock );
// Ensure existence of loaded filter
if (Moviesoap::p_loadedFilter == NULL)
Moviesoap::p_loadedFilter = new Filter;
// Stop loaded filter in case it is running
vlc_mutex_unlock( &Moviesoap::lock );
Moviesoap::spawn_stop_filter();
// Overwrite loaded filter with data from filter file
const char * c_filepath = qPrintable(filepath);
int err = Moviesoap::p_loadedFilter->load( c_filepath );
// Display error (if any) in QMessageBox
if (err) {
stringstream msgs;
msgs << "Failure to load filter from file.\nError code " << err;
QMessageBox::warning( parent,
QString("File IO failure"),
QString(msgs.str().c_str()),
QMessageBox::Ok);
return;
}
// if no error:
#ifdef MSDEBUG1
msg_Info( p_obj, "OLD FILTER OVERWRITTEN" );
msg_Info( p_obj, "IS ACTIVE SELECTED: %d", isActiveSelected() );
#endif
// Start loaded filter if menu has active selected
if ( isActiveSelected() ) {
if (Moviesoap::p_input == NULL)
spawn_set_p_input(false);
#ifdef MSDEBUG1
msg_Info(p_obj, "p input: %x", p_input);
#endif
if (Moviesoap::p_input)
Moviesoap::spawn_restart_filter();
}
}
}
/**
* @brief Thread writing frames to the subprocess
*/
static void* inputThread(void* userData)
{
filter_t* intf = (filter_t*)userData;
filter_sys_t* sys = intf->p_sys;
msg_Info(intf, "inputThread: enter");
while (true)
{
picture_t* pic;
// acquire a frame pushed from y4m_filter()
vlc_mutex_lock(&sys->inputMutex);
mutex_cleanup_push(&sys->inputMutex);
while (NULL == (pic = picture_fifo_Pop(sys->inputFifo)))
{
//msg_Info(intf, "inputThread: wait picture");
vlc_cond_wait(&sys->inputCond, &sys->inputMutex);
}
sys->bufferedIn--;
vlc_mutex_unlock(&sys->inputMutex);
vlc_cleanup_pop();
//msg_Info(intf, "inputThread: write picture");
if (1 != writeY4mFrame(intf, pic, sys->stdin))
{
msg_Err(intf, "inputThread: Failed to write y4m frame");
break;
}
picture_Release(pic);
}
msg_Info(intf, "inputThread: exit");
sys->threadExit = true;
return userData;
}
static void LoopRequest( playlist_t *p_playlist )
{
playlist_private_t *p_sys = pl_priv(p_playlist);
assert( !p_sys->p_input );
/* No input. Several cases
* - No request, running status -> start new item
* - No request, stopped status -> collect garbage
* - Request, running requested -> start new item
* - Request, stopped requested -> collect garbage
*/
const int i_status = p_sys->request.b_request ?
p_sys->request.i_status : p_sys->status.i_status;
if( i_status == PLAYLIST_STOPPED || !vlc_object_alive( p_playlist ) )
{
p_sys->status.i_status = PLAYLIST_STOPPED;
if( p_sys->p_input_resource &&
input_resource_HasVout( p_sys->p_input_resource ) )
{
/* XXX We can unlock if we don't issue the wait as we will be
* call again without anything else done between the calls */
PL_UNLOCK;
/* input_resource_t must be manipulated without playlist lock */
input_resource_TerminateVout( p_sys->p_input_resource );
PL_LOCK;
}
else
{
if( vlc_object_alive( p_playlist ) )
vlc_cond_wait( &p_sys->signal, &p_sys->lock );
}
return;
}
playlist_item_t *p_item = NextItem( p_playlist );
if( p_item )
{
msg_Dbg( p_playlist, "starting playback of the new playlist item" );
PlayItem( p_playlist, p_item );
return;
}
msg_Dbg( p_playlist, "nothing to play" );
p_sys->status.i_status = PLAYLIST_STOPPED;
if( var_GetBool( p_playlist, "play-and-exit" ) )
{
msg_Info( p_playlist, "end of playlist, exiting" );
libvlc_Quit( p_playlist->p_libvlc );
}
}
