void InputManager::UpdateCaching() { if(!hasInput()) return; float f_newCache = var_GetFloat ( p_input, "cache" ); if( f_newCache != f_cache ) { f_cache = f_newCache; /* Update cache */ emit cachingChanged( f_cache ); } }
/* Define the Input used. Add the callbacks on input p_input is held once here */ void InputManager::setInput( input_thread_t *_p_input ) { delInput(); p_input = _p_input; if( p_input != NULL ) { msg_Dbg( p_intf, "IM: Setting an input" ); vlc_object_hold( p_input ); addCallbacks(); UpdateStatus(); UpdateName(); UpdateArt(); UpdateTeletext(); UpdateNavigation(); UpdateVout(); p_item = input_GetItem( p_input ); emit rateChanged( var_GetFloat( p_input, "rate" ) ); /* Get Saved Time */ if( p_item->i_type == ITEM_TYPE_FILE ) { int i_time = RecentsMRL::getInstance( p_intf )->time( p_item->psz_uri ); if( i_time > 0 && !var_GetFloat( p_input, "run-time" ) && !var_GetFloat( p_input, "start-time" ) && !var_GetFloat( p_input, "stop-time" ) ) { emit resumePlayback( (int64_t)i_time * 1000 ); } } } else { p_item = NULL; assert( !p_input_vbi ); emit rateChanged( var_InheritFloat( p_intf, "rate" ) ); } }
void VlcProc::init_equalizer() { playlist_t* pPlaylist = getIntf()->p_sys->p_playlist; audio_output_t* pAout = playlist_GetAout( pPlaylist ); if( pAout ) { if( !var_Type( pAout, "equalizer-bands" ) ) var_Create( pAout, "equalizer-bands", VLC_VAR_STRING | VLC_VAR_DOINHERIT); if( !var_Type( pAout, "equalizer-preamp" ) ) var_Create( pAout, "equalizer-preamp", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT); // New Aout (addCallbacks) var_AddCallback( pAout, "audio-filter", onGenericCallback, this ); var_AddCallback( pAout, "equalizer-bands", onEqBandsChange, this ); var_AddCallback( pAout, "equalizer-preamp", onEqPreampChange, this ); } // is equalizer enabled ? char *pFilters = pAout ? var_GetNonEmptyString( pAout, "audio-filter" ) : var_InheritString( getIntf(), "audio-filter" ); bool b_equalizer = pFilters && strstr( pFilters, "equalizer" ); free( pFilters ); SET_BOOL( m_cVarEqualizer, b_equalizer ); // retrieve initial bands char* bands = pAout ? var_GetString( pAout, "equalizer-bands" ) : var_InheritString( getIntf(), "equalizer-bands" ); if( bands ) { m_varEqBands.set( bands ); free( bands ); } // retrieve initial preamp float preamp = pAout ? var_GetFloat( pAout, "equalizer-preamp" ) : var_InheritFloat( getIntf(), "equalizer-preamp" ); EqualizerPreamp *pVarPreamp = (EqualizerPreamp*)m_cVarEqPreamp.get(); pVarPreamp->set( (preamp + 20.0) / 40.0 ); if( pAout ) vlc_object_release( pAout); }
void VlcProc::init_variables() { playlist_t* pPlaylist = getIntf()->p_sys->p_playlist; SET_BOOL( m_cVarRandom, var_GetBool( pPlaylist, "random" ) ); SET_BOOL( m_cVarLoop, var_GetBool( pPlaylist, "loop" ) ); SET_BOOL( m_cVarRepeat, var_GetBool( pPlaylist, "repeat" ) ); SET_VOLUME( m_cVarVolume, var_GetFloat( pPlaylist, "volume" ), false ); bool b_is_muted = aout_MuteGet( pPlaylist ) > 0; SET_BOOL( m_cVarMute, b_is_muted ); update_equalizer(); }
float libvlc_media_player_get_position( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; float f_position; p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1.0; f_position = var_GetFloat( p_input_thread, "position" ); vlc_object_release( p_input_thread ); return f_position; }
static void MarshalRate( intf_thread_t *p_intf, DBusMessageIter *container ) { double d_rate; input_thread_t *p_input; if( ( p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist ) ) ) { d_rate = var_GetFloat( p_input, "rate" ); vlc_object_release( (vlc_object_t*) p_input ); } else d_rate = 0.; dbus_message_iter_append_basic( container, DBUS_TYPE_DOUBLE, &d_rate ); }
/***************************************************************************** * Get the preamp level *****************************************************************************/ static int vlclua_preamp_get( lua_State *L ) { input_thread_t *p_input = vlclua_get_input_internal( L ); if( p_input ) { aout_instance_t *p_aout = input_GetAout( p_input ); float preamp = var_GetFloat( p_aout, "equalizer-preamp"); lua_pushnumber( L, preamp ); vlc_object_release( p_aout ); vlc_object_release( p_input ); return 1; } return 0; }
void VlcProc::init_variables() { playlist_t* pPlaylist = getIntf()->p_sys->p_playlist; SET_BOOL( m_cVarRandom, var_GetBool( pPlaylist, "random" ) ); SET_BOOL( m_cVarLoop, var_GetBool( pPlaylist, "loop" ) ); SET_BOOL( m_cVarRepeat, var_GetBool( pPlaylist, "repeat" ) ); SET_VOLUME( m_cVarVolume, var_GetFloat( pPlaylist, "volume" ), false ); SET_BOOL( m_cVarMute, var_GetBool( pPlaylist, "mute" ) ); SET_BOOL( m_cVarStopped, true ); init_equalizer(); }
static int RateOffsetCallback( vlc_object_t *obj, char const *psz_cmd, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { playlist_t *p_playlist = (playlist_t *)obj; VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(newval); static const float pf_rate[] = { 1.0/64, 1.0/32, 1.0/16, 1.0/8, 1.0/4, 1.0/3, 1.0/2, 2.0/3, 1.0/1, 3.0/2, 2.0/1, 3.0/1, 4.0/1, 8.0/1, 16.0/1, 32.0/1, 64.0/1, }; const size_t i_rate_count = sizeof(pf_rate)/sizeof(*pf_rate); float f_rate; struct input_thread_t *input; PL_LOCK; input = pl_priv( p_playlist )->p_input; f_rate = var_GetFloat( input ? (vlc_object_t *)input : obj, "rate" ); PL_UNLOCK; if( !strcmp( psz_cmd, "rate-faster" ) ) { /* compensate for input rounding errors */ float r = f_rate * 1.1; for( size_t i = 0; i < i_rate_count; i++ ) if( r < pf_rate[i] ) { f_rate = pf_rate[i]; break; } } else { /* compensate for input rounding errors */ float r = f_rate * .9; for( size_t i = 1; i < i_rate_count; i++ ) if( r <= pf_rate[i] ) { f_rate = pf_rate[i - 1]; break; } } var_SetFloat( p_playlist, "rate", f_rate ); return VLC_SUCCESS; }
static void test_floats( libvlc_int_t *p_libvlc ) { int i; for( i = 0; i < i_var_count; i++ ) var_Create( p_libvlc, psz_var_name[i], VLC_VAR_FLOAT ); for( i = 0; i < i_var_count; i++ ) { var_value[i].f_float = rand(); var_SetFloat( p_libvlc, psz_var_name[i], var_value[i].f_float ); } for( i = 0; i < i_var_count; i++ ) assert( var_GetFloat( p_libvlc, psz_var_name[i] ) == var_value[i].f_float ); for( i = 0; i < i_var_count; i++ ) var_Destroy( p_libvlc, psz_var_name[i] ); }
static int RateOffsetCallback( vlc_object_t *p_this, char const *psz_cmd, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { input_thread_t *p_input = (input_thread_t*)p_this; VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(newval); static const float pf_rate[] = { 1.0/64, 1.0/32, 1.0/16, 1.0/8, 1.0/4, 1.0/3, 1.0/2, 2.0/3, 1.0/1, 3.0/2, 2.0/1, 3.0/1, 4.0/1, 8.0/1, 16.0/1, 32.0/1, 64.0/1, }; const unsigned i_rate_count = sizeof(pf_rate)/sizeof(*pf_rate); const float f_rate = var_GetFloat( p_input, "rate" ); /* Determine the factor closest to the current rate */ float f_error; int i_idx; for( unsigned i = 0; i < i_rate_count; i++ ) { const float f_test_e = fabs( fabs( f_rate ) - pf_rate[i] ); if( i == 0 || f_test_e < f_error ) { i_idx = i; f_error = f_test_e; } } assert( i_idx < (int)i_rate_count ); /* */ i_idx += strcmp( psz_cmd, "rate-faster" ) == 0 ? 1 : -1; if( i_idx >= 0 && i_idx < (int)i_rate_count ) { const float f_rate_min = (float)INPUT_RATE_DEFAULT / INPUT_RATE_MAX; const float f_rate_max = (float)INPUT_RATE_DEFAULT / INPUT_RATE_MIN; const float f_sign = f_rate >= 0 ? +1. : -1.; var_SetFloat( p_input, "rate", f_sign * __MAX( __MIN( pf_rate[i_idx], f_rate_max ), f_rate_min ) ); } return VLC_SUCCESS; }
static int VideoSplitterCallback( vlc_object_t *p_this, char const *psz_cmd, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { playlist_t *p_playlist = (playlist_t*)p_this; VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(newval); PL_LOCK; /* Force the input to restart the video ES to force a vout recreation */ input_thread_t *p_input = pl_priv( p_playlist )->p_input; if( p_input ) { const double f_position = var_GetFloat( p_input, "position" ); input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES ); var_SetFloat( p_input, "position", f_position ); } PL_UNLOCK; return VLC_SUCCESS; }
static int MarshalRate( intf_thread_t *p_intf, DBusMessageIter *container ) { double d_rate; input_thread_t *p_input = pl_CurrentInput( p_intf ); if( p_input != NULL ) { d_rate = var_GetFloat( p_input, "rate" ); vlc_object_release( (vlc_object_t*) p_input ); } else d_rate = 1.0; if( !dbus_message_iter_append_basic( container, DBUS_TYPE_DOUBLE, &d_rate ) ) return VLC_ENOMEM; return VLC_SUCCESS; }
/***************************************************************************** * 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; }
/***************************************************************************** * Run: rtci thread ***************************************************************************** * This part of the interface is in a separate thread so that we can call * exec() from within it without annoying the rest of the program. *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { input_thread_t * p_input; playlist_t * p_playlist; char p_buffer[ MAX_LINE_LENGTH + 1 ]; vlc_bool_t b_showpos = config_GetInt( p_intf, "rtci-show-pos" ); int i_size = 0; int i_oldpos = 0; int i_newpos; p_buffer[0] = 0; p_input = NULL; p_playlist = NULL; p_intf->p_sys->b_extend = config_GetInt( p_intf, "rtci-extend" ); /* Register commands that will be cleaned up upon object destruction */ var_Create( p_intf, "quit", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "quit", Quit, NULL ); var_Create( p_intf, "intf", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "intf", Intf, NULL ); var_Create( p_intf, "add", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "add", Playlist, NULL ); var_Create( p_intf, "playlist", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "playlist", Playlist, NULL ); var_Create( p_intf, "play", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "play", Playlist, NULL ); var_Create( p_intf, "stop", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "stop", Playlist, NULL ); var_Create( p_intf, "prev", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "prev", Playlist, NULL ); var_Create( p_intf, "next", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "next", Playlist, NULL ); var_Create( p_intf, "marq-marquee", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "marq-marquee", Other, NULL ); var_Create( p_intf, "marq-x", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "marq-x", Other, NULL ); var_Create( p_intf, "marq-y", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "marq-y", Other, NULL ); var_Create( p_intf, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "marq-timeout", Other, NULL ); var_Create( p_intf, "pause", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "pause", Input, NULL ); var_Create( p_intf, "seek", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "seek", Input, NULL ); var_Create( p_intf, "title", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "title", Input, NULL ); var_Create( p_intf, "title_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "title_n", Input, NULL ); var_Create( p_intf, "title_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "title_p", Input, NULL ); var_Create( p_intf, "chapter", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "chapter", Input, NULL ); var_Create( p_intf, "chapter_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "chapter_n", Input, NULL ); var_Create( p_intf, "chapter_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "chapter_p", Input, NULL ); var_Create( p_intf, "volume", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "volume", Volume, NULL ); var_Create( p_intf, "volup", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "volup", VolumeMove, NULL ); var_Create( p_intf, "voldown", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "voldown", VolumeMove, NULL ); var_Create( p_intf, "adev", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "adev", AudioConfig, NULL ); var_Create( p_intf, "achan", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_intf, "achan", AudioConfig, NULL ); #ifdef WIN32 /* Get the file descriptor of the console input */ p_intf->p_sys->hConsoleIn = GetStdHandle(STD_INPUT_HANDLE); if( p_intf->p_sys->hConsoleIn == INVALID_HANDLE_VALUE ) { msg_Err( p_intf, "Couldn't open STD_INPUT_HANDLE" ); p_intf->b_die = VLC_TRUE; } #endif while( !p_intf->b_die ) { char *psz_cmd, *psz_arg; vlc_bool_t b_complete; if( p_intf->p_sys->i_socket_listen != - 1 && p_intf->p_sys->i_socket == -1 ) { p_intf->p_sys->i_socket = net_Accept( p_intf, p_intf->p_sys->i_socket_listen, 0 ); } b_complete = ReadCommand( p_intf, p_buffer, &i_size ); /* Manage the input part */ if( p_input == NULL ) { if( p_playlist ) { p_input = vlc_object_find( p_playlist, VLC_OBJECT_INPUT, FIND_CHILD ); } else { p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE ); if( p_input ) { p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST, FIND_PARENT ); } } } else if( p_input->b_dead ) { vlc_object_release( p_input ); p_input = NULL; } if( p_input && b_showpos ) { i_newpos = 100 * var_GetFloat( p_input, "position" ); if( i_oldpos != i_newpos ) { i_oldpos = i_newpos; msg_rtci( "pos: %d%%\n", i_newpos ); } } /* Is there something to do? */ if( !b_complete ) continue; /* Skip heading spaces */ psz_cmd = p_buffer; while( *psz_cmd == ' ' ) { psz_cmd++; } /* Split psz_cmd at the first space and make sure that * psz_arg is valid */ psz_arg = strchr( psz_cmd, ' ' ); if( psz_arg ) { *psz_arg++ = 0; while( *psz_arg == ' ' ) { psz_arg++; } } else { psz_arg = ""; } /* If the user typed a registered local command, try it */ if( var_Type( p_intf, psz_cmd ) & VLC_VAR_ISCOMMAND ) { vlc_value_t val; int i_ret; val.psz_string = psz_arg; i_ret = var_Set( p_intf, psz_cmd, val ); msg_rtci( "%s: returned %i (%s)\n", psz_cmd, i_ret, vlc_error( i_ret ) ); } /* Or maybe it's a global command */ else if( var_Type( p_intf->p_libvlc, psz_cmd ) & VLC_VAR_ISCOMMAND ) { vlc_value_t val; int i_ret; val.psz_string = psz_arg; /* FIXME: it's a global command, but we should pass the * local object as an argument, not p_intf->p_libvlc. */ i_ret = var_Set( p_intf->p_libvlc, psz_cmd, val ); if( i_ret != 0 ) { msg_rtci( "%s: returned %i (%s)\n", psz_cmd, i_ret, vlc_error( i_ret ) ); } } else if( !strcmp( psz_cmd, "logout" ) ) { /* Close connection */ if( p_intf->p_sys->i_socket != -1 ) { net_Close( p_intf->p_sys->i_socket ); } p_intf->p_sys->i_socket = -1; } else if( !strcmp( psz_cmd, "info" ) ) { if( p_input ) { int i, j; vlc_mutex_lock( &p_input->input.p_item->lock ); for ( i = 0; i < p_input->input.p_item->i_categories; i++ ) { info_category_t *p_category = p_input->input.p_item->pp_categories[i]; msg_rtci( "+----[ %s ]\n", p_category->psz_name ); msg_rtci( "| \n" ); for ( j = 0; j < p_category->i_infos; j++ ) { info_t *p_info = p_category->pp_infos[j]; msg_rtci( "| %s: %s\n", p_info->psz_name, p_info->psz_value ); } msg_rtci( "| \n" ); } msg_rtci( "+----[ end of stream info ]\n" ); vlc_mutex_unlock( &p_input->input.p_item->lock ); } else { msg_rtci( "no input\n" ); } } else if( !strcmp( psz_cmd, "is_playing" ) ) { if( ! p_input ) { msg_rtci( "0\n" ); } else { msg_rtci( "1\n" ); } } else if( !strcmp( psz_cmd, "get_time" ) ) { if( ! p_input ) { msg_rtci("0\n"); } else { vlc_value_t time; var_Get( p_input, "time", &time ); msg_rtci( "%i\n", time.i_time / 1000000); } } else if( !strcmp( psz_cmd, "get_length" ) ) { if( ! p_input ) { msg_rtci("0\n"); } else { vlc_value_t time; var_Get( p_input, "length", &time ); msg_rtci( "%i\n", time.i_time / 1000000); } } else if( !strcmp( psz_cmd, "get_title" ) ) { if( ! p_input ) { msg_rtci("\n"); } else { msg_rtci( "%s\n", p_input->input.p_item->psz_name ); } } else switch( psz_cmd[0] ) { case 'f': case 'F': if( p_input ) { vout_thread_t *p_vout; p_vout = vlc_object_find( p_input, VLC_OBJECT_VOUT, FIND_CHILD ); if( p_vout ) { p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE; vlc_object_release( p_vout ); } } break; case 's': case 'S': ; break; case '?': case 'h': case 'H': msg_rtci(_("+----[ Remote control commands ]\n")); msg_rtci("| \n"); msg_rtci(_("| add XYZ . . . . . . . . . . add XYZ to playlist\n")); msg_rtci(_("| playlist . . . show items currently in playlist\n")); msg_rtci(_("| play . . . . . . . . . . . . . . . . play stream\n")); msg_rtci(_("| stop . . . . . . . . . . . . . . . . stop stream\n")); msg_rtci(_("| next . . . . . . . . . . . . next playlist item\n")); msg_rtci(_("| prev . . . . . . . . . . previous playlist item\n")); msg_rtci(_("| title [X] . . . . set/get title in current item\n")); msg_rtci(_("| title_n . . . . . . next title in current item\n")); msg_rtci(_("| title_p . . . . previous title in current item\n")); msg_rtci(_("| chapter [X] . . set/get chapter in current item\n")); msg_rtci(_("| chapter_n . . . . next chapter in current item\n")); msg_rtci(_("| chapter_p . . previous chapter in current item\n")); msg_rtci("| \n"); msg_rtci(_("| seek X . seek in seconds, for instance `seek 12'\n")); msg_rtci(_("| pause . . . . . . . . . . . . . . toggle pause\n")); msg_rtci(_("| f . . . . . . . . . . . . . . toggle fullscreen\n")); msg_rtci(_("| info . . . information about the current stream\n")); msg_rtci("| \n"); msg_rtci(_("| volume [X] . . . . . . . . set/get audio volume\n")); msg_rtci(_("| volup [X] . . . . . raise audio volume X steps\n")); msg_rtci(_("| voldown [X] . . . . lower audio volume X steps\n")); msg_rtci(_("| adev [X] . . . . . . . . . set/get audio device\n")); msg_rtci(_("| achan [X]. . . . . . . . set/get audio channels\n")); msg_rtci("| \n"); if (p_intf->p_sys->b_extend) { msg_rtci(_("| marq-marquee STRING . . overlay STRING in video\n")); msg_rtci(_("| marq-x X . . . . . .offset of marquee, from left\n")); msg_rtci(_("| marq-y Y . . . . . . offset of marquee, from top\n")); msg_rtci(_("| marq-timeout T. . . . .timeout of marquee, in ms\n")); msg_rtci("| \n"); } msg_rtci(_("| help . . . . . . . . . . . . . this help message\n")); msg_rtci(_("| logout . . . . . .exit (if in socket connection)\n")); msg_rtci(_("| quit . . . . . . . . . . . . . . . . . quit vlc\n")); msg_rtci("| \n"); msg_rtci(_("+----[ end of help ]\n")); break; case '\0': /* Ignore empty lines */ break; default: msg_rtci(_("unknown command `%s', type `help' for help\n"), psz_cmd); break; } /* Command processed */ i_size = 0; p_buffer[0] = 0; } if( p_input ) { vlc_object_release( p_input ); p_input = NULL; } if( p_playlist ) { vlc_object_release( p_playlist ); p_playlist = NULL; } }
/***************************************************************************** * Open: probe the encoder *****************************************************************************/ static int Open ( vlc_object_t *p_this ) { encoder_t *p_enc = (encoder_t *)p_this; encoder_sys_t *p_sys; int i_val; char *psz_val; int i_qmin = 0, i_qmax = 0; x264_nal_t *nal; int i, i_nal; if( p_enc->fmt_out.i_codec != VLC_CODEC_H264 && !p_enc->b_force ) { return VLC_EGENERIC; } /* X264_POINTVER or X264_VERSION are not available */ msg_Dbg ( p_enc, "version x264 0.%d.X", X264_BUILD ); config_ChainParse( p_enc, SOUT_CFG_PREFIX, ppsz_sout_options, p_enc->p_cfg ); p_enc->fmt_out.i_cat = VIDEO_ES; p_enc->fmt_out.i_codec = VLC_CODEC_H264; p_enc->fmt_in.i_codec = VLC_CODEC_I420; p_enc->pf_encode_video = Encode; p_enc->pf_encode_audio = NULL; p_enc->p_sys = p_sys = malloc( sizeof( encoder_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; p_sys->i_interpolated_dts = 0; p_sys->psz_stat_name = NULL; p_sys->p_buffer = NULL; x264_param_default( &p_sys->param ); p_sys->param.i_width = p_enc->fmt_in.video.i_width; p_sys->param.i_height = p_enc->fmt_in.video.i_height; p_sys->param.rc.f_qcompress = var_GetFloat( p_enc, SOUT_CFG_PREFIX "qcomp" ); /* transcode-default bitrate is 0, * set more to ABR if user specifies bitrate */ if( p_enc->fmt_out.i_bitrate > 0 ) { p_sys->param.rc.i_bitrate = p_enc->fmt_out.i_bitrate / 1000; p_sys->param.rc.i_rc_method = X264_RC_ABR; } else /* Set default to CRF */ { i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "crf" ); if( i_val > 0 && i_val <= 51 ) { p_sys->param.rc.f_rf_constant = i_val; p_sys->param.rc.i_rc_method = X264_RC_CRF; } } i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpstep" ); if( i_val >= 0 && i_val <= 51 ) p_sys->param.rc.i_qp_step = i_val; i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpmin" ); if( i_val >= 0 && i_val <= 51 ) { i_qmin = i_val; p_sys->param.rc.i_qp_min = i_qmin; } i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpmax" ); if( i_val >= 0 && i_val <= 51 ) { i_qmax = i_val; p_sys->param.rc.i_qp_max = i_qmax; } i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qp" ); if( i_val >= 0 && i_val <= 51 ) { if( i_qmin > i_val ) i_qmin = i_val; if( i_qmax < i_val ) i_qmax = i_val; /* User defined QP-value, so change ratecontrol method */ p_sys->param.rc.i_rc_method = X264_RC_CQP; p_sys->param.rc.i_qp_constant = i_val; p_sys->param.rc.i_qp_min = i_qmin; p_sys->param.rc.i_qp_max = i_qmax; } p_sys->param.rc.f_rate_tolerance = var_GetFloat( p_enc, SOUT_CFG_PREFIX "ratetol" ); p_sys->param.rc.f_vbv_buffer_init = var_GetFloat( p_enc, SOUT_CFG_PREFIX "vbv-init" ); p_sys->param.rc.i_vbv_buffer_size = var_GetInteger( p_enc, SOUT_CFG_PREFIX "vbv-bufsize" ); /* max bitrate = average bitrate -> CBR */ i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "vbv-maxrate" ); if( !i_val && p_sys->param.rc.i_rc_method == X264_RC_ABR ) p_sys->param.rc.i_vbv_max_bitrate = p_sys->param.rc.i_bitrate; else if ( i_val ) p_sys->param.rc.i_vbv_max_bitrate = i_val; p_sys->param.b_cabac = var_GetBool( p_enc, SOUT_CFG_PREFIX "cabac" ); /* disable deblocking when nf (no loop filter) is enabled */ p_sys->param.b_deblocking_filter = !var_GetBool( p_enc, SOUT_CFG_PREFIX "nf" ); psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "deblock" ); if( psz_val ) { char *p = strchr( psz_val, ':' ); p_sys->param.i_deblocking_filter_alphac0 = atoi( psz_val ); p_sys->param.i_deblocking_filter_beta = p ? atoi( p+1 ) : p_sys->param.i_deblocking_filter_alphac0; free( psz_val ); } psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "psy-rd" ); if( psz_val ) { char *p = strchr( psz_val, ':' ); p_sys->param.analyse.f_psy_rd = us_atof( psz_val ); p_sys->param.analyse.f_psy_trellis = p ? us_atof( p+1 ) : 0; free( psz_val ); } psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "level" ); if( psz_val ) { if( us_atof (psz_val) < 6 ) p_sys->param.i_level_idc = (int) (10 * us_atof (psz_val) + .5); else p_sys->param.i_level_idc = atoi (psz_val); free( psz_val ); } p_sys->param.b_interlaced = var_GetBool( p_enc, SOUT_CFG_PREFIX "interlaced" ); p_sys->param.rc.f_ip_factor = var_GetFloat( p_enc, SOUT_CFG_PREFIX "ipratio" ); p_sys->param.rc.f_pb_factor = var_GetFloat( p_enc, SOUT_CFG_PREFIX "pbratio" ); p_sys->param.rc.f_complexity_blur = var_GetFloat( p_enc, SOUT_CFG_PREFIX "cplxblur" ); p_sys->param.rc.f_qblur = var_GetFloat( p_enc, SOUT_CFG_PREFIX "qblur" ); p_sys->param.rc.i_aq_mode = var_GetInteger( p_enc, SOUT_CFG_PREFIX "aq-mode" ); p_sys->param.rc.f_aq_strength = var_GetFloat( p_enc, SOUT_CFG_PREFIX "aq-strength" ); if( var_GetBool( p_enc, SOUT_CFG_PREFIX "verbose" ) ) p_sys->param.i_log_level = X264_LOG_DEBUG; if( var_GetBool( p_enc, SOUT_CFG_PREFIX "quiet" ) ) p_sys->param.i_log_level = X264_LOG_NONE; i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "sps-id" ); if( i_val >= 0 ) p_sys->param.i_sps_id = i_val; if( var_GetBool( p_enc, SOUT_CFG_PREFIX "aud" ) ) p_sys->param.b_aud = true; i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "keyint" ); if( i_val > 0 ) p_sys->param.i_keyint_max = i_val; i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "min-keyint" ); if( i_val > 0 ) p_sys->param.i_keyint_min = i_val; i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "bframes" ); if( i_val >= 0 && i_val <= 16 ) p_sys->param.i_bframe = i_val; #if X264_BUILD >= 78 psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "bpyramid" ); p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_NONE; if( !strcmp( psz_val, "none" ) ) { p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_NONE; } else if ( !strcmp( psz_val, "strict" ) ) { p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_STRICT; } else if ( !strcmp( psz_val, "normal" ) ) { p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_NORMAL; } free( psz_val ); #else p_sys->param.b_bframe_pyramid = var_GetBool( p_enc, SOUT_CFG_PREFIX "bpyramid" ); #endif i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "ref" ); if( i_val > 0 && i_val <= 15 ) p_sys->param.i_frame_reference = i_val; i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "scenecut" ); if( i_val >= -1 && i_val <= 100 ) p_sys->param.i_scenecut_threshold = i_val; p_sys->param.b_deterministic = var_GetBool( p_enc, SOUT_CFG_PREFIX "non-deterministic" ); i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "subme" ); if( i_val >= 1 && i_val <= SUBME_MAX ) p_sys->param.analyse.i_subpel_refine = i_val; //TODO: psz_val == NULL ? psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "me" ); if( !strcmp( psz_val, "dia" ) ) { p_sys->param.analyse.i_me_method = X264_ME_DIA; } else if( !strcmp( psz_val, "hex" ) ) { p_sys->param.analyse.i_me_method = X264_ME_HEX; } else if( !strcmp( psz_val, "umh" ) ) { p_sys->param.analyse.i_me_method = X264_ME_UMH; } else if( !strcmp( psz_val, "esa" ) ) { p_sys->param.analyse.i_me_method = X264_ME_ESA; } else if( !strcmp( psz_val, "tesa" ) ) { p_sys->param.analyse.i_me_method = X264_ME_TESA; } free( psz_val ); i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "merange" ); if( i_val >= 0 && i_val <= 64 ) p_sys->param.analyse.i_me_range = i_val; p_sys->param.analyse.i_mv_range = var_GetInteger( p_enc, SOUT_CFG_PREFIX "mvrange" ); p_sys->param.analyse.i_mv_range_thread = var_GetInteger( p_enc, SOUT_CFG_PREFIX "mvrange-thread" ); psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "direct" ); if( !strcmp( psz_val, "none" ) ) { p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_NONE; } else if( !strcmp( psz_val, "spatial" ) ) { p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_SPATIAL; } else if( !strcmp( psz_val, "temporal" ) ) { p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_TEMPORAL; } else if( !strcmp( psz_val, "auto" ) ) { p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_AUTO; } free( psz_val ); p_sys->param.analyse.b_psnr = var_GetBool( p_enc, SOUT_CFG_PREFIX "psnr" ); p_sys->param.analyse.b_ssim = var_GetBool( p_enc, SOUT_CFG_PREFIX "ssim" ); p_sys->param.analyse.b_weighted_bipred = var_GetBool( p_enc, SOUT_CFG_PREFIX "weightb" ); p_sys->param.i_bframe_adaptive = var_GetInteger( p_enc, SOUT_CFG_PREFIX "b-adapt" ); i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "b-bias" ); if( i_val >= -100 && i_val <= 100 ) p_sys->param.i_bframe_bias = i_val; p_sys->param.analyse.b_chroma_me = var_GetBool( p_enc, SOUT_CFG_PREFIX "chroma-me" ); p_sys->param.analyse.i_chroma_qp_offset = var_GetInteger( p_enc, SOUT_CFG_PREFIX "chroma-qp-offset" ); p_sys->param.analyse.b_mixed_references = var_GetBool( p_enc, SOUT_CFG_PREFIX "mixed-refs" ); i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "trellis" ); if( i_val >= 0 && i_val <= 2 ) p_sys->param.analyse.i_trellis = i_val; p_sys->param.analyse.b_fast_pskip = var_GetBool( p_enc, SOUT_CFG_PREFIX "fast-pskip" ); i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "nr" ); if( i_val >= 0 && i_val <= 1000 ) p_sys->param.analyse.i_noise_reduction = i_val; p_sys->param.analyse.b_dct_decimate = var_GetBool( p_enc, SOUT_CFG_PREFIX "dct-decimate" ); i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "deadzone-inter" ); if( i_val >= 0 && i_val <= 32 ) p_sys->param.analyse.i_luma_deadzone[0] = i_val; i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "deadzone-intra" ); if( i_val >= 0 && i_val <= 32 ) p_sys->param.analyse.i_luma_deadzone[1] = i_val; if( !var_GetBool( p_enc, SOUT_CFG_PREFIX "asm" ) ) p_sys->param.cpu = 0; #ifndef X264_ANALYSE_BSUB16x16 # define X264_ANALYSE_BSUB16x16 0 #endif psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "partitions" ); if( !strcmp( psz_val, "none" ) ) { p_sys->param.analyse.inter = 0; } else if( !strcmp( psz_val, "fast" ) ) { p_sys->param.analyse.inter = X264_ANALYSE_I4x4; } else if( !strcmp( psz_val, "normal" ) ) { p_sys->param.analyse.inter = X264_ANALYSE_I4x4 | X264_ANALYSE_PSUB16x16; #ifdef X264_ANALYSE_I8x8 p_sys->param.analyse.inter |= X264_ANALYSE_I8x8; #endif } else if( !strcmp( psz_val, "slow" ) ) { p_sys->param.analyse.inter = X264_ANALYSE_I4x4 | X264_ANALYSE_PSUB16x16 | X264_ANALYSE_BSUB16x16; #ifdef X264_ANALYSE_I8x8 p_sys->param.analyse.inter |= X264_ANALYSE_I8x8; #endif } else if( !strcmp( psz_val, "all" ) ) { p_sys->param.analyse.inter = ~0; } free( psz_val ); p_sys->param.analyse.b_transform_8x8 = var_GetBool( p_enc, SOUT_CFG_PREFIX "8x8dct" ); if( p_enc->fmt_in.video.i_aspect > 0 ) { int64_t i_num, i_den; unsigned int i_dst_num, i_dst_den; i_num = p_enc->fmt_in.video.i_aspect * (int64_t)p_enc->fmt_in.video.i_height; i_den = VOUT_ASPECT_FACTOR * p_enc->fmt_in.video.i_width; vlc_ureduce( &i_dst_num, &i_dst_den, i_num, i_den, 0 ); p_sys->param.vui.i_sar_width = i_dst_num; p_sys->param.vui.i_sar_height = i_dst_den; } if( p_enc->fmt_in.video.i_frame_rate_base > 0 ) { p_sys->param.i_fps_num = p_enc->fmt_in.video.i_frame_rate; p_sys->param.i_fps_den = p_enc->fmt_in.video.i_frame_rate_base; } /* x264 vbv-bufsize = 0 (default). if not provided set period in seconds for local maximum bitrate (cache/bufsize) based on average bitrate when use has told bitrate. vbv-buffer size is set to bitrate * secods between keyframes */ if( !p_sys->param.rc.i_vbv_buffer_size && p_sys->param.rc.i_rc_method == X264_RC_ABR && p_sys->param.i_fps_num ) { p_sys->param.rc.i_vbv_buffer_size = p_sys->param.rc.i_bitrate * p_sys->param.i_fps_den; p_sys->param.rc.i_vbv_buffer_size *= p_sys->param.i_keyint_max; p_sys->param.rc.i_vbv_buffer_size /= p_sys->param.i_fps_num; } /* Check if user has given some profile (baseline,main,high) to limit * settings, and apply those*/ psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "profile" ); if( psz_val ) { if( !strcasecmp( psz_val, "baseline" ) ) { msg_Dbg( p_enc, "Limiting to baseline profile"); p_sys->param.analyse.b_transform_8x8 = 0; p_sys->param.b_cabac = 0; p_sys->param.i_bframe = 0; } else if (!strcasecmp( psz_val, "main" ) ) { msg_Dbg( p_enc, "Limiting to main-profile"); p_sys->param.analyse.b_transform_8x8 = 0; } /* high profile don't restrict stuff*/ } free( psz_val ); unsigned i_cpu = vlc_CPU(); if( !(i_cpu & CPU_CAPABILITY_MMX) ) { p_sys->param.cpu &= ~X264_CPU_MMX; } if( !(i_cpu & CPU_CAPABILITY_MMXEXT) ) { p_sys->param.cpu &= ~X264_CPU_MMXEXT; } if( !(i_cpu & CPU_CAPABILITY_SSE) ) { p_sys->param.cpu &= ~X264_CPU_SSE; } if( !(i_cpu & CPU_CAPABILITY_SSE2) ) { p_sys->param.cpu &= ~X264_CPU_SSE2; } /* BUILD 29 adds support for multi-threaded encoding while BUILD 49 (r543) also adds support for threads = 0 for automatically selecting an optimal value (cores * 1.5) based on detected CPUs. Default behavior for x264 is threads = 1, however VLC usage differs and uses threads = 0 (auto) by default unless ofcourse transcode threads is explicitly specified.. */ p_sys->param.i_threads = p_enc->i_threads; psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "stats" ); if( psz_val ) { p_sys->param.rc.psz_stat_in = p_sys->param.rc.psz_stat_out = p_sys->psz_stat_name = psz_val; } i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "pass" ); if( i_val > 0 && i_val <= 3 ) { p_sys->param.rc.b_stat_write = i_val & 1; p_sys->param.rc.b_stat_read = i_val & 2; } /* We need to initialize pthreadw32 before we open the encoder, but only once for the whole application. Since pthreadw32 doesn't keep a refcount, do it ourselves. */ #ifdef PTW32_STATIC_LIB vlc_value_t lock, count; var_Create( p_enc->p_libvlc, "pthread_win32_mutex", VLC_VAR_MUTEX ); var_Get( p_enc->p_libvlc, "pthread_win32_mutex", &lock ); vlc_mutex_lock( lock.p_address ); var_Create( p_enc->p_libvlc, "pthread_win32_count", VLC_VAR_INTEGER ); var_Get( p_enc->p_libvlc, "pthread_win32_count", &count ); if( count.i_int == 0 ) { msg_Dbg( p_enc, "initializing pthread-win32" ); if( !pthread_win32_process_attach_np() || !pthread_win32_thread_attach_np() ) { msg_Warn( p_enc, "pthread Win32 Initialization failed" ); vlc_mutex_unlock( lock.p_address ); return VLC_EGENERIC; } } count.i_int++; var_Set( p_enc->p_libvlc, "pthread_win32_count", count ); vlc_mutex_unlock( lock.p_address ); #endif /* Set lookahead value to lower than default, * as rtp-output without mux doesn't handle * difference that well yet*/ p_sys->param.rc.i_lookahead=5; /* Open the encoder */ p_sys->h = x264_encoder_open( &p_sys->param ); if( p_sys->h == NULL ) { msg_Err( p_enc, "cannot open x264 encoder" ); Close( VLC_OBJECT(p_enc) ); return VLC_EGENERIC; } /* alloc mem */ p_sys->i_buffer = 4 * p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height + 1000; p_sys->p_buffer = malloc( p_sys->i_buffer ); if( !p_sys->p_buffer ) { Close( VLC_OBJECT(p_enc) ); return VLC_ENOMEM; } /* get the globals headers */ p_enc->fmt_out.i_extra = 0; p_enc->fmt_out.p_extra = NULL; p_enc->fmt_out.i_extra = x264_encoder_headers( p_sys->h, &nal, &i_nal ); p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra ); if( !p_enc->fmt_out.p_extra ) { Close( VLC_OBJECT(p_enc) ); return VLC_ENOMEM; } void *p_tmp = p_enc->fmt_out.p_extra; for( i = 0; i < i_nal; i++ ) { memcpy( p_tmp, nal[i].p_payload, nal[i].i_payload ); p_tmp += nal[i].i_payload; } return VLC_SUCCESS; }
inline bool StreamTime::havePosition() const { input_thread_t *p_input = getIntf()->p_sys->p_input; return p_input && ( var_GetFloat( p_input, "position" ) != 0.0 ); }
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->obj.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; }
static int input_event_changed( vlc_object_t * p_this, char const * psz_cmd, vlc_value_t oldval, vlc_value_t newval, void * p_userdata ) { VLC_UNUSED(oldval); input_thread_t * p_input = (input_thread_t *)p_this; libvlc_media_player_t * p_mi = p_userdata; libvlc_event_t event; assert( !strcmp( psz_cmd, "intf-event" ) ); if( newval.i_int == INPUT_EVENT_STATE ) { libvlc_state_t libvlc_state; switch ( var_GetInteger( p_input, "state" ) ) { case INIT_S: libvlc_state = libvlc_NothingSpecial; event.type = libvlc_MediaPlayerNothingSpecial; break; case OPENING_S: libvlc_state = libvlc_Opening; event.type = libvlc_MediaPlayerOpening; break; case PLAYING_S: libvlc_state = libvlc_Playing; event.type = libvlc_MediaPlayerPlaying; break; case PAUSE_S: libvlc_state = libvlc_Paused; event.type = libvlc_MediaPlayerPaused; break; case END_S: libvlc_state = libvlc_Ended; event.type = libvlc_MediaPlayerEndReached; break; case ERROR_S: libvlc_state = libvlc_Error; event.type = libvlc_MediaPlayerEncounteredError; break; default: return VLC_SUCCESS; } set_state( p_mi, libvlc_state, false ); libvlc_event_send( p_mi->p_event_manager, &event ); } else if( newval.i_int == INPUT_EVENT_ABORT ) { libvlc_state_t libvlc_state = libvlc_Stopped; event.type = libvlc_MediaPlayerStopped; set_state( p_mi, libvlc_state, false ); libvlc_event_send( p_mi->p_event_manager, &event ); } else if( newval.i_int == INPUT_EVENT_POSITION ) { if( var_GetInteger( p_input, "state" ) != PLAYING_S ) return VLC_SUCCESS; /* Don't send the position while stopped */ /* */ event.type = libvlc_MediaPlayerPositionChanged; event.u.media_player_position_changed.new_position = var_GetFloat( p_input, "position" ); libvlc_event_send( p_mi->p_event_manager, &event ); /* */ event.type = libvlc_MediaPlayerTimeChanged; event.u.media_player_time_changed.new_time = from_mtime(var_GetTime( p_input, "time" )); libvlc_event_send( p_mi->p_event_manager, &event ); } else if( newval.i_int == INPUT_EVENT_LENGTH ) { event.type = libvlc_MediaPlayerLengthChanged; event.u.media_player_length_changed.new_length = from_mtime(var_GetTime( p_input, "length" )); libvlc_event_send( p_mi->p_event_manager, &event ); } else if( newval.i_int == INPUT_EVENT_CACHE ) { event.type = libvlc_MediaPlayerBuffering; event.u.media_player_buffering.new_cache = (int)(100 * var_GetFloat( p_input, "cache" )); libvlc_event_send( p_mi->p_event_manager, &event ); } else if( newval.i_int == INPUT_EVENT_VOUT ) { vout_thread_t **pp_vout; size_t i_vout; if( input_Control( p_input, INPUT_GET_VOUTS, &pp_vout, &i_vout ) ) { i_vout = 0; } else { for( size_t i = 0; i < i_vout; i++ ) vlc_object_release( pp_vout[i] ); free( pp_vout ); } event.type = libvlc_MediaPlayerVout; event.u.media_player_vout.new_count = i_vout; libvlc_event_send( p_mi->p_event_manager, &event ); } return VLC_SUCCESS; }
void vout_IntfInit( vout_thread_t *p_vout ) { vlc_value_t val, text, old_val; char *psz_buf; /* Create a few object variables we'll need later on */ var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER ); var_SetInteger( p_vout, "snapshot-num", 1 ); var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "align", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); 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 ); /* 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 ); 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 ); /* 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 ); old_val.f_float = var_GetFloat( p_vout, "zoom" ); for( size_t i = 0; i < ARRAY_SIZE(p_zoom_values); i++ ) { val.f_float = p_zoom_values[i].f_value; text.psz_string = vlc_gettext( p_zoom_values[i].psz_label ); /* FIXME: This DELCHOICE hack corrupts the the "zoom" variable value * for a short time window. Same for "crop" and "aspect-ratio". */ if( old_val.f_float == val.f_float ) var_Change( p_vout, "zoom", VLC_VAR_DELCHOICE, &old_val, NULL ); var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text ); if( old_val.f_float == val.f_float ) var_Change( p_vout, "zoom", VLC_VAR_SETVALUE, &old_val, NULL ); } 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", CropBorderCallback, NULL ); var_AddCallback( p_vout, "crop-top", CropBorderCallback, NULL ); var_AddCallback( p_vout, "crop-right", CropBorderCallback, NULL ); var_AddCallback( p_vout, "crop-bottom", CropBorderCallback, 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( size_t i = 0; i < ARRAY_SIZE(p_crop_values); 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 ); } /* Add custom crop ratios */ psz_buf = var_CreateGetNonEmptyString( p_vout, "custom-crop-ratios" ); if( psz_buf ) { AddCustomRatios( p_vout, "crop", psz_buf ); free( psz_buf ); } var_AddCallback( p_vout, "crop", CropCallback, NULL ); /* Monitor pixel aspect-ratio */ var_Create( p_vout, "monitor-par", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); /* 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( size_t i = 0; i < ARRAY_SIZE(p_aspect_ratio_values); 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 = var_CreateGetNonEmptyString( p_vout, "custom-aspect-ratios" ); if( psz_buf ) { AddCustomRatios( p_vout, "aspect-ratio", psz_buf ); free( psz_buf ); } var_AddCallback( p_vout, "aspect-ratio", AspectCallback, NULL ); /* 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 */ var_Create( p_vout, "fullscreen", VLC_VAR_BOOL | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); 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 ); /* Add a video-filter variable */ var_Create( p_vout, "video-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); var_AddCallback( p_vout, "video-filter", VideoFilterCallback, NULL ); /* Add a sub-source variable */ var_Create( p_vout, "sub-source", VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); var_AddCallback( p_vout, "sub-source", SubSourceCallback, NULL ); /* Add a sub-filter variable */ var_Create( p_vout, "sub-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); var_AddCallback( p_vout, "sub-filter", SubFilterCallback, NULL ); /* Add sub-margin variable */ var_Create( p_vout, "sub-margin", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); var_AddCallback( p_vout, "sub-margin", SubMarginCallback, NULL ); /* Mouse coordinates */ var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER ); var_Create( p_vout, "mouse-moved", VLC_VAR_COORDS ); var_Create( p_vout, "mouse-clicked", VLC_VAR_COORDS ); var_Create( p_vout, "mouse-object", VLC_VAR_BOOL ); vout_IntfReinit( p_vout ); }
/** * Gets the volume of the audio output stream (independent of mute). * \return Current audio volume (0. = silent, 1. = nominal), * or a strictly negative value if undefined. */ float aout_VolumeGet (audio_output_t *aout) { return var_GetFloat (aout, "volume"); }
/* delete Input if it ever existed. Delete the callbacls on input p_input is released once here */ void InputManager::delInput() { if( !p_input ) return; msg_Dbg( p_intf, "IM: Deleting the input" ); /* Save time / position */ char *uri = input_item_GetURI( p_item ); if( uri != NULL ) { float f_pos = var_GetFloat( p_input , "position" ); int64_t i_time = -1; if( f_pos >= 0.05f && f_pos <= 0.95f && var_GetInteger( p_input, "length" ) >= 60 * CLOCK_FREQ ) i_time = var_GetInteger( p_input, "time"); RecentsMRL::getInstance( p_intf )->setTime( qfu(uri), i_time ); free(uri); } delCallbacks(); i_old_playing_status = END_S; p_item = NULL; oldName = ""; artUrl = ""; b_video = false; timeA = 0; timeB = 0; f_rate = 0. ; if( p_input_vbi ) { vlc_object_release( p_input_vbi ); p_input_vbi = NULL; } vlc_object_release( p_input ); p_input = NULL; emit positionUpdated( -1.0, 0 ,0 ); emit rateChanged( var_InheritFloat( p_intf, "rate" ) ); emit nameChanged( "" ); emit chapterChanged( 0 ); emit titleChanged( 0 ); emit playingStatusChanged( END_S ); emit teletextPossible( false ); emit AtoBchanged( false, false ); emit voutChanged( false ); emit voutListChanged( NULL, 0 ); /* Reset all InfoPanels but stats */ emit artChanged( NULL ); emit artChanged( "" ); emit infoChanged( NULL ); emit currentMetaChanged( (input_item_t *)NULL ); emit encryptionChanged( false ); emit recordingStateChanged( false ); emit cachingChanged( 0.0 ); }
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_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_AOUT: { audio_output_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 VlcProc::on_volume_changed( vlc_object_t* p_obj, vlc_value_t newVal ) { (void)p_obj; (void)newVal; SET_VOLUME( m_cVarVolume, var_GetFloat( getPL(), "volume" ), false ); }
/***************************************************************************** * DoWork : normalizes and sends a buffer *****************************************************************************/ static block_t *DoWork( filter_t *p_filter, block_t *p_in_buf ) { float *pf_sum; float *pf_gain; float f_average = 0; int i, i_chan; int i_samples = p_in_buf->i_nb_samples; int i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio ); float *p_out = (float*)p_in_buf->p_buffer; float *p_in = (float*)p_in_buf->p_buffer; struct filter_sys_t *p_sys = p_filter->p_sys; pf_sum = (float *)calloc( i_channels, sizeof(float) ); // sunqueen modify if( !pf_sum ) goto out; pf_gain = (float *)malloc( sizeof(float) * i_channels ); // sunqueen modify if( !pf_gain ) { free( pf_sum ); goto out; } /* Calculate the average power level on this buffer */ for( i = 0 ; i < i_samples; i++ ) { for( i_chan = 0; i_chan < i_channels; i_chan++ ) { float f_sample = p_in[i_chan]; float f_square = pow( f_sample, 2 ); pf_sum[i_chan] += f_square; } p_in += i_channels; } /* sum now contains for each channel the sigma(value²) */ for( i_chan = 0; i_chan < i_channels; i_chan++ ) { /* Shift our lastbuff */ memmove( &p_sys->p_last[ i_chan * p_sys->i_nb], &p_sys->p_last[i_chan * p_sys->i_nb + 1], (p_sys->i_nb-1) * sizeof( float ) ); /* Insert the new average : sqrt(sigma(value²)) */ p_sys->p_last[ i_chan * p_sys->i_nb + p_sys->i_nb - 1] = sqrt( pf_sum[i_chan] ); pf_sum[i_chan] = 0; /* Get the average power on the lastbuff */ f_average = 0; for( i = 0; i < p_sys->i_nb ; i++) { f_average += p_sys->p_last[ i_chan * p_sys->i_nb + i ]; } f_average = f_average / p_sys->i_nb; /* Seuil arbitraire */ p_sys->f_max = var_GetFloat( p_filter->p_parent, "norm-max-level" ); //fprintf(stderr,"Average %f, max %f\n", f_average, p_sys->f_max ); if( f_average > p_sys->f_max ) { pf_gain[i_chan] = f_average / p_sys->f_max; } else { pf_gain[i_chan] = 1; } } /* Apply gain */ for( i = 0; i < i_samples; i++) { for( i_chan = 0; i_chan < i_channels; i_chan++ ) { p_out[i_chan] /= pf_gain[i_chan]; } p_out += i_channels; } free( pf_sum ); free( pf_gain ); return p_in_buf; out: block_Release( p_in_buf ); return NULL; }
static void ParseExecute( httpd_file_sys_t *p_args, char *p_buffer, int i_buffer, char *p_request, char **pp_data, int *pi_data ) { intf_sys_t *p_sys = p_args->p_intf->p_sys; int i_request = p_request != NULL ? strlen( p_request ) : 0; char *dst; char position[4]; /* percentage */ char time[12]; /* in seconds */ char length[12]; /* in seconds */ audio_volume_t i_volume; char volume[5]; const char *state; char stats[20]; assert( p_sys->p_input == NULL ); /* FIXME: proper locking anyone? */ p_sys->p_input = playlist_CurrentInput( p_sys->p_playlist ); if( p_sys->p_input ) { snprintf( position, sizeof(position), "%d", (int)(var_GetFloat( p_sys->p_input, "position" ) * 100.)); snprintf( time, sizeof(time), "%"PRIi64, var_GetTime( p_sys->p_input, "time" ) / CLOCK_FREQ ); snprintf( length, sizeof(length), "%"PRIi64, var_GetTime( p_sys->p_input, "length" ) / CLOCK_FREQ ); switch( var_GetInteger( p_sys->p_input, "state" ) ) { case PLAYING_S: state = "playing"; break; case OPENING_S: state = "opening/connecting"; break; case PAUSE_S: state = "paused"; break; default: state = "stop"; break; } } else { strcpy( position, "0" ); strcpy( time, "0" ); strcpy( length, "0" ); state = "stop"; } aout_VolumeGet( p_sys->p_playlist, &i_volume ); snprintf( volume, sizeof(volume), "%d", (int)i_volume ); p_args->vars = mvar_New( "variables", "" ); mvar_AppendNewVar( p_args->vars, "url_param", i_request > 0 ? "1" : "0" ); mvar_AppendNewVar( p_args->vars, "url_value", p_request ); mvar_AppendNewVar( p_args->vars, "version", VLC_Version() ); mvar_AppendNewVar( p_args->vars, "copyright", COPYRIGHT_MESSAGE ); mvar_AppendNewVar( p_args->vars, "vlc_compile_by", VLC_CompileBy() ); mvar_AppendNewVar( p_args->vars, "vlc_compile_host", VLC_CompileHost() ); mvar_AppendNewVar( p_args->vars, "vlc_compiler", VLC_Compiler() ); mvar_AppendNewVar( p_args->vars, "stream_position", position ); mvar_AppendNewVar( p_args->vars, "stream_time", time ); mvar_AppendNewVar( p_args->vars, "stream_length", length ); mvar_AppendNewVar( p_args->vars, "volume", volume ); mvar_AppendNewVar( p_args->vars, "stream_state", state ); mvar_AppendNewVar( p_args->vars, "charset", "UTF-8" ); /* Stats */ if( p_sys->p_input ) { /* FIXME: Workarround a stupid assert in input_GetItem */ input_item_t *p_item = p_sys->p_input && p_sys->p_input->p ? input_GetItem( p_sys->p_input ) : NULL; if( p_item ) { vlc_mutex_lock( &p_item->p_stats->lock ); #define STATS_INT( n ) sprintf( stats, "%d", p_item->p_stats->i_ ## n ); \ mvar_AppendNewVar( p_args->vars, #n, stats ); #define STATS_FLOAT( n ) sprintf( stats, "%f", p_item->p_stats->f_ ## n ); \ mvar_AppendNewVar( p_args->vars, #n, stats ); STATS_INT( read_bytes ) STATS_FLOAT( input_bitrate ) STATS_INT( demux_read_bytes ) STATS_FLOAT( demux_bitrate ) STATS_INT( decoded_video ) STATS_INT( displayed_pictures ) STATS_INT( lost_pictures ) STATS_INT( decoded_audio ) STATS_INT( played_abuffers ) STATS_INT( lost_abuffers ) STATS_INT( sent_packets ) STATS_INT( sent_bytes ) STATS_FLOAT( send_bitrate ) #undef STATS_INT #undef STATS_FLOAT vlc_mutex_unlock( &p_item->p_stats->lock ); } } SSInit( &p_args->stack ); /* allocate output */ *pi_data = i_buffer + 1000; dst = *pp_data = malloc( *pi_data ); /* we parse executing all <vlc /> macros */ Execute( p_args, p_request, i_request, pp_data, pi_data, &dst, &p_buffer[0], &p_buffer[i_buffer] ); *dst = '\0'; *pi_data = dst - *pp_data; if( p_sys->p_input != NULL ) { vlc_object_release( p_sys->p_input ); p_sys->p_input = NULL; } SSClean( &p_args->stack ); mvar_Delete( p_args->vars ); }
/* InputIntfEventCallback() fills a callback_info_t data structure in response * to an "intf-event" input event. * * Caution: This function executes in the input thread * * This function must be called with p_sys->lock locked * * @return int VLC_SUCCESS on success, VLC_E* on error * @param intf_thread_t *p_intf the interface thread * @param input_thread_t *p_input This input thread * @param const int i_event input event type * @param callback_info_t *p_info Location of the callback info to fill */ static int InputIntfEventCallback( intf_thread_t *p_intf, input_thread_t *p_input, const int i_event, callback_info_t *p_info ) { dbus_int32_t i_state = PLAYBACK_STATE_INVALID; assert(!p_info->signal); mtime_t i_now = mdate(), i_pos, i_projected_pos, i_interval; float f_current_rate; switch( i_event ) { case INPUT_EVENT_DEAD: case INPUT_EVENT_ABORT: i_state = PLAYBACK_STATE_STOPPED; break; case INPUT_EVENT_STATE: switch( var_GetInteger( p_input, "state" ) ) { case OPENING_S: case PLAYING_S: i_state = PLAYBACK_STATE_PLAYING; break; case PAUSE_S: i_state = PLAYBACK_STATE_PAUSED; break; default: i_state = PLAYBACK_STATE_STOPPED; } break; case INPUT_EVENT_ITEM_META: p_info->signal = SIGNAL_INPUT_METADATA; return VLC_SUCCESS; case INPUT_EVENT_RATE: p_info->signal = SIGNAL_RATE; return VLC_SUCCESS; case INPUT_EVENT_POSITION: /* Detect seeks * XXX: This is way more convoluted than it should be... */ if( !p_intf->p_sys->i_last_input_pos_event || !( var_GetInteger( p_input, "state" ) == PLAYING_S ) ) break; i_pos = var_GetTime( p_input, "time" ); f_current_rate = var_GetFloat( p_input, "rate" ); i_interval = ( i_now - p_intf->p_sys->i_last_input_pos_event ); i_projected_pos = p_intf->p_sys->i_last_input_pos + ( i_interval * f_current_rate ); p_intf->p_sys->i_last_input_pos_event = i_now; p_intf->p_sys->i_last_input_pos = i_pos; if( ABS( i_pos - i_projected_pos ) < SEEK_THRESHOLD ) break; p_info->signal = SIGNAL_SEEK; p_info->i_item = input_GetItem( p_input )->i_id; break; default: return VLC_EGENERIC; } if( i_state != PLAYBACK_STATE_INVALID && i_state != p_intf->p_sys->i_playing_state ) { p_intf->p_sys->i_playing_state = i_state; p_info->signal = SIGNAL_STATE; } return p_info->signal ? VLC_SUCCESS : VLC_EGENERIC; }
float libvlc_media_player_get_rate( libvlc_media_player_t *p_mi ) { return var_GetFloat (p_mi, "rate"); }
/***************************************************************************** * 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[4] = " "; 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] = " "; 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] = " "; 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; }
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; } }