static uint32_t var_InheritCodeRate (vlc_object_t *obj, const char *varname) { char *code_rate = var_InheritString (obj, varname); if (code_rate == NULL) return VLC_FEC_AUTO; uint16_t a, b; int v = sscanf (code_rate, "%"SCNu16"/%"SCNu16, &a, &b); free (code_rate); switch (v) { case 2: return VLC_FEC(a, b); case 1: if (a == 0) return 0; /* Backward compatibility with VLC < 1.2 (= Linux DVBv3 enum) */ if (a < 9) { msg_Warn (obj, "\"%s=%"PRIu16"\" option is obsolete. " "Use \"%s=%"PRIu16"/%"PRIu16"\" instead.", varname + 4, a, varname + 4, a, a + 1); return VLC_FEC(a, a + 1); } else msg_Warn (obj, "\"fec=9\" option is obsolete."); } return VLC_FEC_AUTO; }
/** * Checks for help command line options such as --help or --version. * If one is found, print the corresponding text. * \return true if a command line options caused some help message to be * printed, false otherwise. */ bool config_PrintHelp (vlc_object_t *obj) { char *str; /* Check for short help option */ if (var_InheritBool (obj, "help")) { Help (obj, "help"); return true; } /* Check for version option */ if (var_InheritBool (obj, "version")) { Version(); return true; } /* Check for help on modules */ str = var_InheritString (obj, "module"); if (str != NULL) { Help (obj, str); free (str); return true; } /* Check for full help option */ if (var_InheritBool (obj, "full-help")) { var_Create (obj, "advanced", VLC_VAR_BOOL); var_SetBool (obj, "advanced", true); var_Create (obj, "help-verbose", VLC_VAR_BOOL); var_SetBool (obj, "help-verbose", true); Help (obj, "full-help"); return true; } /* Check for long help option */ if (var_InheritBool (obj, "longhelp")) { Help (obj, "longhelp"); return true; } /* Check for module list option */ if (var_InheritBool (obj, "list")) { ListModules (obj, false ); return true; } if (var_InheritBool (obj, "list-verbose")) { ListModules (obj, true); return true; } return false; }
static void WINAPI ServiceDispatch( DWORD numArgs, char **args ) { (void)numArgs; (void)args; intf_thread_t *p_intf = (intf_thread_t *)p_global_intf; intf_sys_t *p_sys = p_intf->p_sys; char *psz_modules, *psz_parser; /* We have to initialize the service-specific stuff */ memset( &p_sys->status, 0, sizeof(SERVICE_STATUS) ); p_sys->status.dwServiceType = SERVICE_WIN32; p_sys->status.dwCurrentState = SERVICE_START_PENDING; p_sys->status.dwControlsAccepted = SERVICE_ACCEPT_STOP; p_sys->hStatus = RegisterServiceCtrlHandler( p_sys->psz_service, &ServiceCtrlHandler ); if( p_sys->hStatus == (SERVICE_STATUS_HANDLE)0 ) { msg_Err( p_intf, "failed to register service control handler" ); return; } /* * Load background interfaces */ psz_modules = var_InheritString( p_intf, "ntservice-extraintf" ); 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 ) { /* Try to create the interface */ if( intf_Create( p_intf, psz_temp ) ) { msg_Err( p_intf, "interface \"%s\" initialization failed", psz_temp ); free( psz_temp ); continue; } free( psz_temp ); } } free( psz_modules ); /* Initialization complete - report running status */ p_sys->status.dwCurrentState = SERVICE_RUNNING; p_sys->status.dwCheckPoint = 0; p_sys->status.dwWaitHint = 0; SetServiceStatus( p_sys->hStatus, &p_sys->status ); }
static int GetVideoConn(demux_t *demux) { demux_sys_t *sys = demux->p_sys; char *opt = var_InheritString(demux, "decklink-video-connection"); if (!opt) return VLC_SUCCESS; BMDVideoConnection c; if (!strcmp(opt, "sdi")) c = bmdVideoConnectionSDI; else if (!strcmp(opt, "hdmi")) c = bmdVideoConnectionHDMI; else if (!strcmp(opt, "opticalsdi")) c = bmdVideoConnectionOpticalSDI; else if (!strcmp(opt, "component")) c = bmdVideoConnectionComponent; else if (!strcmp(opt, "composite")) c = bmdVideoConnectionComposite; else if (!strcmp(opt, "svideo")) c = bmdVideoConnectionSVideo; else { msg_Err(demux, "Invalid video-connection: `%s\' specified", opt); free(opt); return VLC_EGENERIC; } free(opt); if (sys->config->SetInt(bmdDeckLinkConfigVideoInputConnection, c) != S_OK) { msg_Err(demux, "Failed to set video input connection"); return VLC_EGENERIC; } return VLC_SUCCESS; }
/*** DVB-S ***/ static char var_InheritPolarization (vlc_object_t *obj) { char pol; char *polstr = var_InheritString (obj, "dvb-polarization"); if (polstr != NULL) { pol = *polstr; free (polstr); if (unlikely(pol >= 'a' && pol <= 'z')) pol -= 'a' - 'A'; return pol; } /* Backward compatibility with VLC for Linux < 1.2 */ unsigned voltage = var_InheritInteger (obj, "dvb-voltage"); switch (voltage) { case 13: pol = 'V'; break; case 18: pol = 'H'; break; default: return 0; } msg_Warn (obj, "\"voltage=%u\" option is obsolete. " "Use \"polarization=%c\" instead.", voltage, pol); return pol; }
void RendererDialog::discoveryEventReceived( const vlc_event_t * p_event ) { if ( p_event->type == vlc_RendererDiscoveryItemAdded ) { vlc_renderer_item *p_item = p_event->u.renderer_discovery_item_added.p_new_item; int row = 0; for ( ; row < ui.receiversListWidget->count(); row++ ) { RendererItem *rowItem = reinterpret_cast<RendererItem*>( ui.receiversListWidget->item( row ) ); if ( rowItem->isItemSout( vlc_renderer_item_sout( p_item ), false ) ) return; } RendererItem *newItem = new RendererItem(p_item); ui.receiversListWidget->addItem( newItem ); char *psz_renderer = var_InheritString( THEPL, "sout" ); if ( psz_renderer != NULL ) { if ( newItem->isItemSout( psz_renderer, true ) ) ui.receiversListWidget->setCurrentItem( newItem ); free( psz_renderer ); } } }
/* * Obtain the window type from the window type variable. */ void window_get_param( vlc_object_t * p_aout, window_param * p_param ) { /* Fetch Kaiser parameter */ p_param->f_kaiser_alpha = var_InheritFloat( p_aout, "effect-kaiser-param" ); /* Fetch window type */ char * psz_preset = var_InheritString( p_aout, "effect-fft-window" ); if( !psz_preset ) { goto no_preset; } for( int i = 0; i < NB_WINDOWS; i++ ) { if( !strcasecmp( psz_preset, window_list[i] ) ) { p_param->wind_type = i; return; } } no_preset: msg_Warn( p_aout, "No matching window preset found; using rectangular " "window (i.e. no window)" ); p_param->wind_type = NONE; }
static const char *var_InheritModulation (vlc_object_t *obj, const char *var) { char *mod = var_InheritString (obj, var); if (mod == NULL) return ""; size_t n = sizeof (modulation_vlc) / sizeof (modulation_vlc[0]); const char *const *p = lfind (mod, modulation_vlc, &n, sizeof (mod), modcmp); if (p != NULL) { free (mod); return *p; } /* Backward compatibility with VLC < 1.2 */ const char *str; switch (atoi (mod)) { case -1: str = "QPSK"; break; case 0: str = "QAM"; break; case 8: str = "8VSB"; break; case 16: str = "16QAM"; break; case 32: str = "32QAM"; break; case 64: str = "64QAM"; break; case 128: str = "128QAM"; break; case 256: str = "256QAM"; break; default: return ""; } msg_Warn (obj, "\"modulation=%s\" option is obsolete. " "Use \"modulation=%s\" instead.", mod, str); free (mod); return str; }
int OutOpenAvio(vlc_object_t *object) { sout_access_out_t *access = (sout_access_out_t*)object; config_ChainParse( access, "sout-avio-", ppsz_sout_options, access->p_cfg ); sout_access_out_sys_t *sys = malloc(sizeof(*sys)); if (!sys) return VLC_ENOMEM; sys->context = NULL; /* */ vlc_init_avformat(object); if (!access->psz_path) goto error; int ret; #if LIBAVFORMAT_VERSION_MAJOR < 54 ret = avio_open(&sys->context, access->psz_path, AVIO_FLAG_WRITE); #else AVDictionary *options = NULL; char *psz_opts = var_InheritString(access, "sout-avio-options"); if (psz_opts && *psz_opts) { options = vlc_av_get_options(psz_opts); free(psz_opts); } ret = avio_open2(&sys->context, access->psz_path, AVIO_FLAG_WRITE, NULL, &options); AVDictionaryEntry *t = NULL; while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) msg_Err( access, "unknown option \"%s\"", t->key ); av_dict_free(&options); #endif if (ret < 0) { errno = AVUNERROR(ret); msg_Err(access, "Failed to open %s", access->psz_path); goto error; } #if LIBAVFORMAT_VERSION_MAJOR < 54 /* We can accept only one active user at any time */ if (SetupAvioCb(VLC_OBJECT(access))) { msg_Err(access, "Module aready in use"); goto error; } #endif access->pf_write = Write; access->pf_control = OutControl; access->pf_seek = OutSeek; access->p_sys = sys; return VLC_SUCCESS; error: free(sys); return VLC_EGENERIC; }
UpnpInstanceWrapper *UpnpInstanceWrapper::get(vlc_object_t *p_obj, Upnp_FunPtr callback, SD::MediaServerList *opaque) { vlc_mutex_locker lock( &s_lock ); if ( s_instance == NULL ) { UpnpInstanceWrapper* instance = new(std::nothrow) UpnpInstanceWrapper; if ( unlikely( !instance ) ) return NULL; #ifdef UPNP_ENABLE_IPV6 char* psz_miface = var_InheritString( p_obj, "miface" ); msg_Info( p_obj, "Initializing libupnp on '%s' interface", psz_miface ); int i_res = UpnpInit2( psz_miface, 0 ); free( psz_miface ); #else /* If UpnpInit2 isnt available, initialize on first IPv4-capable interface */ int i_res = UpnpInit( 0, 0 ); #endif if( i_res != UPNP_E_SUCCESS ) { msg_Err( p_obj, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) ); delete instance; return NULL; } ixmlRelaxParser( 1 ); /* Register a control point */ i_res = UpnpRegisterClient( Callback, instance, &instance->handle_ ); if( i_res != UPNP_E_SUCCESS ) { msg_Err( p_obj, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) ); delete instance; return NULL; } /* libupnp does not treat a maximum content length of 0 as unlimited * until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate * between versions */ if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS ) { msg_Err( p_obj, "Failed to set maximum content length: %s", UpnpGetErrorMessage( i_res )); delete instance; return NULL; } s_instance = instance; } s_instance->refcount_++; // This assumes a single UPNP SD instance if (callback && opaque) { assert(!s_instance->callback_ && !s_instance->opaque_); s_instance->opaque_ = opaque; s_instance->callback_ = callback; } return s_instance; }
static bool preConnectHandler( freerdp *p_instance ) { vlcrdp_context_t * p_vlccontext = (vlcrdp_context_t *) p_instance->context; demux_sys_t *p_sys = p_vlccontext->p_demux->p_sys; /* Configure connexion */ p_instance->settings->SoftwareGdi = true; /* render in buffer */ p_instance->settings->Fullscreen = true; p_instance->settings->ServerHostname = strdup( p_sys->psz_hostname ); p_instance->settings->Username = var_InheritString( p_vlccontext->p_demux, CFG_PREFIX "user" ); p_instance->settings->Password = var_InheritString( p_vlccontext->p_demux, CFG_PREFIX "password" ); p_instance->settings->ServerPort = p_sys->i_port; p_instance->settings->EncryptionMethods = var_InheritBool( p_vlccontext->p_demux, CFG_PREFIX "encrypt" ); return true; }
/***************************************************************************** * 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 *outputFile; p_sys = calloc( 1, sizeof( sout_stream_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options, p_stream->p_cfg ); outputFile = var_InheritString( p_stream, SOUT_CFG_PREFIX "output" ); if( outputFile ) { p_sys->output = vlc_fopen( outputFile, "wt" ); if( !p_sys->output ) { msg_Err( p_stream, "Unable to open file '%s' for writing", outputFile ); free( p_sys ); free( outputFile ); return VLC_EGENERIC; } else { fprintf( p_sys->output,"#prefix\ttrack\ttype\tsegment_number\tdts_difference\tlength\tmd5\n"); } free( outputFile ); } p_sys->prefix = var_InheritString( p_stream, SOUT_CFG_PREFIX "prefix" ); p_stream->p_sys = p_sys; p_stream->pf_add = Add; p_stream->pf_del = Del; p_stream->pf_send = Send; return VLC_SUCCESS; }
/** * @brief VLC module construct callback * @return */ static int y4m_open(vlc_object_t* obj) { filter_t* intf = (filter_t*)obj; // todo: defer this check until we know if its needed or not if( !intf->b_allow_fmt_out_change ) { msg_Err(intf, "picture format change isn't allowed"); return VLC_EGENERIC; } filter_sys_t* sys = malloc(sizeof(*sys)); if (unlikely(sys == NULL)) return VLC_ENOMEM; intf->p_sys = sys; memset(sys, 0, sizeof(*sys)); sys->cmd = var_InheritString(intf, "y4m-cmd"); if (sys->cmd == NULL) { msg_Err(intf, "argument parse failed"); free(sys); return VLC_EGENERIC; } sys->echo = var_InheritBool(intf, "y4m-echo"); sys->stdin = -1; sys->stdout = -1; sys->bufferRatio = 1; msg_Info(intf, "open"); sys->inputFifo = picture_fifo_New(); sys->outputFifo = picture_fifo_New(); vlc_cond_init(&sys->inputCond); vlc_cond_init(&sys->outputCond); vlc_mutex_init(&sys->inputMutex); vlc_mutex_init(&sys->outputMutex); intf->pf_video_filter = y4m_filter; intf->pf_flush = y4m_flush; // todo: the conversion needed isn't known until // a frame is read back from the filter, for now // filters in/out format needs to be the same //intf->fmt_out.video.i_frame_rate *= 2; //intf->fmt_out.i_codec = VLC_CODEC_I420; //intf->fmt_out.video.i_chroma = VLC_CODEC_I420; return VLC_SUCCESS; }
vlc_keystore * vlc_keystore_create(vlc_object_t *p_parent) { assert(p_parent); char *modlist = var_InheritString(p_parent, "keystore"); vlc_keystore *p_keystore = keystore_create(p_parent, modlist); free(modlist); return p_keystore; }
/** * Initializes the raw dump pseudo-demuxer. */ static int Open( vlc_object_t * p_this ) { demux_t *p_demux = (demux_t*)p_this; /* Accept only if forced */ if( !p_demux->b_force ) return VLC_EGENERIC; char *access = var_InheritString( p_demux, "demuxdump-access" ); if( access == NULL ) return VLC_EGENERIC; /* --sout-file-append (defaults to false) */ var_Create( p_demux, "sout-file-append", VLC_VAR_BOOL ); if( var_InheritBool( p_demux, "demuxdump-append" ) ) var_SetBool( p_demux, "sout-file-append", true ); /* --sout-file-format (always false) */ var_Create( p_demux, "sout-file-format", VLC_VAR_BOOL ); char *path = var_InheritString( p_demux, "demuxdump-file" ); if( path == NULL ) { free( access ); msg_Err( p_demux, "no dump file name given" ); return VLC_EGENERIC; } sout_access_out_t *out = sout_AccessOutNew( p_demux, access, path ); free( path ); free( access ); if( out == NULL ) { msg_Err( p_demux, "cannot create output" ); return VLC_EGENERIC; } p_demux->p_sys = (void *)out; p_demux->pf_demux = Demux; p_demux->pf_control = Control; return VLC_SUCCESS; }
static vlc_fourcc_t var_InheritFourCC (vlc_object_t *obj, const char *varname) { char *str = var_InheritString (obj, varname); if (str == NULL) return 0; vlc_fourcc_t fourcc = vlc_fourcc_GetCodecFromString (VIDEO_ES, str); if (fourcc == 0) msg_Err (obj, "invalid codec %s", str); free (str); return fourcc; }
static int vlc_sd_probe_Open (vlc_object_t *obj) { vlc_probe_t *probe = (vlc_probe_t *)obj; char *display = var_InheritString (obj, "x11-display"); xcb_connection_t *conn = xcb_connect (display, NULL); free (display); if (xcb_connection_has_error (conn)) return VLC_PROBE_CONTINUE; xcb_disconnect (conn); return vlc_sd_probe_Add (probe, "xcb_apps", N_("Screen capture"), SD_CAT_DEVICES); }
int DemuxOpen( vlc_object_t *obj ) { demux_t *demux = (demux_t *)obj; demux_sys_t *sys = malloc (sizeof (*sys)); if (unlikely(sys == NULL)) return VLC_ENOMEM; demux->p_sys = sys; ParseMRL( obj, demux->psz_location ); char *path = var_InheritString (obj, CFG_PREFIX"dev"); if (unlikely(path == NULL)) goto error; /* probably OOM */ msg_Dbg (obj, "opening device '%s'", path); int rawfd = vlc_open (path, O_RDWR); if (rawfd == -1) { msg_Err (obj, "cannot open device '%s': %m", path); free (path); goto error; } free (path); int fd = v4l2_fd_open (rawfd, 0); if (fd == -1) { msg_Warn (obj, "cannot initialize user-space library: %m"); /* fallback to direct kernel mode anyway */ fd = rawfd; } sys->fd = fd; if (InitVideo (demux, fd)) { v4l2_close (fd); goto error; } sys->controls = ControlsInit (VLC_OBJECT(demux), fd); demux->pf_demux = NULL; demux->pf_control = DemuxControl; demux->info.i_update = 0; demux->info.i_title = 0; demux->info.i_seekpoint = 0; return VLC_SUCCESS; error: free (sys); return VLC_EGENERIC; }
/* Get credentials from uri or variables. */ static void get_credentials( access_t *p_access ) { access_sys_t *p_sys = p_access->p_sys; /* Fetch credentials, either from URI or from options if not provided */ if( p_sys->url.psz_password == NULL ) p_sys->creds.password = var_InheritString( p_access, "smb-pwd" ); else p_sys->creds.password = strdup( p_sys->url.psz_password ); /* Here we support smb://DOMAIN\User:password@XXX, get user from options or default to "Guest" as last resort */ if( p_sys->url.psz_username != NULL ) { p_sys->creds.login = strdup( p_sys->url.psz_username ); split_domain_login( &p_sys->creds.login, &p_sys->creds.domain ); } else p_sys->creds.login = var_InheritString( p_access, "smb-user" ); if( p_sys->creds.domain == NULL ) p_sys->creds.domain = var_InheritString( p_access, "smb-domain" ); }
/***************************************************************************** * CreateFilter: allocates marquee video filter *****************************************************************************/ static int CreateFilter( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; filter_sys_t *p_sys; /* Allocate structure */ p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) ); if( p_sys == NULL ) return VLC_ENOMEM; p_sys->p_style = text_style_Create( STYLE_NO_DEFAULTS ); if(unlikely(!p_sys->p_style)) { free(p_sys); return VLC_ENOMEM; } vlc_mutex_init( &p_sys->lock ); config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options, p_filter->p_cfg ); #define CREATE_VAR( stor, type, var ) \ p_sys->stor = var_CreateGet##type##Command( p_filter, var ); \ var_AddCallback( p_filter, var, MarqueeCallback, p_sys ); CREATE_VAR( i_xoff, Integer, "marq-x" ); CREATE_VAR( i_yoff, Integer, "marq-y" ); CREATE_VAR( i_timeout,Integer, "marq-timeout" ); p_sys->i_refresh = 1000 * var_CreateGetIntegerCommand( p_filter, "marq-refresh" ); var_AddCallback( p_filter, "marq-refresh", MarqueeCallback, p_sys ); CREATE_VAR( i_pos, Integer, "marq-position" ); CREATE_VAR( format, String, "marq-marquee" ); p_sys->filepath = var_InheritString( p_filter, "marq-file" ); p_sys->message = NULL; p_sys->p_style->i_font_alpha = var_CreateGetIntegerCommand( p_filter, "marq-opacity" ); var_AddCallback( p_filter, "marq-opacity", MarqueeCallback, p_sys ); p_sys->p_style->i_features |= STYLE_HAS_FONT_ALPHA; CREATE_VAR( p_style->i_font_color, Integer, "marq-color" ); p_sys->p_style->i_features |= STYLE_HAS_FONT_COLOR; CREATE_VAR( p_style->i_font_size, Integer, "marq-size" ); /* Misc init */ p_filter->pf_sub_source = Filter; p_sys->last_time = 0; return VLC_SUCCESS; }
/** * Cleanup a libvlc instance. The instance is not completely deallocated * \param p_libvlc the instance to clean */ void libvlc_InternalCleanup( libvlc_int_t *p_libvlc ) { libvlc_priv_t *priv = libvlc_priv (p_libvlc); /* Ask the interfaces to stop and destroy them */ msg_Dbg( p_libvlc, "removing all interfaces" ); libvlc_Quit( p_libvlc ); intf_DestroyAll( p_libvlc ); #ifdef ENABLE_VLM /* Destroy VLM if created in libvlc_InternalInit */ if( priv->p_vlm ) { vlm_Delete( priv->p_vlm ); } #endif /* Free playlist now, all threads are gone */ playlist_t *p_playlist = libvlc_priv (p_libvlc)->p_playlist; if( p_playlist != NULL ) playlist_Destroy( p_playlist ); #if !defined( _WIN32 ) && !defined( __OS2__ ) char *pidfile = var_InheritString( p_libvlc, "pidfile" ); if( pidfile != NULL ) { msg_Dbg( p_libvlc, "removing PID file %s", pidfile ); if( unlink( pidfile ) ) msg_Warn( p_libvlc, "cannot remove PID file %s: %s", pidfile, vlc_strerror_c(errno) ); free( pidfile ); } #endif if (priv->parser != NULL) playlist_preparser_Delete(priv->parser); vlc_DeinitActions( p_libvlc, priv->actions ); /* Save the configuration */ if( !var_InheritBool( p_libvlc, "ignore-config" ) ) config_AutoSaveConfigFile( VLC_OBJECT(p_libvlc) ); /* Free module bank. It is refcounted, so we call this each time */ module_EndBank (true); vlc_LogDeinit (p_libvlc); #if defined(_WIN32) || defined(__OS2__) system_End( ); #endif }
void VlcProc::update_equalizer() { char *pFilters; if( m_pAout ) pFilters = var_GetNonEmptyString( m_pAout, "audio-filter" ); else pFilters = var_InheritString( getIntf(), "audio-filter" ); bool b_equalizer = pFilters && strstr( pFilters, "equalizer" ); free( pFilters ); SET_BOOL( m_cVarEqualizer, b_equalizer ); }
void EventThreadUpdateTitle( event_thread_t *p_event, const char *psz_fallback ) { char *psz_title = var_InheritString( p_event->vd, "video-title" ); if( !psz_title ) psz_title = strdup( psz_fallback ); if( !psz_title ) return; vlc_mutex_lock( &p_event->lock ); free( p_event->psz_title ); p_event->psz_title = psz_title; vlc_mutex_unlock( &p_event->lock ); PostMessage( p_event->hwnd, WM_VLC_CHANGE_TEXT, 0, 0 ); }
/** * It inherits a string as an unsigned rational number (it also accepts basic * float number). * * It returns an error if the rational number cannot be parsed (0/0 is valid). * The rational is already reduced. */ int (var_InheritURational)(vlc_object_t *object, unsigned *num, unsigned *den, const char *var) { /* */ *num = 0; *den = 0; /* */ char *tmp = var_InheritString(object, var); if (!tmp) goto error; char *next; unsigned n = strtol(tmp, &next, 0); unsigned d = strtol(*next ? &next[1] : "0", NULL, 0); if (*next == '.') { /* Interpret as a float number */ double r = us_atof(tmp); double c = ceil(r); if (c >= UINT_MAX) goto error; unsigned m = c; if (m > 0) { d = UINT_MAX / m; n = r * d; } else { n = 0; d = 0; } } else if ( *next == '\0' ) { /* plain integer given */ *num = n; *den = 1; } if (n > 0 && d > 0) vlc_ureduce(num, den, n, d, 0); free(tmp); return VLC_SUCCESS; error: free(tmp); return VLC_EGENERIC; }
bool InputManager::hasVisualisation() { if( !p_input ) return false; audio_output_t *aout = input_GetAout( p_input ); if( !aout ) return false; char *visual = var_InheritString( aout, "visual" ); vlc_object_release( aout ); if( !visual ) return false; free( visual ); return true; }
/***************************************************************************** * Open: initialize interface *****************************************************************************/ static int Open( vlc_object_t *p_this ) { intf_thread_t *p_intf = (intf_thread_t *)p_this; intf_sys_t *p_sys; /* Allocate instance and initialize some members */ p_intf->p_sys = p_sys = malloc( sizeof( intf_sys_t ) ); if( p_sys == NULL ) return VLC_ENOMEM; p_sys->i_fd = lirc_init( "vlc", 1 ); if( p_sys->i_fd == -1 ) { msg_Err( p_intf, "lirc initialisation failed" ); goto error; } /* We want polling */ fcntl( p_sys->i_fd, F_SETFL, fcntl( p_sys->i_fd, F_GETFL ) | O_NONBLOCK ); /* Read the configuration file */ char *psz_file = var_InheritString( p_intf, "lirc-file" ); int val = lirc_readconfig( psz_file, &p_sys->config, NULL ); free( psz_file ); if( val != 0 ) { msg_Err( p_intf, "failure while reading lirc config" ); lirc_deinit(); goto error; } if( vlc_clone( &p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW ) ) { lirc_freeconfig( p_sys->config ); lirc_deinit(); goto error; } return VLC_SUCCESS; error: free( p_sys ); return VLC_EGENERIC; }
void InputManager::UpdateName() { assert( p_input ); /* Update text, name and nowplaying */ QString name; /* Try to get the nowplaying */ char *format = var_InheritString( p_intf, "input-title-format" ); char *formatted = NULL; if (format != NULL) { formatted = str_format_meta( p_input, format ); free( format ); if( formatted != NULL ) { name = qfu(formatted); free( formatted ); } } /* If we have Nothing */ if( name.simplified().isEmpty() ) { char *uri = input_item_GetURI( input_GetItem( p_input ) ); char *file = uri ? strrchr( uri, '/' ) : NULL; if( file != NULL ) { decode_URI( ++file ); name = qfu(file); } else name = qfu(uri); free( uri ); } name = name.trimmed(); if( oldName != name ) { emit nameChanged( name ); oldName = name; } }
int OutOpenAvio(vlc_object_t *object) { sout_access_out_t *access = (sout_access_out_t*)object; config_ChainParse( access, "sout-avio-", ppsz_sout_options, access->p_cfg ); sout_access_out_sys_t *sys = vlc_obj_malloc(object, sizeof(*sys)); if (!sys) return VLC_ENOMEM; sys->context = NULL; /* */ vlc_init_avformat(object); if (!access->psz_path) return VLC_EGENERIC; int ret; AVDictionary *options = NULL; char *psz_opts = var_InheritString(access, "sout-avio-options"); if (psz_opts) { vlc_av_get_options(psz_opts, &options); free(psz_opts); } ret = avio_open2(&sys->context, access->psz_path, AVIO_FLAG_WRITE, NULL, &options); AVDictionaryEntry *t = NULL; while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) msg_Err( access, "unknown option \"%s\"", t->key ); av_dict_free(&options); if (ret < 0) { errno = AVUNERROR(ret); msg_Err(access, "Failed to open %s", access->psz_path); return VLC_EGENERIC; } access->pf_write = Write; access->pf_control = OutControl; access->pf_seek = OutSeek; access->p_sys = sys; return VLC_SUCCESS; }
int DemuxOpen( vlc_object_t *obj ) { demux_t *demux = (demux_t *)obj; demux_sys_t *sys = malloc (sizeof (*sys)); if (unlikely(sys == NULL)) return VLC_ENOMEM; demux->p_sys = sys; #ifdef ZVBI_COMPILED sys->vbi = NULL; #endif ParseMRL( obj, demux->psz_location ); char *path = var_InheritString (obj, CFG_PREFIX"dev"); if (unlikely(path == NULL)) goto error; /* probably OOM */ uint32_t caps; int fd = OpenDevice (obj, path, &caps); free (path); if (fd == -1) goto error; sys->fd = fd; if (InitVideo (demux, fd, caps)) { v4l2_close (fd); goto error; } sys->controls = ControlsInit (VLC_OBJECT(demux), fd); sys->start = mdate (); demux->pf_demux = NULL; demux->pf_control = DemuxControl; demux->info.i_update = 0; demux->info.i_title = 0; demux->info.i_seekpoint = 0; return VLC_SUCCESS; error: free (sys); return VLC_EGENERIC; }
static void ClearSurface(vout_display_t *vd) { vout_display_sys_t *sys = vd->sys; if (sys->p_window->b_opaque) { /* Clear the surface to black with OpenGL ES 2 */ char *modlist = var_InheritString(sys->embed, "gles2"); vlc_gl_t *gl = vlc_gl_Create(vd->cfg, VLC_OPENGL_ES2, modlist); free(modlist); if (gl == NULL) return; if (vlc_gl_MakeCurrent(gl)) goto end; vlc_gl_Resize(gl, 1, 1); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT); vlc_gl_Swap(gl); vlc_gl_ReleaseCurrent(gl); end: vlc_gl_Release(gl); } else { android_window *p_window = sys->p_window; ANativeWindow_Buffer buf; if (sys->anw->setBuffersGeometry(p_window->p_surface, 1, 1, WINDOW_FORMAT_RGB_565) == 0 && sys->anw->winLock(p_window->p_surface, &buf, NULL) == 0) { uint16_t *p_bit = buf.bits; p_bit[0] = 0x0000; sys->anw->unlockAndPost(p_window->p_surface); } } }