static int ParseImageAttachments( decoder_t *p_dec ) { decoder_sys_t *p_sys = p_dec->p_sys; input_attachment_t **pp_attachments; int i_attachments_cnt; int k = 0; if( VLC_SUCCESS != decoder_GetInputAttachments( p_dec, &pp_attachments, &i_attachments_cnt )) return VLC_EGENERIC; for( k = 0; k < i_attachments_cnt; k++ ) { input_attachment_t *p_attach = pp_attachments[k]; vlc_fourcc_t type = image_Mime2Fourcc( p_attach->psz_mime ); if( ( type != 0 ) && ( p_attach->i_data > 0 ) && ( p_attach->p_data != NULL ) ) { picture_t *p_pic = NULL; image_handler_t *p_image; p_image = image_HandlerCreate( p_dec ); if( p_image != NULL ) { block_t *p_block; p_block = block_Alloc( p_attach->i_data ); if( p_block != NULL ) { video_format_t fmt_in; video_format_t fmt_out; memcpy( p_block->p_buffer, p_attach->p_data, p_attach->i_data ); memset( &fmt_in, 0, sizeof( video_format_t)); memset( &fmt_out, 0, sizeof( video_format_t)); fmt_in.i_chroma = type; fmt_out.i_chroma = VLC_CODEC_YUVA; /* Find a suitable decoder module */ if( module_exists( "sdl_image" ) ) { /* ffmpeg thinks it can handle bmp properly but it can't (at least * not all of them), so use sdl_image if it is available */ var_Create( p_dec, "codec", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_SetString( p_dec, "codec", "sdl_image" ); } p_pic = image_Read( p_image, p_block, &fmt_in, &fmt_out ); var_Destroy( p_dec, "codec" ); } image_HandlerDelete( p_image ); } if( p_pic ) { image_attach_t *p_picture = malloc( sizeof(image_attach_t) ); if( p_picture ) { p_picture->psz_filename = strdup( p_attach->psz_name ); p_picture->p_pic = p_pic; TAB_APPEND( (image_attach_t **), p_sys->i_images, p_sys->pp_images, p_picture ); // sunqueen modify } } } vlc_input_attachment_Delete( pp_attachments[ k ] ); }
void vout_IntfInit( vout_thread_t *p_vout ) { vlc_value_t val, text; 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, "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", AutoScaleCallback, NULL ); var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND | VLC_VAR_DOINHERIT ); text.psz_string = _("Zoom"); var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL ); 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 ); var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text ); } 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_DOINHERIT ); text.psz_string = _("Crop"); var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL ); 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_DOINHERIT ); text.psz_string = _("Aspect ratio"); var_Change( p_vout, "aspect-ratio", VLC_VAR_SETTEXT, &text, NULL ); 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", AboveCallback, NULL ); /* Add a variable to indicate if the window should be below all others */ var_Create( p_vout, "video-wallpaper", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_AddCallback( p_vout, "video-wallpaper", WallPaperCallback, (void *)(uintptr_t)VOUT_WINDOW_STATE_BELOW ); /* 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 ); var_Create( p_vout, "sub-text-scale", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); /* 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 ); }
static void VariablesInit( playlist_t *p_playlist ) { /* These variables control updates */ var_Create( p_playlist, "intf-change", VLC_VAR_BOOL ); var_SetBool( p_playlist, "intf-change", true ); var_Create( p_playlist, "item-change", VLC_VAR_ADDRESS ); var_Create( p_playlist, "leaf-to-parent", VLC_VAR_INTEGER ); var_Create( p_playlist, "playlist-item-deleted", VLC_VAR_INTEGER ); var_SetInteger( p_playlist, "playlist-item-deleted", -1 ); var_Create( p_playlist, "playlist-item-append", VLC_VAR_ADDRESS ); var_Create( p_playlist, "input-current", VLC_VAR_ADDRESS ); /* Variables to control playback */ var_Create( p_playlist, "playlist-autostart", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_playlist, "random", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_AddCallback( p_playlist, "random", RandomCallback, NULL ); var_Create( p_playlist, "repeat", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_playlist, "loop", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_playlist, "corks", VLC_VAR_INTEGER ); var_AddCallback( p_playlist, "corks", CorksCallback, NULL ); var_Create( p_playlist, "rate", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); var_AddCallback( p_playlist, "rate", RateCallback, NULL ); var_Create( p_playlist, "rate-slower", VLC_VAR_VOID ); var_AddCallback( p_playlist, "rate-slower", RateOffsetCallback, NULL ); var_Create( p_playlist, "rate-faster", VLC_VAR_VOID ); var_AddCallback( p_playlist, "rate-faster", RateOffsetCallback, NULL ); var_Create( p_playlist, "video-splitter", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_AddCallback( p_playlist, "video-splitter", VideoSplitterCallback, NULL ); /* */ var_Create( p_playlist, "album-art", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_playlist, "metadata-network-access", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); /* Variables to preserve video output parameters */ var_Create( p_playlist, "fullscreen", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_playlist, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_playlist, "video-wallpaper", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); /* Audio output parameters */ var_Create( p_playlist, "mute", VLC_VAR_BOOL ); var_Create( p_playlist, "volume", VLC_VAR_FLOAT ); var_SetFloat( p_playlist, "volume", -1.f ); }
/** This function allocates and initialize the DirectX vout display. */ static int Open(vlc_object_t *object) { vout_display_t *vd = (vout_display_t *)object; vout_display_sys_t *sys; /* Allocate structure */ vd->sys = sys = calloc(1, sizeof(*sys)); if (!sys) return VLC_ENOMEM; /* Load direct draw DLL */ sys->hddraw_dll = LoadLibrary(_T("DDRAW.DLL")); if (!sys->hddraw_dll) { msg_Warn(vd, "DirectXInitDDraw failed loading ddraw.dll"); free(sys); return VLC_EGENERIC; } /* */ sys->use_wallpaper = var_CreateGetBool(vd, "video-wallpaper"); /* FIXME */ sys->use_overlay = false;//var_CreateGetBool(vd, "overlay"); /* FIXME */ sys->restore_overlay = false; var_Create(vd, "directx-device", VLC_VAR_STRING | VLC_VAR_DOINHERIT); /* Initialisation */ if (CommonInit(vd)) goto error; /* */ video_format_t fmt = vd->fmt; if (DirectXOpen(vd, &fmt)) goto error; /* */ vout_display_info_t info = vd->info; info.is_slow = true; info.has_double_click = true; info.has_hide_mouse = false; info.has_pictures_invalid = true; info.has_event_thread = true; /* Interaction TODO support starting with wallpaper mode */ vlc_mutex_init(&sys->lock); sys->ch_wallpaper = sys->use_wallpaper; sys->wallpaper_requested = sys->use_wallpaper; sys->use_wallpaper = false; vlc_value_t val; val.psz_string = _("Wallpaper"); var_Change(vd, "video-wallpaper", VLC_VAR_SETTEXT, &val, NULL); var_AddCallback(vd, "video-wallpaper", WallpaperCallback, NULL); /* Setup vout_display now that everything is fine */ video_format_Clean(&vd->fmt); video_format_Copy(&vd->fmt, &fmt); vd->info = info; vd->pool = Pool; vd->prepare = NULL; vd->display = Display; vd->control = Control; vd->manage = Manage; return VLC_SUCCESS; error: DirectXClose(vd); CommonClean(vd); if (sys->hddraw_dll) FreeLibrary(sys->hddraw_dll); free(sys); return VLC_EGENERIC; }
/***************************************************************************** * Open: open the audio device *****************************************************************************/ static int Start ( audio_output_t *p_aout, audio_sample_format_t *fmt ) { aout_sys_t *p_sys = p_aout->sys; char *psz_mode; ULONG i_kai_mode; KAISPEC ks_wanted, ks_obtained; int i_nb_channels; int i_bytes_per_frame; vlc_value_t val, text; audio_sample_format_t format = *fmt; if( var_Get( p_aout, "audio-device", &val ) != VLC_ENOVAR ) { /* The user has selected an audio device. */ if ( val.i_int == AOUT_VAR_STEREO ) { format.i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT; } else if ( val.i_int == AOUT_VAR_MONO ) { format.i_physical_channels = AOUT_CHAN_CENTER; } } psz_mode = var_InheritString( p_aout, "kai-audio-device" ); if( !psz_mode ) psz_mode = ( char * )ppsz_kai_audio_device[ 0 ]; // "auto" i_kai_mode = KAIM_AUTO; if( strcmp( psz_mode, "dart" ) == 0 ) i_kai_mode = KAIM_DART; else if( strcmp( psz_mode, "uniaud" ) == 0 ) i_kai_mode = KAIM_UNIAUD; msg_Dbg( p_aout, "selected mode = %s", psz_mode ); if( psz_mode != ppsz_kai_audio_device[ 0 ]) free( psz_mode ); i_nb_channels = aout_FormatNbChannels( &format ); if ( i_nb_channels > 2 ) { /* KAI doesn't support more than two channels. */ i_nb_channels = 2; format.i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT; } /* Support s16l only */ format.i_format = VLC_CODEC_S16L; aout_FormatPrepare( &format ); i_bytes_per_frame = format.i_bytes_per_frame; /* Initialize library */ if( kaiInit( i_kai_mode )) { msg_Err( p_aout, "cannot initialize KAI"); return VLC_EGENERIC; } ks_wanted.usDeviceIndex = 0; ks_wanted.ulType = KAIT_PLAY; ks_wanted.ulBitsPerSample = BPS_16; ks_wanted.ulSamplingRate = format.i_rate; ks_wanted.ulDataFormat = MCI_WAVE_FORMAT_PCM; ks_wanted.ulChannels = i_nb_channels; ks_wanted.ulNumBuffers = 2; ks_wanted.ulBufferSize = FRAME_SIZE * i_bytes_per_frame; ks_wanted.fShareable = !var_InheritBool( p_aout, "kai-audio-exclusive-mode"); ks_wanted.pfnCallBack = KaiCallback; ks_wanted.pCallBackData = p_aout; msg_Dbg( p_aout, "requested ulBufferSize = %ld", ks_wanted.ulBufferSize ); /* Open the sound device. */ if( kaiOpen( &ks_wanted, &ks_obtained, &p_sys->hkai )) { msg_Err( p_aout, "cannot open KAI device"); goto exit_kai_done; } msg_Dbg( p_aout, "open in %s mode", ks_obtained.fShareable ? "shareable" : "exclusive" ); msg_Dbg( p_aout, "obtained i_nb_samples = %lu", ks_obtained.ulBufferSize / i_bytes_per_frame ); msg_Dbg( p_aout, "obtained i_bytes_per_frame = %d", format.i_bytes_per_frame ); p_sys->format = *fmt = format; p_aout->time_get = aout_PacketTimeGet; p_aout->play = Play; p_aout->pause = NULL; p_aout->flush = aout_PacketFlush; aout_SoftVolumeStart( p_aout ); aout_PacketInit( p_aout, &p_sys->packet, ks_obtained.ulBufferSize / i_bytes_per_frame, &format ); if ( var_Type( p_aout, "audio-device" ) == 0 ) { /* First launch. */ var_Create( p_aout, "audio-device", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE ); text.psz_string = _("Audio Device"); var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL ); val.i_int = AOUT_VAR_STEREO; text.psz_string = _("Stereo"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); val.i_int = AOUT_VAR_MONO; text.psz_string = _("Mono"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); if ( i_nb_channels == 2 ) { val.i_int = AOUT_VAR_STEREO; } else { val.i_int = AOUT_VAR_MONO; } var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL ); var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL ); } /* Prevent SIG_FPE */ _control87(MCW_EM, MCW_EM); return VLC_SUCCESS; exit_kai_done : kaiDone(); return VLC_EGENERIC; }
static int PAOpenDevice( audio_output_t *p_aout ) { aout_sys_t *p_sys = p_aout->sys; const PaDeviceInfo *p_pdi; PaError i_err; vlc_value_t val, text; int i; /* Initialize portaudio */ i_err = Pa_Initialize(); if( i_err != paNoError ) { msg_Err( p_aout, "Pa_Initialize returned %d : %s", i_err, Pa_GetErrorText( i_err ) ); return VLC_EGENERIC; } p_sys->i_devices = Pa_GetDeviceCount(); if( p_sys->i_devices < 0 ) { i_err = p_sys->i_devices; msg_Err( p_aout, "Pa_GetDeviceCount returned %d : %s", i_err, Pa_GetErrorText( i_err ) ); goto error; } /* Display all devices info */ msg_Dbg( p_aout, "number of devices = %d", p_sys->i_devices ); for( i = 0; i < p_sys->i_devices; i++ ) { p_pdi = Pa_GetDeviceInfo( i ); msg_Dbg( p_aout, "------------------------------------- #%d", i ); msg_Dbg( p_aout, "Name = %s", p_pdi->name ); msg_Dbg( p_aout, "Max Inputs = %d, Max Outputs = %d", p_pdi->maxInputChannels, p_pdi->maxOutputChannels ); } msg_Dbg( p_aout, "-------------------------------------" ); msg_Dbg( p_aout, "requested device is #%d", p_sys->i_device_id ); if( p_sys->i_device_id >= p_sys->i_devices ) { msg_Err( p_aout, "device %d does not exist", p_sys->i_device_id ); goto error; } p_sys->deviceInfo = Pa_GetDeviceInfo( p_sys->i_device_id ); if( p_sys->deviceInfo->maxOutputChannels < 1 ) { msg_Err( p_aout, "no channel available" ); goto error; } if( var_Type( p_aout, "audio-device" ) == 0 ) { var_Create( p_aout, "audio-device", VLC_VAR_INTEGER|VLC_VAR_HASCHOICE); text.psz_string = _("Audio Device"); var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL ); if( p_sys->deviceInfo->maxOutputChannels >= 1 ) { val.i_int = AOUT_VAR_MONO; text.psz_string = _("Mono"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); msg_Dbg( p_aout, "device supports 1 channel" ); } if( p_sys->deviceInfo->maxOutputChannels >= 2 ) { val.i_int = AOUT_VAR_STEREO; text.psz_string = _("Stereo"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL ); var_Set( p_aout, "audio-device", val ); msg_Dbg( p_aout, "device supports 2 channels" ); } if( p_sys->deviceInfo->maxOutputChannels >= 4 ) { val.i_int = AOUT_VAR_2F2R; text.psz_string = _("2 Front 2 Rear"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); msg_Dbg( p_aout, "device supports 4 channels" ); } if( p_sys->deviceInfo->maxOutputChannels >= 5 ) { val.i_int = AOUT_VAR_3F2R; text.psz_string = _("3 Front 2 Rear"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); msg_Dbg( p_aout, "device supports 5 channels" ); } if( p_sys->deviceInfo->maxOutputChannels >= 6 ) { val.i_int = AOUT_VAR_5_1; text.psz_string = _("5.1"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); msg_Dbg( p_aout, "device supports 5.1 channels" ); } var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL ); var_TriggerCallback( p_aout, "intf-change" ); } /* Audio format is paFloat32 (always supported by portaudio v19) */ p_aout->format.i_format = VLC_CODEC_FL32; return VLC_SUCCESS; error: if( ( i_err = Pa_Terminate() ) != paNoError ) { msg_Err( p_aout, "Pa_Terminate returned %d", i_err ); } return VLC_EGENERIC; }
/** * Creates an audio output object and initializes an output module. */ audio_output_t *aout_New (vlc_object_t *parent) { vlc_value_t val, text; audio_output_t *aout = vlc_custom_create (parent, sizeof (aout_instance_t), "audio output"); if (unlikely(aout == NULL)) return NULL; aout_owner_t *owner = aout_owner (aout); vlc_mutex_init (&owner->lock); vlc_mutex_init (&owner->req.lock); vlc_mutex_init (&owner->dev.lock); owner->req.device = (char *)unset_str; owner->req.volume = -1.f; owner->req.mute = -1; vlc_object_set_destructor (aout, aout_Destructor); /* Audio output module callbacks */ var_Create (aout, "volume", VLC_VAR_FLOAT); var_AddCallback (aout, "volume", var_Copy, parent); var_Create (aout, "mute", VLC_VAR_BOOL | VLC_VAR_DOINHERIT); var_AddCallback (aout, "mute", var_Copy, parent); var_Create (aout, "device", VLC_VAR_STRING); aout->event.volume_report = aout_VolumeNotify; aout->event.mute_report = aout_MuteNotify; aout->event.policy_report = aout_PolicyNotify; aout->event.device_report = aout_DeviceNotify; aout->event.hotplug_report = aout_HotplugNotify; aout->event.gain_request = aout_GainNotify; aout->event.restart_request = aout_RestartNotify; /* Audio output module initialization */ aout->start = NULL; aout->stop = NULL; aout->volume_set = NULL; aout->mute_set = NULL; aout->device_select = NULL; owner->module = module_need (aout, "audio output", "$aout", false); if (owner->module == NULL) { msg_Err (aout, "no suitable audio output module"); vlc_object_release (aout); return NULL; } /* * Persistent audio output variables */ module_config_t *cfg; char *str; /* Visualizations */ var_Create (aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE); text.psz_string = _("Visualizations"); var_Change (aout, "visual", VLC_VAR_SETTEXT, &text, NULL); val.psz_string = (char *)""; text.psz_string = _("Disable"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"spectrometer"; text.psz_string = _("Spectrometer"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"scope"; text.psz_string = _("Scope"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"spectrum"; text.psz_string = _("Spectrum"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"vuMeter"; text.psz_string = _("Vu meter"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); /* Look for goom plugin */ if (module_exists ("goom")) { val.psz_string = (char *)"goom"; text.psz_string = (char *)"Goom"; var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); } /* Look for libprojectM plugin */ if (module_exists ("projectm")) { val.psz_string = (char *)"projectm"; text.psz_string = (char*)"projectM"; var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); } /* Look for VSXu plugin */ if (module_exists ("vsxu")) { val.psz_string = (char *)"vsxu"; text.psz_string = (char*)"Vovoid VSXu"; var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); } str = var_GetNonEmptyString (aout, "effect-list"); if (str != NULL) { var_SetString (aout, "visual", str); free (str); } /* Equalizer */ var_Create (aout, "equalizer", VLC_VAR_STRING | VLC_VAR_HASCHOICE); text.psz_string = _("Equalizer"); var_Change (aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL); val.psz_string = (char*)""; text.psz_string = _("Disable"); var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text); cfg = config_FindConfig (VLC_OBJECT(aout), "equalizer-preset"); if (likely(cfg != NULL)) for (unsigned i = 0; i < cfg->list_count; i++) { val.psz_string = cfg->list.psz[i]; text.psz_string = vlc_gettext(cfg->list_text[i]); var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text); } var_Create (aout, "audio-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT); text.psz_string = _("Audio filters"); var_Change (aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL); var_Create (aout, "audio-visual", VLC_VAR_STRING | VLC_VAR_DOINHERIT); text.psz_string = _("Audio visualizations"); var_Change (aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL); /* Replay gain */ var_Create (aout, "audio-replay-gain-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); text.psz_string = _("Replay gain"); var_Change (aout, "audio-replay-gain-mode", VLC_VAR_SETTEXT, &text, NULL); cfg = config_FindConfig (VLC_OBJECT(aout), "audio-replay-gain-mode"); if (likely(cfg != NULL)) for (unsigned i = 0; i < cfg->list_count; i++) { val.psz_string = cfg->list.psz[i]; text.psz_string = vlc_gettext(cfg->list_text[i]); var_Change (aout, "audio-replay-gain-mode", VLC_VAR_ADDCHOICE, &val, &text); } return aout; }
/** * Probes and initializes. */ static int Open (vlc_object_t *obj) { demux_t *demux = (demux_t *)obj; int tp; /* transport protocol */ if (!strcmp (demux->psz_access, "dccp")) tp = IPPROTO_DCCP; else if (!strcmp (demux->psz_access, "rtptcp")) tp = IPPROTO_TCP; else if (!strcmp (demux->psz_access, "rtp")) tp = IPPROTO_UDP; else if (!strcmp (demux->psz_access, "udplite")) tp = IPPROTO_UDPLITE; else return VLC_EGENERIC; char *tmp = strdup (demux->psz_path); char *shost = tmp; if (shost == NULL) return VLC_ENOMEM; char *dhost = strchr (shost, '@'); if (dhost) *dhost++ = '\0'; /* Parses the port numbers */ int sport = 0, dport = 0; sport = extract_port (&shost); if (dhost != NULL) dport = extract_port (&dhost); if (dport == 0) dport = 5004; /* avt-profile-1 port */ int rtcp_dport = var_CreateGetInteger (obj, "rtcp-port"); /* Try to connect */ int fd = -1, rtcp_fd = -1; switch (tp) { case IPPROTO_UDP: case IPPROTO_UDPLITE: fd = net_OpenDgram (obj, dhost, dport, shost, sport, AF_UNSPEC, tp); if (fd == -1) break; if (rtcp_dport > 0) /* XXX: source port is unknown */ rtcp_fd = net_OpenDgram (obj, dhost, rtcp_dport, shost, 0, AF_UNSPEC, tp); break; case IPPROTO_DCCP: #ifndef SOCK_DCCP /* provisional API (FIXME) */ # ifdef __linux__ # define SOCK_DCCP 6 # endif #endif #ifdef SOCK_DCCP var_Create (obj, "dccp-service", VLC_VAR_STRING); var_SetString (obj, "dccp-service", "RTPV"); /* FIXME: RTPA? */ fd = net_Connect (obj, shost, sport, SOCK_DCCP, tp); #else msg_Err (obj, "DCCP support not included"); #endif break; case IPPROTO_TCP: fd = net_Connect (obj, shost, sport, SOCK_STREAM, tp); break; } free (tmp); if (fd == -1) return VLC_EGENERIC; net_SetCSCov (fd, -1, 12); /* Initializes demux */ demux_sys_t *p_sys = malloc (sizeof (*p_sys)); if (p_sys == NULL) { net_Close (fd); if (rtcp_fd != -1) net_Close (rtcp_fd); return VLC_EGENERIC; } vlc_mutex_init (&p_sys->lock); #ifdef HAVE_SRTP p_sys->srtp = NULL; #endif p_sys->fd = fd; p_sys->rtcp_fd = rtcp_fd; p_sys->caching = var_CreateGetInteger (obj, "rtp-caching"); p_sys->max_src = var_CreateGetInteger (obj, "rtp-max-src"); p_sys->timeout = var_CreateGetInteger (obj, "rtp-timeout"); p_sys->max_dropout = var_CreateGetInteger (obj, "rtp-max-dropout"); p_sys->max_misorder = var_CreateGetInteger (obj, "rtp-max-misorder"); p_sys->framed_rtp = (tp == IPPROTO_TCP); demux->pf_demux = NULL; demux->pf_control = Control; demux->p_sys = p_sys; p_sys->session = rtp_session_create (demux); if (p_sys->session == NULL) goto error; #ifdef HAVE_SRTP char *key = var_CreateGetNonEmptyString (demux, "srtp-key"); if (key) { p_sys->srtp = srtp_create (SRTP_ENCR_AES_CM, SRTP_AUTH_HMAC_SHA1, 10, SRTP_PRF_AES_CM, SRTP_RCC_MODE1); if (p_sys->srtp == NULL) { free (key); goto error; } char *salt = var_CreateGetNonEmptyString (demux, "srtp-salt"); errno = srtp_setkeystring (p_sys->srtp, key, salt ? salt : ""); free (salt); free (key); if (errno) { msg_Err (obj, "bad SRTP key/salt combination (%m)"); goto error; } } #endif if (vlc_clone (&p_sys->thread, rtp_thread, demux, VLC_THREAD_PRIORITY_INPUT)) goto error; p_sys->thread_ready = true; return VLC_SUCCESS; error: Close (obj); return VLC_EGENERIC; }
// TODO don't leak shit. static PP_Bool vlc_did_create(PP_Instance instance, uint32_t _argc, const char *_argn[], const char *_argv[]) { vlc_setPPAPI_InitializingInstance(instance); VLC_UNUSED(_argc); VLC_UNUSED(_argn); VLC_UNUSED(_argv); if(vlc_PPAPI_InitializeInstance(instance) != VLC_SUCCESS) { return PP_FALSE; } PP_Bool ret = PP_FALSE; libvlc_instance_t* vlc_inst = NULL; libvlc_media_player_t* media_player = NULL; libvlc_media_list_player_t* media_list_player = NULL; libvlc_media_list_t* playlist = NULL; instance_t* new_inst = add_instance(instance); if(new_inst == NULL) { vlc_ppapi_log_error(instance, "failed to create the plugin instance object!\n"); goto error; } vlc_inst = libvlc_new(0, NULL); if(vlc_inst == NULL) { vlc_ppapi_log_error(instance, "failed to create the vlc instance!\n"); goto error; } else { new_inst->vlc = vlc_inst; } libvlc_log_set(vlc_inst, libvlc_logging_callback, (void*)new_inst); media_player = libvlc_media_player_new(vlc_inst); if(media_player == NULL) { vlc_ppapi_log_error(instance, "libvlc_media_player_t creation failed"); goto error; } else { new_inst->media_player = media_player; } var_Create(media_player, "ppapi-instance", VLC_VAR_INTEGER); var_SetInteger(media_player, "ppapi-instance", instance); var_SetString(media_player, "vout", "ppapi_vout_graphics3d"); if(-1 == libvlc_add_intf(vlc_inst, "ppapi_control")) { vlc_ppapi_log_error(instance, "failed to start `ppapi-control`"); goto error; } ret = PP_TRUE; goto done; error: ret = PP_FALSE; if(new_inst != NULL) { remove_instance(new_inst); } done: vlc_setPPAPI_InitializingInstance(0); return ret; }
/***************************************************************************** * aout_DecNew : create a decoder *****************************************************************************/ static aout_input_t * DecNew( vlc_object_t * p_this, aout_instance_t * p_aout, audio_sample_format_t * p_format ) { aout_input_t * p_input; input_thread_t * p_input_thread; vlc_value_t val; /* We can only be called by the decoder, so no need to lock * p_input->lock. */ vlc_mutex_lock( &p_aout->mixer_lock ); if ( p_aout->i_nb_inputs >= AOUT_MAX_INPUTS ) { msg_Err( p_aout, "too many inputs already (%d)", p_aout->i_nb_inputs ); return NULL; } p_input = malloc(sizeof(aout_input_t)); if ( p_input == NULL ) { msg_Err( p_aout, "out of memory" ); return NULL; } vlc_mutex_init( p_aout, &p_input->lock ); p_input->b_changed = 0; p_input->b_error = 1; aout_FormatPrepare( p_format ); memcpy( &p_input->input, p_format, sizeof(audio_sample_format_t) ); p_aout->pp_inputs[p_aout->i_nb_inputs] = p_input; p_aout->i_nb_inputs++; if ( p_aout->mixer.b_error ) { int i; var_Destroy( p_aout, "audio-device" ); var_Destroy( p_aout, "audio-channels" ); /* Recreate the output using the new format. */ if ( aout_OutputNew( p_aout, p_format ) < 0 ) { for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ ) { vlc_mutex_lock( &p_aout->pp_inputs[i]->lock ); aout_InputDelete( p_aout, p_aout->pp_inputs[i] ); vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock ); } vlc_mutex_unlock( &p_aout->mixer_lock ); return p_input; } /* Create other input streams. */ for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ ) { vlc_mutex_lock( &p_aout->pp_inputs[i]->lock ); aout_InputDelete( p_aout, p_aout->pp_inputs[i] ); aout_InputNew( p_aout, p_aout->pp_inputs[i] ); vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock ); } } else { aout_MixerDelete( p_aout ); } if ( aout_MixerNew( p_aout ) == -1 ) { aout_OutputDelete( p_aout ); vlc_mutex_unlock( &p_aout->mixer_lock ); return NULL; } aout_InputNew( p_aout, p_input ); vlc_mutex_unlock( &p_aout->mixer_lock ); var_Create( p_this, "audio-desync", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Get( p_this, "audio-desync", &val ); p_input->i_desync = val.i_int * 1000; p_input_thread = (input_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_PARENT ); if( p_input_thread ) { p_input->i_pts_delay = p_input_thread->i_pts_delay; p_input->i_pts_delay += p_input->i_desync; vlc_object_release( p_input_thread ); } else { p_input->i_pts_delay = DEFAULT_PTS_DELAY; p_input->i_pts_delay += p_input->i_desync; } return p_input; }
void vout_IntfInit( vout_thread_t *p_vout ) { vlc_value_t val, text, old_val; bool b_force_par = false; char *psz_buf; int i; /* Create a few object variables we'll need later on */ var_Create( p_vout, "snapshot-path", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-prefix", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-format", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-preview", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-sequential", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER ); var_SetInteger( p_vout, "snapshot-num", 1 ); var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); p_vout->i_alignment = var_CreateGetInteger( p_vout, "align" ); var_Create( p_vout, "video-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "video-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_vout, "mouse-hide-timeout", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); p_vout->p->b_title_show = var_CreateGetBool( p_vout, "video-title-show" ); p_vout->p->i_title_timeout = (mtime_t)var_CreateGetInteger( p_vout, "video-title-timeout" ); p_vout->p->i_title_position = var_CreateGetInteger( p_vout, "video-title-position" ); p_vout->p->psz_title = NULL; var_AddCallback( p_vout, "video-title-show", TitleShowCallback, NULL ); var_AddCallback( p_vout, "video-title-timeout", TitleTimeoutCallback, NULL ); var_AddCallback( p_vout, "video-title-position", TitlePositionCallback, NULL ); /* Zoom object var */ var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT ); text.psz_string = _("Zoom"); var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL ); var_Get( p_vout, "zoom", &old_val ); for( i = 0; p_zoom_values[i].f_value; i++ ) { if( old_val.f_float == p_zoom_values[i].f_value ) var_Change( p_vout, "zoom", VLC_VAR_DELCHOICE, &old_val, NULL ); val.f_float = p_zoom_values[i].f_value; text.psz_string = _( p_zoom_values[i].psz_label ); var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text ); } var_Set( p_vout, "zoom", old_val ); /* Is this really needed? */ var_AddCallback( p_vout, "zoom", ZoomCallback, NULL ); /* Crop offset vars */ var_Create( p_vout, "crop-left", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_Create( p_vout, "crop-top", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_Create( p_vout, "crop-right", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_Create( p_vout, "crop-bottom", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ); var_AddCallback( p_vout, "crop-left", CropCallback, NULL ); var_AddCallback( p_vout, "crop-top", CropCallback, NULL ); var_AddCallback( p_vout, "crop-right", CropCallback, NULL ); var_AddCallback( p_vout, "crop-bottom", CropCallback, NULL ); /* Crop object var */ var_Create( p_vout, "crop", VLC_VAR_STRING | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT ); text.psz_string = _("Crop"); var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL ); val.psz_string = (char*)""; var_Change( p_vout, "crop", VLC_VAR_DELCHOICE, &val, 0 ); for( i = 0; p_crop_values[i].psz_value; i++ ) { val.psz_string = (char*)p_crop_values[i].psz_value; text.psz_string = _( p_crop_values[i].psz_label ); var_Change( p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &text ); } /* update triggered every time the vout's crop parameters are changed */ var_Create( p_vout, "crop-update", VLC_VAR_VOID ); /* Add custom crop ratios */ psz_buf = config_GetPsz( p_vout, "custom-crop-ratios" ); AddCustomRatios( p_vout, "crop", psz_buf ); free( psz_buf ); var_AddCallback( p_vout, "crop", CropCallback, NULL ); var_Get( p_vout, "crop", &old_val ); if( old_val.psz_string && *old_val.psz_string ) var_TriggerCallback( p_vout, "crop" ); free( old_val.psz_string ); /* Monitor pixel aspect-ratio */ var_Create( p_vout, "monitor-par", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Get( p_vout, "monitor-par", &val ); if( val.psz_string && *val.psz_string ) { char *psz_parser = strchr( val.psz_string, ':' ); unsigned int i_aspect_num = 0, i_aspect_den = 0; float i_aspect = 0; if( psz_parser ) { i_aspect_num = strtol( val.psz_string, 0, 10 ); i_aspect_den = strtol( ++psz_parser, 0, 10 ); } else { i_aspect = atof( val.psz_string ); vlc_ureduce( &i_aspect_num, &i_aspect_den, i_aspect *VOUT_ASPECT_FACTOR, VOUT_ASPECT_FACTOR, 0 ); } if( !i_aspect_num || !i_aspect_den ) i_aspect_num = i_aspect_den = 1; p_vout->p->i_par_num = i_aspect_num; p_vout->p->i_par_den = i_aspect_den; vlc_ureduce( &p_vout->p->i_par_num, &p_vout->p->i_par_den, p_vout->p->i_par_num, p_vout->p->i_par_den, 0 ); msg_Dbg( p_vout, "overriding monitor pixel aspect-ratio: %i:%i", p_vout->p->i_par_num, p_vout->p->i_par_den ); b_force_par = true; } free( val.psz_string ); /* Aspect-ratio object var */ var_Create( p_vout, "aspect-ratio", VLC_VAR_STRING | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT ); text.psz_string = _("Aspect-ratio"); var_Change( p_vout, "aspect-ratio", VLC_VAR_SETTEXT, &text, NULL ); val.psz_string = (char*)""; var_Change( p_vout, "aspect-ratio", VLC_VAR_DELCHOICE, &val, 0 ); for( i = 0; p_aspect_ratio_values[i].psz_value; i++ ) { val.psz_string = (char*)p_aspect_ratio_values[i].psz_value; text.psz_string = _( p_aspect_ratio_values[i].psz_label ); var_Change( p_vout, "aspect-ratio", VLC_VAR_ADDCHOICE, &val, &text ); } /* Add custom aspect ratios */ psz_buf = config_GetPsz( p_vout, "custom-aspect-ratios" ); AddCustomRatios( p_vout, "aspect-ratio", psz_buf ); free( psz_buf ); var_AddCallback( p_vout, "aspect-ratio", AspectCallback, NULL ); var_Get( p_vout, "aspect-ratio", &old_val ); if( (old_val.psz_string && *old_val.psz_string) || b_force_par ) var_TriggerCallback( p_vout, "aspect-ratio" ); free( old_val.psz_string ); /* Add variables to manage scaling video */ var_Create( p_vout, "autoscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); text.psz_string = _("Autoscale video"); var_Change( p_vout, "autoscale", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "autoscale", ScalingCallback, NULL ); p_vout->b_autoscale = var_GetBool( p_vout, "autoscale" ); var_Create( p_vout, "scale", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); text.psz_string = _("Scale factor"); var_Change( p_vout, "scale", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "scale", ScalingCallback, NULL ); p_vout->i_zoom = (int)( ZOOM_FP_FACTOR * var_GetFloat( p_vout, "scale" ) ); /* Initialize the dimensions of the video window */ InitWindowSize( p_vout, &p_vout->i_window_width, &p_vout->i_window_height ); /* Add a variable to indicate if the window should be on top of others */ var_Create( p_vout, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); text.psz_string = _("Always on top"); var_Change( p_vout, "video-on-top", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "video-on-top", OnTopCallback, NULL ); /* Add a variable to indicate whether we want window decoration or not */ var_Create( p_vout, "video-deco", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); /* Add a fullscreen variable */ if( var_CreateGetBoolCommand( p_vout, "fullscreen" ) ) { /* user requested fullscreen */ p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE; } text.psz_string = _("Fullscreen"); var_Change( p_vout, "fullscreen", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "fullscreen", FullscreenCallback, NULL ); /* Add a snapshot variable */ var_Create( p_vout, "video-snapshot", VLC_VAR_VOID | VLC_VAR_ISCOMMAND ); text.psz_string = _("Snapshot"); var_Change( p_vout, "video-snapshot", VLC_VAR_SETTEXT, &text, NULL ); var_AddCallback( p_vout, "video-snapshot", SnapshotCallback, NULL ); /* Mouse coordinates */ var_Create( p_vout, "mouse-x", VLC_VAR_INTEGER ); var_Create( p_vout, "mouse-y", VLC_VAR_INTEGER ); var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER ); var_Create( p_vout, "mouse-moved", VLC_VAR_BOOL ); var_Create( p_vout, "mouse-clicked", VLC_VAR_BOOL ); var_Create( p_vout, "intf-change", VLC_VAR_BOOL ); var_SetBool( p_vout, "intf-change", true ); }
/** * Initialize a libvlc instance * This function initializes a previously allocated libvlc instance: * - CPU detection * - gettext initialization * - message queue, module bank and playlist initialization * - configuration and commandline parsing */ int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc, const char *ppsz_argv[] ) { libvlc_priv_t *priv = libvlc_priv (p_libvlc); char * psz_modules = NULL; char * psz_parser = NULL; char * psz_control = NULL; playlist_t *p_playlist = NULL; char *psz_val; /* System specific initialization code */ system_Init(); /* Initialize the module bank and load the configuration of the * main module. We need to do this at this stage to be able to display * a short help if required by the user. (short help == main module * options) */ module_InitBank (); /* Get command line options that affect module loading. */ if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, NULL ) ) { module_EndBank (false); return VLC_EGENERIC; } priv->i_verbose = var_InheritInteger( p_libvlc, "verbose" ); /* Find verbosity from VLC_VERBOSE environment variable */ { char *env = getenv( "VLC_VERBOSE" ); if( env != NULL ) priv->i_verbose = atoi( env ); } /* Announce who we are (TODO: only first instance?) */ msg_Dbg( p_libvlc, "VLC media player - %s", VERSION_MESSAGE ); msg_Dbg( p_libvlc, "%s", COPYRIGHT_MESSAGE ); msg_Dbg( p_libvlc, "revision %s", psz_vlc_changeset ); msg_Dbg( p_libvlc, "configured with %s", CONFIGURE_LINE ); vlc_threads_setup (p_libvlc); /* Load the builtins and plugins into the module_bank. * We have to do it before config_Load*() because this also gets the * list of configuration options exported by each module and loads their * default values. */ size_t module_count = module_LoadPlugins (p_libvlc); /* * Override default configuration with config file settings */ if( !var_InheritBool( p_libvlc, "ignore-config" ) ) { if( var_InheritBool( p_libvlc, "reset-config" ) ) config_SaveConfigFile( p_libvlc ); /* Save default config */ else config_LoadConfigFile( p_libvlc ); } /* * Override configuration with command line settings */ int vlc_optind; if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, &vlc_optind ) ) { #ifdef WIN32 MessageBox (NULL, TEXT("The command line options could not be parsed.\n" "Make sure they are valid."), TEXT("VLC media player"), MB_OK|MB_ICONERROR); #endif module_EndBank (true); return VLC_EGENERIC; } priv->i_verbose = var_InheritInteger( p_libvlc, "verbose" ); /* * Support for gettext */ #if defined( ENABLE_NLS ) \ && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) ) vlc_bindtextdomain (PACKAGE_NAME); #endif /*xgettext: Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */ msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") ); if (config_PrintHelp (VLC_OBJECT(p_libvlc))) { module_EndBank (true); return VLC_EEXITSUCCESS; } if( module_count <= 1 ) { msg_Err( p_libvlc, "No plugins found! Check your VLC installation."); module_EndBank (true); return VLC_ENOITEM; } #ifdef HAVE_DAEMON /* Check for daemon mode */ if( var_InheritBool( p_libvlc, "daemon" ) ) { char *psz_pidfile = NULL; if( daemon( 1, 0) != 0 ) { msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" ); module_EndBank (true); return VLC_EEXIT; } b_daemon = true; /* lets check if we need to write the pidfile */ psz_pidfile = var_CreateGetNonEmptyString( p_libvlc, "pidfile" ); if( psz_pidfile != NULL ) { FILE *pidfile; pid_t i_pid = getpid (); msg_Dbg( p_libvlc, "PID is %d, writing it to %s", i_pid, psz_pidfile ); pidfile = vlc_fopen( psz_pidfile,"w" ); if( pidfile != NULL ) { utf8_fprintf( pidfile, "%d", (int)i_pid ); fclose( pidfile ); } else { msg_Err( p_libvlc, "cannot open pid file for writing: %s (%m)", psz_pidfile ); } } free( psz_pidfile ); } #endif /* FIXME: could be replaced by using Unix sockets */ #ifdef HAVE_DBUS #define MPRIS_APPEND "/org/mpris/MediaPlayer2/TrackList/Append" #define MPRIS_BUS_NAME "org.mpris.MediaPlayer2.vlc" #define MPRIS_OBJECT_PATH "/org/mpris/MediaPlayer2" #define MPRIS_TRACKLIST_INTERFACE "org.mpris.MediaPlayer2.TrackList" if( var_InheritBool( p_libvlc, "one-instance" ) || ( var_InheritBool( p_libvlc, "one-instance-when-started-from-file" ) && var_InheritBool( p_libvlc, "started-from-file" ) ) ) { for( int i = vlc_optind; i < i_argc; i++ ) if( ppsz_argv[i][0] == ':' ) { msg_Err( p_libvlc, "item option %s incompatible with single instance", ppsz_argv[i] ); goto dbus_out; } /* Initialise D-Bus interface, check for other instances */ dbus_threads_init_default(); DBusError err; dbus_error_init( &err ); /* connect to the session bus */ DBusConnection *conn = dbus_bus_get( DBUS_BUS_SESSION, &err ); if( conn == NULL ) { msg_Err( p_libvlc, "Failed to connect to D-Bus session daemon: %s", err.message ); dbus_error_free( &err ); goto dbus_out; } /* check if VLC is available on the bus * if not: D-Bus control is not enabled on the other * instance and we can't pass MRLs to it */ /* FIXME: This check is totally brain-dead and buggy. */ if( !dbus_bus_name_has_owner( conn, MPRIS_BUS_NAME, &err ) ) { dbus_connection_unref( conn ); if( dbus_error_is_set( &err ) ) { msg_Err( p_libvlc, "D-Bus error: %s", err.message ); } else msg_Dbg( p_libvlc, "No media player running. Continuing normally." ); dbus_error_free( &err ); goto dbus_out; } const dbus_bool_t play = !var_InheritBool( p_libvlc, "playlist-enqueue" ); msg_Warn( p_libvlc, "media player running. Exiting..."); for( int i = vlc_optind; i < i_argc; i++ ) { DBusMessage *msg = dbus_message_new_method_call( MPRIS_BUS_NAME, MPRIS_OBJECT_PATH, MPRIS_TRACKLIST_INTERFACE, "AddTrack" ); if( unlikely(msg == NULL) ) continue; /* We need to resolve relative paths in this instance */ char *mrl; if( strstr( ppsz_argv[i], "://" ) ) mrl = strdup( ppsz_argv[i] ); else mrl = vlc_path2uri( ppsz_argv[i], NULL ); if( mrl == NULL ) { dbus_message_unref( msg ); continue; } const char *after_track = MPRIS_APPEND; /* append MRLs */ if( !dbus_message_append_args( msg, DBUS_TYPE_STRING, &mrl, DBUS_TYPE_STRING, &after_track, DBUS_TYPE_BOOLEAN, &play, DBUS_TYPE_INVALID ) ) { dbus_message_unref( msg ); msg = NULL; } free( mrl ); if( unlikely(msg == NULL) ) continue; msg_Dbg( p_libvlc, "Adds %s to the running media player", mrl ); /* send message and get a handle for a reply */ DBusMessage *reply = dbus_connection_send_with_reply_and_block( conn, msg, -1, &err ); dbus_message_unref( msg ); if( reply == NULL ) { msg_Err( p_libvlc, "D-Bus error: %s", err.message ); continue; } dbus_message_unref( reply ); } /* we unreference the connection when we've finished with it */ dbus_connection_unref( conn ); exit( 1 ); } #undef MPRIS_APPEND #undef MPRIS_BUS_NAME #undef MPRIS_OBJECT_PATH #undef MPRIS_TRACKLIST_INTERFACE dbus_out: #endif // HAVE_DBUS /* * Message queue options */ /* Last chance to set the verbosity. Once we start interfaces and other * threads, verbosity becomes read-only. */ var_Create( p_libvlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); if( var_InheritBool( p_libvlc, "quiet" ) ) { var_SetInteger( p_libvlc, "verbose", -1 ); priv->i_verbose = -1; } if( priv->b_color ) priv->b_color = var_InheritBool( p_libvlc, "color" ); vlc_CPU_dump( VLC_OBJECT(p_libvlc) ); vlc_object_set_name( p_libvlc, "main" ); priv->b_stats = var_InheritBool( p_libvlc, "stats" ); /* * Initialize hotkey handling */ priv->actions = vlc_InitActions( p_libvlc ); /* Create a variable for showing the fullscreen interface */ var_Create( p_libvlc, "intf-toggle-fscontrol", VLC_VAR_BOOL ); var_SetBool( p_libvlc, "intf-toggle-fscontrol", true ); /* Create a variable for the Boss Key */ var_Create( p_libvlc, "intf-boss", VLC_VAR_VOID ); /* Create a variable for showing the main interface */ var_Create( p_libvlc, "intf-show", VLC_VAR_BOOL ); /* Create a variable for showing the right click menu */ var_Create( p_libvlc, "intf-popupmenu", VLC_VAR_BOOL ); /* variables for signalling creation of new files */ var_Create( p_libvlc, "snapshot-file", VLC_VAR_STRING ); var_Create( p_libvlc, "record-file", VLC_VAR_STRING ); /* some default internal settings */ var_Create( p_libvlc, "window", VLC_VAR_STRING ); var_Create( p_libvlc, "user-agent", VLC_VAR_STRING ); var_SetString( p_libvlc, "user-agent", "(LibVLC "VERSION")" ); /* Initialize playlist and get commandline files */ p_playlist = playlist_Create( VLC_OBJECT(p_libvlc) ); if( !p_playlist ) { msg_Err( p_libvlc, "playlist initialization failed" ); module_EndBank (true); return VLC_EGENERIC; } /* System specific configuration */ system_Configure( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind ); #if defined(MEDIA_LIBRARY) /* Get the ML */ if( var_GetBool( p_libvlc, "load-media-library-on-startup" ) ) { priv->p_ml = ml_Create( VLC_OBJECT( p_libvlc ), NULL ); if( !priv->p_ml ) { msg_Err( p_libvlc, "ML initialization failed" ); return VLC_EGENERIC; } } else { priv->p_ml = NULL; } #endif /* Add service discovery modules */ psz_modules = var_InheritString( p_libvlc, "services-discovery" ); if( psz_modules ) { char *p = psz_modules, *m; while( ( m = strsep( &p, " :," ) ) != NULL ) playlist_ServicesDiscoveryAdd( p_playlist, m ); free( psz_modules ); } #ifdef ENABLE_VLM /* Initialize VLM if vlm-conf is specified */ psz_parser = var_CreateGetNonEmptyString( p_libvlc, "vlm-conf" ); if( psz_parser ) { priv->p_vlm = vlm_New( p_libvlc ); if( !priv->p_vlm ) msg_Err( p_libvlc, "VLM initialization failed" ); } free( psz_parser ); #endif /* * Load background interfaces */ psz_modules = var_CreateGetNonEmptyString( p_libvlc, "extraintf" ); psz_control = var_CreateGetNonEmptyString( p_libvlc, "control" ); if( psz_modules && psz_control ) { char* psz_tmp; if( asprintf( &psz_tmp, "%s:%s", psz_modules, psz_control ) != -1 ) { free( psz_modules ); psz_modules = psz_tmp; } } else if( psz_control ) { free( psz_modules ); psz_modules = strdup( psz_control ); } psz_parser = psz_modules; while ( psz_parser && *psz_parser ) { char *psz_module, *psz_temp; psz_module = psz_parser; psz_parser = strchr( psz_module, ':' ); if ( psz_parser ) { *psz_parser = '\0'; psz_parser++; } if( asprintf( &psz_temp, "%s,none", psz_module ) != -1) { intf_Create( p_libvlc, psz_temp ); free( psz_temp ); } } free( psz_modules ); free( psz_control ); /* * Always load the hotkeys interface if it exists */ intf_Create( p_libvlc, "hotkeys,none" ); if( var_InheritBool( p_libvlc, "file-logging" ) #ifdef HAVE_SYSLOG_H && !var_InheritBool( p_libvlc, "syslog" ) #endif ) { intf_Create( p_libvlc, "logger,none" ); } #ifdef HAVE_SYSLOG_H if( var_InheritBool( p_libvlc, "syslog" ) ) { char *logmode = var_CreateGetNonEmptyString( p_libvlc, "logmode" ); var_SetString( p_libvlc, "logmode", "syslog" ); intf_Create( p_libvlc, "logger,none" ); if( logmode ) { var_SetString( p_libvlc, "logmode", logmode ); free( logmode ); } var_Destroy( p_libvlc, "logmode" ); } #endif if( var_InheritBool( p_libvlc, "network-synchronisation") ) { intf_Create( p_libvlc, "netsync,none" ); } #ifdef __APPLE__ var_Create( p_libvlc, "drawable-view-top", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-view-left", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-view-bottom", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-view-right", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-top", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-left", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-bottom", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-right", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-nsobject", VLC_VAR_ADDRESS ); #endif #if defined (WIN32) || defined (__OS2__) var_Create( p_libvlc, "drawable-hwnd", VLC_VAR_INTEGER ); #endif /* * Get input filenames given as commandline arguments. * We assume that the remaining parameters are filenames * and their input options. */ GetFilenames( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind ); /* * Get --open argument */ psz_val = var_InheritString( p_libvlc, "open" ); if ( psz_val != NULL ) { playlist_AddExt( p_playlist, psz_val, NULL, PLAYLIST_INSERT, 0, -1, 0, NULL, 0, true, pl_Unlocked ); free( psz_val ); } return VLC_SUCCESS; }
/***************************************************************************** * Probe: probe the audio device for available formats and channels *****************************************************************************/ static void Probe( aout_instance_t * p_aout ) { struct aout_sys_t * p_sys = p_aout->output.p_sys; vlc_value_t val, text; int i_format, i_nb_channels; var_Create( p_aout, "audio-device", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE ); text.psz_string = _("Audio Device"); var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL ); /* Test for multi-channel. */ #ifdef SNDCTL_DSP_GETCHANNELMASK if ( aout_FormatNbChannels( &p_aout->output.output ) > 2 ) { /* Check that the device supports this. */ int i_chanmask; /* Reset all. */ i_format = AFMT_S16_NE; if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 || ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 ) { msg_Err( p_aout, "cannot reset OSS audio device" ); var_Destroy( p_aout, "audio-device" ); return; } if ( ioctl( p_sys->i_fd, SNDCTL_DSP_GETCHANNELMASK, &i_chanmask ) == 0 ) { if ( !(i_chanmask & DSP_BIND_FRONT) ) { msg_Err( p_aout, "No front channels ! (%x)", i_chanmask ); return; } if ( (i_chanmask & (DSP_BIND_SURR | DSP_BIND_CENTER_LFE)) && (p_aout->output.output.i_physical_channels == (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE)) ) { val.i_int = AOUT_VAR_5_1; text.psz_string = N_("5.1"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); } if ( (i_chanmask & DSP_BIND_SURR) && (p_aout->output.output.i_physical_channels & (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT)) ) { val.i_int = AOUT_VAR_2F2R; text.psz_string = N_("2 Front 2 Rear"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); } } } #endif /* Reset all. */ i_format = AFMT_S16_NE; if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 || ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 ) { msg_Err( p_aout, "cannot reset OSS audio device" ); var_Destroy( p_aout, "audio-device" ); return; } /* Test for stereo. */ i_nb_channels = 2; if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) >= 0 && i_nb_channels == 2 ) { val.i_int = AOUT_VAR_STEREO; text.psz_string = N_("Stereo"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); } /* Reset all. */ i_format = AFMT_S16_NE; if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 || ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 ) { msg_Err( p_aout, "cannot reset OSS audio device" ); var_Destroy( p_aout, "audio-device" ); return; } /* Test for mono. */ i_nb_channels = 1; if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) >= 0 && i_nb_channels == 1 ) { val.i_int = AOUT_VAR_MONO; text.psz_string = N_("Mono"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); if ( p_aout->output.output.i_physical_channels == AOUT_CHAN_CENTER ) { var_Set( p_aout, "audio-device", val ); } } if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 ) { msg_Err( p_aout, "cannot reset OSS audio device" ); var_Destroy( p_aout, "audio-device" ); return; } /* Test for spdif. */ if ( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) ) { i_format = AFMT_AC3; if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) >= 0 && i_format == AFMT_AC3 ) { val.i_int = AOUT_VAR_SPDIF; text.psz_string = N_("A/52 over S/PDIF"); var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text ); if( config_GetInt( p_aout, "spdif" ) ) var_Set( p_aout, "audio-device", val ); } else if( config_GetInt( p_aout, "spdif" ) ) { msg_Warn( p_aout, "s/pdif not supported by card" ); } } var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL ); }
/***************************************************************************** * 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; vlc_object_t *p_libvlc = VLC_OBJECT( p_this->p_libvlc ); vlc_value_t val; config_ChainParse( p_stream, CFG_PREFIX, ppsz_sout_options, p_stream->p_cfg ); p_sys = malloc( sizeof( sout_stream_sys_t ) ); if( !p_sys ) return VLC_ENOMEM; p_stream->p_sys = p_sys; p_sys->b_inited = false; var_Create( p_libvlc, "mosaic-lock", VLC_VAR_MUTEX ); var_Get( p_libvlc, "mosaic-lock", &val ); p_sys->p_lock = val.p_address; p_sys->psz_id = var_CreateGetString( p_stream, CFG_PREFIX "id" ); p_sys->i_height = var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "height" ); var_AddCallback( p_stream, CFG_PREFIX "height", HeightCallback, p_stream ); p_sys->i_width = var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "width" ); var_AddCallback( p_stream, CFG_PREFIX "width", WidthCallback, p_stream ); var_Get( p_stream, CFG_PREFIX "sar", &val ); if( val.psz_string ) { char *psz_parser = strchr( val.psz_string, ':' ); if( psz_parser ) { *psz_parser++ = '\0'; p_sys->i_sar_num = atoi( val.psz_string ); p_sys->i_sar_den = atoi( psz_parser ); vlc_ureduce( &p_sys->i_sar_num, &p_sys->i_sar_den, p_sys->i_sar_num, p_sys->i_sar_den, 0 ); } else { msg_Warn( p_stream, "bad aspect ratio %s", val.psz_string ); p_sys->i_sar_num = p_sys->i_sar_den = 1; } free( val.psz_string ); } else { p_sys->i_sar_num = p_sys->i_sar_den = 1; } p_sys->i_chroma = 0; val.psz_string = var_GetNonEmptyString( p_stream, CFG_PREFIX "chroma" ); if( val.psz_string && strlen( val.psz_string ) >= 4 ) { memcpy( &p_sys->i_chroma, val.psz_string, 4 ); msg_Dbg( p_stream, "Forcing image chroma to 0x%.8x (%4.4s)", p_sys->i_chroma, (char*)&p_sys->i_chroma ); } free( val.psz_string ); #define INT_COMMAND( a ) do { \ var_Create( p_stream, CFG_PREFIX #a, \ VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); \ var_AddCallback( p_stream, CFG_PREFIX #a, a ## Callback, \ p_stream ); } while(0) INT_COMMAND( alpha ); INT_COMMAND( x ); INT_COMMAND( y ); #undef INT_COMMAND p_stream->pf_add = Add; p_stream->pf_del = Del; p_stream->pf_send = Send; p_stream->p_sout->i_out_pace_nocontrol++; return VLC_SUCCESS; }
static sout_stream_id_t * Add( sout_stream_t *p_stream, es_format_t *p_fmt ) { sout_stream_sys_t *p_sys = p_stream->p_sys; bridge_t *p_bridge; bridged_es_t *p_es; char *psz_chain; int i; if( p_sys->b_inited || p_fmt->i_cat != VIDEO_ES ) return NULL; /* Create decoder object */ p_sys->p_decoder = (decoder_t *)vlc_object_create( p_stream, sizeof( decoder_t ) ); // sunqueen modify if( !p_sys->p_decoder ) return NULL; p_sys->p_decoder->p_module = NULL; p_sys->p_decoder->fmt_in = *p_fmt; p_sys->p_decoder->b_pace_control = false; p_sys->p_decoder->fmt_out = p_sys->p_decoder->fmt_in; p_sys->p_decoder->fmt_out.i_extra = 0; p_sys->p_decoder->fmt_out.p_extra = 0; p_sys->p_decoder->pf_decode_video = 0; p_sys->p_decoder->pf_vout_buffer_new = video_new_buffer_decoder; p_sys->p_decoder->pf_vout_buffer_del = video_del_buffer_decoder; p_sys->p_decoder->pf_picture_link = video_link_picture_decoder; p_sys->p_decoder->pf_picture_unlink = video_unlink_picture_decoder; p_sys->p_decoder->p_owner = (decoder_owner_sys_t *)malloc( sizeof(decoder_owner_sys_t) ); // sunqueen modify if( !p_sys->p_decoder->p_owner ) { vlc_object_release( p_sys->p_decoder ); return NULL; } p_sys->p_decoder->p_owner->video = p_fmt->video; //p_sys->p_decoder->p_cfg = p_sys->p_video_cfg; p_sys->p_decoder->p_module = module_need( p_sys->p_decoder, "decoder", "$codec", false ); if( !p_sys->p_decoder->p_module || !p_sys->p_decoder->pf_decode_video ) { if( p_sys->p_decoder->p_module ) { msg_Err( p_stream, "instanciated a non video decoder" ); module_unneed( p_sys->p_decoder, p_sys->p_decoder->p_module ); } else { msg_Err( p_stream, "cannot find decoder" ); } free( p_sys->p_decoder->p_owner ); vlc_object_release( p_sys->p_decoder ); return NULL; } p_sys->b_inited = true; vlc_global_lock( VLC_MOSAIC_MUTEX ); p_bridge = GetBridge( p_stream ); if ( p_bridge == NULL ) { vlc_object_t *p_libvlc = VLC_OBJECT( p_stream->p_libvlc ); vlc_value_t val; p_bridge = (bridge_t *)xmalloc( sizeof( bridge_t ) ); // sunqueen modify var_Create( p_libvlc, "mosaic-struct", VLC_VAR_ADDRESS ); val.p_address = p_bridge; var_Set( p_libvlc, "mosaic-struct", val ); p_bridge->i_es_num = 0; p_bridge->pp_es = NULL; } for ( i = 0; i < p_bridge->i_es_num; i++ ) { if ( p_bridge->pp_es[i]->b_empty ) break; } if ( i == p_bridge->i_es_num ) { p_bridge->pp_es = (bridged_es_t **)xrealloc( p_bridge->pp_es, // sunqueen modify (p_bridge->i_es_num + 1) * sizeof(bridged_es_t *) ); p_bridge->i_es_num++; p_bridge->pp_es[i] = (bridged_es_t *)xmalloc( sizeof(bridged_es_t) ); // sunqueen modify } p_sys->p_es = p_es = p_bridge->pp_es[i]; p_es->i_alpha = var_GetInteger( p_stream, CFG_PREFIX "alpha" ); p_es->i_x = var_GetInteger( p_stream, CFG_PREFIX "x" ); p_es->i_y = var_GetInteger( p_stream, CFG_PREFIX "y" ); //p_es->fmt = *p_fmt; p_es->psz_id = p_sys->psz_id; p_es->p_picture = NULL; p_es->pp_last = &p_es->p_picture; p_es->b_empty = false; vlc_global_unlock( VLC_MOSAIC_MUTEX ); if ( p_sys->i_height || p_sys->i_width ) { p_sys->p_image = image_HandlerCreate( p_stream ); } else { p_sys->p_image = NULL; } msg_Dbg( p_stream, "mosaic bridge id=%s pos=%d", p_es->psz_id, i ); /* Create user specified video filters */ psz_chain = var_GetNonEmptyString( p_stream, CFG_PREFIX "vfilter" ); msg_Dbg( p_stream, "psz_chain: %s", psz_chain ); if( psz_chain ) { p_sys->p_vf2 = filter_chain_New( p_stream, "video filter2", false, video_filter_buffer_allocation_init, NULL, p_sys->p_decoder->p_owner ); es_format_t fmt; es_format_Copy( &fmt, &p_sys->p_decoder->fmt_out ); if( p_sys->i_chroma ) fmt.video.i_chroma = p_sys->i_chroma; filter_chain_Reset( p_sys->p_vf2, &fmt, &fmt ); filter_chain_AppendFromString( p_sys->p_vf2, psz_chain ); free( psz_chain ); } else { p_sys->p_vf2 = NULL; } return (sout_stream_id_t *)p_sys; }
static int EqzInit( filter_t *p_filter, int i_rate ) { filter_sys_t *p_sys = p_filter->p_sys; const eqz_config_t *p_cfg; int i, ch; vlc_value_t val1, val2, val3; vlc_object_t *p_aout = p_filter->p_parent; int i_ret = VLC_ENOMEM; /* Select the config */ if( i_rate == 48000 ) { p_cfg = &eqz_config_48000_10b; } else if( i_rate == 44100 ) { p_cfg = &eqz_config_44100_10b; } else { /* TODO compute the coeffs on the fly */ msg_Err( p_filter, "rate not supported" ); return VLC_EGENERIC; } /* Create the static filter config */ p_sys->i_band = p_cfg->i_band; p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) ); p_sys->f_beta = malloc( p_sys->i_band * sizeof(float) ); p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) ); if( !p_sys->f_alpha || !p_sys->f_beta || !p_sys->f_gamma ) goto error; for( i = 0; i < p_sys->i_band; i++ ) { p_sys->f_alpha[i] = p_cfg->band[i].f_alpha; p_sys->f_beta[i] = p_cfg->band[i].f_beta; p_sys->f_gamma[i] = p_cfg->band[i].f_gamma; } /* Filter dyn config */ p_sys->b_2eqz = false; p_sys->f_gamp = 1.0; p_sys->f_amp = malloc( p_sys->i_band * sizeof(float) ); if( !p_sys->f_amp ) goto error; for( i = 0; i < p_sys->i_band; i++ ) { p_sys->f_amp[i] = 0.0; } /* Filter state */ for( ch = 0; ch < 32; ch++ ) { p_sys->x[ch][0] = p_sys->x[ch][1] = p_sys->x2[ch][0] = p_sys->x2[ch][1] = 0.0; for( i = 0; i < p_sys->i_band; i++ ) { p_sys->y[ch][i][0] = p_sys->y[ch][i][1] = p_sys->y2[ch][i][0] = p_sys->y2[ch][i][1] = 0.0; } } var_Create( p_aout, "equalizer-bands", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_aout, "equalizer-preset", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" ); var_Create( p_aout, "equalizer-preamp", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); /* Get initial values */ var_Get( p_aout, "equalizer-preset", &val1 ); var_Get( p_aout, "equalizer-bands", &val2 ); var_Get( p_aout, "equalizer-preamp", &val3 ); p_sys->b_first = true; PresetCallback( VLC_OBJECT( p_aout ), NULL, val1, val1, p_sys ); BandsCallback( VLC_OBJECT( p_aout ), NULL, val2, val2, p_sys ); PreampCallback( VLC_OBJECT( p_aout ), NULL, val3, val3, p_sys ); p_sys->b_first = false; free( val1.psz_string ); /* Register preset bands (for intf) if : */ /* We have no bands info --> the preset info must be given to the intf */ /* or The bands info matches the preset */ if (p_sys->psz_newbands == NULL) { msg_Err(p_filter, "No preset selected"); free( val2.psz_string ); free( p_sys->f_amp ); i_ret = VLC_EGENERIC; goto error; } if( ( *(val2.psz_string) && strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string ) { var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands ); if( p_sys->f_newpreamp == p_sys->f_gamp ) var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp ); } free( val2.psz_string ); /* Add our own callbacks */ var_AddCallback( p_aout, "equalizer-preset", PresetCallback, p_sys ); var_AddCallback( p_aout, "equalizer-bands", BandsCallback, p_sys ); var_AddCallback( p_aout, "equalizer-preamp", PreampCallback, p_sys ); var_AddCallback( p_aout, "equalizer-2pass", TwoPassCallback, p_sys ); msg_Dbg( p_filter, "equalizer loaded for %d Hz with %d bands %d pass", i_rate, p_sys->i_band, p_sys->b_2eqz ? 2 : 1 ); for( i = 0; i < p_sys->i_band; i++ ) { msg_Dbg( p_filter, " %d Hz -> factor:%f alpha:%f beta:%f gamma:%f", (int)p_cfg->band[i].f_frequency, p_sys->f_amp[i], p_sys->f_alpha[i], p_sys->f_beta[i], p_sys->f_gamma[i]); } return VLC_SUCCESS; error: free( p_sys->f_alpha ); free( p_sys->f_beta ); free( p_sys->f_gamma ); return i_ret; }
/** * ProjectM update thread which do the rendering * @param p_this: the p_thread object */ static void *Thread( void *p_data ) { filter_t *p_filter = (filter_t*)p_data; filter_sys_t *p_sys = p_filter->p_sys; video_format_t fmt; vlc_gl_t *gl; unsigned int i_last_width = 0; unsigned int i_last_height = 0; locale_t loc; locale_t oldloc; projectM *p_projectm; #ifndef HAVE_PROJECTM2 char *psz_config; #else char *psz_preset_path; char *psz_title_font; char *psz_menu_font; projectM::Settings settings; #endif vlc_savecancel(); /* Create the openGL provider */ p_sys->p_vout = (vout_thread_t *)vlc_object_create( p_filter, sizeof(vout_thread_t) ); if( !p_sys->p_vout ) goto error; /* */ video_format_Init( &fmt, 0 ); video_format_Setup( &fmt, VLC_CODEC_RGB32, p_sys->i_width, p_sys->i_height, 0, 1 ); fmt.i_sar_num = 1; fmt.i_sar_den = 1; vout_display_state_t state; memset( &state, 0, sizeof(state) ); state.cfg.display.sar.num = 1; state.cfg.display.sar.den = 1; state.cfg.is_display_filled = true; state.cfg.zoom.num = 1; state.cfg.zoom.den = 1; state.sar.num = 1; state.sar.den = 1; p_sys->p_vd = vout_NewDisplay( p_sys->p_vout, &fmt, &state, "opengl", 300000, 1000000 ); if( !p_sys->p_vd ) { vlc_object_release( p_sys->p_vout ); goto error; } var_Create( p_sys->p_vout, "fullscreen", VLC_VAR_BOOL ); var_AddCallback( p_sys->p_vout, "fullscreen", VoutCallback, p_sys->p_vd ); gl = vout_GetDisplayOpengl( p_sys->p_vd ); if( !gl ) { var_DelCallback( p_sys->p_vout, "fullscreen", VoutCallback, p_sys->p_vd ); vout_DeleteDisplay( p_sys->p_vd, NULL ); vlc_object_release( p_sys->p_vout ); goto error; } /* Work-around the projectM locale bug */ loc = newlocale (LC_NUMERIC_MASK, "C", NULL); oldloc = uselocale (loc); /* Create the projectM object */ #ifndef HAVE_PROJECTM2 psz_config = var_InheritString( p_filter, "projectm-config" ); p_projectm = new projectM( psz_config ); free( psz_config ); #else psz_preset_path = var_InheritString( p_filter, "projectm-preset-path" ); #ifdef _WIN32 if ( psz_preset_path == NULL ) { char *psz_data_path = config_GetDataDir(); asprintf( &psz_preset_path, "%s" DIR_SEP "visualization", psz_data_path ); free( psz_data_path ); } #endif psz_title_font = var_InheritString( p_filter, "projectm-title-font" ); psz_menu_font = var_InheritString( p_filter, "projectm-menu-font" ); settings.meshX = var_InheritInteger( p_filter, "projectm-meshx" ); settings.meshY = var_InheritInteger( p_filter, "projectm-meshy" ); settings.fps = 35; settings.textureSize = var_InheritInteger( p_filter, "projectm-texture-size" ); settings.windowWidth = p_sys->i_width; settings.windowHeight = p_sys->i_height; settings.presetURL = psz_preset_path; settings.titleFontURL = psz_title_font; settings.menuFontURL = psz_menu_font; settings.smoothPresetDuration = 5; settings.presetDuration = 30; settings.beatSensitivity = 10; settings.aspectCorrection = 1; settings.easterEgg = 1; settings.shuffleEnabled = 1; p_projectm = new projectM( settings ); free( psz_menu_font ); free( psz_title_font ); free( psz_preset_path ); #endif /* HAVE_PROJECTM2 */ p_sys->i_buffer_size = p_projectm->pcm()->maxsamples; p_sys->p_buffer = (float*)calloc( p_sys->i_buffer_size, sizeof( float ) ); vlc_sem_post( &p_sys->ready ); /* Choose a preset randomly or projectM will always show the first one */ if ( p_projectm->getPlaylistSize() > 0 ) p_projectm->selectPreset( (unsigned)vlc_mrand48() % p_projectm->getPlaylistSize() ); /* */ for( ;; ) { const mtime_t i_deadline = mdate() + CLOCK_FREQ / 50; /* 50 fps max */ /* Manage the events */ vout_ManageDisplay( p_sys->p_vd, true ); if( p_sys->p_vd->cfg->display.width != i_last_width || p_sys->p_vd->cfg->display.height != i_last_height ) { /* FIXME it is not perfect as we will have black bands */ vout_display_place_t place; vout_display_PlacePicture( &place, &p_sys->p_vd->source, p_sys->p_vd->cfg, false ); p_projectm->projectM_resetGL( place.width, place.height ); i_last_width = p_sys->p_vd->cfg->display.width; i_last_height = p_sys->p_vd->cfg->display.height; } /* Render the image and swap the buffers */ vlc_mutex_lock( &p_sys->lock ); if( p_sys->i_nb_samples > 0 ) { p_projectm->pcm()->addPCMfloat( p_sys->p_buffer, p_sys->i_nb_samples ); p_sys->i_nb_samples = 0; } if( p_sys->b_quit ) { vlc_mutex_unlock( &p_sys->lock ); delete p_projectm; var_DelCallback( p_sys->p_vout, "fullscreen", VoutCallback, p_sys->p_vd ); vout_DeleteDisplay( p_sys->p_vd, NULL ); vlc_object_release( p_sys->p_vout ); if (loc != (locale_t)0) { uselocale (oldloc); freelocale (loc); } return NULL; } vlc_mutex_unlock( &p_sys->lock ); p_projectm->renderFrame(); /* */ mwait( i_deadline ); if( !vlc_gl_Lock(gl) ) { vlc_gl_Swap( gl ); vlc_gl_Unlock( gl ); } } abort(); error: p_sys->b_error = true; vlc_sem_post( &p_sys->ready ); return NULL; }
/***************************************************************************** * aout_New: initialize aout structure *****************************************************************************/ audio_output_t *aout_New( vlc_object_t * p_parent ) { audio_output_t *aout = vlc_custom_create (p_parent, sizeof (aout_instance_t), "audio output"); if (unlikely(aout == NULL)) return NULL; aout_owner_t *owner = aout_owner (aout); vlc_mutex_init (&owner->lock); owner->module = NULL; owner->input = NULL; vlc_mutex_init (&owner->volume.lock); owner->volume.multiplier = 1.0; owner->volume.mixer = NULL; aout->pf_play = aout_DecDeleteBuffer; aout_VolumeNoneInit (aout); vlc_object_set_destructor (aout, aout_Destructor); /* * Persistent audio output variables */ vlc_value_t val, text; char *str; var_Create (aout, "intf-change", VLC_VAR_VOID); /* Visualizations */ var_Create (aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE); text.psz_string = _("Visualizations"); var_Change (aout, "visual", VLC_VAR_SETTEXT, &text, NULL); val.psz_string = (char *)""; text.psz_string = _("Disable"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"spectrometer"; text.psz_string = _("Spectrometer"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"scope"; text.psz_string = _("Scope"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"spectrum"; text.psz_string = _("Spectrum"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); val.psz_string = (char *)"vuMeter"; text.psz_string = _("Vu meter"); var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); /* Look for goom plugin */ if (module_exists ("goom")) { val.psz_string = (char *)"goom"; text.psz_string = (char *)"Goom"; var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); } /* Look for libprojectM plugin */ if (module_exists ("projectm")) { val.psz_string = (char *)"projectm"; text.psz_string = (char*)"projectM"; var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text); } str = var_GetNonEmptyString (aout, "effect-list"); if (str != NULL) { var_SetString (aout, "visual", str); free (str); } /* Equalizer */ var_Create (aout, "equalizer", VLC_VAR_STRING | VLC_VAR_HASCHOICE); text.psz_string = _("Equalizer"); var_Change (aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL); val.psz_string = (char*)""; text.psz_string = _("Disable"); var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text); { module_config_t *cfg = config_FindConfig (VLC_OBJECT(aout), "equalizer-preset"); if (cfg != NULL) for (int i = 0; i < cfg->i_list; i++) { val.psz_string = (char *)cfg->ppsz_list[i]; text.psz_string = (char *)cfg->ppsz_list_text[i]; var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text); } } var_Create (aout, "audio-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT); text.psz_string = _("Audio filters"); var_Change (aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL); var_Create (aout, "audio-visual", VLC_VAR_STRING | VLC_VAR_DOINHERIT); text.psz_string = _("Audio visualizations"); var_Change (aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL); /* Replay gain */ var_Create (aout, "audio-replay-gain-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); text.psz_string = _("Replay gain"); var_Change (aout, "audio-replay-gain-mode", VLC_VAR_SETTEXT, &text, NULL); { module_config_t *cfg = config_FindConfig (VLC_OBJECT(aout), "audio-replay-gain-mode"); if( cfg != NULL ) for (int i = 0; i < cfg->i_list; i++) { val.psz_string = (char *)cfg->ppsz_list[i]; text.psz_string = (char *)cfg->ppsz_list_text[i]; var_Change (aout, "audio-replay-gain-mode", VLC_VAR_ADDCHOICE, &val, &text); } } return aout; }
/** * Initialize a libvlc instance * This function initializes a previously allocated libvlc instance: * - CPU detection * - gettext initialization * - message queue, module bank and playlist initialization * - configuration and commandline parsing */ int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc, const char *ppsz_argv[] ) { libvlc_priv_t *priv = libvlc_priv (p_libvlc); char * psz_modules = NULL; char * psz_parser = NULL; char * psz_control = NULL; char *psz_val; /* System specific initialization code */ system_Init(); /* Initialize the module bank and load the configuration of the * core module. We need to do this at this stage to be able to display * a short help if required by the user. (short help == core module * options) */ module_InitBank (); /* Get command line options that affect module loading. */ if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, NULL ) ) { module_EndBank (false); return VLC_EGENERIC; } vlc_LogInit (p_libvlc); vlc_threads_setup (p_libvlc); /* Load the builtins and plugins into the module_bank. * We have to do it before config_Load*() because this also gets the * list of configuration options exported by each module and loads their * default values. */ size_t module_count = module_LoadPlugins (p_libvlc); /* * Override default configuration with config file settings */ if( !var_InheritBool( p_libvlc, "ignore-config" ) ) { if( var_InheritBool( p_libvlc, "reset-config" ) ) config_SaveConfigFile( p_libvlc ); /* Save default config */ else config_LoadConfigFile( p_libvlc ); } /* * Override configuration with command line settings */ int vlc_optind; if( config_LoadCmdLine( p_libvlc, i_argc, ppsz_argv, &vlc_optind ) ) { module_EndBank (true); vlc_LogDeinit (p_libvlc); return VLC_EGENERIC; } /* * Support for gettext */ #if defined( ENABLE_NLS ) \ && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) ) vlc_bindtextdomain (PACKAGE_NAME); #endif /*xgettext: Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */ msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") ); if (config_PrintHelp (VLC_OBJECT(p_libvlc))) { module_EndBank (true); exit(0); } if( module_count <= 1 ) { msg_Err( p_libvlc, "No plugins found! Check your VLC installation."); module_EndBank (true); vlc_LogDeinit (p_libvlc); return VLC_ENOMOD; } #ifdef HAVE_DAEMON /* Check for daemon mode */ if( var_InheritBool( p_libvlc, "daemon" ) ) { if( daemon( 1, 0) != 0 ) { msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" ); module_EndBank (true); vlc_LogDeinit (p_libvlc); return VLC_ENOMEM; } /* lets check if we need to write the pidfile */ char *pidfile = var_InheritString( p_libvlc, "pidfile" ); if( pidfile != NULL ) { FILE *stream = vlc_fopen( pidfile, "w" ); if( stream != NULL ) { fprintf( stream, "%d", (int)getpid() ); fclose( stream ); msg_Dbg( p_libvlc, "written PID file %s", pidfile ); } else msg_Err( p_libvlc, "cannot write PID file %s: %s", pidfile, vlc_strerror_c(errno) ); free( pidfile ); } } else { var_Create( p_libvlc, "pidfile", VLC_VAR_STRING ); var_SetString( p_libvlc, "pidfile", "" ); } #endif /* FIXME: could be replaced by using Unix sockets */ #ifdef HAVE_DBUS #define MPRIS_APPEND "/org/mpris/MediaPlayer2/TrackList/Append" #define MPRIS_BUS_NAME "org.mpris.MediaPlayer2.vlc" #define MPRIS_OBJECT_PATH "/org/mpris/MediaPlayer2" #define MPRIS_TRACKLIST_INTERFACE "org.mpris.MediaPlayer2.TrackList" if( var_InheritBool( p_libvlc, "one-instance" ) || ( var_InheritBool( p_libvlc, "one-instance-when-started-from-file" ) && var_InheritBool( p_libvlc, "started-from-file" ) ) ) { for( int i = vlc_optind; i < i_argc; i++ ) if( ppsz_argv[i][0] == ':' ) { msg_Err( p_libvlc, "item option %s incompatible with single instance", ppsz_argv[i] ); goto dbus_out; } /* Initialise D-Bus interface, check for other instances */ dbus_threads_init_default(); DBusError err; dbus_error_init( &err ); /* connect to the session bus */ DBusConnection *conn = dbus_bus_get( DBUS_BUS_SESSION, &err ); if( conn == NULL ) { msg_Err( p_libvlc, "Failed to connect to D-Bus session daemon: %s", err.message ); dbus_error_free( &err ); goto dbus_out; } /* check if VLC is available on the bus * if not: D-Bus control is not enabled on the other * instance and we can't pass MRLs to it */ /* FIXME: This check is totally brain-dead and buggy. */ if( !dbus_bus_name_has_owner( conn, MPRIS_BUS_NAME, &err ) ) { dbus_connection_unref( conn ); if( dbus_error_is_set( &err ) ) { msg_Err( p_libvlc, "D-Bus error: %s", err.message ); } else msg_Dbg( p_libvlc, "No media player running. Continuing normally." ); dbus_error_free( &err ); goto dbus_out; } const dbus_bool_t play = !var_InheritBool( p_libvlc, "playlist-enqueue" ); msg_Warn( p_libvlc, "media player running. Exiting..."); for( int i = vlc_optind; i < i_argc; i++ ) { DBusMessage *msg = dbus_message_new_method_call( MPRIS_BUS_NAME, MPRIS_OBJECT_PATH, MPRIS_TRACKLIST_INTERFACE, "AddTrack" ); if( unlikely(msg == NULL) ) continue; /* We need to resolve relative paths in this instance */ char *mrl; if( strstr( ppsz_argv[i], "://" ) ) mrl = strdup( ppsz_argv[i] ); else mrl = vlc_path2uri( ppsz_argv[i], NULL ); if( mrl == NULL ) { dbus_message_unref( msg ); continue; } const char *after_track = MPRIS_APPEND; /* append MRLs */ if( !dbus_message_append_args( msg, DBUS_TYPE_STRING, &mrl, DBUS_TYPE_OBJECT_PATH, &after_track, DBUS_TYPE_BOOLEAN, &play, DBUS_TYPE_INVALID ) ) { dbus_message_unref( msg ); msg = NULL; free( mrl ); continue; } msg_Dbg( p_libvlc, "Adds %s to the running media player", mrl ); free( mrl ); /* send message and get a handle for a reply */ DBusMessage *reply = dbus_connection_send_with_reply_and_block( conn, msg, -1, &err ); dbus_message_unref( msg ); if( reply == NULL ) { msg_Err( p_libvlc, "D-Bus error: %s", err.message ); continue; } dbus_message_unref( reply ); } /* we unreference the connection when we've finished with it */ dbus_connection_unref( conn ); exit( 1 ); } #undef MPRIS_APPEND #undef MPRIS_BUS_NAME #undef MPRIS_OBJECT_PATH #undef MPRIS_TRACKLIST_INTERFACE dbus_out: #endif // HAVE_DBUS vlc_CPU_dump( VLC_OBJECT(p_libvlc) ); priv->b_stats = var_InheritBool( p_libvlc, "stats" ); /* * Initialize hotkey handling */ priv->actions = vlc_InitActions( p_libvlc ); /* * Meta data handling */ priv->parser = playlist_preparser_New(VLC_OBJECT(p_libvlc)); /* Create a variable for showing the fullscreen interface */ var_Create( p_libvlc, "intf-toggle-fscontrol", VLC_VAR_BOOL ); var_SetBool( p_libvlc, "intf-toggle-fscontrol", true ); /* Create a variable for the Boss Key */ var_Create( p_libvlc, "intf-boss", VLC_VAR_VOID ); /* Create a variable for showing the main interface */ var_Create( p_libvlc, "intf-show", VLC_VAR_BOOL ); /* Create a variable for showing the right click menu */ var_Create( p_libvlc, "intf-popupmenu", VLC_VAR_BOOL ); /* variables for signalling creation of new files */ var_Create( p_libvlc, "snapshot-file", VLC_VAR_STRING ); var_Create( p_libvlc, "record-file", VLC_VAR_STRING ); /* some default internal settings */ var_Create( p_libvlc, "window", VLC_VAR_STRING ); /* NOTE: Because the playlist and interfaces start before this function * returns control to the application (DESIGN BUG!), all these variables * must be created (in place of libvlc_new()) and set to VLC defaults * (in place of VLC main()) *here*. */ var_Create( p_libvlc, "user-agent", VLC_VAR_STRING ); var_SetString( p_libvlc, "user-agent", "VLC media player (LibVLC "VERSION")" ); var_Create( p_libvlc, "http-user-agent", VLC_VAR_STRING ); var_SetString( p_libvlc, "http-user-agent", "VLC/"PACKAGE_VERSION" LibVLC/"PACKAGE_VERSION ); var_Create( p_libvlc, "app-icon-name", VLC_VAR_STRING ); var_SetString( p_libvlc, "app-icon-name", PACKAGE_NAME ); var_Create( p_libvlc, "app-id", VLC_VAR_STRING ); var_SetString( p_libvlc, "app-id", "org.VideoLAN.VLC" ); var_Create( p_libvlc, "app-version", VLC_VAR_STRING ); var_SetString( p_libvlc, "app-version", PACKAGE_VERSION ); /* System specific configuration */ system_Configure( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind ); #ifdef ENABLE_VLM /* Initialize VLM if vlm-conf is specified */ psz_parser = var_CreateGetNonEmptyString( p_libvlc, "vlm-conf" ); if( psz_parser ) { priv->p_vlm = vlm_New( p_libvlc ); if( !priv->p_vlm ) msg_Err( p_libvlc, "VLM initialization failed" ); } free( psz_parser ); #endif /* * Load background interfaces */ psz_modules = var_CreateGetNonEmptyString( p_libvlc, "extraintf" ); psz_control = var_CreateGetNonEmptyString( p_libvlc, "control" ); if( psz_modules && psz_control ) { char* psz_tmp; if( asprintf( &psz_tmp, "%s:%s", psz_modules, psz_control ) != -1 ) { free( psz_modules ); psz_modules = psz_tmp; } } else if( psz_control ) { free( psz_modules ); psz_modules = strdup( psz_control ); } psz_parser = psz_modules; while ( psz_parser && *psz_parser ) { char *psz_module, *psz_temp; psz_module = psz_parser; psz_parser = strchr( psz_module, ':' ); if ( psz_parser ) { *psz_parser = '\0'; psz_parser++; } if( asprintf( &psz_temp, "%s,none", psz_module ) != -1) { intf_Create( p_libvlc, psz_temp ); free( psz_temp ); } } free( psz_modules ); free( psz_control ); #ifdef HAVE_SYSLOG_H if( var_InheritBool( p_libvlc, "syslog" ) ) { char *logmode = var_CreateGetNonEmptyString( p_libvlc, "logmode" ); var_SetString( p_libvlc, "logmode", "syslog" ); intf_Create( p_libvlc, "logger,none" ); if( logmode ) { var_SetString( p_libvlc, "logmode", logmode ); free( logmode ); } var_Destroy( p_libvlc, "logmode" ); } else #endif if( var_InheritBool( p_libvlc, "file-logging" ) ) intf_Create( p_libvlc, "logger,none" ); if( var_InheritBool( p_libvlc, "network-synchronisation") ) { intf_Create( p_libvlc, "netsync,none" ); } #ifdef __APPLE__ var_Create( p_libvlc, "drawable-view-top", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-view-left", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-view-bottom", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-view-right", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-top", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-left", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-bottom", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-clip-right", VLC_VAR_INTEGER ); var_Create( p_libvlc, "drawable-nsobject", VLC_VAR_ADDRESS ); #endif #if defined (_WIN32) || defined (__OS2__) var_Create( p_libvlc, "drawable-hwnd", VLC_VAR_INTEGER ); #endif /* * Get input filenames given as commandline arguments. * We assume that the remaining parameters are filenames * and their input options. */ GetFilenames( p_libvlc, i_argc - vlc_optind, ppsz_argv + vlc_optind ); /* * Get --open argument */ psz_val = var_InheritString( p_libvlc, "open" ); if ( psz_val != NULL ) { playlist_AddExt( pl_Get(p_libvlc), psz_val, NULL, PLAYLIST_INSERT, 0, -1, 0, NULL, 0, true, pl_Unlocked ); free( psz_val ); } return VLC_SUCCESS; }
void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, int i_type, const char *psz_type ) { vlc_object_t *p_new; vlc_object_internals_t *p_priv; /* NOTE: * VLC objects are laid out as follow: * - first the LibVLC-private per-object data, * - then VLC_COMMON members from vlc_object_t, * - finally, the type-specific data (if any). * * This function initializes the LibVLC and common data, * and zeroes the rest. */ p_priv = calloc( 1, sizeof( *p_priv ) + i_size ); if( p_priv == NULL ) return NULL; assert (i_size >= sizeof (vlc_object_t)); p_new = (vlc_object_t *)(p_priv + 1); p_priv->i_object_type = i_type; p_new->psz_object_type = psz_type; p_priv->psz_name = NULL; p_new->b_die = false; p_new->b_force = false; p_new->psz_header = NULL; if (p_this) p_new->i_flags = p_this->i_flags & (OBJECT_FLAGS_NODBG|OBJECT_FLAGS_QUIET|OBJECT_FLAGS_NOINTERACT); p_priv->var_root = NULL; if( p_this == NULL ) { libvlc_int_t *self = (libvlc_int_t*)p_new; p_new->p_libvlc = self; vlc_mutex_init (&(libvlc_priv (self)->structure_lock)); p_this = p_new; } else p_new->p_libvlc = p_this->p_libvlc; vlc_spin_init( &p_priv->ref_spin ); p_priv->i_refcount = 1; p_priv->pf_destructor = NULL; p_priv->b_thread = false; p_new->p_parent = NULL; p_priv->first = NULL; /* Initialize mutexes and condvars */ vlc_mutex_init( &p_priv->var_lock ); vlc_cond_init( &p_priv->var_wait ); p_priv->pipes[0] = p_priv->pipes[1] = -1; if (p_new == VLC_OBJECT(p_new->p_libvlc)) { /* TODO: should be in src/libvlc.c */ int canc = vlc_savecancel (); var_Create( p_new, "tree", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_new, "tree", DumpCommand, NULL ); var_Create( p_new, "vars", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_new, "vars", DumpCommand, NULL ); vlc_restorecancel (canc); } return p_new; }
VlcProc::VlcProc( intf_thread_t *pIntf ): SkinObject( pIntf ), m_varEqBands( pIntf ), m_pVout( NULL ), m_pAout( NULL ), m_bEqualizer_started( false ), m_cmdManage( this ) { // Create a timer to poll the status of the vlc OSFactory *pOsFactory = OSFactory::instance( pIntf ); m_pTimer = pOsFactory->createOSTimer( m_cmdManage ); m_pTimer->start( 100, false ); // Create and register VLC variables VarManager *pVarManager = VarManager::instance( getIntf() ); #define REGISTER_VAR( var, type, name ) \ var = VariablePtr( new type( getIntf() ) ); \ pVarManager->registerVar( var, name ); REGISTER_VAR( m_cVarRandom, VarBoolImpl, "playlist.isRandom" ) REGISTER_VAR( m_cVarLoop, VarBoolImpl, "playlist.isLoop" ) REGISTER_VAR( m_cVarRepeat, VarBoolImpl, "playlist.isRepeat" ) REGISTER_VAR( m_cPlaytree, Playtree, "playtree" ) pVarManager->registerVar( getPlaytreeVar().getPositionVarPtr(), "playtree.slider" ); pVarManager->registerVar( m_cVarRandom, "playtree.isRandom" ); pVarManager->registerVar( m_cVarLoop, "playtree.isLoop" ); REGISTER_VAR( m_cVarPlaying, VarBoolImpl, "vlc.isPlaying" ) REGISTER_VAR( m_cVarStopped, VarBoolImpl, "vlc.isStopped" ) REGISTER_VAR( m_cVarPaused, VarBoolImpl, "vlc.isPaused" ) /* Input variables */ pVarManager->registerVar( m_cVarRepeat, "playtree.isRepeat" ); REGISTER_VAR( m_cVarTime, StreamTime, "time" ) REGISTER_VAR( m_cVarSeekable, VarBoolImpl, "vlc.isSeekable" ) REGISTER_VAR( m_cVarDvdActive, VarBoolImpl, "dvd.isActive" ) REGISTER_VAR( m_cVarRecordable, VarBoolImpl, "vlc.canRecord" ) REGISTER_VAR( m_cVarRecording, VarBoolImpl, "vlc.isRecording" ) /* Vout variables */ REGISTER_VAR( m_cVarFullscreen, VarBoolImpl, "vlc.isFullscreen" ) REGISTER_VAR( m_cVarHasVout, VarBoolImpl, "vlc.hasVout" ) /* Aout variables */ REGISTER_VAR( m_cVarHasAudio, VarBoolImpl, "vlc.hasAudio" ) REGISTER_VAR( m_cVarVolume, Volume, "volume" ) REGISTER_VAR( m_cVarMute, VarBoolImpl, "vlc.isMute" ) REGISTER_VAR( m_cVarEqualizer, VarBoolImpl, "equalizer.isEnabled" ) REGISTER_VAR( m_cVarEqPreamp, EqualizerPreamp, "equalizer.preamp" ) #undef REGISTER_VAR m_cVarStreamName = VariablePtr( new VarText( getIntf(), false ) ); pVarManager->registerVar( m_cVarStreamName, "streamName" ); m_cVarStreamURI = VariablePtr( new VarText( getIntf(), false ) ); pVarManager->registerVar( m_cVarStreamURI, "streamURI" ); m_cVarStreamBitRate = VariablePtr( new VarText( getIntf(), false ) ); pVarManager->registerVar( m_cVarStreamBitRate, "bitrate" ); m_cVarStreamSampleRate = VariablePtr( new VarText( getIntf(), false ) ); pVarManager->registerVar( m_cVarStreamSampleRate, "samplerate" ); m_cVarStreamArt = VariablePtr( new VarString( getIntf() ) ); pVarManager->registerVar( m_cVarStreamArt, "streamArt" ); // Register the equalizer bands for( int i = 0; i < EqualizerBands::kNbBands; i++) { stringstream ss; ss << "equalizer.band(" << i << ")"; pVarManager->registerVar( m_varEqBands.getBand( i ), ss.str() ); } // XXX WARNING XXX // The object variable callbacks are called from other VLC threads, // so they must put commands in the queue and NOT do anything else // (X11 calls are not reentrant) #define ADD_CALLBACK( p_object, var ) \ var_AddCallback( p_object, var, onGenericCallback, this ); ADD_CALLBACK( pIntf->p_sys->p_playlist, "volume" ) ADD_CALLBACK( pIntf->p_libvlc, "intf-show" ) ADD_CALLBACK( pIntf->p_sys->p_playlist, "item-current" ) ADD_CALLBACK( pIntf->p_sys->p_playlist, "random" ) ADD_CALLBACK( pIntf->p_sys->p_playlist, "loop" ) ADD_CALLBACK( pIntf->p_sys->p_playlist, "repeat" ) #undef ADD_CALLBACK // Called when a playlist item is added var_AddCallback( pIntf->p_sys->p_playlist, "playlist-item-append", onItemAppend, this ); // Called when a playlist item is deleted // TODO: properly handle item-deleted var_AddCallback( pIntf->p_sys->p_playlist, "playlist-item-deleted", onItemDelete, this ); // Called when the current input changes var_AddCallback( pIntf->p_sys->p_playlist, "input-current", onInputNew, this ); // Called when a playlist item changed var_AddCallback( pIntf->p_sys->p_playlist, "item-change", onItemChange, this ); // Called when we have an interaction dialog to display var_Create( pIntf, "interaction", VLC_VAR_ADDRESS ); var_AddCallback( pIntf, "interaction", onInteraction, this ); interaction_Register( pIntf ); // initialize variables refering to liblvc and playlist objects init_variables(); }
static ass_handle_t *AssHandleHold( decoder_t *p_dec ) { vlc_mutex_lock( &libass_lock ); ass_handle_t *p_ass = NULL; ASS_Library *p_library = NULL; ASS_Renderer *p_renderer = NULL; vlc_value_t val; var_Create( p_dec->p_libvlc, "libass-handle", VLC_VAR_ADDRESS ); if( var_Get( p_dec->p_libvlc, "libass-handle", &val ) ) val.p_address = NULL; if( val.p_address ) { p_ass = val.p_address; p_ass->i_refcount++; vlc_mutex_unlock( &libass_lock ); return p_ass; } /* */ p_ass = malloc( sizeof(*p_ass) ); if( !p_ass ) goto error; /* */ p_ass->p_libvlc = VLC_OBJECT(p_dec->p_libvlc); p_ass->i_refcount = 1; /* Create libass library */ p_ass->p_library = p_library = ass_library_init(); if( !p_library ) goto error; /* load attachments */ input_attachment_t **pp_attachments; int i_attachments; if( decoder_GetInputAttachments( p_dec, &pp_attachments, &i_attachments )) { i_attachments = 0; pp_attachments = NULL; } for( int k = 0; k < i_attachments; k++ ) { input_attachment_t *p_attach = pp_attachments[k]; if( !strcasecmp( p_attach->psz_mime, "application/x-truetype-font" ) ) { msg_Dbg( p_dec, "adding embedded font %s", p_attach->psz_name ); ass_add_font( p_ass->p_library, p_attach->psz_name, p_attach->p_data, p_attach->i_data ); } vlc_input_attachment_Delete( p_attach ); } free( pp_attachments ); ass_set_extract_fonts( p_library, true ); ass_set_style_overrides( p_library, NULL ); /* Create the renderer */ p_ass->p_renderer = p_renderer = ass_renderer_init( p_library ); if( !p_renderer ) goto error; ass_set_use_margins( p_renderer, false); //if( false ) // ass_set_margins( p_renderer, int t, int b, int l, int r); ass_set_hinting( p_renderer, ASS_HINTING_LIGHT ); ass_set_font_scale( p_renderer, 1.0 ); ass_set_line_spacing( p_renderer, 0.0 ); const char *psz_font = NULL; /* We don't ship a default font with VLC */ const char *psz_family = "Arial"; /* Use Arial if we can't find anything more suitable */ #ifdef HAVE_FONTCONFIG #if defined(WIN32) dialog_progress_bar_t *p_dialog = dialog_ProgressCreate( p_dec, _("Building font cache"), _( "Please wait while your font cache is rebuilt.\n" "This should take less than a minute." ), NULL ); if( p_dialog ) dialog_ProgressSet( p_dialog, NULL, 0.2 ); #endif #if defined( LIBASS_VERSION ) && LIBASS_VERSION >= 0x00907000 ass_set_fonts( p_renderer, psz_font, psz_family, true, NULL, 1 ); // setup default font/family #else ass_set_fonts( p_renderer, psz_font, psz_family ); // setup default font/family #endif #ifdef WIN32 if( p_dialog ) { dialog_ProgressSet( p_dialog, NULL, 1.0 ); dialog_ProgressDestroy( p_dialog ); p_dialog = NULL; } #endif #else /* FIXME you HAVE to give him a font if no fontconfig */ #if defined( LIBASS_VERSION ) && LIBASS_VERSION >= 0x00907000 ass_set_fonts( p_renderer, psz_font, psz_family, false, NULL, 1 ); #else ass_set_fonts_nofc( p_renderer, psz_font, psz_family ); #endif #endif memset( &p_ass->fmt, 0, sizeof(p_ass->fmt) ); /* */ val.p_address = p_ass; var_Set( p_dec->p_libvlc, "libass-handle", val ); /* */ vlc_mutex_unlock( &libass_lock ); return p_ass; error: if( p_renderer ) ass_renderer_done( p_renderer ); if( p_library ) ass_library_done( p_library ); msg_Warn( p_dec, "Libass creation failed" ); free( p_ass ); vlc_mutex_unlock( &libass_lock ); return NULL; }
/***************************************************************************** * Open: open the file *****************************************************************************/ static int Open( vlc_object_t *p_this ) { sout_access_out_t *p_access = (sout_access_out_t*)p_this; sout_access_out_sys_t *p_sys; char *psz_user; char *psz_pwd; char *psz_mime; if( !( p_sys = p_access->p_sys = (sout_access_out_sys_t *) malloc( sizeof( sout_access_out_sys_t ) ) ) ) // sunqueen modify return VLC_ENOMEM ; config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg ); const char *path = p_access->psz_path; path += strcspn( path, "/" ); if( path > p_access->psz_path ) { const char *port = strrchr( p_access->psz_path, ':' ); if( port != NULL && strchr( port, ']' ) != NULL ) port = NULL; /* IPv6 numeral */ if( port != p_access->psz_path ) { int len = (port ? port : path) - p_access->psz_path; msg_Warn( p_access, "\"%.*s\" HTTP host might be ignored in " "multiple-host configurations, use at your own risks.", len, p_access->psz_path ); msg_Info( p_access, "Consider passing --http-host=IP on the " "command line instead." ); // sunqueen modify start // char host[len + 1]; char *host = (char *)malloc(len + 1); // sunqueen modify end strncpy( host, p_access->psz_path, len ); host[len] = '\0'; var_Create( p_access, "http-host", VLC_VAR_STRING ); var_SetString( p_access, "http-host", host ); free(host); // sunqueen add } if( port != NULL ) { /* int len = path - ++port; msg_Info( p_access, "Consider passing --%s-port=%.*s on the " "command line instead.", strcasecmp( p_access->psz_access, "https" ) ? "http" : "https", len, port ); */ port++; int bind_port = atoi( port ); if( bind_port > 0 ) { const char *var = strcasecmp( p_access->psz_access, "https" ) ? "http-port" : "https-port"; var_Create( p_access, var, VLC_VAR_INTEGER ); var_SetInteger( p_access, var, bind_port ); } } } if( !*path ) path = "/"; /* TLS support */ if( p_access->psz_access && !strcmp( p_access->psz_access, "https" ) ) p_sys->p_httpd_host = vlc_https_HostNew( VLC_OBJECT(p_access) ); else p_sys->p_httpd_host = vlc_http_HostNew( VLC_OBJECT(p_access) ); if( p_sys->p_httpd_host == NULL ) { msg_Err( p_access, "cannot start HTTP server" ); free( p_sys ); return VLC_EGENERIC; } psz_user = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "user" ); psz_pwd = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "pwd" ); if( p_access->psz_access && !strcmp( p_access->psz_access, "mmsh" ) ) { psz_mime = strdup( "video/x-ms-asf-stream" ); } else { psz_mime = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "mime" ); } p_sys->p_httpd_stream = httpd_StreamNew( p_sys->p_httpd_host, path, psz_mime, psz_user, psz_pwd ); free( psz_user ); free( psz_pwd ); free( psz_mime ); if( p_sys->p_httpd_stream == NULL ) { msg_Err( p_access, "cannot add stream %s", path ); httpd_HostDelete( p_sys->p_httpd_host ); free( p_sys ); return VLC_EGENERIC; } p_sys->i_header_allocated = 1024; p_sys->i_header_size = 0; p_sys->p_header = (uint8_t *)xmalloc( p_sys->i_header_allocated ); // sunqueen modify p_sys->b_header_complete = false; p_access->pf_write = Write; p_access->pf_seek = Seek; p_access->pf_control = Control; return VLC_SUCCESS; }
/***************************************************************************** * OpenFilter *****************************************************************************/ static int OpenFilter( vlc_object_t *p_this ) { filter_t * p_filter = (filter_t *)p_this; filter_sys_t *p_sys = NULL; if( aout_FormatNbChannels( &(p_filter->fmt_in.audio) ) == 1 ) { /*msg_Dbg( p_filter, "filter discarded (incompatible format)" );*/ return VLC_EGENERIC; } if( (p_filter->fmt_in.i_codec != VLC_CODEC_S16N) || (p_filter->fmt_out.i_codec != VLC_CODEC_S16N) ) { /*msg_Err( p_this, "filter discarded (invalid format)" );*/ return VLC_EGENERIC; } if( (p_filter->fmt_in.audio.i_format != p_filter->fmt_out.audio.i_format) && (p_filter->fmt_in.audio.i_rate != p_filter->fmt_out.audio.i_rate) && (p_filter->fmt_in.audio.i_format != VLC_CODEC_S16N) && (p_filter->fmt_out.audio.i_format != VLC_CODEC_S16N) && (p_filter->fmt_in.audio.i_bitspersample != p_filter->fmt_out.audio.i_bitspersample)) { /*msg_Err( p_this, "couldn't load mono filter" );*/ return VLC_EGENERIC; } /* Allocate the memory needed to store the module's structure */ p_sys = p_filter->p_sys = malloc( sizeof(filter_sys_t) ); if( p_sys == NULL ) return VLC_EGENERIC; var_Create( p_this, MONO_CFG "downmix", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); p_sys->b_downmix = var_GetBool( p_this, MONO_CFG "downmix" ); var_Create( p_this, MONO_CFG "channel", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); p_sys->i_channel_selected = (unsigned int) var_GetInteger( p_this, MONO_CFG "channel" ); if( p_sys->b_downmix ) { msg_Dbg( p_this, "using stereo to mono downmix" ); p_filter->fmt_out.audio.i_physical_channels = AOUT_CHAN_CENTER; p_filter->fmt_out.audio.i_channels = 1; } else { msg_Dbg( p_this, "using pseudo mono" ); p_filter->fmt_out.audio.i_physical_channels = (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT); p_filter->fmt_out.audio.i_channels = 2; } p_filter->fmt_out.audio.i_rate = p_filter->fmt_in.audio.i_rate; p_filter->fmt_out.audio.i_format = p_filter->fmt_out.i_codec; p_sys->i_nb_channels = aout_FormatNbChannels( &(p_filter->fmt_in.audio) ); p_sys->i_bitspersample = p_filter->fmt_out.audio.i_bitspersample; p_sys->i_overflow_buffer_size = 0; p_sys->p_overflow_buffer = NULL; p_sys->i_nb_atomic_operations = 0; p_sys->p_atomic_operations = NULL; if( Init( VLC_OBJECT(p_filter), p_filter->p_sys, aout_FormatNbChannels( &p_filter->fmt_in.audio ), p_filter->fmt_in.audio.i_physical_channels, p_filter->fmt_in.audio.i_rate ) < 0 ) { var_Destroy( p_this, MONO_CFG "channel" ); var_Destroy( p_this, MONO_CFG "downmix" ); free( p_sys ); return VLC_EGENERIC; } p_filter->pf_audio_filter = Convert; msg_Dbg( p_this, "%4.4s->%4.4s, channels %d->%d, bits per sample: %i->%i", (char *)&p_filter->fmt_in.i_codec, (char *)&p_filter->fmt_out.i_codec, p_filter->fmt_in.audio.i_physical_channels, p_filter->fmt_out.audio.i_physical_channels, p_filter->fmt_in.audio.i_bitspersample, p_filter->fmt_out.audio.i_bitspersample ); return VLC_SUCCESS; }
void vout_InitInterlacingSupport(vout_thread_t *vout) { vlc_value_t val; msg_Dbg(vout, "Deinterlacing available"); vout->p->filter.has_deint = false; /* Create the configuration variables */ /* */ var_Create(vout, "deinterlace", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); int deinterlace_state = var_GetInteger(vout, "deinterlace"); var_Change(vout, "deinterlace", VLC_VAR_SETTEXT, _("Deinterlace")); const module_config_t *optd = config_FindConfig("deinterlace"); var_Change(vout, "deinterlace", VLC_VAR_CLEARCHOICES); if (likely(optd != NULL)) for (unsigned i = 0; i < optd->list_count; i++) { val.i_int = optd->list.i[i]; var_Change(vout, "deinterlace", VLC_VAR_ADDCHOICE, val, vlc_gettext(optd->list_text[i])); } var_AddCallback(vout, "deinterlace", DeinterlaceCallback, NULL); /* */ var_Create(vout, "deinterlace-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); char *deinterlace_mode = var_GetNonEmptyString(vout, "deinterlace-mode"); var_Change(vout, "deinterlace-mode", VLC_VAR_SETTEXT, _("Deinterlace mode")); const module_config_t *optm = config_FindConfig("deinterlace-mode"); var_Change(vout, "deinterlace-mode", VLC_VAR_CLEARCHOICES); if (likely(optm != NULL)) for (unsigned i = 0; i < optm->list_count; i++) { if (!DeinterlaceIsModeValid(optm->list.psz[i])) continue; val.psz_string = (char *)optm->list.psz[i]; var_Change(vout, "deinterlace-mode", VLC_VAR_ADDCHOICE, val, vlc_gettext(optm->list_text[i])); } var_AddCallback(vout, "deinterlace-mode", DeinterlaceCallback, NULL); /* */ var_Create(vout, "deinterlace-needed", VLC_VAR_BOOL); var_AddCallback(vout, "deinterlace-needed", DeinterlaceCallback, NULL); /* Override the initial value from filters if present */ char *filter_mode = NULL; if (vout->p->filter.has_deint) filter_mode = var_CreateGetNonEmptyString(vout, "sout-deinterlace-mode"); if (filter_mode) { deinterlace_state = 1; free(deinterlace_mode); deinterlace_mode = filter_mode; } /* */ val.psz_string = deinterlace_mode ? deinterlace_mode : optm->orig.psz; var_Change(vout, "deinterlace-mode", VLC_VAR_SETVALUE, val); var_SetInteger(vout, "deinterlace", deinterlace_state); free(deinterlace_mode); vout->p->interlacing.is_interlaced = false; }
static void DoFingerprint( fingerprinter_thread_t *p_fingerprinter, acoustid_fingerprint_t *fp, const char *psz_uri ) { input_item_t *p_item = input_item_New( NULL, NULL ); if ( unlikely(p_item == NULL) ) return; char *psz_sout_option; /* Note: need at -max- 2 channels, but we can't guess it before playing */ /* the stereo upmix could make the mono tracks fingerprint to differ :/ */ if ( asprintf( &psz_sout_option, "sout=#transcode{acodec=%s,channels=2}:chromaprint", ( VLC_CODEC_S16L == VLC_CODEC_S16N ) ? "s16l" : "s16b" ) == -1 ) { input_item_Release( p_item ); return; } input_item_AddOption( p_item, psz_sout_option, VLC_INPUT_OPTION_TRUSTED ); free( psz_sout_option ); input_item_AddOption( p_item, "vout=dummy", VLC_INPUT_OPTION_TRUSTED ); input_item_AddOption( p_item, "aout=dummy", VLC_INPUT_OPTION_TRUSTED ); if ( fp->i_duration ) { if ( asprintf( &psz_sout_option, "stop-time=%u", fp->i_duration ) == -1 ) { input_item_Release( p_item ); return; } input_item_AddOption( p_item, psz_sout_option, VLC_INPUT_OPTION_TRUSTED ); free( psz_sout_option ); } input_item_SetURI( p_item, psz_uri ) ; input_thread_t *p_input = input_Create( p_fingerprinter, p_item, "fingerprinter", NULL, NULL ); input_item_Release( p_item ); if( p_input == NULL ) return; chromaprint_fingerprint_t chroma_fingerprint; chroma_fingerprint.psz_fingerprint = NULL; chroma_fingerprint.i_duration = fp->i_duration; var_Create( p_input, "fingerprint-data", VLC_VAR_ADDRESS ); var_SetAddress( p_input, "fingerprint-data", &chroma_fingerprint ); var_AddCallback( p_input, "intf-event", InputEventHandler, p_fingerprinter->p_sys ); if( input_Start( p_input ) != VLC_SUCCESS ) { var_DelCallback( p_input, "intf-event", InputEventHandler, p_fingerprinter->p_sys ); input_Close( p_input ); } else { p_fingerprinter->p_sys->processing.b_working = true; while( p_fingerprinter->p_sys->processing.b_working ) { vlc_cond_wait( &p_fingerprinter->p_sys->processing.cond, &p_fingerprinter->p_sys->processing.lock ); } var_DelCallback( p_input, "intf-event", InputEventHandler, p_fingerprinter->p_sys ); input_Stop( p_input ); input_Close( p_input ); fp->psz_fingerprint = chroma_fingerprint.psz_fingerprint; if( !fp->i_duration ) /* had not given hint */ fp->i_duration = chroma_fingerprint.i_duration; } }
/** * Create playlist * * Create a playlist structure. * \param p_parent the vlc object that is to be the parent of this playlist * \return a pointer to the created playlist, or NULL on error */ playlist_t *playlist_Create( vlc_object_t *p_parent ) { playlist_t *p_playlist; playlist_private_t *p; /* Allocate structure */ p = vlc_custom_create( p_parent, sizeof( *p ), "playlist" ); if( !p ) return NULL; assert( offsetof( playlist_private_t, public_data ) == 0 ); p_playlist = &p->public_data; TAB_INIT( pl_priv(p_playlist)->i_sds, pl_priv(p_playlist)->pp_sds ); VariablesInit( p_playlist ); vlc_mutex_init( &p->lock ); vlc_cond_init( &p->signal ); p->killed = false; /* Initialise data structures */ pl_priv(p_playlist)->i_last_playlist_id = 0; pl_priv(p_playlist)->p_input = NULL; ARRAY_INIT( p_playlist->items ); ARRAY_INIT( p_playlist->all_items ); ARRAY_INIT( pl_priv(p_playlist)->items_to_delete ); ARRAY_INIT( p_playlist->current ); p_playlist->i_current_index = 0; pl_priv(p_playlist)->b_reset_currently_playing = true; pl_priv(p_playlist)->b_tree = var_InheritBool( p_parent, "playlist-tree" ); /* Create the root, playing items and meida library nodes */ playlist_item_t *root, *playing, *ml; PL_LOCK; root = playlist_NodeCreate( p_playlist, NULL, NULL, PLAYLIST_END, 0, NULL ); playing = playlist_NodeCreate( p_playlist, _( "Playlist" ), root, PLAYLIST_END, PLAYLIST_RO_FLAG, NULL ); if( var_InheritBool( p_parent, "media-library") ) ml = playlist_NodeCreate( p_playlist, _( "Media Library" ), root, PLAYLIST_END, PLAYLIST_RO_FLAG, NULL ); else ml = NULL; PL_UNLOCK; if( unlikely(root == NULL || playing == NULL) ) abort(); p_playlist->p_root = root; p_playlist->p_playing = playing; p_playlist->p_media_library = ml; p_playlist->p_root_category = p_playlist->p_root; p_playlist->p_root_onelevel = p_playlist->p_root; p_playlist->p_local_category = p_playlist->p_playing; p_playlist->p_local_onelevel = p_playlist->p_playing; p_playlist->p_ml_category = p_playlist->p_media_library; p_playlist->p_ml_onelevel = p_playlist->p_media_library;; /* Initial status */ pl_priv(p_playlist)->status.p_item = NULL; pl_priv(p_playlist)->status.p_node = p_playlist->p_playing; pl_priv(p_playlist)->request.b_request = false; if (ml != NULL) playlist_MLLoad( p_playlist ); /* Preparser (and meta retriever) _after_ the Media Library*/ if( var_InheritBool( p_parent, "auto-preparse" ) ) { p->p_preparser = playlist_preparser_New( VLC_OBJECT(p_playlist) ); if( unlikely(p->p_preparser == NULL) ) msg_Err( p_playlist, "cannot create preparser" ); } /* Input resources */ p->p_input_resource = input_resource_New( VLC_OBJECT( p_playlist ) ); if( unlikely(p->p_input_resource == NULL) ) abort(); /* Audio output (needed for volume and device controls). */ audio_output_t *aout = input_resource_GetAout( p->p_input_resource ); if( aout != NULL ) input_resource_PutAout( p->p_input_resource, aout ); /* Initialize the shared HTTP cookie jar */ vlc_value_t cookies; cookies.p_address = vlc_http_cookies_new(); if ( likely(cookies.p_address) ) { var_Create( p_playlist, "http-cookies", VLC_VAR_ADDRESS ); var_SetChecked( p_playlist, "http-cookies", VLC_VAR_ADDRESS, cookies ); } /* Thread */ playlist_Activate (p_playlist); /* Add service discovery modules */ char *mods = var_InheritString( p_playlist, "services-discovery" ); if( mods != NULL ) { char *s = mods, *m; while( (m = strsep( &s, " :," )) != NULL ) playlist_ServicesDiscoveryAdd( p_playlist, m ); free( mods ); } return p_playlist; }
/** Parse a stringified option * This function parse a string option and create the associated object * variable * The option must be of the form "[no[-]]foo[=bar]" where foo is the * option name and bar is the value of the option. * \param p_obj the object in which the variable must be created * \param psz_option the option to parse * \return nothing */ void __var_OptionParse( vlc_object_t *p_obj, const char *psz_option ) { char *psz_name, *psz_value = strchr( psz_option, '=' ); int i_name_len, i_type; vlc_bool_t b_isno = VLC_FALSE; vlc_value_t val; if( psz_value ) i_name_len = psz_value - psz_option; else i_name_len = strlen( psz_option ); /* It's too much of an hassle to remove the ':' when we parse * the cmd line :) */ if( i_name_len && *psz_option == ':' ) { psz_option++; i_name_len--; } if( i_name_len == 0 ) return; psz_name = strndup( psz_option, i_name_len ); if( psz_value ) psz_value++; /* FIXME: :programs should be handled generically */ if( !strcmp( psz_name, "programs" ) ) i_type = VLC_VAR_LIST; else i_type = config_GetType( p_obj, psz_name ); if( !i_type && !psz_value ) { /* check for "no-foo" or "nofoo" */ if( !strncmp( psz_name, "no-", 3 ) ) { memmove( psz_name, psz_name + 3, strlen(psz_name) + 1 - 3 ); } else if( !strncmp( psz_name, "no", 2 ) ) { memmove( psz_name, psz_name + 2, strlen(psz_name) + 1 - 2 ); } else goto cleanup; /* Option doesn't exist */ b_isno = VLC_TRUE; i_type = config_GetType( p_obj, psz_name ); if( !i_type ) goto cleanup; /* Option doesn't exist */ } else if( !i_type ) goto cleanup; /* Option doesn't exist */ if( ( i_type != VLC_VAR_BOOL ) && ( !psz_value || !*psz_value ) ) goto cleanup; /* Invalid value */ /* Create the variable in the input object. * Children of the input object will be able to retreive this value * thanks to the inheritance property of the object variables. */ var_Create( p_obj, psz_name, i_type ); switch( i_type ) { case VLC_VAR_BOOL: val.b_bool = !b_isno; break; case VLC_VAR_INTEGER: val.i_int = strtol( psz_value, NULL, 0 ); break; case VLC_VAR_FLOAT: val.f_float = atof( psz_value ); break; case VLC_VAR_STRING: case VLC_VAR_MODULE: case VLC_VAR_FILE: case VLC_VAR_DIRECTORY: val.psz_string = psz_value; break; case VLC_VAR_LIST: { char *psz_orig, *psz_var; vlc_list_t *p_list = malloc(sizeof(vlc_list_t)); val.p_list = p_list; p_list->i_count = 0; psz_var = psz_orig = strdup(psz_value); while( psz_var && *psz_var ) { char *psz_item = psz_var; vlc_value_t val2; while( *psz_var && *psz_var != ',' ) psz_var++; if( *psz_var == ',' ) { *psz_var = '\0'; psz_var++; } val2.i_int = strtol( psz_item, NULL, 0 ); INSERT_ELEM( p_list->p_values, p_list->i_count, p_list->i_count, val2 ); /* p_list->i_count is incremented twice by INSERT_ELEM */ p_list->i_count--; INSERT_ELEM( p_list->pi_types, p_list->i_count, p_list->i_count, VLC_VAR_INTEGER ); } if( psz_orig ) free( psz_orig ); break; } default: goto cleanup; break; } var_Set( p_obj, psz_name, val ); cleanup: if( psz_name ) free( psz_name ); return; }
/***************************************************************************** * OSD menu Funtions *****************************************************************************/ osd_menu_t *__osd_MenuCreate( vlc_object_t *p_this, const char *psz_file ) { osd_menu_t *p_osd = NULL; vlc_value_t lockval; int i_volume = 0; int i_steps = 0; /* to be sure to avoid multiple creation */ var_Create( p_this->p_libvlc, "osd_mutex", VLC_VAR_MUTEX ); var_Get( p_this->p_libvlc, "osd_mutex", &lockval ); vlc_mutex_lock( lockval.p_address ); p_osd = vlc_object_find( p_this, VLC_OBJECT_OSDMENU, FIND_ANYWHERE ); if( p_osd == NULL ) { static const char osdmenu_name[] = "osd menu"; vlc_value_t val; p_osd = vlc_custom_create( p_this, sizeof( *p_osd ), VLC_OBJECT_OSDMENU, osdmenu_name ); if( !p_osd ) return NULL; p_osd->p_parser = NULL; vlc_object_attach( p_osd, p_this->p_libvlc ); /* Parse configuration file */ if ( !osd_ParserLoad( p_osd, psz_file ) ) goto error; if( !p_osd->p_state ) goto error; /* Setup default button (first button) */ p_osd->p_state->p_visible = p_osd->p_button; p_osd->p_state->p_visible->p_current_state = osd_StateChange( p_osd->p_state->p_visible, OSD_BUTTON_SELECT ); p_osd->i_width = p_osd->p_state->p_visible->p_current_state->p_pic->p[Y_PLANE].i_visible_pitch; p_osd->i_height = p_osd->p_state->p_visible->p_current_state->p_pic->p[Y_PLANE].i_visible_lines; if( p_osd->p_state->p_volume ) { /* Update the volume state images to match the current volume */ i_volume = config_GetInt( p_this, "volume" ); i_steps = osd_VolumeStep( p_this, i_volume, p_osd->p_state->p_volume->i_ranges ); p_osd->p_state->p_volume->p_current_state = osd_VolumeStateChange( p_osd->p_state->p_volume->p_states, i_steps ); } /* Initialize OSD state */ osd_UpdateState( p_osd->p_state, p_osd->i_x, p_osd->i_y, p_osd->i_width, p_osd->i_height, NULL ); /* Signal when an update of OSD menu is needed */ var_Create( p_osd, "osd-menu-update", VLC_VAR_BOOL ); var_Create( p_osd, "osd-menu-visible", VLC_VAR_BOOL ); val.b_bool = false; var_Set( p_osd, "osd-menu-update", val ); var_Set( p_osd, "osd-menu-visible", val ); } vlc_mutex_unlock( lockval.p_address ); return p_osd; error: vlc_mutex_unlock( lockval.p_address ); __osd_MenuDelete( p_this, p_osd ); return NULL; }
/***************************************************************************** * input_ConfigVarInit: * Create all config object variables *****************************************************************************/ void input_ConfigVarInit ( input_thread_t *p_input ) { /* Create Object Variables for private use only */ if( !p_input->b_preparsing ) { var_Create( p_input, "video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "audio-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT ); var_Create( p_input, "sub-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT ); var_Create( p_input, "audio-language", VLC_VAR_STRING|VLC_VAR_DOINHERIT ); var_Create( p_input, "sub-language", VLC_VAR_STRING|VLC_VAR_DOINHERIT ); var_Create( p_input, "menu-language", VLC_VAR_STRING|VLC_VAR_DOINHERIT ); var_Create( p_input, "audio-track-id", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT ); var_Create( p_input, "sub-track-id", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT ); var_Create( p_input, "sub-file", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "sub-autodetect-file", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "sub-autodetect-path", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "sub-autodetect-fuzzy", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_input, "sout", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "sout-all", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "sout-audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "sout-video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "sout-spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "sout-keep", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); var_Create( p_input, "input-repeat", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT ); var_Create( p_input, "start-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT ); var_Create( p_input, "stop-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT ); var_Create( p_input, "run-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT ); var_Create( p_input, "input-fast-seek", VLC_VAR_BOOL|VLC_VAR_DOINHERIT ); var_Create( p_input, "input-slave", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "audio-desync", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_input, "cr-average", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); var_Create( p_input, "clock-synchro", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT); } var_Create( p_input, "can-seek", VLC_VAR_BOOL ); var_SetBool( p_input, "can-seek", true ); /* Fixed later*/ var_Create( p_input, "can-pause", VLC_VAR_BOOL ); var_SetBool( p_input, "can-pause", true ); /* Fixed later*/ var_Create( p_input, "can-rate", VLC_VAR_BOOL ); var_SetBool( p_input, "can-rate", false ); var_Create( p_input, "can-rewind", VLC_VAR_BOOL ); var_SetBool( p_input, "can-rewind", false ); var_Create( p_input, "can-record", VLC_VAR_BOOL ); var_SetBool( p_input, "can-record", false ); /* Fixed later*/ var_Create( p_input, "record", VLC_VAR_BOOL ); var_SetBool( p_input, "record", false ); var_Create( p_input, "teletext-es", VLC_VAR_INTEGER ); var_SetInteger( p_input, "teletext-es", -1 ); var_Create( p_input, "signal-quality", VLC_VAR_FLOAT ); var_SetFloat( p_input, "signal-quality", -1 ); var_Create( p_input, "signal-strength", VLC_VAR_FLOAT ); var_SetFloat( p_input, "signal-strength", -1 ); var_Create( p_input, "program-scrambled", VLC_VAR_BOOL ); var_SetBool( p_input, "program-scrambled", false ); var_Create( p_input, "cache", VLC_VAR_FLOAT ); var_SetFloat( p_input, "cache", 0.0 ); /* */ var_Create( p_input, "input-record-native", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); /* */ var_Create( p_input, "access", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "demux", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "stream-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); /* Meta */ var_Create( p_input, "meta-title", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "meta-author", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "meta-artist", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "meta-genre", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "meta-copyright", VLC_VAR_STRING | VLC_VAR_DOINHERIT); var_Create( p_input, "meta-description", VLC_VAR_STRING|VLC_VAR_DOINHERIT); var_Create( p_input, "meta-date", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); var_Create( p_input, "meta-url", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); }