static int OpenEncoder( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys;
int i_frequency;
if( p_enc->fmt_out.i_codec != VLC_CODEC_MP2 &&
p_enc->fmt_out.i_codec != VLC_CODEC_MPGA &&
p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '2', 'a' ) &&
!p_enc->b_force )
{
return VLC_EGENERIC;
}
if( p_enc->fmt_in.audio.i_channels > 2 )
{
msg_Err( p_enc, "doesn't support > 2 channels" );
return VLC_EGENERIC;
}
for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
{
if ( p_enc->fmt_out.audio.i_rate == mpa_freq_tab[i_frequency] )
break;
}
if ( i_frequency == 6 )
{
msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
p_enc->fmt_out.audio.i_rate );
return VLC_EGENERIC;
}
/* Allocate the memory needed to store the decoder's structure */
if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
return VLC_ENOMEM;
p_enc->p_sys = p_sys;
p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
p_enc->fmt_out.i_cat = AUDIO_ES;
p_enc->fmt_out.i_codec = VLC_CODEC_MPGA;
config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
p_sys->p_twolame = twolame_init();
/* Set options */
twolame_set_in_samplerate( p_sys->p_twolame, p_enc->fmt_out.audio.i_rate );
twolame_set_out_samplerate( p_sys->p_twolame, p_enc->fmt_out.audio.i_rate );
if( var_GetBool( p_enc, ENC_CFG_PREFIX "vbr" ) )
{
float f_quality = var_GetFloat( p_enc, ENC_CFG_PREFIX "quality" );
if ( f_quality > 50.f ) f_quality = 50.f;
if ( f_quality < 0.f ) f_quality = 0.f;
twolame_set_VBR( p_sys->p_twolame, 1 );
twolame_set_VBR_q( p_sys->p_twolame, f_quality );
}
else
{
int i;
for ( i = 1; i < 14; i++ )
{
if ( p_enc->fmt_out.i_bitrate / 1000
<= mpa_bitrate_tab[i_frequency / 3][i] )
break;
}
if ( p_enc->fmt_out.i_bitrate / 1000
!= mpa_bitrate_tab[i_frequency / 3][i] )
{
msg_Warn( p_enc, "MPEG audio doesn't support bitrate=%d, using %d",
p_enc->fmt_out.i_bitrate,
mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
p_enc->fmt_out.i_bitrate = mpa_bitrate_tab[i_frequency / 3][i]
* 1000;
}
twolame_set_bitrate( p_sys->p_twolame,
p_enc->fmt_out.i_bitrate / 1000 );
}
if ( p_enc->fmt_in.audio.i_channels == 1 )
{
twolame_set_num_channels( p_sys->p_twolame, 1 );
twolame_set_mode( p_sys->p_twolame, TWOLAME_MONO );
}
else
{
twolame_set_num_channels( p_sys->p_twolame, 2 );
switch( var_GetInteger( p_enc, ENC_CFG_PREFIX "mode" ) )
{
case 1:
twolame_set_mode( p_sys->p_twolame, TWOLAME_DUAL_CHANNEL );
break;
case 2:
twolame_set_mode( p_sys->p_twolame, TWOLAME_JOINT_STEREO );
break;
case 0:
default:
twolame_set_mode( p_sys->p_twolame, TWOLAME_STEREO );
break;
}
}
twolame_set_psymodel( p_sys->p_twolame,
var_GetInteger( p_enc, ENC_CFG_PREFIX "psy" ) );
if ( twolame_init_params( p_sys->p_twolame ) )
{
msg_Err( p_enc, "twolame initialization failed" );
return -VLC_EGENERIC;
}
p_enc->pf_encode_audio = Encode;
p_sys->i_nb_samples = 0;
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
int fd;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access, "no file name specified" );
return VLC_EGENERIC;
}
bool overwrite = var_GetBool (p_access, SOUT_CFG_PREFIX"overwrite");
bool append = var_GetBool( p_access, SOUT_CFG_PREFIX "append" );
if (!strcmp (p_access->psz_access, "fd"))
{
char *end;
fd = strtol (p_access->psz_path, &end, 0);
if (!*p_access->psz_path || *end)
{
msg_Err (p_access, "invalid file descriptor: %s",
p_access->psz_path);
return VLC_EGENERIC;
}
fd = vlc_dup (fd);
if (fd == -1)
{
msg_Err (p_access, "cannot use file descriptor: %s",
vlc_strerror_c(errno));
return VLC_EGENERIC;
}
}
else
if( !strcmp( p_access->psz_path, "-" ) )
{
#if defined( _WIN32 ) || defined( __OS2__ )
setmode (STDOUT_FILENO, O_BINARY);
#endif
fd = vlc_dup (STDOUT_FILENO);
if (fd == -1)
{
msg_Err (p_access, "cannot use standard output: %s",
vlc_strerror_c(errno));
return VLC_EGENERIC;
}
msg_Dbg( p_access, "using stdout" );
}
else
{
const char *path = p_access->psz_path;
char *buf = NULL;
if (var_InheritBool (p_access, SOUT_CFG_PREFIX"format"))
{
buf = str_format_time (path);
path_sanitize (buf);
path = buf;
}
int flags = O_RDWR | O_CREAT | O_LARGEFILE;
if (!overwrite)
flags |= O_EXCL;
if (!append)
flags |= O_TRUNC;
#ifdef O_SYNC
if (var_GetBool (p_access, SOUT_CFG_PREFIX"sync"))
flags |= O_SYNC;
#endif
do
{
fd = vlc_open (path, flags, 0666);
if (fd != -1)
break;
if (fd == -1)
msg_Err (p_access, "cannot create %s: %s", path,
vlc_strerror_c(errno));
if (overwrite || errno != EEXIST)
break;
flags &= ~O_EXCL;
}
while (vlc_dialog_wait_question (p_access, VLC_DIALOG_QUESTION_NORMAL,
_("Keep existing file"),
_("Overwrite"), NULL, path,
_("The output file already exists. "
"If recording continues, the file will be "
"overridden and its content will be lost.")) == 1);
free (buf);
if (fd == -1)
return VLC_EGENERIC;
}
struct stat st;
if (fstat (fd, &st))
{
msg_Err (p_access, "write error: %s", vlc_strerror_c(errno));
close (fd);
return VLC_EGENERIC;
}
p_access->pf_read = Read;
if (S_ISREG(st.st_mode) || S_ISBLK(st.st_mode))
{
p_access->pf_write = Write;
p_access->pf_seek = Seek;
}
#ifdef S_ISSOCK
else if (S_ISSOCK(st.st_mode))
{
p_access->pf_write = Send;
p_access->pf_seek = NoSeek;
}
#endif
else
{
p_access->pf_write = WritePipe;
p_access->pf_seek = NoSeek;
}
p_access->pf_control = Control;
p_access->p_sys = (void *)(intptr_t)fd;
msg_Dbg( p_access, "file access output opened (%s)", p_access->psz_path );
if (append)
lseek (fd, 0, SEEK_END);
return VLC_SUCCESS;
}
/*****************************************************************************
* EventThread: Create video window & handle its messages
*****************************************************************************
* This function creates a video window and then enters an infinite loop
* that handles the messages sent to that window.
* The main goal of this thread is to isolate the Win32 PeekMessage function
* because this one can block for a long time.
*****************************************************************************/
static void *EventThread( void *p_this )
{
event_thread_t *p_event = (event_thread_t *)p_this;
vout_display_t *vd = p_event->vd;
MSG msg;
POINT old_mouse_pos = {0,0}, mouse_pos;
int canc = vlc_savecancel ();
bool b_mouse_support = var_InheritBool( p_event->vd, "mouse-events" );
bool b_key_support = var_InheritBool( p_event->vd, "keyboard-events" );
vlc_mutex_lock( &p_event->lock );
/* Create a window for the video */
/* Creating a window under Windows also initializes the thread's event
* message queue */
if( Win32VoutCreateWindow( p_event ) )
p_event->b_error = true;
p_event->b_ready = true;
vlc_cond_signal( &p_event->wait );
const bool b_error = p_event->b_error;
vlc_mutex_unlock( &p_event->lock );
if( b_error )
{
vlc_restorecancel( canc );
return NULL;
}
/* Prevent monitor from powering off */
if (var_GetBool(vd, "disable-screensaver"))
SetThreadExecutionState( ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED | ES_CONTINUOUS );
/* Main loop */
/* GetMessage will sleep if there's no message in the queue */
for( ;; )
{
vout_display_place_t place;
video_format_t source;
if( !GetMessage( &msg, 0, 0, 0 ) )
{
vlc_mutex_lock( &p_event->lock );
p_event->b_done = true;
vlc_mutex_unlock( &p_event->lock );
break;
}
/* Check if we are asked to exit */
vlc_mutex_lock( &p_event->lock );
const bool b_done = p_event->b_done;
vlc_mutex_unlock( &p_event->lock );
if( b_done )
break;
if( !b_mouse_support && isMouseEvent( msg.message ) )
continue;
if( !b_key_support && isKeyEvent( msg.message ) )
continue;
/* Handle mouse state */
if( msg.message == WM_MOUSEMOVE ||
msg.message == WM_NCMOUSEMOVE )
{
GetCursorPos( &mouse_pos );
/* FIXME, why this >2 limits ? */
if( (abs(mouse_pos.x - old_mouse_pos.x) > 2 ||
(abs(mouse_pos.y - old_mouse_pos.y)) > 2 ) )
{
old_mouse_pos = mouse_pos;
UpdateCursor( p_event, true );
}
}
else if( isMouseEvent( msg.message ) )
{
UpdateCursor( p_event, true );
}
else if( msg.message == WM_VLC_HIDE_MOUSE )
{
UpdateCursor( p_event, false );
}
/* */
switch( msg.message )
{
case WM_MOUSEMOVE:
vlc_mutex_lock( &p_event->lock );
place = p_event->place;
source = p_event->source;
vlc_mutex_unlock( &p_event->lock );
if( place.width > 0 && place.height > 0 )
{
if( msg.hwnd == p_event->hvideownd )
{
/* Child window */
place.x = 0;
place.y = 0;
}
const int x = source.i_x_offset +
(int64_t)(GET_X_LPARAM(msg.lParam) - place.x) * source.i_width / place.width;
const int y = source.i_y_offset +
(int64_t)(GET_Y_LPARAM(msg.lParam) - place.y) * source.i_height / place.height;
vout_display_SendEventMouseMoved(vd, x, y);
}
break;
case WM_NCMOUSEMOVE:
break;
case WM_VLC_HIDE_MOUSE:
break;
case WM_LBUTTONDOWN:
MousePressed( p_event, msg.hwnd, MOUSE_BUTTON_LEFT );
break;
case WM_LBUTTONUP:
MouseReleased( p_event, MOUSE_BUTTON_LEFT );
break;
case WM_LBUTTONDBLCLK:
vout_display_SendEventMouseDoubleClick(vd);
break;
case WM_MBUTTONDOWN:
MousePressed( p_event, msg.hwnd, MOUSE_BUTTON_CENTER );
break;
case WM_MBUTTONUP:
MouseReleased( p_event, MOUSE_BUTTON_CENTER );
break;
case WM_RBUTTONDOWN:
MousePressed( p_event, msg.hwnd, MOUSE_BUTTON_RIGHT );
break;
case WM_RBUTTONUP:
MouseReleased( p_event, MOUSE_BUTTON_RIGHT );
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
/* The key events are first processed here and not translated
* into WM_CHAR events because we need to know the status of the
* modifier keys. */
int i_key = Win32VoutConvertKey( msg.wParam );
if( !i_key )
{
/* This appears to be a "normal" (ascii) key */
i_key = tolower( (unsigned char)MapVirtualKey( msg.wParam, 2 ) );
}
if( i_key )
{
if( GetKeyState(VK_CONTROL) & 0x8000 )
{
i_key |= KEY_MODIFIER_CTRL;
}
if( GetKeyState(VK_SHIFT) & 0x8000 )
{
i_key |= KEY_MODIFIER_SHIFT;
}
if( GetKeyState(VK_MENU) & 0x8000 )
{
i_key |= KEY_MODIFIER_ALT;
}
vout_display_SendEventKey(vd, i_key);
}
break;
}
case WM_MOUSEWHEEL:
{
int i_key;
if( GET_WHEEL_DELTA_WPARAM( msg.wParam ) > 0 )
{
i_key = KEY_MOUSEWHEELUP;
}
else
{
i_key = KEY_MOUSEWHEELDOWN;
}
if( i_key )
{
if( GetKeyState(VK_CONTROL) & 0x8000 )
{
i_key |= KEY_MODIFIER_CTRL;
}
if( GetKeyState(VK_SHIFT) & 0x8000 )
{
i_key |= KEY_MODIFIER_SHIFT;
}
if( GetKeyState(VK_MENU) & 0x8000 )
{
i_key |= KEY_MODIFIER_ALT;
}
vout_display_SendEventKey(vd, i_key);
}
break;
}
case WM_VLC_CHANGE_TEXT:
{
vlc_mutex_lock( &p_event->lock );
wchar_t *pwz_title = NULL;
if( p_event->psz_title )
{
const size_t i_length = strlen(p_event->psz_title);
pwz_title = malloc( 2 * (i_length + 1) );
if( pwz_title )
{
mbstowcs( pwz_title, p_event->psz_title, 2 * i_length );
pwz_title[i_length] = 0;
}
}
vlc_mutex_unlock( &p_event->lock );
if( pwz_title )
{
SetWindowTextW( p_event->hwnd, pwz_title );
if( p_event->hfswnd )
SetWindowTextW( p_event->hfswnd, pwz_title );
free( pwz_title );
}
break;
}
default:
/* Messages we don't handle directly are dispatched to the
* window procedure */
TranslateMessage(&msg);
DispatchMessage(&msg);
break;
} /* End Switch */
} /* End Main loop */
/* Check for WM_QUIT if we created the window */
if( !p_event->hparent && msg.message == WM_QUIT )
{
msg_Warn( vd, "WM_QUIT... should not happen!!" );
p_event->hwnd = NULL; /* Window already destroyed */
}
msg_Dbg( vd, "Win32 Vout EventThread terminating" );
Win32VoutCloseWindow( p_event );
vlc_restorecancel(canc);
return NULL;
}
void VlcProc::on_intf_event_changed( vlc_object_t* p_obj, vlc_value_t newVal )
{
input_thread_t* pInput = (input_thread_t*) p_obj;
assert( getIntf()->p_sys->p_input == NULL || getIntf()->p_sys->p_input == pInput );
if( !getIntf()->p_sys->p_input )
{
msg_Dbg( getIntf(), "new input %p detected", pInput );
getIntf()->p_sys->p_input = pInput;
vlc_object_hold( pInput );
// update global variables pertaining to this input
update_current_input();
// ensure the playtree is also updated
// (highlights the new item to be played back)
getPlaytreeVar().onUpdateCurrent( true );
}
switch( newVal.i_int )
{
case INPUT_EVENT_STATE:
{
int state = var_GetInteger( pInput, "state" );
SET_BOOL( m_cVarStopped, false );
SET_BOOL( m_cVarPlaying, state != PAUSE_S );
SET_BOOL( m_cVarPaused, state == PAUSE_S );
break;
}
case INPUT_EVENT_POSITION:
{
float pos = var_GetFloat( pInput, "position" );
SET_STREAMTIME( m_cVarTime, pos, false );
SET_BOOL( m_cVarSeekable, pos != 0.0 );
break;
}
case INPUT_EVENT_RATE:
{
float rate = var_GetFloat( pInput, "rate" );
char* buffer;
if( asprintf( &buffer, "%.3g", rate ) != -1 )
{
SET_TEXT( m_cVarSpeed, UString( getIntf(), buffer ) );
free( buffer );
}
break;
}
case INPUT_EVENT_ES:
{
// Do we have audio
vlc_value_t audio_es;
var_Change( pInput, "audio-es", VLC_VAR_CHOICESCOUNT,
&audio_es, NULL );
SET_BOOL( m_cVarHasAudio, audio_es.i_int > 0 );
break;
}
case INPUT_EVENT_VOUT:
{
vout_thread_t* pVout = input_GetVout( pInput );
SET_BOOL( m_cVarHasVout, pVout != NULL );
if( !pVout || pVout == m_pVout )
{
// end of input or vout reuse (nothing to do)
if( pVout )
vlc_object_release( pVout );
break;
}
if( m_pVout )
{
// remove previous Vout callbacks
var_DelCallback( m_pVout, "mouse-moved",
onGenericCallback, this );
vlc_object_release( m_pVout );
m_pVout = NULL;
}
// add new Vout callbackx
var_AddCallback( pVout, "mouse-moved",
onGenericCallback, this );
m_pVout = pVout;
break;
}
case INPUT_EVENT_CHAPTER:
{
vlc_value_t chapters_count;
var_Change( pInput, "chapter", VLC_VAR_CHOICESCOUNT,
&chapters_count, NULL );
SET_BOOL( m_cVarDvdActive, chapters_count.i_int > 0 );
break;
}
case INPUT_EVENT_RECORD:
SET_BOOL( m_cVarRecording, var_GetBool( pInput, "record" ) );
break;
case INPUT_EVENT_DEAD:
msg_Dbg( getIntf(), "end of input detected for %p", pInput );
var_DelCallback( pInput, "intf-event", onGenericCallback2, this );
var_DelCallback( pInput, "bit-rate", onGenericCallback, this );
var_DelCallback( pInput, "sample-rate", onGenericCallback, this );
var_DelCallback( pInput, "can-record" , onGenericCallback, this );
vlc_object_release( pInput );
getIntf()->p_sys->p_input = NULL;
reset_input();
break;
default:
break;
}
}
QWidget *AbstractController::createWidget( buttonType_e button, int options )
{
bool b_flat = options & WIDGET_FLAT;
bool b_big = options & WIDGET_BIG;
bool b_shiny = options & WIDGET_SHINY;
bool b_special = false;
QWidget *widget = NULL;
switch( button )
{
case PLAY_BUTTON: {
PlayButton *playButton = new PlayButton;
setupButton( playButton );
BUTTON_SET_BAR( playButton );
CONNECT_MAP_SET( playButton, PLAY_ACTION );
CONNECT( this, inputPlaying( bool ),
playButton, updateButtonIcons( bool ));
playButton->updateButtonIcons( THEMIM->getIM()->playingStatus() == PLAYING_S );
widget = playButton;
}
break;
case STOP_BUTTON:{
NORMAL_BUTTON( STOP );
}
break;
case OPEN_BUTTON:{
NORMAL_BUTTON( OPEN );
}
break;
case OPEN_SUB_BUTTON:{
NORMAL_BUTTON( OPEN_SUB );
}
break;
case PREVIOUS_BUTTON:{
NORMAL_BUTTON( PREVIOUS );
}
break;
case NEXT_BUTTON: {
NORMAL_BUTTON( NEXT );
}
break;
case SLOWER_BUTTON:{
NORMAL_BUTTON( SLOWER );
ENABLE_ON_INPUT( SLOWERButton );
}
break;
case FASTER_BUTTON:{
NORMAL_BUTTON( FASTER );
ENABLE_ON_INPUT( FASTERButton );
}
break;
case PREV_SLOW_BUTTON:{
QToolButtonExt *but = new QToolButtonExt;
setupButton( but );
BUTTON_SET_BAR( but );
CONNECT( but, shortClicked(), THEMIM, prev() );
CONNECT( but, longClicked(), THEAM, skipBackward() );
widget = but;
}
break;
case NEXT_FAST_BUTTON:{
QToolButtonExt *but = new QToolButtonExt;
setupButton( but );
BUTTON_SET_BAR( but );
CONNECT( but, shortClicked(), THEMIM, next() );
CONNECT( but, longClicked(), THEAM, skipForward() );
widget = but;
}
break;
case FRAME_BUTTON: {
NORMAL_BUTTON( FRAME );
ENABLE_ON_VIDEO( FRAMEButton );
}
break;
case FULLSCREEN_BUTTON:
case DEFULLSCREEN_BUTTON:
{
NORMAL_BUTTON( FULLSCREEN );
ENABLE_ON_VIDEO( FULLSCREENButton );
}
break;
case FULLWIDTH_BUTTON: {
NORMAL_BUTTON( FULLWIDTH );
}
break;
case EXTENDED_BUTTON:{
NORMAL_BUTTON( EXTENDED );
}
break;
case PLAYLIST_BUTTON:{
NORMAL_BUTTON( PLAYLIST );
}
break;
case SNAPSHOT_BUTTON:{
NORMAL_BUTTON( SNAPSHOT );
ENABLE_ON_VIDEO( SNAPSHOTButton );
}
break;
case RECORD_BUTTON:{
QToolButton *recordButton = new QToolButton;
setupButton( recordButton );
CONNECT_MAP_SET( recordButton, RECORD_ACTION );
BUTTON_SET_BAR( recordButton );
ENABLE_ON_INPUT( recordButton );
recordButton->setCheckable( true );
CONNECT( THEMIM->getIM(), recordingStateChanged( bool ),
recordButton, setChecked( bool ) );
widget = recordButton;
}
break;
case ATOB_BUTTON: {
AtoB_Button *ABButton = new AtoB_Button;
setupButton( ABButton );
ABButton->setShortcut( qtr("Shift+L") );
BUTTON_SET_BAR( ABButton );
ENABLE_ON_INPUT( ABButton );
CONNECT_MAP_SET( ABButton, ATOB_ACTION );
CONNECT( THEMIM->getIM(), AtoBchanged( bool, bool),
ABButton, updateButtonIcons( bool, bool ) );
widget = ABButton;
}
break;
case INPUT_SLIDER: {
SeekSlider *slider = new SeekSlider( Qt::Horizontal, NULL, !b_shiny );
SeekPoints *chapters = new SeekPoints( this, p_intf );
CONNECT( THEMIM->getIM(), chapterChanged( bool ), chapters, update() );
slider->setChapters( chapters );
/* Update the position when the IM has changed */
CONNECT( THEMIM->getIM(), positionUpdated( float, int64_t, int ),
slider, setPosition( float, int64_t, int ) );
/* And update the IM, when the position has changed */
CONNECT( slider, sliderDragged( float ),
THEMIM->getIM(), sliderUpdate( float ) );
CONNECT( THEMIM->getIM(), cachingChanged( float ),
slider, updateBuffering( float ) );
/* Give hint to disable slider's interactivity when useless */
CONNECT( THEMIM->getIM(), inputCanSeek( bool ),
slider, setSeekable( bool ) );
widget = slider;
}
break;
case MENU_BUTTONS:
widget = discFrame();
break;
case TELETEXT_BUTTONS:
widget = telexFrame();
widget->hide();
break;
case VOLUME_SPECIAL:
b_special = true;
case VOLUME:
{
SoundWidget *snd = new SoundWidget( this, p_intf, b_shiny, b_special );
widget = snd;
}
break;
case TIME_LABEL:
{
TimeLabel *timeLabel = new TimeLabel( p_intf );
widget = timeLabel;
}
break;
case SPLITTER:
{
QFrame *line = new QFrame;
line->setFrameShape( QFrame::VLine );
line->setFrameShadow( QFrame::Raised );
line->setLineWidth( 0 );
line->setMidLineWidth( 1 );
widget = line;
}
break;
case ADVANCED_CONTROLLER:
if( qobject_cast<AdvControlsWidget *>(this) == NULL )
{
advControls = new AdvControlsWidget( p_intf, this );
widget = advControls;
}
break;
case REVERSE_BUTTON:{
QToolButton *reverseButton = new QToolButton;
setupButton( reverseButton );
CONNECT_MAP_SET( reverseButton, REVERSE_ACTION );
BUTTON_SET_BAR( reverseButton );
reverseButton->setCheckable( true );
/* You should, of COURSE change this to the correct event,
when/if we have one, that tells us if trickplay is possible . */
CONNECT( this, inputIsTrickPlayable( bool ), reverseButton, setVisible( bool ) );
reverseButton->setVisible( false );
widget = reverseButton;
}
break;
case SKIP_BACK_BUTTON: {
NORMAL_BUTTON( SKIP_BACK );
ENABLE_ON_INPUT( SKIP_BACKButton );
}
break;
case SKIP_FW_BUTTON: {
NORMAL_BUTTON( SKIP_FW );
ENABLE_ON_INPUT( SKIP_FWButton );
}
break;
case QUIT_BUTTON: {
NORMAL_BUTTON( QUIT );
}
break;
case RANDOM_BUTTON: {
NORMAL_BUTTON( RANDOM );
RANDOMButton->setCheckable( true );
RANDOMButton->setChecked( var_GetBool( THEPL, "random" ) );
CONNECT( THEMIM, randomChanged( bool ),
RANDOMButton, setChecked( bool ) );
}
break;
case LOOP_BUTTON:{
LoopButton *loopButton = new LoopButton;
setupButton( loopButton );
loopButton->setToolTip( qtr( "Click to toggle between loop all, loop one and no loop") );
loopButton->setCheckable( true );
{
int i_state = NORMAL;
if( var_GetBool( THEPL, "loop" ) ) i_state = REPEAT_ALL;
if( var_GetBool( THEPL, "repeat" ) ) i_state = REPEAT_ONE;
loopButton->updateButtonIcons( i_state );
}
CONNECT( THEMIM, repeatLoopChanged( int ), loopButton, updateButtonIcons( int ) );
CONNECT( loopButton, clicked(), THEMIM, loopRepeatLoopStatus() );
widget = loopButton;
}
break;
case INFO_BUTTON: {
NORMAL_BUTTON( INFO );
}
break;
case PLAYBACK_BUTTONS:{
widget = new QWidget;
DeckButtonsLayout *layout = new DeckButtonsLayout( widget );
BrowseButton *prev = new BrowseButton( widget, BrowseButton::Backward );
BrowseButton *next = new BrowseButton( widget );
RoundButton *play = new RoundButton( widget );
layout->setBackwardButton( prev );
layout->setForwardButton( next );
layout->setRoundButton( play );
CONNECT_MAP_SET( prev, PREVIOUS_ACTION );
CONNECT_MAP_SET( next, NEXT_ACTION );
CONNECT_MAP_SET( play, PLAY_ACTION );
}
break;
case ASPECT_RATIO_COMBOBOX:
widget = new AspectRatioComboBox( p_intf );
widget->setMinimumHeight( 26 );
break;
case SPEED_LABEL:
widget = new SpeedLabel( p_intf, this );
break;
case TIME_LABEL_ELAPSED:
widget = new TimeLabel( p_intf, TimeLabel::Elapsed );
break;
case TIME_LABEL_REMAINING:
widget = new TimeLabel( p_intf, TimeLabel::Remaining );
break;
default:
msg_Warn( p_intf, "This should not happen %i", button );
break;
}
/* Customize Buttons */
if( b_flat || b_big )
{
QFrame *frame = qobject_cast<QFrame *>(widget);
if( frame )
{
QList<QToolButton *> allTButtons = frame->findChildren<QToolButton *>();
for( int i = 0; i < allTButtons.count(); i++ )
applyAttributes( allTButtons[i], b_flat, b_big );
}
else
{
QToolButton *tmpButton = qobject_cast<QToolButton *>(widget);
if( tmpButton )
applyAttributes( tmpButton, b_flat, b_big );
}
}
return widget;
}
int libvlc_get_fullscreen( libvlc_media_player_t *p_mi )
{
return var_GetBool (p_mi, "fullscreen");
}
void InputManager::UpdateProgramEvent()
{
bool b_scrambled = var_GetBool( p_input, "program-scrambled" );
emit encryptionChanged( b_scrambled );
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
sout_access_out_sys_t *p_sys;
char *psz_idx;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access, "no file name specified" );
return VLC_EGENERIC;
}
if( unlikely( !( p_sys = calloc ( 1, sizeof( *p_sys ) ) ) ) )
return VLC_ENOMEM;
p_sys->i_seglen = var_GetInteger( p_access, SOUT_CFG_PREFIX "seglen" );
/* Try to get within asked segment length */
p_sys->i_seglenm = CLOCK_FREQ * p_sys->i_seglen;
p_sys->block_buffer = NULL;
p_sys->i_numsegs = var_GetInteger( p_access, SOUT_CFG_PREFIX "numsegs" );
p_sys->i_initial_segment = var_GetInteger( p_access, SOUT_CFG_PREFIX "initial-segment-number" );
p_sys->b_splitanywhere = var_GetBool( p_access, SOUT_CFG_PREFIX "splitanywhere" );
p_sys->b_delsegs = var_GetBool( p_access, SOUT_CFG_PREFIX "delsegs" );
p_sys->b_ratecontrol = var_GetBool( p_access, SOUT_CFG_PREFIX "ratecontrol") ;
p_sys->b_caching = var_GetBool( p_access, SOUT_CFG_PREFIX "caching") ;
p_sys->b_generate_iv = var_GetBool( p_access, SOUT_CFG_PREFIX "generate-iv") ;
p_sys->segments_t = vlc_array_new();
p_sys->stuffing_size = 0;
p_sys->i_opendts = VLC_TS_INVALID;
p_sys->psz_indexPath = NULL;
psz_idx = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index" );
if ( psz_idx )
{
char *psz_tmp;
psz_tmp = str_format_time( psz_idx );
free( psz_idx );
if ( !psz_tmp )
{
free( p_sys );
return VLC_ENOMEM;
}
path_sanitize( psz_tmp );
p_sys->psz_indexPath = psz_tmp;
vlc_unlink( p_sys->psz_indexPath );
}
p_sys->psz_indexUrl = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index-url" );
p_sys->psz_keyfile = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "key-loadfile" );
p_sys->key_uri = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "key-uri" );
p_access->p_sys = p_sys;
if( p_sys->psz_keyfile && ( LoadCryptFile( p_access ) < 0 ) )
{
free( p_sys->psz_indexUrl );
free( p_sys->psz_indexPath );
free( p_sys );
msg_Err( p_access, "Encryption init failed" );
return VLC_EGENERIC;
}
else if( !p_sys->psz_keyfile && ( CryptSetup( p_access, NULL ) < 0 ) )
{
free( p_sys->psz_indexUrl );
free( p_sys->psz_indexPath );
free( p_sys );
msg_Err( p_access, "Encryption init failed" );
return VLC_EGENERIC;
}
p_sys->i_handle = -1;
p_sys->i_segment = p_sys->i_initial_segment > 0 ? p_sys->i_initial_segment -1 : 0;
p_sys->psz_cursegPath = NULL;
p_access->pf_write = Write;
p_access->pf_seek = Seek;
p_access->pf_control = Control;
return VLC_SUCCESS;
}
/*****************************************************************************
* OpenFilter
*****************************************************************************/
static int OpenFilter( vlc_object_t *p_this )
{
filter_t * p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = NULL;
if( aout_FormatNbChannels( &(p_filter->fmt_in.audio) ) == 1 )
{
/*msg_Dbg( p_filter, "filter discarded (incompatible format)" );*/
return VLC_EGENERIC;
}
if( (p_filter->fmt_in.i_codec != VLC_CODEC_S16N) ||
(p_filter->fmt_out.i_codec != VLC_CODEC_S16N) )
{
/*msg_Err( p_this, "filter discarded (invalid format)" );*/
return VLC_EGENERIC;
}
if( (p_filter->fmt_in.audio.i_format != p_filter->fmt_out.audio.i_format) &&
(p_filter->fmt_in.audio.i_rate != p_filter->fmt_out.audio.i_rate) &&
(p_filter->fmt_in.audio.i_format != VLC_CODEC_S16N) &&
(p_filter->fmt_out.audio.i_format != VLC_CODEC_S16N) &&
(p_filter->fmt_in.audio.i_bitspersample !=
p_filter->fmt_out.audio.i_bitspersample))
{
/*msg_Err( p_this, "couldn't load mono filter" );*/
return VLC_EGENERIC;
}
/* Allocate the memory needed to store the module's structure */
p_sys = p_filter->p_sys = malloc( sizeof(filter_sys_t) );
if( p_sys == NULL )
return VLC_EGENERIC;
var_Create( p_this, MONO_CFG "downmix",
VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
p_sys->b_downmix = var_GetBool( p_this, MONO_CFG "downmix" );
var_Create( p_this, MONO_CFG "channel",
VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
p_sys->i_channel_selected =
(unsigned int) var_GetInteger( p_this, MONO_CFG "channel" );
if( p_sys->b_downmix )
{
msg_Dbg( p_this, "using stereo to mono downmix" );
p_filter->fmt_out.audio.i_physical_channels = AOUT_CHAN_CENTER;
p_filter->fmt_out.audio.i_channels = 1;
}
else
{
msg_Dbg( p_this, "using pseudo mono" );
p_filter->fmt_out.audio.i_physical_channels =
(AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT);
p_filter->fmt_out.audio.i_channels = 2;
}
p_filter->fmt_out.audio.i_rate = p_filter->fmt_in.audio.i_rate;
p_filter->fmt_out.audio.i_format = p_filter->fmt_out.i_codec;
p_sys->i_nb_channels = aout_FormatNbChannels( &(p_filter->fmt_in.audio) );
p_sys->i_bitspersample = p_filter->fmt_out.audio.i_bitspersample;
p_sys->i_overflow_buffer_size = 0;
p_sys->p_overflow_buffer = NULL;
p_sys->i_nb_atomic_operations = 0;
p_sys->p_atomic_operations = NULL;
if( Init( VLC_OBJECT(p_filter), p_filter->p_sys,
aout_FormatNbChannels( &p_filter->fmt_in.audio ),
p_filter->fmt_in.audio.i_physical_channels,
p_filter->fmt_in.audio.i_rate ) < 0 )
{
var_Destroy( p_this, MONO_CFG "channel" );
var_Destroy( p_this, MONO_CFG "downmix" );
free( p_sys );
return VLC_EGENERIC;
}
p_filter->pf_audio_filter = Convert;
msg_Dbg( p_this, "%4.4s->%4.4s, channels %d->%d, bits per sample: %i->%i",
(char *)&p_filter->fmt_in.i_codec,
(char *)&p_filter->fmt_out.i_codec,
p_filter->fmt_in.audio.i_physical_channels,
p_filter->fmt_out.audio.i_physical_channels,
p_filter->fmt_in.audio.i_bitspersample,
p_filter->fmt_out.audio.i_bitspersample );
return VLC_SUCCESS;
}
/**
* This function will save a video snapshot to a file
*/
static int VoutWriteSnapshot( vout_thread_t *p_vout, char **ppsz_filename,
const block_t *p_image,
const char *psz_path,
const char *psz_format,
const char *psz_prefix_fmt )
{
/* */
char *psz_filename;
DIR *p_path = utf8_opendir( psz_path );
if( p_path != NULL )
{
/* The use specified a directory path */
closedir( p_path );
/* */
char *psz_prefix = NULL;
if( psz_prefix_fmt )
psz_prefix = str_format( p_vout, psz_prefix_fmt );
if( !psz_prefix )
{
psz_prefix = strdup( "vlcsnap-" );
if( !psz_prefix )
goto error;
}
if( var_GetBool( p_vout, "snapshot-sequential" ) )
{
int i_num = var_GetInteger( p_vout, "snapshot-num" );
for( ; ; i_num++ )
{
struct stat st;
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%05d.%s",
psz_path, psz_prefix, i_num++, psz_format ) < 0 )
{
free( psz_prefix );
goto error;
}
if( utf8_stat( psz_filename, &st ) )
break;
free( psz_filename );
}
var_SetInteger( p_vout, "snapshot-num", i_num );
}
else
{
struct tm curtime;
time_t lcurtime = time( NULL ) ;
if( !localtime_r( &lcurtime, &curtime ) )
{
const unsigned int i_id = (p_image->i_pts / 100000) & 0xFFFFFF;
msg_Warn( p_vout, "failed to get current time. Falling back to legacy snapshot naming" );
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%u.%s",
psz_path, psz_prefix, i_id, psz_format ) < 0 )
psz_filename = NULL;
}
else
{
/* suffix with the last decimal digit in 10s of seconds resolution
* FIXME gni ? */
const int i_id = (p_image->i_pts / (100*1000)) & 0xFF;
char psz_curtime[128];
if( !strftime( psz_curtime, sizeof(psz_curtime), "%Y-%m-%d-%Hh%Mm%Ss", &curtime ) )
strcpy( psz_curtime, "error" );
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%s%1u.%s",
psz_path, psz_prefix, psz_curtime, i_id, psz_format ) < 0 )
psz_filename = NULL;
}
}
free( psz_prefix );
}
else
{
/* The user specified a full path name (including file name) */
psz_filename = str_format( p_vout, psz_path );
path_sanitize( psz_filename );
}
if( !psz_filename )
goto error;
/* Save the snapshot */
FILE *p_file = utf8_fopen( psz_filename, "wb" );
if( !p_file )
{
msg_Err( p_vout, "Failed to open '%s'", psz_filename );
free( psz_filename );
goto error;
}
if( fwrite( p_image->p_buffer, p_image->i_buffer, 1, p_file ) != 1 )
{
msg_Err( p_vout, "Failed to write to '%s'", psz_filename );
fclose( p_file );
free( psz_filename );
goto error;
}
fclose( p_file );
/* */
if( ppsz_filename )
*ppsz_filename = psz_filename;
else
free( psz_filename );
return VLC_SUCCESS;
error:
msg_Err( p_vout, "could not save snapshot" );
return VLC_EGENERIC;
}
/*****************************************************************************
* OpenEncoder: probe the encoder and return score
*****************************************************************************/
static int OpenEncoder( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys;
int i_quality, i_min_bitrate, i_max_bitrate;
ogg_packet header[3];
if( p_enc->fmt_out.i_codec != VLC_CODEC_VORBIS &&
!p_enc->b_force )
{
return VLC_EGENERIC;
}
/* Allocate the memory needed to store the decoder's structure */
if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
return VLC_ENOMEM;
p_enc->p_sys = p_sys;
p_enc->pf_encode_audio = Encode;
p_enc->fmt_in.i_codec = VLC_CODEC_FL32;
p_enc->fmt_out.i_codec = VLC_CODEC_VORBIS;
config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
i_quality = var_GetInteger( p_enc, ENC_CFG_PREFIX "quality" );
if( i_quality > 10 ) i_quality = 10;
if( i_quality < 0 ) i_quality = 0;
if( var_GetBool( p_enc, ENC_CFG_PREFIX "cbr" ) ) i_quality = 0;
i_max_bitrate = var_GetInteger( p_enc, ENC_CFG_PREFIX "max-bitrate" );
i_min_bitrate = var_GetInteger( p_enc, ENC_CFG_PREFIX "min-bitrate" );
/* Initialize vorbis encoder */
vorbis_info_init( &p_sys->vi );
if( i_quality > 0 )
{
/* VBR mode */
if( vorbis_encode_setup_vbr( &p_sys->vi,
p_enc->fmt_in.audio.i_channels, p_enc->fmt_in.audio.i_rate,
i_quality * 0.1 ) )
{
vorbis_info_clear( &p_sys->vi );
free( p_enc->p_sys );
msg_Err( p_enc, "VBR mode initialisation failed" );
return VLC_EGENERIC;
}
/* Do we have optional hard quality restrictions? */
if( i_max_bitrate > 0 || i_min_bitrate > 0 )
{
struct ovectl_ratemanage_arg ai;
vorbis_encode_ctl( &p_sys->vi, OV_ECTL_RATEMANAGE_GET, &ai );
ai.bitrate_hard_min = i_min_bitrate;
ai.bitrate_hard_max = i_max_bitrate;
ai.management_active = 1;
vorbis_encode_ctl( &p_sys->vi, OV_ECTL_RATEMANAGE_SET, &ai );
}
else
{
/* Turn off management entirely */
vorbis_encode_ctl( &p_sys->vi, OV_ECTL_RATEMANAGE_SET, NULL );
}
}
else
{
if( vorbis_encode_setup_managed( &p_sys->vi,
p_enc->fmt_in.audio.i_channels, p_enc->fmt_in.audio.i_rate,
i_min_bitrate > 0 ? i_min_bitrate * 1000: -1,
p_enc->fmt_out.i_bitrate,
i_max_bitrate > 0 ? i_max_bitrate * 1000: -1 ) )
{
vorbis_info_clear( &p_sys->vi );
msg_Err( p_enc, "CBR mode initialisation failed" );
free( p_enc->p_sys );
return VLC_EGENERIC;
}
}
vorbis_encode_setup_init( &p_sys->vi );
/* Add a comment */
vorbis_comment_init( &p_sys->vc);
vorbis_comment_add_tag( &p_sys->vc, "ENCODER", "VLC media player");
/* Set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init( &p_sys->vd, &p_sys->vi );
vorbis_block_init( &p_sys->vd, &p_sys->vb );
/* Create and store headers */
vorbis_analysis_headerout( &p_sys->vd, &p_sys->vc,
&header[0], &header[1], &header[2]);
for( int i = 0; i < 3; i++ )
{
if( xiph_AppendHeaders( &p_enc->fmt_out.i_extra, &p_enc->fmt_out.p_extra,
header[i].bytes, header[i].packet ) )
{
p_enc->fmt_out.i_extra = 0;
p_enc->fmt_out.p_extra = NULL;
}
}
p_sys->i_channels = p_enc->fmt_in.audio.i_channels;
p_sys->i_last_block_size = 0;
p_sys->i_samples_delay = 0;
ConfigureChannelOrder(p_sys->pi_chan_table, p_sys->vi.channels,
p_enc->fmt_in.audio.i_physical_channels, true);
return VLC_SUCCESS;
}
void vout_IntfInit( vout_thread_t *p_vout )
{
vlc_value_t val, text, old_val;
bool b_force_par = false;
char *psz_buf;
int i;
/* Create a few object variables we'll need later on */
var_Create( p_vout, "snapshot-path", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-prefix", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-format", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-preview", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-sequential",
VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER );
var_SetInteger( p_vout, "snapshot-num", 1 );
var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
p_vout->i_alignment = var_CreateGetInteger( p_vout, "align" );
var_Create( p_vout, "video-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "video-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "mouse-hide-timeout",
VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
p_vout->p->b_title_show = var_CreateGetBool( p_vout, "video-title-show" );
p_vout->p->i_title_timeout =
(mtime_t)var_CreateGetInteger( p_vout, "video-title-timeout" );
p_vout->p->i_title_position =
var_CreateGetInteger( p_vout, "video-title-position" );
p_vout->p->psz_title = NULL;
var_AddCallback( p_vout, "video-title-show", TitleShowCallback, NULL );
var_AddCallback( p_vout, "video-title-timeout", TitleTimeoutCallback, NULL );
var_AddCallback( p_vout, "video-title-position", TitlePositionCallback, NULL );
/* Zoom object var */
var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND |
VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );
text.psz_string = _("Zoom");
var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL );
var_Get( p_vout, "zoom", &old_val );
for( i = 0; p_zoom_values[i].f_value; i++ )
{
if( old_val.f_float == p_zoom_values[i].f_value )
var_Change( p_vout, "zoom", VLC_VAR_DELCHOICE, &old_val, NULL );
val.f_float = p_zoom_values[i].f_value;
text.psz_string = _( p_zoom_values[i].psz_label );
var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text );
}
var_Set( p_vout, "zoom", old_val ); /* Is this really needed? */
var_AddCallback( p_vout, "zoom", ZoomCallback, NULL );
/* Crop offset vars */
var_Create( p_vout, "crop-left", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_Create( p_vout, "crop-top", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_Create( p_vout, "crop-right", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_Create( p_vout, "crop-bottom", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_AddCallback( p_vout, "crop-left", CropCallback, NULL );
var_AddCallback( p_vout, "crop-top", CropCallback, NULL );
var_AddCallback( p_vout, "crop-right", CropCallback, NULL );
var_AddCallback( p_vout, "crop-bottom", CropCallback, NULL );
/* Crop object var */
var_Create( p_vout, "crop", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |
VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );
text.psz_string = _("Crop");
var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL );
val.psz_string = (char*)"";
var_Change( p_vout, "crop", VLC_VAR_DELCHOICE, &val, 0 );
for( i = 0; p_crop_values[i].psz_value; i++ )
{
val.psz_string = (char*)p_crop_values[i].psz_value;
text.psz_string = _( p_crop_values[i].psz_label );
var_Change( p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &text );
}
/* update triggered every time the vout's crop parameters are changed */
var_Create( p_vout, "crop-update", VLC_VAR_VOID );
/* Add custom crop ratios */
psz_buf = config_GetPsz( p_vout, "custom-crop-ratios" );
AddCustomRatios( p_vout, "crop", psz_buf );
free( psz_buf );
var_AddCallback( p_vout, "crop", CropCallback, NULL );
var_Get( p_vout, "crop", &old_val );
if( old_val.psz_string && *old_val.psz_string )
var_TriggerCallback( p_vout, "crop" );
free( old_val.psz_string );
/* Monitor pixel aspect-ratio */
var_Create( p_vout, "monitor-par", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_vout, "monitor-par", &val );
if( val.psz_string && *val.psz_string )
{
char *psz_parser = strchr( val.psz_string, ':' );
unsigned int i_aspect_num = 0, i_aspect_den = 0;
float i_aspect = 0;
if( psz_parser )
{
i_aspect_num = strtol( val.psz_string, 0, 10 );
i_aspect_den = strtol( ++psz_parser, 0, 10 );
}
else
{
i_aspect = atof( val.psz_string );
vlc_ureduce( &i_aspect_num, &i_aspect_den,
i_aspect *VOUT_ASPECT_FACTOR, VOUT_ASPECT_FACTOR, 0 );
}
if( !i_aspect_num || !i_aspect_den ) i_aspect_num = i_aspect_den = 1;
p_vout->p->i_par_num = i_aspect_num;
p_vout->p->i_par_den = i_aspect_den;
vlc_ureduce( &p_vout->p->i_par_num, &p_vout->p->i_par_den,
p_vout->p->i_par_num, p_vout->p->i_par_den, 0 );
msg_Dbg( p_vout, "overriding monitor pixel aspect-ratio: %i:%i",
p_vout->p->i_par_num, p_vout->p->i_par_den );
b_force_par = true;
}
free( val.psz_string );
/* Aspect-ratio object var */
var_Create( p_vout, "aspect-ratio", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |
VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );
text.psz_string = _("Aspect-ratio");
var_Change( p_vout, "aspect-ratio", VLC_VAR_SETTEXT, &text, NULL );
val.psz_string = (char*)"";
var_Change( p_vout, "aspect-ratio", VLC_VAR_DELCHOICE, &val, 0 );
for( i = 0; p_aspect_ratio_values[i].psz_value; i++ )
{
val.psz_string = (char*)p_aspect_ratio_values[i].psz_value;
text.psz_string = _( p_aspect_ratio_values[i].psz_label );
var_Change( p_vout, "aspect-ratio", VLC_VAR_ADDCHOICE, &val, &text );
}
/* Add custom aspect ratios */
psz_buf = config_GetPsz( p_vout, "custom-aspect-ratios" );
AddCustomRatios( p_vout, "aspect-ratio", psz_buf );
free( psz_buf );
var_AddCallback( p_vout, "aspect-ratio", AspectCallback, NULL );
var_Get( p_vout, "aspect-ratio", &old_val );
if( (old_val.psz_string && *old_val.psz_string) || b_force_par )
var_TriggerCallback( p_vout, "aspect-ratio" );
free( old_val.psz_string );
/* Add variables to manage scaling video */
var_Create( p_vout, "autoscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT
| VLC_VAR_ISCOMMAND );
text.psz_string = _("Autoscale video");
var_Change( p_vout, "autoscale", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "autoscale", ScalingCallback, NULL );
p_vout->b_autoscale = var_GetBool( p_vout, "autoscale" );
var_Create( p_vout, "scale", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT
| VLC_VAR_ISCOMMAND );
text.psz_string = _("Scale factor");
var_Change( p_vout, "scale", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "scale", ScalingCallback, NULL );
p_vout->i_zoom = (int)( ZOOM_FP_FACTOR * var_GetFloat( p_vout, "scale" ) );
/* Initialize the dimensions of the video window */
InitWindowSize( p_vout, &p_vout->i_window_width,
&p_vout->i_window_height );
/* Add a variable to indicate if the window should be on top of others */
var_Create( p_vout, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT
| VLC_VAR_ISCOMMAND );
text.psz_string = _("Always on top");
var_Change( p_vout, "video-on-top", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "video-on-top", OnTopCallback, NULL );
/* Add a variable to indicate whether we want window decoration or not */
var_Create( p_vout, "video-deco", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
/* Add a fullscreen variable */
if( var_CreateGetBoolCommand( p_vout, "fullscreen" ) )
{
/* user requested fullscreen */
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
}
text.psz_string = _("Fullscreen");
var_Change( p_vout, "fullscreen", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "fullscreen", FullscreenCallback, NULL );
/* Add a snapshot variable */
var_Create( p_vout, "video-snapshot", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
text.psz_string = _("Snapshot");
var_Change( p_vout, "video-snapshot", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "video-snapshot", SnapshotCallback, NULL );
/* Mouse coordinates */
var_Create( p_vout, "mouse-x", VLC_VAR_INTEGER );
var_Create( p_vout, "mouse-y", VLC_VAR_INTEGER );
var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER );
var_Create( p_vout, "mouse-moved", VLC_VAR_BOOL );
var_Create( p_vout, "mouse-clicked", VLC_VAR_BOOL );
var_Create( p_vout, "intf-change", VLC_VAR_BOOL );
var_SetBool( p_vout, "intf-change", true );
}
/**
* Initialize a libvlc instance
* This function initializes a previously allocated libvlc instance:
* - CPU detection
* - gettext initialization
* - message queue, module bank and playlist initialization
* - configuration and commandline parsing
*/
int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc,
const char *ppsz_argv[] )
{
libvlc_priv_t *priv = libvlc_priv (p_libvlc);
char * psz_modules = NULL;
char * psz_parser = NULL;
char * psz_control = NULL;
playlist_t *p_playlist = NULL;
char *psz_val;
/* System specific initialization code */
system_Init();
/* Initialize the module bank and load the configuration of the
* main module. We need to do this at this stage to be able to display
* a short help if required by the user. (short help == main module
* options) */
module_InitBank ();
/* Get command line options that affect module loading. */
if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, NULL ) )
{
module_EndBank (false);
return VLC_EGENERIC;
}
priv->i_verbose = var_InheritInteger( p_libvlc, "verbose" );
/* Find verbosity from VLC_VERBOSE environment variable */
{
char *env = getenv( "VLC_VERBOSE" );
if( env != NULL )
priv->i_verbose = atoi( env );
}
/* Announce who we are (TODO: only first instance?) */
msg_Dbg( p_libvlc, "VLC media player - %s", VERSION_MESSAGE );
msg_Dbg( p_libvlc, "%s", COPYRIGHT_MESSAGE );
msg_Dbg( p_libvlc, "revision %s", psz_vlc_changeset );
msg_Dbg( p_libvlc, "configured with %s", CONFIGURE_LINE );
vlc_threads_setup (p_libvlc);
/* Load the builtins and plugins into the module_bank.
* We have to do it before config_Load*() because this also gets the
* list of configuration options exported by each module and loads their
* default values. */
size_t module_count = module_LoadPlugins (p_libvlc);
/*
* Override default configuration with config file settings
*/
if( !var_InheritBool( p_libvlc, "ignore-config" ) )
{
if( var_InheritBool( p_libvlc, "reset-config" ) )
config_SaveConfigFile( p_libvlc ); /* Save default config */
else
config_LoadConfigFile( p_libvlc );
}
/*
* Override configuration with command line settings
*/
int vlc_optind;
if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, &vlc_optind ) )
{
#ifdef WIN32
MessageBox (NULL, TEXT("The command line options could not be parsed.\n"
"Make sure they are valid."), TEXT("VLC media player"),
MB_OK|MB_ICONERROR);
#endif
module_EndBank (true);
return VLC_EGENERIC;
}
priv->i_verbose = var_InheritInteger( p_libvlc, "verbose" );
/*
* Support for gettext
*/
#if defined( ENABLE_NLS ) \
&& ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
vlc_bindtextdomain (PACKAGE_NAME);
#endif
/*xgettext: Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") );
if (config_PrintHelp (VLC_OBJECT(p_libvlc)))
{
module_EndBank (true);
return VLC_EEXITSUCCESS;
}
if( module_count <= 1 )
{
msg_Err( p_libvlc, "No plugins found! Check your VLC installation.");
module_EndBank (true);
return VLC_ENOITEM;
}
#ifdef HAVE_DAEMON
/* Check for daemon mode */
if( var_InheritBool( p_libvlc, "daemon" ) )
{
char *psz_pidfile = NULL;
if( daemon( 1, 0) != 0 )
{
msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" );
module_EndBank (true);
return VLC_EEXIT;
}
b_daemon = true;
/* lets check if we need to write the pidfile */
psz_pidfile = var_CreateGetNonEmptyString( p_libvlc, "pidfile" );
if( psz_pidfile != NULL )
{
FILE *pidfile;
pid_t i_pid = getpid ();
msg_Dbg( p_libvlc, "PID is %d, writing it to %s",
i_pid, psz_pidfile );
pidfile = vlc_fopen( psz_pidfile,"w" );
if( pidfile != NULL )
{
utf8_fprintf( pidfile, "%d", (int)i_pid );
fclose( pidfile );
}
else
{
msg_Err( p_libvlc, "cannot open pid file for writing: %s (%m)",
psz_pidfile );
}
}
free( psz_pidfile );
}
#endif
/* FIXME: could be replaced by using Unix sockets */
#ifdef HAVE_DBUS
#define MPRIS_APPEND "/org/mpris/MediaPlayer2/TrackList/Append"
#define MPRIS_BUS_NAME "org.mpris.MediaPlayer2.vlc"
#define MPRIS_OBJECT_PATH "/org/mpris/MediaPlayer2"
#define MPRIS_TRACKLIST_INTERFACE "org.mpris.MediaPlayer2.TrackList"
if( var_InheritBool( p_libvlc, "one-instance" )
|| ( var_InheritBool( p_libvlc, "one-instance-when-started-from-file" )
&& var_InheritBool( p_libvlc, "started-from-file" ) ) )
{
for( int i = vlc_optind; i < i_argc; i++ )
if( ppsz_argv[i][0] == ':' )
{
msg_Err( p_libvlc, "item option %s incompatible with single instance",
ppsz_argv[i] );
goto dbus_out;
}
/* Initialise D-Bus interface, check for other instances */
dbus_threads_init_default();
DBusError err;
dbus_error_init( &err );
/* connect to the session bus */
DBusConnection *conn = dbus_bus_get( DBUS_BUS_SESSION, &err );
if( conn == NULL )
{
msg_Err( p_libvlc, "Failed to connect to D-Bus session daemon: %s",
err.message );
dbus_error_free( &err );
goto dbus_out;
}
/* check if VLC is available on the bus
* if not: D-Bus control is not enabled on the other
* instance and we can't pass MRLs to it */
/* FIXME: This check is totally brain-dead and buggy. */
if( !dbus_bus_name_has_owner( conn, MPRIS_BUS_NAME, &err ) )
{
dbus_connection_unref( conn );
if( dbus_error_is_set( &err ) )
{
msg_Err( p_libvlc, "D-Bus error: %s", err.message );
}
else
msg_Dbg( p_libvlc, "No media player running. Continuing normally." );
dbus_error_free( &err );
goto dbus_out;
}
const dbus_bool_t play = !var_InheritBool( p_libvlc, "playlist-enqueue" );
msg_Warn( p_libvlc, "media player running. Exiting...");
for( int i = vlc_optind; i < i_argc; i++ )
{
DBusMessage *msg = dbus_message_new_method_call(
MPRIS_BUS_NAME, MPRIS_OBJECT_PATH, MPRIS_TRACKLIST_INTERFACE, "AddTrack" );
if( unlikely(msg == NULL) )
continue;
/* We need to resolve relative paths in this instance */
char *mrl;
if( strstr( ppsz_argv[i], "://" ) )
mrl = strdup( ppsz_argv[i] );
else
mrl = vlc_path2uri( ppsz_argv[i], NULL );
if( mrl == NULL )
{
dbus_message_unref( msg );
continue;
}
const char *after_track = MPRIS_APPEND;
/* append MRLs */
if( !dbus_message_append_args( msg, DBUS_TYPE_STRING, &mrl,
DBUS_TYPE_STRING, &after_track,
DBUS_TYPE_BOOLEAN, &play,
DBUS_TYPE_INVALID ) )
{
dbus_message_unref( msg );
msg = NULL;
}
free( mrl );
if( unlikely(msg == NULL) )
continue;
msg_Dbg( p_libvlc, "Adds %s to the running media player", mrl );
/* send message and get a handle for a reply */
DBusMessage *reply = dbus_connection_send_with_reply_and_block( conn, msg, -1,
&err );
dbus_message_unref( msg );
if( reply == NULL )
{
msg_Err( p_libvlc, "D-Bus error: %s", err.message );
continue;
}
dbus_message_unref( reply );
}
/* we unreference the connection when we've finished with it */
dbus_connection_unref( conn );
exit( 1 );
}
#undef MPRIS_APPEND
#undef MPRIS_BUS_NAME
#undef MPRIS_OBJECT_PATH
#undef MPRIS_TRACKLIST_INTERFACE
dbus_out:
#endif // HAVE_DBUS
/*
* Message queue options
*/
/* Last chance to set the verbosity. Once we start interfaces and other
* threads, verbosity becomes read-only. */
var_Create( p_libvlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
if( var_InheritBool( p_libvlc, "quiet" ) )
{
var_SetInteger( p_libvlc, "verbose", -1 );
priv->i_verbose = -1;
}
if( priv->b_color )
priv->b_color = var_InheritBool( p_libvlc, "color" );
vlc_CPU_dump( VLC_OBJECT(p_libvlc) );
vlc_object_set_name( p_libvlc, "main" );
priv->b_stats = var_InheritBool( p_libvlc, "stats" );
/*
* Initialize hotkey handling
*/
priv->actions = vlc_InitActions( p_libvlc );
/* Create a variable for showing the fullscreen interface */
var_Create( p_libvlc, "intf-toggle-fscontrol", VLC_VAR_BOOL );
var_SetBool( p_libvlc, "intf-toggle-fscontrol", true );
/* Create a variable for the Boss Key */
var_Create( p_libvlc, "intf-boss", VLC_VAR_VOID );
/* Create a variable for showing the main interface */
var_Create( p_libvlc, "intf-show", VLC_VAR_BOOL );
/* Create a variable for showing the right click menu */
var_Create( p_libvlc, "intf-popupmenu", VLC_VAR_BOOL );
/* variables for signalling creation of new files */
var_Create( p_libvlc, "snapshot-file", VLC_VAR_STRING );
var_Create( p_libvlc, "record-file", VLC_VAR_STRING );
/* some default internal settings */
var_Create( p_libvlc, "window", VLC_VAR_STRING );
var_Create( p_libvlc, "user-agent", VLC_VAR_STRING );
var_SetString( p_libvlc, "user-agent", "(LibVLC "VERSION")" );
/* Initialize playlist and get commandline files */
p_playlist = playlist_Create( VLC_OBJECT(p_libvlc) );
if( !p_playlist )
{
msg_Err( p_libvlc, "playlist initialization failed" );
module_EndBank (true);
return VLC_EGENERIC;
}
/* System specific configuration */
system_Configure( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind );
#if defined(MEDIA_LIBRARY)
/* Get the ML */
if( var_GetBool( p_libvlc, "load-media-library-on-startup" ) )
{
priv->p_ml = ml_Create( VLC_OBJECT( p_libvlc ), NULL );
if( !priv->p_ml )
{
msg_Err( p_libvlc, "ML initialization failed" );
return VLC_EGENERIC;
}
}
else
{
priv->p_ml = NULL;
}
#endif
/* Add service discovery modules */
psz_modules = var_InheritString( p_libvlc, "services-discovery" );
if( psz_modules )
{
char *p = psz_modules, *m;
while( ( m = strsep( &p, " :," ) ) != NULL )
playlist_ServicesDiscoveryAdd( p_playlist, m );
free( psz_modules );
}
#ifdef ENABLE_VLM
/* Initialize VLM if vlm-conf is specified */
psz_parser = var_CreateGetNonEmptyString( p_libvlc, "vlm-conf" );
if( psz_parser )
{
priv->p_vlm = vlm_New( p_libvlc );
if( !priv->p_vlm )
msg_Err( p_libvlc, "VLM initialization failed" );
}
free( psz_parser );
#endif
/*
* Load background interfaces
*/
psz_modules = var_CreateGetNonEmptyString( p_libvlc, "extraintf" );
psz_control = var_CreateGetNonEmptyString( p_libvlc, "control" );
if( psz_modules && psz_control )
{
char* psz_tmp;
if( asprintf( &psz_tmp, "%s:%s", psz_modules, psz_control ) != -1 )
{
free( psz_modules );
psz_modules = psz_tmp;
}
}
else if( psz_control )
{
free( psz_modules );
psz_modules = strdup( psz_control );
}
psz_parser = psz_modules;
while ( psz_parser && *psz_parser )
{
char *psz_module, *psz_temp;
psz_module = psz_parser;
psz_parser = strchr( psz_module, ':' );
if ( psz_parser )
{
*psz_parser = '\0';
psz_parser++;
}
if( asprintf( &psz_temp, "%s,none", psz_module ) != -1)
{
intf_Create( p_libvlc, psz_temp );
free( psz_temp );
}
}
free( psz_modules );
free( psz_control );
/*
* Always load the hotkeys interface if it exists
*/
intf_Create( p_libvlc, "hotkeys,none" );
if( var_InheritBool( p_libvlc, "file-logging" )
#ifdef HAVE_SYSLOG_H
&& !var_InheritBool( p_libvlc, "syslog" )
#endif
)
{
intf_Create( p_libvlc, "logger,none" );
}
#ifdef HAVE_SYSLOG_H
if( var_InheritBool( p_libvlc, "syslog" ) )
{
char *logmode = var_CreateGetNonEmptyString( p_libvlc, "logmode" );
var_SetString( p_libvlc, "logmode", "syslog" );
intf_Create( p_libvlc, "logger,none" );
if( logmode )
{
var_SetString( p_libvlc, "logmode", logmode );
free( logmode );
}
var_Destroy( p_libvlc, "logmode" );
}
#endif
if( var_InheritBool( p_libvlc, "network-synchronisation") )
{
intf_Create( p_libvlc, "netsync,none" );
}
#ifdef __APPLE__
var_Create( p_libvlc, "drawable-view-top", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-view-left", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-view-bottom", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-view-right", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-top", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-left", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-bottom", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-clip-right", VLC_VAR_INTEGER );
var_Create( p_libvlc, "drawable-nsobject", VLC_VAR_ADDRESS );
#endif
#if defined (WIN32) || defined (__OS2__)
var_Create( p_libvlc, "drawable-hwnd", VLC_VAR_INTEGER );
#endif
/*
* Get input filenames given as commandline arguments.
* We assume that the remaining parameters are filenames
* and their input options.
*/
GetFilenames( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind );
/*
* Get --open argument
*/
psz_val = var_InheritString( p_libvlc, "open" );
if ( psz_val != NULL )
{
playlist_AddExt( p_playlist, psz_val, NULL, PLAYLIST_INSERT, 0,
-1, 0, NULL, 0, true, pl_Unlocked );
free( psz_val );
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_stream_sys_t *p_sys;
char *psz_string;
if( !p_stream->p_next )
{
msg_Err( p_stream, "cannot create chain" );
return VLC_EGENERIC;
}
p_sys = (sout_stream_sys_t *)calloc( 1, sizeof( *p_sys ) ); // sunqueen modify
p_sys->i_master_drift = 0;
config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
/* Audio transcoding parameters */
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "aenc" );
p_sys->psz_aenc = NULL;
p_sys->p_audio_cfg = NULL;
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_aenc, &p_sys->p_audio_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "acodec" );
p_sys->i_acodec = 0;
if( psz_string && *psz_string )
{
char fcc[/*4*/] = " "; // sunqueen modify
memcpy( fcc, psz_string, __MIN( strlen( psz_string ), 4 ) );
p_sys->i_acodec = VLC_FOURCC( fcc[0], fcc[1], fcc[2], fcc[3] );
}
free( psz_string );
p_sys->psz_alang = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "alang" );
p_sys->i_abitrate = var_GetInteger( p_stream, SOUT_CFG_PREFIX "ab" );
if( p_sys->i_abitrate < 4000 ) p_sys->i_abitrate *= 1000;
p_sys->i_sample_rate = var_GetInteger( p_stream, SOUT_CFG_PREFIX "samplerate" );
p_sys->i_channels = var_GetInteger( p_stream, SOUT_CFG_PREFIX "channels" );
if( p_sys->i_acodec )
{
if( ( p_sys->i_acodec == VLC_CODEC_MP3 ||
p_sys->i_acodec == VLC_CODEC_MP2 ||
p_sys->i_acodec == VLC_CODEC_MPGA ) && p_sys->i_channels > 2 )
{
msg_Warn( p_stream, "%d channels invalid for mp2/mp3, forcing to 2",
p_sys->i_channels );
p_sys->i_channels = 2;
}
msg_Dbg( p_stream, "codec audio=%4.4s %dHz %d channels %dKb/s",
(char *)&p_sys->i_acodec, p_sys->i_sample_rate,
p_sys->i_channels, p_sys->i_abitrate / 1000 );
}
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "afilter" );
if( psz_string && *psz_string )
p_sys->psz_af = strdup( psz_string );
else
p_sys->psz_af = NULL;
free( psz_string );
/* Video transcoding parameters */
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "venc" );
p_sys->psz_venc = NULL;
p_sys->p_video_cfg = NULL;
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_venc, &p_sys->p_video_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "vcodec" );
p_sys->i_vcodec = 0;
if( psz_string && *psz_string )
{
char fcc[/*4*/] = " "; // sunqueen modify
memcpy( fcc, psz_string, __MIN( strlen( psz_string ), 4 ) );
p_sys->i_vcodec = VLC_FOURCC( fcc[0], fcc[1], fcc[2], fcc[3] );
}
free( psz_string );
p_sys->i_vbitrate = var_GetInteger( p_stream, SOUT_CFG_PREFIX "vb" );
if( p_sys->i_vbitrate < 16000 ) p_sys->i_vbitrate *= 1000;
p_sys->f_scale = var_GetFloat( p_stream, SOUT_CFG_PREFIX "scale" );
p_sys->f_fps = var_GetFloat( p_stream, SOUT_CFG_PREFIX "fps" );
p_sys->b_hurry_up = var_GetBool( p_stream, SOUT_CFG_PREFIX "hurry-up" );
p_sys->i_width = var_GetInteger( p_stream, SOUT_CFG_PREFIX "width" );
p_sys->i_height = var_GetInteger( p_stream, SOUT_CFG_PREFIX "height" );
p_sys->i_maxwidth = var_GetInteger( p_stream, SOUT_CFG_PREFIX "maxwidth" );
p_sys->i_maxheight = var_GetInteger( p_stream, SOUT_CFG_PREFIX "maxheight" );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "vfilter" );
if( psz_string && *psz_string )
p_sys->psz_vf2 = strdup(psz_string );
else
p_sys->psz_vf2 = NULL;
free( psz_string );
p_sys->b_deinterlace = var_GetBool( p_stream, SOUT_CFG_PREFIX "deinterlace" );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "deinterlace-module" );
p_sys->psz_deinterlace = NULL;
p_sys->p_deinterlace_cfg = NULL;
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_deinterlace,
&p_sys->p_deinterlace_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
p_sys->i_threads = var_GetInteger( p_stream, SOUT_CFG_PREFIX "threads" );
p_sys->b_high_priority = var_GetBool( p_stream, SOUT_CFG_PREFIX "high-priority" );
if( p_sys->i_vcodec )
{
msg_Dbg( p_stream, "codec video=%4.4s %dx%d scaling: %f %dkb/s",
(char *)&p_sys->i_vcodec, p_sys->i_width, p_sys->i_height,
p_sys->f_scale, p_sys->i_vbitrate / 1000 );
}
/* Subpictures transcoding parameters */
p_sys->p_spu = NULL;
p_sys->p_spu_blend = NULL;
p_sys->psz_senc = NULL;
p_sys->p_spu_cfg = NULL;
p_sys->i_scodec = 0;
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "senc" );
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_senc, &p_sys->p_spu_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "scodec" );
if( psz_string && *psz_string )
{
char fcc[/*4*/] = " "; // sunqueen modify
memcpy( fcc, psz_string, __MIN( strlen( psz_string ), 4 ) );
p_sys->i_scodec = VLC_FOURCC( fcc[0], fcc[1], fcc[2], fcc[3] );
}
free( psz_string );
if( p_sys->i_scodec )
{
msg_Dbg( p_stream, "codec spu=%4.4s", (char *)&p_sys->i_scodec );
}
p_sys->b_soverlay = var_GetBool( p_stream, SOUT_CFG_PREFIX "soverlay" );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "sfilter" );
if( psz_string && *psz_string )
{
p_sys->p_spu = spu_Create( p_stream );
if( p_sys->p_spu )
spu_ChangeSources( p_sys->p_spu, psz_string );
}
free( psz_string );
/* OSD menu transcoding parameters */
p_sys->psz_osdenc = NULL;
p_sys->p_osd_cfg = NULL;
p_sys->i_osdcodec = 0;
p_sys->b_osd = var_GetBool( p_stream, SOUT_CFG_PREFIX "osd" );
if( p_sys->b_osd )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_osdenc,
&p_sys->p_osd_cfg, strdup( "dvbsub") );
free( psz_next );
p_sys->i_osdcodec = VLC_CODEC_YUVP;
msg_Dbg( p_stream, "codec osd=%4.4s", (char *)&p_sys->i_osdcodec );
if( !p_sys->p_spu )
{
p_sys->p_spu = spu_Create( p_stream );
if( p_sys->p_spu )
spu_ChangeSources( p_sys->p_spu, "osdmenu" );
}
else
{
spu_ChangeSources( p_sys->p_spu, "osdmenu" );
}
}
/* Audio settings */
p_sys->b_master_sync = var_GetBool( p_stream, SOUT_CFG_PREFIX "audio-sync" );
if( p_sys->f_fps > 0 ) p_sys->b_master_sync = true;
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->p_sys = p_sys;
return VLC_SUCCESS;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_stream_sys_t *p_sys;
char *psz_mux, *psz_access, *psz_url;
sout_access_out_t *p_access;
int ret = VLC_EGENERIC;
config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
psz_mux = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "mux" );
psz_access = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "access" );
if( !psz_access )
psz_access = strdup(p_stream->psz_name);
psz_url = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "dst" );
if (!psz_url)
{
char *psz_bind = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "bind" );
if( psz_bind )
{
char *psz_path = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "path" );
if( psz_path )
{
if( asprintf( &psz_url, "%s/%s", psz_bind, psz_path ) == -1 )
psz_url = NULL;
free(psz_bind);
free( psz_path );
}
else
psz_url = psz_bind;
}
}
p_sys = p_stream->p_sys = malloc( sizeof( sout_stream_sys_t) );
if( !p_sys )
{
ret = VLC_ENOMEM;
goto end;
}
p_sys->p_session = NULL;
if( fixAccessMux( p_stream, &psz_mux, &psz_access, psz_url ) )
goto end;
checkAccessMux( p_stream, psz_access, psz_mux );
p_access = sout_AccessOutNew( p_stream, psz_access, psz_url );
if( p_access == NULL )
{
msg_Err( p_stream, "no suitable sout access module for `%s/%s://%s'",
psz_access, psz_mux, psz_url );
goto end;
}
p_sys->p_mux = sout_MuxNew( p_stream->p_sout, psz_mux, p_access );
if( !p_sys->p_mux )
{
const char *psz_mux_guess = getMuxFromAlias( psz_mux );
if( psz_mux_guess && strcmp( psz_mux_guess, psz_mux ) )
{
msg_Dbg( p_stream, "Couldn't open mux `%s', trying `%s' instead",
psz_mux, psz_mux_guess );
p_sys->p_mux = sout_MuxNew( p_stream->p_sout, psz_mux_guess, p_access );
}
if( !p_sys->p_mux )
{
msg_Err( p_stream, "no suitable sout mux module for `%s/%s://%s'",
psz_access, psz_mux, psz_url );
sout_AccessOutDelete( p_access );
goto end;
}
}
if( var_GetBool( p_stream, SOUT_CFG_PREFIX"sap" ) )
create_SDP( p_stream, p_access );
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->pf_flush = Flush;
if( !sout_AccessOutCanControlPace( p_access ) )
p_stream->pace_nocontrol = true;
ret = VLC_SUCCESS;
msg_Dbg( p_this, "using `%s/%s://%s'", psz_access, psz_mux, psz_url );
end:
if( ret != VLC_SUCCESS )
free( p_sys );
free( psz_access );
free( psz_mux );
free( psz_url );
return ret;
}
static LRESULT HandleCadMessage(intf_thread_t* p_intf, HWND hwnd, WPARAM wParam, LPARAM lParam)
{
intf_sys_t* const p_sys = p_intf->p_sys;
switch (lParam)
{
case IPC_PLAY:
{
playlist_Play(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_PLAYPAUSE:
{
playlist_t* p_playlist = pl_Get(p_intf->p_libvlc);
const bool playing = playlist_Status(p_playlist) == PLAYLIST_RUNNING;
playlist_Control(p_playlist, playing ? PLAYLIST_PAUSE : PLAYLIST_PLAY, pl_Unlocked);
return 1;
}
case IPC_PAUSE:
{
playlist_Pause(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_STOP:
{
playlist_Stop(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_NEXT:
{
playlist_Next(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_PREVIOUS:
{
playlist_Prev(pl_Get(p_intf->p_libvlc));
return 1;
}
case IPC_SET_VOLUME:
{
playlist_VolumeSet(pl_Get(p_intf->p_libvlc), (int)wParam / 100.0f);
return 1;
}
case IPC_GET_VOLUME:
{
// VLC can return a volume larger than 100% so we need to cap it to 100 here.
const float volume = playlist_VolumeGet(pl_Get(p_intf->p_libvlc)) * 100.0f;
return (LRESULT)min(volume, 100.0f);
}
case IPC_GET_DURATION:
{
unsigned int duration = 0;
if (p_sys->p_input)
{
input_item_t* const p_item = input_GetItem(p_sys->p_input);
duration = (unsigned int)(input_item_GetDuration(p_item) / 1000000);
}
return duration;
}
case IPC_GET_POSITION:
{
int pos = 0;
if (p_sys->p_input)
{
pos = (int)(var_GetTime(p_sys->p_input, "time") / CLOCK_FREQ);
}
return pos;
}
case IPC_SET_POSITION:
{
if (p_sys->p_input)
{
var_SetTime(p_sys->p_input, "time", (int64_t)wParam * CLOCK_FREQ);
}
return 0;
}
case IPC_GET_SHUFFLE:
{
return (int)var_GetBool(pl_Get(p_intf->p_libvlc), "random");
}
case IPC_SET_SHUFFLE:
{
return (int)var_SetBool(pl_Get(p_intf->p_libvlc), "random", (bool)wParam);
}
case IPC_GET_REPEAT:
{
return (int)var_GetBool(pl_Get(p_intf->p_libvlc), "repeat");
}
case IPC_SET_REPEAT:
{
return (int)var_SetBool(pl_Get(p_intf->p_libvlc), "repeat", (bool)wParam);
}
case IPC_SET_RATING:
{
// VLC does not support ratings so send back 0.
PostMessage(p_sys->cad_window, WM_USER, 0, IPC_RATING_CHANGED_NOTIFICATION);
return 0;
}
case IPC_SET_CALLBACK_HWND:
{
p_sys->cad_window = (HWND)wParam;
return 1;
}
case IPC_SHOW_WINDOW:
{
// TODO.
return 0;
}
case IPC_GET_STATE:
{
const int status = playlist_Status(pl_Get(p_intf->p_libvlc));
return
status == PLAYLIST_RUNNING ? 1 :
status == PLAYLIST_PAUSED ? 2 :
0;
}
case IPC_SHUTDOWN_NOTIFICATION:
{
p_sys->cad_window = NULL;
return 1;
}
case IPC_CLOSE:
{
libvlc_Quit(p_intf->p_libvlc);
return 1;
}
case IPC_GET_CURRENT_TRACK:
{
if (!p_sys->p_input) return 0;
input_item_t* p_item = input_GetItem(p_sys->p_input);
char buffer[DATA_MAX_LENGTH];
int buffer_len = 0;
// If the i sstarts with file://, we assume that it is a local file and detailed
// metadata is available. Otherwise, we assume it to be a network stream (i.e. radio)
// with limited info (only a title).
char* const file = decode_URI(input_item_GetURI(p_item));
if (strncmp(file, "file://", 7) == 0)
{
char* const title = input_item_GetTitleFbName(p_item);
char* const artist = input_item_GetArtist(p_item);
char* const album = input_item_GetAlbum(p_item);
char* const cover = decode_URI(input_item_GetArtworkURL(p_item));
const unsigned int duration = input_item_GetDuration(p_item) / 1000000U;
buffer_len = _snprintf(
buffer, ARRAYSIZE(buffer), "%s\t%s\t%s\t\t\t\t\t%u\t%s\t\t%s\t\t\t\t\t\t\t",
title ? title : "",
artist ? artist : "",
album ? album : "",
duration,
file ? &file[8] : "",
cover ? &cover[8] : ""); // Skip the "file://" part.
free(title);
free(artist);
free(album);
free(cover);
}
else if (char* now_playing = input_item_GetNowPlaying(p_item))
{
char* artist = NULL;
char* title = now_playing;
char* pos = strstr(now_playing, " - ");
if (pos)
{
pos[0] = '\0';
artist = title;
title = pos + 3; // Skip the " - "
}
buffer_len = _snprintf(
buffer, ARRAYSIZE(buffer), "%s\t%s\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t",
title ? title : "",
artist ? artist : "");
free(now_playing);
}
free(file);
if (buffer_len)
{
wchar_t buffer_w[DATA_MAX_LENGTH];
const int buffer_w_len = MultiByteToWideChar(
CP_UTF8, 0, buffer, buffer_len + 1, buffer_w, ARRAYSIZE(buffer_w));
COPYDATASTRUCT cds;
cds.dwData = IPC_CURRENT_TRACK_NOTIFICATION;
cds.lpData = &buffer_w;
cds.cbData = buffer_w_len * sizeof(buffer_w[0]);
SendMessage(
p_sys->cad_window, WM_COPYDATA, IPC_CURRENT_TRACK_NOTIFICATION, (LPARAM)&cds);
}
return 1;
}
}
return 0;
}
/*****************************************************************************
* OpenEncoder: probe the encoder and return score
*****************************************************************************/
static int OpenEncoder( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys = p_enc->p_sys;
int i_tmp;
float f_tmp;
char *psz_tmp;
if( p_enc->fmt_out.i_codec != VLC_CODEC_DIRAC &&
!p_enc->b_force )
{
return VLC_EGENERIC;
}
if( !p_enc->fmt_in.video.i_frame_rate || !p_enc->fmt_in.video.i_frame_rate_base ||
!p_enc->fmt_in.video.i_height || !p_enc->fmt_in.video.i_width )
{
msg_Err( p_enc, "Framerate and picture dimensions must be non-zero" );
return VLC_EGENERIC;
}
/* Allocate the memory needed to store the decoder's structure */
if( ( p_sys = calloc( 1, sizeof(*p_sys) ) ) == NULL )
return VLC_ENOMEM;
p_enc->p_sys = p_sys;
p_enc->pf_encode_video = Encode;
p_enc->fmt_out.i_codec = VLC_CODEC_DIRAC;
p_enc->fmt_out.i_cat = VIDEO_ES;
if( ( p_sys->p_dts_fifo = block_FifoNew() ) == NULL )
{
CloseEncoder( p_this );
return VLC_ENOMEM;
}
ResetPTStlb( p_enc );
/* guess the video format based upon number of lines and picture height */
int i = 0;
VideoFormat guessed_video_fmt = VIDEO_FORMAT_CUSTOM;
/* Pick the dirac_video_format in this order of preference:
* 1. an exact match in frame height and an approximate fps match
* 2. the previous preset with a smaller number of lines.
*/
do
{
if( dirac_format_guess[i].i_height > p_enc->fmt_in.video.i_height )
{
guessed_video_fmt = dirac_format_guess[i-1].i_vf;
break;
}
if( dirac_format_guess[i].i_height != p_enc->fmt_in.video.i_height )
continue;
int src_fps = p_enc->fmt_in.video.i_frame_rate / p_enc->fmt_in.video.i_frame_rate_base;
int delta_fps = abs( dirac_format_guess[i].i_approx_fps - src_fps );
if( delta_fps > 2 )
continue;
guessed_video_fmt = dirac_format_guess[i].i_vf;
break;
} while( dirac_format_guess[++i].i_height );
dirac_encoder_context_init( &p_sys->ctx, guessed_video_fmt );
/* constants set from the input video format */
p_sys->ctx.src_params.width = p_enc->fmt_in.video.i_width;
p_sys->ctx.src_params.height = p_enc->fmt_in.video.i_height;
p_sys->ctx.src_params.frame_rate.numerator = p_enc->fmt_in.video.i_frame_rate;
p_sys->ctx.src_params.frame_rate.denominator = p_enc->fmt_in.video.i_frame_rate_base;
unsigned u_asr_num, u_asr_den;
vlc_ureduce( &u_asr_num, &u_asr_den,
p_enc->fmt_in.video.i_sar_num,
p_enc->fmt_in.video.i_sar_den, 0 );
p_sys->ctx.src_params.pix_asr.numerator = u_asr_num;
p_sys->ctx.src_params.pix_asr.denominator = u_asr_den;
config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_CHROMAFMT );
if( !psz_tmp )
goto error;
else if( !strcmp( psz_tmp, "420" ) ) {
p_enc->fmt_in.i_codec = VLC_CODEC_I420;
p_enc->fmt_in.video.i_bits_per_pixel = 12;
p_sys->ctx.src_params.chroma = format420;
p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 3 / 2;
}
else if( !strcmp( psz_tmp, "422" ) ) {
p_enc->fmt_in.i_codec = VLC_CODEC_I422;
p_enc->fmt_in.video.i_bits_per_pixel = 16;
p_sys->ctx.src_params.chroma = format422;
p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 2;
}
else if( !strcmp( psz_tmp, "444" ) ) {
p_enc->fmt_in.i_codec = VLC_CODEC_I444;
p_enc->fmt_in.video.i_bits_per_pixel = 24;
p_sys->ctx.src_params.chroma = format444;
p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 3;
}
else {
msg_Err( p_enc, "Invalid chroma format: %s", psz_tmp );
free( psz_tmp );
goto error;
}
free( psz_tmp );
p_sys->ctx.enc_params.qf = var_GetFloat( p_enc, ENC_CFG_PREFIX ENC_QUALITY_FACTOR );
/* use bitrate from sout-transcode-vb in kbps */
p_sys->ctx.enc_params.trate = p_enc->fmt_out.i_bitrate / 1000;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_TARGETRATE );
if( i_tmp > -1 )
p_sys->ctx.enc_params.trate = i_tmp;
p_enc->fmt_out.i_bitrate = p_sys->ctx.enc_params.trate * 1000;
p_sys->ctx.enc_params.lossless = var_GetBool( p_enc, ENC_CFG_PREFIX ENC_LOSSLESS );
psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_PREFILTER );
if( !psz_tmp )
goto error;
else if( !strcmp( psz_tmp, "none" ) ) {
p_sys->ctx.enc_params.prefilter = NO_PF;
}
else if( !strcmp( psz_tmp, "cwm" ) ) {
p_sys->ctx.enc_params.prefilter = CWM;
}
else if( !strcmp( psz_tmp, "rectlp" ) ) {
p_sys->ctx.enc_params.prefilter = RECTLP;
}
else if( !strcmp( psz_tmp, "diaglp" ) ) {
p_sys->ctx.enc_params.prefilter = DIAGLP;
}
else {
msg_Err( p_enc, "Invalid prefilter: %s", psz_tmp );
free( psz_tmp );
goto error;
}
free( psz_tmp );
p_sys->ctx.enc_params.prefilter_strength =
var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_PREFILTER_STRENGTH );
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_L1SEP );
if( i_tmp > -1 )
p_sys->ctx.enc_params.L1_sep = i_tmp;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_L1NUM );
if( i_tmp > -1 )
p_sys->ctx.enc_params.num_L1 = i_tmp;
psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_CODINGMODE );
if( !psz_tmp )
goto error;
else if( !strcmp( psz_tmp, "auto" ) ) {
p_sys->b_auto_field_coding = true;
}
else if( !strcmp( psz_tmp, "progressive" ) ) {
p_sys->b_auto_field_coding = false;
p_sys->ctx.enc_params.picture_coding_mode = 0;
}
else if( !strcmp( psz_tmp, "field" ) ) {
p_sys->b_auto_field_coding = false;
p_sys->ctx.enc_params.picture_coding_mode = 1;
}
else {
msg_Err( p_enc, "Invalid codingmode: %s", psz_tmp );
free( psz_tmp );
goto error;
}
free( psz_tmp );
psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_MVPREC );
if( !psz_tmp )
goto error;
else if( !strcmp( psz_tmp, "1" ) ) {
p_sys->ctx.enc_params.mv_precision = MV_PRECISION_PIXEL;
}
else if( !strcmp( psz_tmp, "1/2" ) ) {
p_sys->ctx.enc_params.mv_precision = MV_PRECISION_HALF_PIXEL;
}
else if( !strcmp( psz_tmp, "1/4" ) ) {
p_sys->ctx.enc_params.mv_precision = MV_PRECISION_QUARTER_PIXEL;
}
else if( !strcmp( psz_tmp, "1/8" ) ) {
p_sys->ctx.enc_params.mv_precision = MV_PRECISION_EIGHTH_PIXEL;
}
else {
msg_Err( p_enc, "Invalid mv-prec: %s", psz_tmp );
free( psz_tmp );
goto error;
}
free( psz_tmp );
/*
* {x,y}b{len,sep} must be multiples of 4
*/
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_WIDTH );
if( i_tmp > -1 )
p_sys->ctx.enc_params.xbsep = i_tmp / 4 * 4;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_HEIGHT );
if( i_tmp > -1 )
p_sys->ctx.enc_params.ybsep = i_tmp / 4 * 4;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_OVERLAP );
if( i_tmp > -1 ) {
p_sys->ctx.enc_params.xblen = p_sys->ctx.enc_params.xbsep * (100 + i_tmp) / 400 * 4;
p_sys->ctx.enc_params.yblen = p_sys->ctx.enc_params.ybsep * (100 + i_tmp) / 400 * 4;
}
/*
* {x,y}blen >= {x,y}bsep
* {x,y}blen <= 2* {x,y}bsep
*/
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_XBLEN );
if( i_tmp > -1 ) {
int xblen = __MAX( i_tmp, p_sys->ctx.enc_params.xbsep );
xblen = __MIN( xblen, 2 * p_sys->ctx.enc_params.xbsep );
p_sys->ctx.enc_params.xblen = xblen;
}
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_YBLEN );
if( i_tmp > -1 ) {
int yblen = __MAX( i_tmp, p_sys->ctx.enc_params.ybsep );
yblen = __MIN( yblen, 2 * p_sys->ctx.enc_params.ybsep );
p_sys->ctx.enc_params.yblen = yblen;
}
psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_ME_SIMPLESEARCH );
if( !psz_tmp )
goto error;
if( *psz_tmp != '\0' ) {
/* of the form [0-9]+:[0-9]+ */
char *psz_start = psz_tmp;
char *psz_end = psz_tmp;
p_sys->ctx.enc_params.x_range_me = strtol(psz_start, &psz_end, 10);
if( *psz_end != ':' || psz_end == psz_start ) {
msg_Err( p_enc, "Invalid simple search range: %s", psz_tmp );
free( psz_tmp );
goto error;
}
psz_start = ++psz_end;
p_sys->ctx.enc_params.y_range_me = strtol(psz_start, &psz_end, 10);
if( *psz_end != '\0' || psz_end == psz_start ) {
msg_Err( p_enc, "Invalid simple search range: %s", psz_tmp );
free( psz_tmp );
goto error;
}
if( p_sys->ctx.enc_params.x_range_me < 0 ||
p_sys->ctx.enc_params.y_range_me < 0 )
{
msg_Err( p_enc, "Invalid negative simple search range: %s", psz_tmp );
free( psz_tmp );
goto error;
}
p_sys->ctx.enc_params.full_search = 1;
}
free( psz_tmp );
#if DIRAC_RESEARCH_VERSION_ATLEAST(1,0,1)
p_sys->ctx.enc_params.combined_me = var_GetBool( p_enc, ENC_CFG_PREFIX ENC_ME_COMBINED );
#endif
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_DWTINTRA );
if( i_tmp > -1 )
p_sys->ctx.enc_params.intra_wlt_filter = i_tmp;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_DWTINTER );
if( i_tmp > -1 )
p_sys->ctx.enc_params.inter_wlt_filter = i_tmp;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_DWTDEPTH );
if( i_tmp > -1 )
p_sys->ctx.enc_params.wlt_depth = i_tmp;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MULTIQUANT );
if( i_tmp > -1 )
p_sys->ctx.enc_params.multi_quants = i_tmp;
i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_SPARTITION );
if( i_tmp > -1 )
p_sys->ctx.enc_params.spatial_partition = i_tmp;
p_sys->ctx.enc_params.using_ac = !var_GetBool( p_enc, ENC_CFG_PREFIX ENC_NOAC );
f_tmp = var_GetFloat( p_enc, ENC_CFG_PREFIX ENC_CPD );
if( f_tmp > -1 )
p_sys->ctx.enc_params.cpd = f_tmp;
/* Allocate the buffer for inputing frames into the encoder */
if( ( p_sys->p_buffer_in = malloc( p_sys->i_buffer_in ) ) == NULL )
{
CloseEncoder( p_this );
return VLC_ENOMEM;
}
/* Set up output buffer */
/* Unfortunately it isn't possible to determine if the buffer
* is too small (and then reallocate it) */
p_sys->i_buffer_out = 4096 + p_sys->i_buffer_in;
if( ( p_sys->p_buffer_out = malloc( p_sys->i_buffer_out ) ) == NULL )
{
CloseEncoder( p_this );
return VLC_ENOMEM;
}
return VLC_SUCCESS;
error:
CloseEncoder( p_this );
return VLC_EGENERIC;
}
void VlcProc::on_intf_event_changed( vlc_object_t* p_obj, vlc_value_t newVal )
{
input_thread_t* pInput = (input_thread_t*) p_obj;
assert( getIntf()->p_sys->p_input == NULL || getIntf()->p_sys->p_input == pInput );
if( !getIntf()->p_sys->p_input )
{
msg_Dbg( getIntf(), "new input %p detected", pInput );
getIntf()->p_sys->p_input = pInput;
vlc_object_hold( pInput );
}
switch( newVal.i_int )
{
case INPUT_EVENT_STATE:
{
int state = var_GetInteger( pInput, "state" );
SET_BOOL( m_cVarStopped, false );
SET_BOOL( m_cVarPlaying, state != PAUSE_S );
SET_BOOL( m_cVarPaused, state == PAUSE_S );
break;
}
case INPUT_EVENT_POSITION:
{
float pos = var_GetFloat( pInput, "position" );
SET_STREAMTIME( m_cVarTime, pos, false );
SET_BOOL( m_cVarSeekable, pos != 0.0 );
break;
}
case INPUT_EVENT_ES:
{
// Do we have audio
vlc_value_t audio_es;
var_Change( pInput, "audio-es", VLC_VAR_CHOICESCOUNT,
&audio_es, NULL );
SET_BOOL( m_cVarHasAudio, audio_es.i_int > 0 );
break;
}
case INPUT_EVENT_VOUT:
{
vout_thread_t* pVout = input_GetVout( pInput );
SET_BOOL( m_cVarHasVout, pVout != NULL );
if( !pVout || pVout == m_pVout )
{
// end of input or vout reuse (nothing to do)
if( pVout )
vlc_object_release( pVout );
break;
}
if( m_pVout )
{
// remove previous Vout callbacks
var_DelCallback( m_pVout, "mouse-moved",
onGenericCallback, this );
vlc_object_release( m_pVout );
m_pVout = NULL;
}
// add new Vout callbackx
var_AddCallback( pVout, "mouse-moved",
onGenericCallback, this );
m_pVout = pVout;
break;
}
case INPUT_EVENT_AOUT:
{
aout_instance_t* pAout = input_GetAout( pInput );
// end of input or aout reuse (nothing to do)
if( !pAout || pAout == m_pAout )
{
if( pAout )
vlc_object_release( pAout );
break;
}
// remove previous Aout if any
if( m_pAout )
{
var_DelCallback( m_pAout, "audio-filter",
onGenericCallback, this );
if( m_bEqualizer_started )
{
var_DelCallback( m_pAout, "equalizer-bands",
onEqBandsChange, this );
var_DelCallback( m_pAout, "equalizer-preamp",
onEqPreampChange, this );
}
vlc_object_release( m_pAout );
m_pAout = NULL;
m_bEqualizer_started = false;
}
// New Aout (addCallbacks)
var_AddCallback( pAout, "audio-filter", onGenericCallback, this );
char *pFilters = var_GetNonEmptyString( pAout, "audio-filter" );
bool b_equalizer = pFilters && strstr( pFilters, "equalizer" );
free( pFilters );
SET_BOOL( m_cVarEqualizer, b_equalizer );
if( b_equalizer )
{
var_AddCallback( pAout, "equalizer-bands",
onEqBandsChange, this );
var_AddCallback( pAout, "equalizer-preamp",
onEqPreampChange, this );
m_bEqualizer_started = true;
}
m_pAout = pAout;
break;
}
case INPUT_EVENT_CHAPTER:
{
vlc_value_t chapters_count;
var_Change( pInput, "chapter", VLC_VAR_CHOICESCOUNT,
&chapters_count, NULL );
SET_BOOL( m_cVarDvdActive, chapters_count.i_int > 0 );
break;
}
case INPUT_EVENT_RECORD:
SET_BOOL( m_cVarRecording, var_GetBool( pInput, "record" ) );
break;
case INPUT_EVENT_DEAD:
msg_Dbg( getIntf(), "end of input detected for %p", pInput );
var_DelCallback( pInput, "intf-event", onGenericCallback2, this );
var_DelCallback( pInput, "bit-rate", onGenericCallback, this );
var_DelCallback( pInput, "sample-rate", onGenericCallback, this );
var_DelCallback( pInput, "can-record" , onGenericCallback, this );
vlc_object_release( pInput );
getIntf()->p_sys->p_input = NULL;
reset_input();
break;
default:
break;
}
}
void InputManager::UpdateRecord()
{
emit recordingStateChanged( var_GetBool( p_input, "record" ) );
}
void VlcProc::on_loop_changed( vlc_object_t* p_obj, vlc_value_t newVal )
{
playlist_t* pPlaylist = (playlist_t*) p_obj;
SET_BOOL( m_cVarLoop, var_GetBool( pPlaylist, "loop" ) );
}
/** Changes the EWMH state of the window */
static void set_wm_state (vout_window_t *wnd, bool on, xcb_atom_t state)
{
vout_window_sys_t *sys = wnd->sys;
/* From EWMH "_WM_STATE" */
xcb_client_message_event_t ev = {
.response_type = XCB_CLIENT_MESSAGE,
.format = 32,
.window = wnd->handle.xid,
.type = sys->wm_state,
};
ev.data.data32[0] = on ? NET_WM_STATE_ADD : NET_WM_STATE_REMOVE;
ev.data.data32[1] = state;
ev.data.data32[2] = 0;
ev.data.data32[3] = 1;
/* From ICCCM "Changing Window State" */
xcb_send_event (sys->conn, 0, sys->root,
XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
(const char *)&ev);
}
static int Control (vout_window_t *wnd, int cmd, va_list ap)
{
vout_window_sys_t *p_sys = wnd->sys;
xcb_connection_t *conn = p_sys->conn;
switch (cmd)
{
case VOUT_WINDOW_SET_SIZE:
{
unsigned width = va_arg (ap, unsigned);
unsigned height = va_arg (ap, unsigned);
const uint32_t values[] = { width, height, };
xcb_configure_window (conn, wnd->handle.xid,
XCB_CONFIG_WINDOW_WIDTH |
XCB_CONFIG_WINDOW_HEIGHT, values);
break;
}
case VOUT_WINDOW_SET_STATE:
{
unsigned state = va_arg (ap, unsigned);
bool above = (state & VOUT_WINDOW_STATE_ABOVE) != 0;
bool below = (state & VOUT_WINDOW_STATE_BELOW) != 0;
set_wm_state (wnd, above, p_sys->wm_state_above);
set_wm_state (wnd, below, p_sys->wm_state_below);
break;
}
case VOUT_WINDOW_SET_FULLSCREEN:
{
bool fs = va_arg (ap, int);
if (!fs && var_GetBool (wnd, "video-wallpaper"))
return VLC_EGENERIC;
set_wm_state (wnd, fs, p_sys->wm_state_fullscreen);
break;
}
default:
msg_Err (wnd, "request %d not implemented", cmd);
return VLC_EGENERIC;
}
xcb_flush (p_sys->conn);
return VLC_SUCCESS;
}
void VlcProc::on_repeat_changed( vlc_object_t* p_obj, vlc_value_t newVal )
{
playlist_t* pPlaylist = (playlist_t*) p_obj;
SET_BOOL( m_cVarRepeat, var_GetBool( pPlaylist, "repeat" ) );
}
static void input_item_add_subitem_tree ( const vlc_event_t * p_event,
void * user_data )
{
input_item_t *p_input = p_event->p_obj;
playlist_t *p_playlist = (( playlist_item_t* ) user_data)->p_playlist;
input_item_node_t *p_new_root = p_event->u.input_item_subitem_tree_added.p_root;
PL_LOCK;
playlist_item_t *p_item =
playlist_ItemGetByInput( p_playlist, p_input );
assert( p_item != NULL );
bool b_current = get_current_status_item( p_playlist ) == p_item;
bool b_autostart = var_GetBool( p_playlist, "playlist-autostart" );
bool b_stop = p_item->i_flags & PLAYLIST_SUBITEM_STOP_FLAG;
bool b_flat = false;
p_item->i_flags &= ~PLAYLIST_SUBITEM_STOP_FLAG;
/* We will have to flatten the tree out if we are in "the playlist" node and
the user setting demands flat playlist */
if( !pl_priv(p_playlist)->b_tree ) {
playlist_item_t *p_up = p_item;
while( p_up->p_parent )
{
if( p_up->p_parent == p_playlist->p_playing )
{
b_flat = true;
break;
}
p_up = p_up->p_parent;
}
}
int pos = 0;
/* If we have to flatten out, then take the item's position in the parent as
insertion point and delete the item */
if( b_flat )
{
playlist_item_t *p_parent = p_item->p_parent;
assert( p_parent != NULL );
int i;
for( i = 0; i < p_parent->i_children; i++ )
{
if( p_parent->pp_children[i] == p_item )
{
pos = i;
break;
}
}
assert( i < p_parent->i_children );
playlist_DeleteItem( p_playlist, p_item, true );
p_item = p_parent;
}
else
{
pos = p_item->i_children >= 0 ? p_item->i_children : 0;
}
/* At this point:
"p_item" is the node where sub-items should be inserted,
"pos" is the insertion position in that node */
int last_pos = playlist_InsertInputItemTree( p_playlist,
p_item,
p_new_root,
pos,
b_flat );
if( !b_flat ) var_SetInteger( p_playlist, "leaf-to-parent", p_item->i_id );
//control playback only if it was the current playing item that got subitems
if( b_current )
{
if( last_pos == pos || ( b_stop && !b_flat ) || !b_autostart )
{
/* We stop, either because no sub-item was actually created, or some
flags/settings want us to do so at this point */
PL_UNLOCK;
playlist_Stop( p_playlist );
return;
}
else
{
/* Continue to play, either random or the first new item */
playlist_item_t *p_play_item;
if( var_GetBool( p_playlist, "random" ) )
{
unsigned rand_pos =
((unsigned)vlc_mrand48()) % (last_pos - pos);
rand_pos += pos;
p_play_item = p_item->pp_children[rand_pos];
}
else
{
p_play_item = p_item->pp_children[pos];
/* NOTE: this is a work around the general bug:
if node-to-be-played contains sub-nodes, then second instead
of first leaf starts playing (only in case the leafs have just
been instered and playlist has not yet been rebuilt.)
*/
while( p_play_item->i_children > 0 )
p_play_item = p_play_item->pp_children[0];
}
playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
pl_Locked,
get_current_status_node( p_playlist ),
p_play_item );
}
}
PL_UNLOCK;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_stream_sys_t *p_sys;
char *psz_string;
if( !p_stream->p_next )
{
msg_Err( p_stream, "cannot create chain" );
return VLC_EGENERIC;
}
p_sys = calloc( 1, sizeof( *p_sys ) );
p_sys->i_master_drift = 0;
config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
/* Audio transcoding parameters */
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "aenc" );
p_sys->psz_aenc = NULL;
p_sys->p_audio_cfg = NULL;
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_aenc, &p_sys->p_audio_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "acodec" );
p_sys->i_acodec = 0;
if( psz_string && *psz_string )
{
char fcc[5] = " \0";
memcpy( fcc, psz_string, __MIN( strlen( psz_string ), 4 ) );
p_sys->i_acodec = vlc_fourcc_GetCodecFromString( AUDIO_ES, fcc );
msg_Dbg( p_stream, "Checking codec mapping for %s got %4.4s ", fcc, (char*)&p_sys->i_acodec);
}
free( psz_string );
p_sys->psz_alang = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "alang" );
p_sys->i_abitrate = var_GetInteger( p_stream, SOUT_CFG_PREFIX "ab" );
if( p_sys->i_abitrate < 4000 ) p_sys->i_abitrate *= 1000;
p_sys->i_sample_rate = var_GetInteger( p_stream, SOUT_CFG_PREFIX "samplerate" );
p_sys->i_channels = var_GetInteger( p_stream, SOUT_CFG_PREFIX "channels" );
if( p_sys->i_acodec )
{
if( ( p_sys->i_acodec == VLC_CODEC_MP3 ||
p_sys->i_acodec == VLC_CODEC_MP2 ||
p_sys->i_acodec == VLC_CODEC_MPGA ) && p_sys->i_channels > 2 )
{
msg_Warn( p_stream, "%d channels invalid for mp2/mp3, forcing to 2",
p_sys->i_channels );
p_sys->i_channels = 2;
}
msg_Dbg( p_stream, "codec audio=%4.4s %dHz %d channels %dKb/s",
(char *)&p_sys->i_acodec, p_sys->i_sample_rate,
p_sys->i_channels, p_sys->i_abitrate / 1000 );
}
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "afilter" );
if( psz_string && *psz_string )
p_sys->psz_af = strdup( psz_string );
else
p_sys->psz_af = NULL;
free( psz_string );
/* Video transcoding parameters */
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "venc" );
p_sys->psz_venc = NULL;
p_sys->p_video_cfg = NULL;
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_venc, &p_sys->p_video_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "vcodec" );
p_sys->i_vcodec = 0;
if( psz_string && *psz_string )
{
char fcc[5] = " \0";
memcpy( fcc, psz_string, __MIN( strlen( psz_string ), 4 ) );
p_sys->i_vcodec = vlc_fourcc_GetCodecFromString( VIDEO_ES, fcc );
msg_Dbg( p_stream, "Checking video codec mapping for %s got %4.4s ", fcc, (char*)&p_sys->i_vcodec);
}
free( psz_string );
p_sys->i_vbitrate = var_GetInteger( p_stream, SOUT_CFG_PREFIX "vb" );
if( p_sys->i_vbitrate < 16000 ) p_sys->i_vbitrate *= 1000;
p_sys->f_scale = var_GetFloat( p_stream, SOUT_CFG_PREFIX "scale" );
p_sys->b_master_sync = var_InheritURational( p_stream, &p_sys->fps_num, &p_sys->fps_den, SOUT_CFG_PREFIX "fps" ) == VLC_SUCCESS;
p_sys->i_width = var_GetInteger( p_stream, SOUT_CFG_PREFIX "width" );
p_sys->i_height = var_GetInteger( p_stream, SOUT_CFG_PREFIX "height" );
p_sys->i_maxwidth = var_GetInteger( p_stream, SOUT_CFG_PREFIX "maxwidth" );
p_sys->i_maxheight = var_GetInteger( p_stream, SOUT_CFG_PREFIX "maxheight" );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "vfilter" );
if( psz_string && *psz_string )
p_sys->psz_vf2 = strdup(psz_string );
else
p_sys->psz_vf2 = NULL;
free( psz_string );
p_sys->b_deinterlace = var_GetBool( p_stream, SOUT_CFG_PREFIX "deinterlace" );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "deinterlace-module" );
p_sys->psz_deinterlace = NULL;
p_sys->p_deinterlace_cfg = NULL;
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_deinterlace,
&p_sys->p_deinterlace_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
p_sys->i_threads = var_GetInteger( p_stream, SOUT_CFG_PREFIX "threads" );
p_sys->b_high_priority = var_GetBool( p_stream, SOUT_CFG_PREFIX "high-priority" );
if( p_sys->i_vcodec )
{
msg_Dbg( p_stream, "codec video=%4.4s %dx%d scaling: %f %dkb/s",
(char *)&p_sys->i_vcodec, p_sys->i_width, p_sys->i_height,
p_sys->f_scale, p_sys->i_vbitrate / 1000 );
}
/* Disable hardware decoding by default (unlike normal playback) */
psz_string = var_CreateGetString( p_stream, "avcodec-hw" );
if( !strcasecmp( "any", psz_string ) )
var_SetString( p_stream, "avcodec-hw", "none" );
free( psz_string );
/* Subpictures transcoding parameters */
p_sys->p_spu = NULL;
p_sys->p_spu_blend = NULL;
p_sys->psz_senc = NULL;
p_sys->p_spu_cfg = NULL;
p_sys->i_scodec = 0;
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "senc" );
if( psz_string && *psz_string )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_senc, &p_sys->p_spu_cfg,
psz_string );
free( psz_next );
}
free( psz_string );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "scodec" );
if( psz_string && *psz_string )
{
char fcc[5] = " \0";
memcpy( fcc, psz_string, __MIN( strlen( psz_string ), 4 ) );
p_sys->i_scodec = vlc_fourcc_GetCodecFromString( SPU_ES, fcc );
msg_Dbg( p_stream, "Checking spu codec mapping for %s got %4.4s ", fcc, (char*)&p_sys->i_scodec);
}
free( psz_string );
if( p_sys->i_scodec )
{
msg_Dbg( p_stream, "codec spu=%4.4s", (char *)&p_sys->i_scodec );
}
p_sys->b_soverlay = var_GetBool( p_stream, SOUT_CFG_PREFIX "soverlay" );
psz_string = var_GetString( p_stream, SOUT_CFG_PREFIX "sfilter" );
if( psz_string && *psz_string )
{
p_sys->p_spu = spu_Create( p_stream );
if( p_sys->p_spu )
spu_ChangeSources( p_sys->p_spu, psz_string );
}
free( psz_string );
/* OSD menu transcoding parameters */
p_sys->psz_osdenc = NULL;
p_sys->p_osd_cfg = NULL;
p_sys->i_osdcodec = 0;
p_sys->b_osd = var_GetBool( p_stream, SOUT_CFG_PREFIX "osd" );
if( p_sys->b_osd )
{
char *psz_next;
psz_next = config_ChainCreate( &p_sys->psz_osdenc,
&p_sys->p_osd_cfg, "dvbsub" );
free( psz_next );
p_sys->i_osdcodec = VLC_CODEC_YUVP;
msg_Dbg( p_stream, "codec osd=%4.4s", (char *)&p_sys->i_osdcodec );
if( !p_sys->p_spu )
{
p_sys->p_spu = spu_Create( p_stream );
if( p_sys->p_spu )
spu_ChangeSources( p_sys->p_spu, "osdmenu" );
}
else
{
spu_ChangeSources( p_sys->p_spu, "osdmenu" );
}
}
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->p_sys = p_sys;
return VLC_SUCCESS;
}
static inline bool osd_isVisible( osd_menu_t *p_osd )
{
return var_GetBool( p_osd, "osd-menu-visible" );
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
int fd;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access, "no file name specified" );
return VLC_EGENERIC;
}
bool append = var_GetBool( p_access, SOUT_CFG_PREFIX "append" );
if (!strcmp (p_access->psz_access, "fd"))
{
char *end;
fd = strtol (p_access->psz_path, &end, 0);
if (!*p_access->psz_path || *end)
{
msg_Err (p_access, "invalid file descriptor: %s",
p_access->psz_path);
return VLC_EGENERIC;
}
fd = vlc_dup (fd);
if (fd == -1)
{
msg_Err (p_access, "cannot use file descriptor: %m");
return VLC_EGENERIC;
}
}
#ifndef UNDER_CE
else
if( !strcmp( p_access->psz_path, "-" ) )
{
#ifdef WIN32
setmode (fileno (stdout), O_BINARY);
#endif
fd = vlc_dup (fileno (stdout));
if (fd == -1)
{
msg_Err (p_access, "cannot use standard output: %m");
return VLC_EGENERIC;
}
msg_Dbg( p_access, "using stdout" );
}
#endif
else
{
char *psz_tmp = str_format( p_access, p_access->psz_path );
path_sanitize( psz_tmp );
fd = vlc_open( psz_tmp, O_RDWR | O_CREAT | O_LARGEFILE |
#ifdef O_SYNC
(var_GetBool( p_access, SOUT_CFG_PREFIX "sync" ) ? O_SYNC : 0) |
#endif
(append ? 0 : O_TRUNC), 0666 );
free( psz_tmp );
if (fd == -1)
{
msg_Err (p_access, "cannot create %s: %m", p_access->psz_path);
return VLC_EGENERIC;
}
}
p_access->pf_write = Write;
p_access->pf_read = Read;
p_access->pf_seek = Seek;
p_access->pf_control = Control;
p_access->p_sys = (void *)(intptr_t)fd;
msg_Dbg( p_access, "file access output opened (%s)", p_access->psz_path );
if (append)
lseek (fd, 0, SEEK_END);
return VLC_SUCCESS;
}
/**
* Compute the next playlist item depending on
* the playlist course mode (forward, backward, random, view,...).
*
* \param p_playlist the playlist object
* \return nothing
*/
static playlist_item_t *NextItem( playlist_t *p_playlist )
{
playlist_private_t *p_sys = pl_priv(p_playlist);
playlist_item_t *p_new = NULL;
/* Handle quickly a few special cases */
/* No items to play */
if( p_playlist->items.i_size == 0 )
{
msg_Info( p_playlist, "playlist is empty" );
return NULL;
}
/* Start the real work */
if( p_sys->request.b_request )
{
p_new = p_sys->request.p_item;
int i_skip = p_sys->request.i_skip;
PL_DEBUG( "processing request item: %s, node: %s, skip: %i",
PLI_NAME( p_sys->request.p_item ),
PLI_NAME( p_sys->request.p_node ), i_skip );
if( p_sys->request.p_node &&
p_sys->request.p_node != get_current_status_node( p_playlist ) )
{
set_current_status_node( p_playlist, p_sys->request.p_node );
p_sys->request.p_node = NULL;
p_sys->b_reset_currently_playing = true;
}
/* If we are asked for a node, go to it's first child */
if( i_skip == 0 && ( p_new == NULL || p_new->i_children != -1 ) )
{
i_skip++;
if( p_new != NULL )
{
p_new = playlist_GetNextLeaf( p_playlist, p_new, NULL, true, false );
for( int i = 0; i < p_playlist->current.i_size; i++ )
{
if( p_new == ARRAY_VAL( p_playlist->current, i ) )
{
p_playlist->i_current_index = i;
i_skip = 0;
}
}
}
}
if( p_sys->b_reset_currently_playing )
/* A bit too bad to reset twice ... */
ResetCurrentlyPlaying( p_playlist, p_new );
else if( p_new )
ResyncCurrentIndex( p_playlist, p_new );
else
p_playlist->i_current_index = -1;
if( p_playlist->current.i_size && (i_skip > 0) )
{
if( p_playlist->i_current_index < -1 )
p_playlist->i_current_index = -1;
for( int i = i_skip; i > 0 ; i-- )
{
p_playlist->i_current_index++;
if( p_playlist->i_current_index >= p_playlist->current.i_size )
{
PL_DEBUG( "looping - restarting at beginning of node" );
/* reshuffle playlist when end is reached */
if( var_GetBool( p_playlist, "random" ) ) {
PL_DEBUG( "reshuffle playlist" );
ResetCurrentlyPlaying( p_playlist,
get_current_status_item( p_playlist ) );
}
p_playlist->i_current_index = 0;
}
}
p_new = ARRAY_VAL( p_playlist->current,
p_playlist->i_current_index );
}
else if( p_playlist->current.i_size && (i_skip < 0) )
{
for( int i = i_skip; i < 0 ; i++ )
{
p_playlist->i_current_index--;
if( p_playlist->i_current_index <= -1 )
{
PL_DEBUG( "looping - restarting at end of node" );
/* reshuffle playlist when beginning is reached */
if( var_GetBool( p_playlist, "random" ) ) {
PL_DEBUG( "reshuffle playlist" );
ResetCurrentlyPlaying( p_playlist,
get_current_status_item( p_playlist ) );
}
p_playlist->i_current_index = p_playlist->current.i_size-1;
}
}
p_new = ARRAY_VAL( p_playlist->current,
p_playlist->i_current_index );
}
/* Clear the request */
p_sys->request.b_request = false;
}
/* "Automatic" item change ( next ) */
else
{
bool b_loop = var_GetBool( p_playlist, "loop" );
bool b_repeat = var_GetBool( p_playlist, "repeat" );
bool b_playstop = var_GetBool( p_playlist, "play-and-stop" );
/* Repeat and play/stop */
if( b_repeat && get_current_status_item( p_playlist ) )
{
msg_Dbg( p_playlist,"repeating item" );
return get_current_status_item( p_playlist );
}
if( b_playstop )
{
msg_Dbg( p_playlist,"stopping (play and stop)" );
return NULL;
}
/* */
if( get_current_status_item( p_playlist ) )
{
playlist_item_t *p_parent = get_current_status_item( p_playlist );
while( p_parent )
{
if( p_parent->i_flags & PLAYLIST_SKIP_FLAG )
{
msg_Dbg( p_playlist, "blocking item, stopping") ;
return NULL;
}
p_parent = p_parent->p_parent;
}
}
PL_DEBUG( "changing item without a request (current %i/%i)",
p_playlist->i_current_index, p_playlist->current.i_size );
/* Cant go to next from current item */
if( get_current_status_item( p_playlist ) &&
get_current_status_item( p_playlist )->i_flags & PLAYLIST_SKIP_FLAG )
return NULL;
if( p_sys->b_reset_currently_playing )
ResetCurrentlyPlaying( p_playlist,
get_current_status_item( p_playlist ) );
p_playlist->i_current_index++;
assert( p_playlist->i_current_index <= p_playlist->current.i_size );
if( p_playlist->i_current_index == p_playlist->current.i_size )
{
if( !b_loop || p_playlist->current.i_size == 0 )
return NULL;
/* reshuffle after last item has been played */
if( var_GetBool( p_playlist, "random" ) ) {
PL_DEBUG( "reshuffle playlist" );
ResetCurrentlyPlaying( p_playlist,
get_current_status_item( p_playlist ) );
}
p_playlist->i_current_index = 0;
}
PL_DEBUG( "using item %i", p_playlist->i_current_index );
if ( p_playlist->current.i_size == 0 )
return NULL;
p_new = ARRAY_VAL( p_playlist->current, p_playlist->i_current_index );
/* The new item can't be autoselected */
if( p_new != NULL && p_new->i_flags & PLAYLIST_SKIP_FLAG )
return NULL;
}
return p_new;
}
/*****************************************************************************
* FrontendOpen : Determine frontend device information and capabilities
*****************************************************************************/
int FrontendOpen( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
frontend_t * p_frontend;
unsigned int i_adapter, i_device;
bool b_probe;
char frontend[128];
i_adapter = var_GetInteger( p_access, "dvb-adapter" );
i_device = var_GetInteger( p_access, "dvb-device" );
b_probe = var_GetBool( p_access, "dvb-probe" );
if( snprintf( frontend, sizeof(frontend), FRONTEND, i_adapter, i_device ) >= (int)sizeof(frontend) )
{
msg_Err( p_access, "snprintf() truncated string for FRONTEND" );
frontend[sizeof(frontend) - 1] = '\0';
}
p_sys->p_frontend = p_frontend = malloc( sizeof(frontend_t) );
if( !p_frontend )
return VLC_ENOMEM;
msg_Dbg( p_access, "Opening device %s", frontend );
if( (p_sys->i_frontend_handle = vlc_open(frontend, O_RDWR | O_NONBLOCK)) < 0 )
{
msg_Err( p_access, "FrontEndOpen: opening device failed (%m)" );
free( p_frontend );
return VLC_EGENERIC;
}
if( b_probe )
{
const char * psz_expected = NULL;
const char * psz_real;
if( FrontendInfo( p_access ) < 0 )
{
close( p_sys->i_frontend_handle );
free( p_frontend );
return VLC_EGENERIC;
}
switch( p_frontend->info.type )
{
case FE_OFDM:
psz_real = "DVB-T";
break;
case FE_QAM:
psz_real = "DVB-C";
break;
case FE_QPSK:
psz_real = "DVB-S";
break;
case FE_ATSC:
psz_real = "ATSC";
break;
default:
psz_real = "unknown";
}
/* Sanity checks */
if( (!strncmp( p_access->psz_access, "qpsk", 4 ) ||
!strncmp( p_access->psz_access, "dvb-s", 5 ) ||
!strncmp( p_access->psz_access, "satellite", 9 ) ) &&
(p_frontend->info.type != FE_QPSK) )
{
psz_expected = "DVB-S";
}
if( (!strncmp( p_access->psz_access, "cable", 5 ) ||
!strncmp( p_access->psz_access, "dvb-c", 5 ) ) &&
(p_frontend->info.type != FE_QAM) )
{
psz_expected = "DVB-C";
}
if( (!strncmp( p_access->psz_access, "terrestrial", 11 ) ||
!strncmp( p_access->psz_access, "dvb-t", 5 ) ) &&
(p_frontend->info.type != FE_OFDM) )
{
psz_expected = "DVB-T";
}
if( (!strncmp( p_access->psz_access, "usdigital", 9 ) ||
!strncmp( p_access->psz_access, "atsc", 4 ) ) &&
(p_frontend->info.type != FE_ATSC) )
{
psz_expected = "ATSC";
}
if( psz_expected != NULL )
{
msg_Err( p_access, "requested type %s not supported by %s tuner",
psz_expected, psz_real );
close( p_sys->i_frontend_handle );
free( p_frontend );
return VLC_EGENERIC;
}
}
else /* no frontend probing is done so use default border values. */
{
msg_Dbg( p_access, "using default values for frontend info" );
msg_Dbg( p_access, "method of access is %s", p_access->psz_access );
p_frontend->info.type = FE_QPSK;
if( !strncmp( p_access->psz_access, "qpsk", 4 ) ||
!strncmp( p_access->psz_access, "dvb-s", 5 ) )
p_frontend->info.type = FE_QPSK;
else if( !strncmp( p_access->psz_access, "cable", 5 ) ||
!strncmp( p_access->psz_access, "dvb-c", 5 ) )
p_frontend->info.type = FE_QAM;
else if( !strncmp( p_access->psz_access, "terrestrial", 11 ) ||
!strncmp( p_access->psz_access, "dvb-t", 5 ) )
p_frontend->info.type = FE_OFDM;
else if( !strncmp( p_access->psz_access, "usdigital", 9 ) ||
!strncmp( p_access->psz_access, "atsc", 4 ) )
p_frontend->info.type = FE_ATSC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Win32VoutCreateWindow: create a window for the video.
*****************************************************************************
* Before creating a direct draw surface, we need to create a window in which
* the video will be displayed. This window will also allow us to capture the
* events.
*****************************************************************************/
static int Win32VoutCreateWindow( event_thread_t *p_event )
{
vout_display_t *vd = p_event->vd;
HINSTANCE hInstance;
HMENU hMenu;
RECT rect_window;
WNDCLASS wc; /* window class components */
TCHAR vlc_path[MAX_PATH+1];
int i_style, i_stylex;
msg_Dbg( vd, "Win32VoutCreateWindow" );
/* Get this module's instance */
hInstance = GetModuleHandle(NULL);
#ifdef MODULE_NAME_IS_direct3d
if( !p_event->use_desktop )
#endif
{
/* If an external window was specified, we'll draw in it. */
p_event->parent_window = vout_display_NewWindow(vd, &p_event->wnd_cfg );
if( p_event->parent_window )
p_event->hparent = p_event->parent_window->handle.hwnd;
else
p_event->hparent = NULL;
}
#ifdef MODULE_NAME_IS_direct3d
else
{
vout_display_DeleteWindow(vd, NULL);
p_event->parent_window = NULL;
p_event->hparent = GetDesktopHandle(vd);
}
#endif
p_event->cursor_arrow = LoadCursor(NULL, IDC_ARROW);
p_event->cursor_empty = EmptyCursor(hInstance);
/* Get the Icon from the main app */
p_event->vlc_icon = NULL;
if( GetModuleFileName( NULL, vlc_path, MAX_PATH ) )
{
p_event->vlc_icon = ExtractIcon( hInstance, vlc_path, 0 );
}
/* Fill in the window class structure */
wc.style = CS_OWNDC|CS_DBLCLKS; /* style: dbl click */
wc.lpfnWndProc = (WNDPROC)WinVoutEventProc; /* event handler */
wc.cbClsExtra = 0; /* no extra class data */
wc.cbWndExtra = 0; /* no extra window data */
wc.hInstance = hInstance; /* instance */
wc.hIcon = p_event->vlc_icon; /* load the vlc big icon */
wc.hCursor = p_event->is_cursor_hidden ? p_event->cursor_empty :
p_event->cursor_arrow;
wc.hbrBackground = GetStockObject(BLACK_BRUSH); /* background color */
wc.lpszMenuName = NULL; /* no menu */
wc.lpszClassName = p_event->class_main; /* use a special class */
/* Register the window class */
if( !RegisterClass(&wc) )
{
if( p_event->vlc_icon )
DestroyIcon( p_event->vlc_icon );
msg_Err( vd, "Win32VoutCreateWindow RegisterClass FAILED (err=%lu)", GetLastError() );
return VLC_EGENERIC;
}
/* Register the video sub-window class */
wc.lpszClassName = p_event->class_video;
wc.hIcon = 0;
wc.hbrBackground = NULL; /* no background color */
if( !RegisterClass(&wc) )
{
msg_Err( vd, "Win32VoutCreateWindow RegisterClass FAILED (err=%lu)", GetLastError() );
return VLC_EGENERIC;
}
/* When you create a window you give the dimensions you wish it to
* have. Unfortunatly these dimensions will include the borders and
* titlebar. We use the following function to find out the size of
* the window corresponding to the useable surface we want */
rect_window.left = 10;
rect_window.top = 10;
rect_window.right = rect_window.left + p_event->wnd_cfg.width;
rect_window.bottom = rect_window.top + p_event->wnd_cfg.height;
if( var_GetBool( vd, "video-deco" ) )
{
/* Open with window decoration */
AdjustWindowRect( &rect_window, WS_OVERLAPPEDWINDOW|WS_SIZEBOX, 0 );
i_style = WS_OVERLAPPEDWINDOW|WS_SIZEBOX|WS_VISIBLE|WS_CLIPCHILDREN;
i_stylex = 0;
}
else
{
/* No window decoration */
AdjustWindowRect( &rect_window, WS_POPUP, 0 );
i_style = WS_POPUP|WS_VISIBLE|WS_CLIPCHILDREN;
i_stylex = 0; // WS_EX_TOOLWINDOW; Is TOOLWINDOW really needed ?
// It messes up the fullscreen window.
}
if( p_event->hparent )
{
i_style = WS_VISIBLE|WS_CLIPCHILDREN|WS_CHILD;
i_stylex = 0;
/* allow user to regain control over input events if requested */
bool b_mouse_support = var_InheritBool( vd, "mouse-events" );
bool b_key_support = var_InheritBool( vd, "keyboard-events" );
if( !b_mouse_support && !b_key_support )
i_style |= WS_DISABLED;
}
p_event->i_window_style = i_style;
/* Create the window */
p_event->hwnd =
CreateWindowEx( WS_EX_NOPARENTNOTIFY | i_stylex,
p_event->class_main, /* name of window class */
_T(VOUT_TITLE) _T(" (VLC Video Output)"), /* window title */
i_style, /* window style */
(!p_event->wnd_cfg.x) ? (UINT)CW_USEDEFAULT :
(UINT)p_event->wnd_cfg.x, /* default X coordinate */
(!p_event->wnd_cfg.y) ? (UINT)CW_USEDEFAULT :
(UINT)p_event->wnd_cfg.y, /* default Y coordinate */
rect_window.right - rect_window.left, /* window width */
rect_window.bottom - rect_window.top, /* window height */
p_event->hparent, /* parent window */
NULL, /* no menu in this window */
hInstance, /* handle of this program instance */
(LPVOID)p_event ); /* send vd to WM_CREATE */
if( !p_event->hwnd )
{
msg_Warn( vd, "Win32VoutCreateWindow create window FAILED (err=%lu)", GetLastError() );
return VLC_EGENERIC;
}
InitGestures( p_event->hwnd, &p_event->p_gesture );
if( p_event->hparent )
{
LONG i_style;
/* We don't want the window owner to overwrite our client area */
i_style = GetWindowLong( p_event->hparent, GWL_STYLE );
if( !(i_style & WS_CLIPCHILDREN) )
/* Hmmm, apparently this is a blocking call... */
SetWindowLong( p_event->hparent, GWL_STYLE,
i_style | WS_CLIPCHILDREN );
/* Create our fullscreen window */
p_event->hfswnd =
CreateWindowEx( WS_EX_APPWINDOW, p_event->class_main,
_T(VOUT_TITLE) _T(" (VLC Fullscreen Video Output)"),
WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN|WS_SIZEBOX,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL, hInstance, NULL );
}
else
{
p_event->hfswnd = NULL;
}
/* Append a "Always On Top" entry in the system menu */
hMenu = GetSystemMenu( p_event->hwnd, FALSE );
AppendMenu( hMenu, MF_SEPARATOR, 0, _T("") );
AppendMenu( hMenu, MF_STRING | MF_UNCHECKED,
IDM_TOGGLE_ON_TOP, _T("Always on &Top") );
/* Create video sub-window. This sub window will always exactly match
* the size of the video, which allows us to use crazy overlay colorkeys
* without having them shown outside of the video area. */
/* FIXME vd->source.i_width/i_height seems wrong */
p_event->hvideownd =
CreateWindow( p_event->class_video, _T(""), /* window class */
WS_CHILD, /* window style, not visible initially */
0, 0,
vd->source.i_width, /* default width */
vd->source.i_height, /* default height */
p_event->hwnd, /* parent window */
NULL, hInstance,
(LPVOID)p_event ); /* send vd to WM_CREATE */
if( !p_event->hvideownd )
msg_Warn( vd, "can't create video sub-window" );
else
msg_Dbg( vd, "created video sub-window" );
/* Now display the window */
ShowWindow( p_event->hwnd, SW_SHOW );
return VLC_SUCCESS;
}
void CommonManage( vout_thread_t *p_vout )
{
/* If we do not control our window, we check for geometry changes
* ourselves because the parent might not send us its events. */
vlc_mutex_lock( &p_vout->p_sys->lock );
if( p_vout->p_sys->hparent && !p_vout->b_fullscreen )
{
RECT rect_parent;
POINT point;
vlc_mutex_unlock( &p_vout->p_sys->lock );
GetClientRect( p_vout->p_sys->hparent, &rect_parent );
point.x = point.y = 0;
ClientToScreen( p_vout->p_sys->hparent, &point );
OffsetRect( &rect_parent, point.x, point.y );
if( !EqualRect( &rect_parent, &p_vout->p_sys->rect_parent ) )
{
p_vout->p_sys->rect_parent = rect_parent;
/* FIXME I find such #ifdef quite weirds. Are they really needed ? */
#if defined(MODULE_NAME_IS_direct3d)
SetWindowPos( p_vout->p_sys->hwnd, 0, 0, 0,
rect_parent.right - rect_parent.left,
rect_parent.bottom - rect_parent.top,
SWP_NOZORDER );
UpdateRects( p_vout, true );
#else
/* This one is to force the update even if only
* the position has changed */
SetWindowPos( p_vout->p_sys->hwnd, 0, 1, 1,
rect_parent.right - rect_parent.left,
rect_parent.bottom - rect_parent.top, 0 );
SetWindowPos( p_vout->p_sys->hwnd, 0, 0, 0,
rect_parent.right - rect_parent.left,
rect_parent.bottom - rect_parent.top, 0 );
#if defined(MODULE_NAME_IS_wingdi) || defined(MODULE_NAME_IS_wingapi)
unsigned int i_x, i_y, i_width, i_height;
vout_PlacePicture( p_vout, rect_parent.right - rect_parent.left,
rect_parent.bottom - rect_parent.top,
&i_x, &i_y, &i_width, &i_height );
SetWindowPos( p_vout->p_sys->hvideownd, HWND_TOP,
i_x, i_y, i_width, i_height, 0 );
#endif
#endif
}
}
else
{
vlc_mutex_unlock( &p_vout->p_sys->lock );
}
/* autoscale toggle */
if( p_vout->i_changes & VOUT_SCALE_CHANGE )
{
p_vout->i_changes &= ~VOUT_SCALE_CHANGE;
p_vout->b_autoscale = var_GetBool( p_vout, "autoscale" );
p_vout->i_zoom = (int) ZOOM_FP_FACTOR;
UpdateRects( p_vout, true );
}
/* scaling factor */
if( p_vout->i_changes & VOUT_ZOOM_CHANGE )
{
p_vout->i_changes &= ~VOUT_ZOOM_CHANGE;
p_vout->b_autoscale = false;
p_vout->i_zoom =
(int)( ZOOM_FP_FACTOR * var_GetFloat( p_vout, "scale" ) );
UpdateRects( p_vout, true );
}
/* Check for cropping / aspect changes */
if( p_vout->i_changes & VOUT_CROP_CHANGE ||
p_vout->i_changes & VOUT_ASPECT_CHANGE )
{
p_vout->i_changes &= ~VOUT_CROP_CHANGE;
p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
p_vout->fmt_out.i_x_offset = p_vout->fmt_in.i_x_offset;
p_vout->fmt_out.i_y_offset = p_vout->fmt_in.i_y_offset;
p_vout->fmt_out.i_visible_width = p_vout->fmt_in.i_visible_width;
p_vout->fmt_out.i_visible_height = p_vout->fmt_in.i_visible_height;
p_vout->fmt_out.i_aspect = p_vout->fmt_in.i_aspect;
p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
UpdateRects( p_vout, true );
}
/* We used to call the Win32 PeekMessage function here to read the window
* messages. But since window can stay blocked into this function for a
* long time (for example when you move your window on the screen), I
* decided to isolate PeekMessage in another thread. */
/*
* Fullscreen change
*/
if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE
|| p_vout->p_sys->i_changes & VOUT_FULLSCREEN_CHANGE )
{
Win32ToggleFullscreen( p_vout );
p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
p_vout->p_sys->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
}
/*
* Pointer change
*/
EventThreadMouseAutoHide( p_vout->p_sys->p_event );
/*
* "Always on top" status change
*/
if( p_vout->p_sys->b_on_top_change )
{
HMENU hMenu = GetSystemMenu( p_vout->p_sys->hwnd, FALSE );
bool b = var_GetBool( p_vout, "video-on-top" );
/* Set the window on top if necessary */
if( b && !( GetWindowLong( p_vout->p_sys->hwnd, GWL_EXSTYLE )
& WS_EX_TOPMOST ) )
{
CheckMenuItem( hMenu, IDM_TOGGLE_ON_TOP,
MF_BYCOMMAND | MFS_CHECKED );
SetWindowPos( p_vout->p_sys->hwnd, HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE );
}
else
/* The window shouldn't be on top */
if( !b && ( GetWindowLong( p_vout->p_sys->hwnd, GWL_EXSTYLE )
& WS_EX_TOPMOST ) )
{
CheckMenuItem( hMenu, IDM_TOGGLE_ON_TOP,
MF_BYCOMMAND | MFS_UNCHECKED );
SetWindowPos( p_vout->p_sys->hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE );
}
p_vout->p_sys->b_on_top_change = false;
}
}
