control.c

Revision 1b025556e3277cc727d1e70c7c55a2a0192b4d1a, 23.1 kB (checked in by Laurent Aimar <fenrir@videolan.org>, 1 week ago)

Added a INPUT_CONTROL_RESTART_ES and use it in video_output.

This removes the need for suxor_thread_t.

Property mode set to 100644

Line
1	/*****************************************************************************
2	* control.c
3	*****************************************************************************
4	* Copyright (C) 1999-2004 the VideoLAN team
5	* $Id$
6	*
7	* Authors: Gildas Bazin <gbazin@videolan.org>
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation; either version 2 of the License, or
12	* (at your option) any later version.
13	*
14	* This program is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, write to the Free Software
21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22	*****************************************************************************/
23
24	#ifdef HAVE_CONFIG_H
25	# include "config.h"
26	#endif
27
28	#include <vlc_common.h>
29
30	#include <stdio.h>
31	#include <stdlib.h>
32
33	#include "input_internal.h"
34
35
36	static void UpdateBookmarksOption( input_thread_t * );
37
38	/****************************************************************************
39	* input_Control
40	****************************************************************************/
41	/**
42	* Control function for inputs.
43	* \param p_input input handle
44	* \param i_query query type
45	* \return VLC_SUCCESS if ok
46	*/
47	int input_Control( input_thread_t p_input, int* i_query, ... )
48	{
49	va_list args;
50	int i_result;
51
52	va_start( args, i_query );
53	i_result = input_vaControl( p_input, i_query, args );
54	va_end( args );
55
56	return i_result;
57	}
58
59	int input_vaControl( input_thread_t p_input, int* i_query, va_list args )
60	{
61	seekpoint_t p_bkmk, **ppp_bkmk;
62	int i_bkmk = 0;
63	int *pi_bkmk;
64
65	int i_int, *pi_int;
66	bool b_bool, *pb_bool;
67	double f, *pf;
68	int64_t i_64, *pi_64;
69
70	char *psz;
71	vlc_value_t val;
72
73	switch( i_query )
74	{
75	case INPUT_GET_POSITION:
76	pf = (double)va_arg( args, double* * );
77	pf = var_GetFloat( p_input, "position"* );
78	return VLC_SUCCESS;
79
80	case INPUT_SET_POSITION:
81	f = (double)va_arg( args, double );
82	return var_SetFloat( p_input, "position", f );
83
84	case INPUT_GET_LENGTH:
85	pi_64 = (int64_t)va_arg( args, int64_t );
86	pi_64 = var_GetTime( p_input, "length"* );
87	return VLC_SUCCESS;
88
89	case INPUT_GET_TIME:
90	pi_64 = (int64_t)va_arg( args, int64_t );
91	pi_64 = var_GetTime( p_input, "time"* );
92	return VLC_SUCCESS;
93
94	case INPUT_SET_TIME:
95	i_64 = (int64_t)va_arg( args, int64_t );
96	return var_SetTime( p_input, "time", i_64 );
97
98	case INPUT_GET_RATE:
99	pi_int = (int)va_arg( args, int* * );
100	pi_int = var_GetInteger( p_input, "rate"* );
101	return VLC_SUCCESS;
102
103	case INPUT_SET_RATE:
104	i_int = (int)va_arg( args, int );
105	return var_SetInteger( p_input, "rate", i_int );
106
107	case INPUT_GET_STATE:
108	pi_int = (int)va_arg( args, int* * );
109	pi_int = var_GetInteger( p_input, "state"* );
110	return VLC_SUCCESS;
111
112	case INPUT_SET_STATE:
113	i_int = (int)va_arg( args, int );
114	return var_SetInteger( p_input, "state", i_int );
115
116	case INPUT_GET_AUDIO_DELAY:
117	pi_64 = (int64_t)va_arg( args, int64_t );
118	pi_64 = var_GetTime( p_input, "audio-delay"* );
119	return VLC_SUCCESS;
120
121	case INPUT_GET_SPU_DELAY:
122	pi_64 = (int64_t)va_arg( args, int64_t );
123	pi_64 = var_GetTime( p_input, "spu-delay"* );
124	return VLC_SUCCESS;
125
126	case INPUT_SET_AUDIO_DELAY:
127	i_64 = (int64_t)va_arg( args, int64_t );
128	return var_SetTime( p_input, "audio-delay", i_64 );
129
130	case INPUT_SET_SPU_DELAY:
131	i_64 = (int64_t)va_arg( args, int64_t );
132	return var_SetTime( p_input, "spu-delay", i_64 );
133
134	case INPUT_ADD_INFO:
135	{
136	/ FIXME : Impossible to use input_item_AddInfo because of*
137	* the ... problem ? */
138	char psz_cat = (char* )va_arg( args, char* * );
139	char psz_name = (char* )va_arg( args, char* * );
140	char psz_format = (char* )va_arg( args, char* * );
141
142	info_category_t *p_cat;
143	info_t *p_info;
144	int i;
145
146	vlc_mutex_lock( &p_input->p->input.p_item->lock );
147	for( i = 0; i < p_input->p->input.p_item->i_categories; i++ )
148	{
149	if( !strcmp( p_input->p->input.p_item->pp_categories[i]->psz_name,
150	psz_cat ) ) break;
151	}
152
153	if( i == p_input->p->input.p_item->i_categories )
154	{
155	p_cat = malloc( sizeof( info_category_t ) );
156	if( !p_cat )
157	{
158	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
159	return VLC_EGENERIC;
160	}
161	p_cat->psz_name = strdup( psz_cat );
162	p_cat->i_infos = 0;
163	p_cat->pp_infos = NULL;
164	INSERT_ELEM( p_input->p->input.p_item->pp_categories,
165	p_input->p->input.p_item->i_categories,
166	p_input->p->input.p_item->i_categories, p_cat );
167	}
168
169	p_cat = p_input->p->input.p_item->pp_categories[i];
170
171	for( i = 0; i < p_cat->i_infos; i++ )
172	{
173	if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
174	{
175	if( p_cat->pp_infos[i]->psz_value )
176	free( p_cat->pp_infos[i]->psz_value );
177	break;
178	}
179	}
180
181	if( i == p_cat->i_infos )
182	{
183	p_info = malloc( sizeof( info_t ) );
184	if( !p_info )
185	{
186	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
187	return VLC_EGENERIC;
188	}
189
190	INSERT_ELEM( p_cat->pp_infos, p_cat->i_infos,
191	p_cat->i_infos, p_info );
192	p_info->psz_name = strdup( psz_name );
193	}
194
195	p_info = p_cat->pp_infos[i];
196	if( vasprintf( &p_info->psz_value, psz_format, args ) == -1 )
197	p_info->psz_value = NULL;
198
199	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
200
201	if( !p_input->b_preparsing )
202	{
203	vlc_event_t event;
204	event.type = vlc_InputItemInfoChanged;
205	vlc_event_send( &p_input->p->input.p_item->event_manager, &event );
206	}
207	}
208	return VLC_SUCCESS;
209
210	case INPUT_DEL_INFO:
211	{
212	char psz_cat = (char* )va_arg( args, char* * );
213	char psz_name = (char* )va_arg( args, char* * );
214
215	info_category_t *p_cat = NULL;
216	int i_cat;
217	int i;
218
219	vlc_mutex_lock( &p_input->p->input.p_item->lock );
220	for( i_cat = 0; i_cat < p_input->p->input.p_item->i_categories; i_cat++ )
221	{
222	if( !strcmp( p_input->p->input.p_item->pp_categories[i_cat]->psz_name,
223	psz_cat ) )
224	{
225	p_cat = p_input->p->input.p_item->pp_categories[i_cat];
226	break;
227	}
228	}
229	if( p_cat == NULL )
230	{
231	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
232	return VLC_EGENERIC;
233	}
234
235	if( psz_name )
236	{
237	/ Remove a specific info /
238	for( i = 0; i < p_cat->i_infos; i++ )
239	{
240	if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
241	{
242	free( p_cat->pp_infos[i]->psz_name );
243	if( p_cat->pp_infos[i]->psz_value )
244	free( p_cat->pp_infos[i]->psz_value );
245	free( p_cat->pp_infos[i] );
246	REMOVE_ELEM( p_cat->pp_infos, p_cat->i_infos, i );
247	break;
248	}
249	}
250	if( i >= p_cat->i_infos )
251	{
252	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
253	return VLC_EGENERIC;
254	}
255	}
256	else
257	{
258	/ Remove the complete categorie /
259	for( i = 0; i < p_cat->i_infos; i++ )
260	{
261	free( p_cat->pp_infos[i]->psz_name );
262	if( p_cat->pp_infos[i]->psz_value )
263	free( p_cat->pp_infos[i]->psz_value );
264	free( p_cat->pp_infos[i] );
265	}
266	if( p_cat->pp_infos )
267	free( p_cat->pp_infos );
268	REMOVE_ELEM( p_input->p->input.p_item->pp_categories, p_input->p->input.p_item->i_categories, i_cat );
269	}
270	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
271
272	if( !p_input->b_preparsing )
273	{
274	vlc_event_t event;
275	event.type = vlc_InputItemInfoChanged;
276	vlc_event_send( &p_input->p->input.p_item->event_manager, &event );
277	}
278	return VLC_SUCCESS;
279	}
280
281
282	case INPUT_GET_INFO:
283	{
284	char psz_cat = (char* )va_arg( args, char* * );
285	char psz_name = (char* )va_arg( args, char* * );
286	char ppsz_value = (char )va_arg( args, char ** );
287	int i_ret = VLC_EGENERIC;
288	*ppsz_value = NULL;
289
290	*ppsz_value = input_item_GetInfo( p_input->p->input.p_item,
291	psz_cat, psz_name );
292	return i_ret;
293	}
294
295	case INPUT_SET_NAME:
296	{
297	char psz_name = (char* )va_arg( args, char* * );
298
299	if( !psz_name ) return VLC_EGENERIC;
300
301	vlc_mutex_lock( &p_input->p->input.p_item->lock );
302	if( p_input->p->input.p_item->psz_name )
303	free( p_input->p->input.p_item->psz_name );
304	p_input->p->input.p_item->psz_name = strdup( psz_name );
305	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
306
307	if( !p_input->b_preparsing )
308	{
309	vlc_event_t event;
310	event.type = vlc_InputItemNameChanged;
311	event.u.input_item_name_changed.new_name = psz_name;
312	vlc_event_send( &p_input->p->input.p_item->event_manager, &event );
313	}
314	return VLC_SUCCESS;
315	}
316
317	case INPUT_ADD_BOOKMARK:
318	p_bkmk = (seekpoint_t )va_arg( args, seekpoint_t );
319	p_bkmk = vlc_seekpoint_Duplicate( p_bkmk );
320
321	vlc_mutex_lock( &p_input->p->input.p_item->lock );
322	if( !p_bkmk->psz_name )
323	{
324	if( asprintf( &p_bkmk->psz_name, _("Bookmark %i"),
325	p_input->p->i_bookmark ) == -1 )
326	p_bkmk->psz_name = NULL;
327	}
328
329	TAB_APPEND( p_input->p->i_bookmark, p_input->p->bookmark, p_bkmk );
330
331	/ Reflect the changes on the object var /
332	var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
333	{
334	vlc_value_t val, text;
335	int i;
336
337	for( i = 0; i < p_input->p->i_bookmark; i++ )
338	{
339	val.i_int = i;
340	text.psz_string = p_input->p->bookmark[i]->psz_name;
341	var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
342	&val, &text );
343	}
344	}
345	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
346
347	UpdateBookmarksOption( p_input );
348
349	return VLC_SUCCESS;
350
351	case INPUT_CHANGE_BOOKMARK:
352	p_bkmk = (seekpoint_t )va_arg( args, seekpoint_t );
353	i_bkmk = (int)va_arg( args, int );
354
355	vlc_mutex_lock( &p_input->p->input.p_item->lock );
356	if( i_bkmk < p_input->p->i_bookmark )
357	{
358	vlc_value_t val, text;
359	int i;
360
361	p_input->p->bookmark[i_bkmk] = p_bkmk;
362
363	/ Reflect the changes on the object var /
364	var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
365	for( i = 0; i < p_input->p->i_bookmark; i++ )
366	{
367	val.i_int = i;
368	text.psz_string = p_input->p->bookmark[i]->psz_name;
369	var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
370	&val, &text );
371	}
372	}
373	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
374
375	UpdateBookmarksOption( p_input );
376
377	return VLC_SUCCESS;
378
379	case INPUT_DEL_BOOKMARK:
380	i_bkmk = (int)va_arg( args, int );
381
382	vlc_mutex_lock( &p_input->p->input.p_item->lock );
383	if( i_bkmk < p_input->p->i_bookmark )
384	{
385	vlc_value_t val, text;
386	int i;
387
388	p_bkmk = p_input->p->bookmark[i_bkmk];
389	TAB_REMOVE( p_input->p->i_bookmark, p_input->p->bookmark,
390	p_bkmk );
391	vlc_seekpoint_Delete( p_bkmk );
392
393	/ Reflect the changes on the object var /
394	var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
395	for( i = 0; i < p_input->p->i_bookmark; i++ )
396	{
397	val.i_int = i;
398	text.psz_string = p_input->p->bookmark[i]->psz_name;
399	var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
400	&val, &text );
401	}
402	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
403
404	UpdateBookmarksOption( p_input );
405
406	return VLC_SUCCESS;
407	}
408	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
409
410	return VLC_EGENERIC;
411
412	case INPUT_GET_BOOKMARKS:
413	ppp_bkmk = (seekpoint_t *)va_arg( args, seekpoint_t * );
414	pi_bkmk = (int )va_arg( args, int* * );
415
416	vlc_mutex_lock( &p_input->p->input.p_item->lock );
417	if( p_input->p->i_bookmark )
418	{
419	int i;
420
421	*pi_bkmk = p_input->p->i_bookmark;
422	ppp_bkmk = malloc( sizeof(seekpoint_t ) *
423	p_input->p->i_bookmark );
424	for( i = 0; i < p_input->p->i_bookmark; i++ )
425	{
426	(*ppp_bkmk)[i] =
427	vlc_seekpoint_Duplicate(p_input->p->bookmark[i]);
428	}
429
430	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
431	return VLC_SUCCESS;
432	}
433	else
434	{
435	*ppp_bkmk = NULL;
436	*pi_bkmk = 0;
437
438	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
439	return VLC_EGENERIC;
440	}
441	break;
442
443	case INPUT_CLEAR_BOOKMARKS:
444
445	vlc_mutex_lock( &p_input->p->input.p_item->lock );
446	if( p_input->p->i_bookmark )
447	{
448	int i;
449
450	for( i = p_input->p->i_bookmark - 1; i >= 0; i-- )
451	{
452	p_bkmk = p_input->p->bookmark[i];
453	TAB_REMOVE( p_input->p->i_bookmark, p_input->p->bookmark,
454	p_bkmk );
455	vlc_seekpoint_Delete( p_bkmk );
456	}
457	var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
458	}
459	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
460
461	UpdateBookmarksOption( p_input );
462
463	return VLC_SUCCESS;
464
465	case INPUT_SET_BOOKMARK:
466	i_bkmk = (int)va_arg( args, int );
467
468	vlc_mutex_lock( &p_input->p->input.p_item->lock );
469	if( i_bkmk >= 0 && i_bkmk < p_input->p->i_bookmark )
470	{
471	vlc_value_t pos;
472	int i_ret;
473
474	if( p_input->p->bookmark[i_bkmk]->i_time_offset != -1 )
475	{
476	pos.i_time = p_input->p->bookmark[i_bkmk]->i_time_offset;
477	i_ret = var_Set( p_input, "time", pos );
478	}
479	else if( p_input->p->bookmark[i_bkmk]->i_byte_offset != -1 )
480	{
481	// don't crash on bookmarks in live streams
482	if( stream_Size( p_input->p->input.p_stream ) == 0 )
483	{
484	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
485	return VLC_EGENERIC;
486	}
487	pos.f_float = !p_input->p->input.p_stream ? 0 :
488	p_input->p->bookmark[i_bkmk]->i_byte_offset /
489	stream_Size( p_input->p->input.p_stream );
490	i_ret = var_Set( p_input, "position", pos );
491	}
492	else
493	{
494	pos.f_float = 0;
495	i_ret = var_Set( p_input, "position", pos );
496	}
497
498	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
499	return i_ret;
500	}
501	else
502	{
503	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
504	return VLC_EGENERIC;
505	}
506
507	break;
508
509	case INPUT_ADD_OPTION:
510	{
511	const char psz_option = va_arg( args, const* char * );
512	const char psz_value = va_arg( args, const* char * );
513	char *str;
514	int i;
515
516	if( asprintf( &str, "%s=%s", psz_option, psz_value ) == -1 )
517	return VLC_ENOMEM;
518
519	i = input_item_AddOpt( p_input->p->input.p_item, str,
520	VLC_INPUT_OPTION_UNIQUE );
521	free( str );
522	return i;
523	}
524
525	case INPUT_GET_BYTE_POSITION:
526	pi_64 = (int64_t)va_arg( args, int64_t );
527	*pi_64 = !p_input->p->input.p_stream ? 0 :
528	stream_Tell( p_input->p->input.p_stream );
529	return VLC_SUCCESS;
530
531	case INPUT_SET_BYTE_SIZE:
532	pi_64 = (int64_t)va_arg( args, int64_t );
533	*pi_64 = !p_input->p->input.p_stream ? 0 :
534	stream_Size( p_input->p->input.p_stream );
535	return VLC_SUCCESS;
536
537	case INPUT_GET_VIDEO_FPS:
538	{
539	int i;
540	pf = (double)va_arg( args, double* * );
541	vlc_mutex_lock( &p_input->p->input.p_item->lock );
542	*pf = p_input->p->input.f_fps;
543	for( i = 0; i < p_input->p->i_slave && *pf <= 0.001; i++ )
544	*pf = p_input->p->slave[i]->f_fps;
545	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
546	return VLC_SUCCESS;
547	}
548
549	case INPUT_ADD_SLAVE:
550	psz = (char)va_arg( args, char* * );
551	if( psz && *psz )
552	{
553	val.psz_string = strdup( psz );
554	input_ControlPush( p_input, INPUT_CONTROL_ADD_SLAVE, &val );
555	}
556	return VLC_SUCCESS;
557
558	case INPUT_GET_ATTACHMENTS: / arg1=input_attachment_t**, arg2=int res=can fail /
559	{
560	input_attachment_t *ppp_attachment = (input_attachment_t)va_arg( args, input_attachment_t ** );
561	int pi_attachment = (int)va_arg( args, int** * );
562	int i;
563
564	vlc_mutex_lock( &p_input->p->input.p_item->lock );
565	if( p_input->p->i_attachment <= 0 )
566	{
567	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
568	*ppp_attachment = NULL;
569	*pi_attachment = 0;
570	return VLC_EGENERIC;
571	}
572	*pi_attachment = p_input->p->i_attachment;
573	ppp_attachment = malloc( sizeof(input_attachment_t) p_input->p->i_attachment );
574	for( i = 0; i < p_input->p->i_attachment; i++ )
575	(*ppp_attachment)[i] = vlc_input_attachment_Duplicate( p_input->p->attachment[i] );
576
577	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
578	return VLC_SUCCESS;
579	}
580
581	case INPUT_GET_ATTACHMENT: / arg1=input_attachment_t*, arg2=char res=can fail /
582	{
583	input_attachment_t pp_attachment = (input_attachment_t)va_arg( args, input_attachment_t ** );
584	const char psz_name = (const* char)va_arg( args, const* char * );
585	int i;
586
587	vlc_mutex_lock( &p_input->p->input.p_item->lock );
588	for( i = 0; i < p_input->p->i_attachment; i++ )
589	{
590	if( !strcmp( p_input->p->attachment[i]->psz_name, psz_name ) )
591	{
592	*pp_attachment = vlc_input_attachment_Duplicate( p_input->p->attachment[i] );
593	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
594	return VLC_SUCCESS;
595	}
596	}
597	*pp_attachment = NULL;
598	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
599	return VLC_EGENERIC;
600	}
601
602	case INPUT_SET_RECORD_STATE:
603	b_bool = (bool)va_arg( args, int );
604	var_SetBool( p_input, "record", b_bool );
605	return VLC_SUCCESS;
606
607	case INPUT_GET_RECORD_STATE:
608	pb_bool = (bool)va_arg( args, bool );
609	pb_bool = var_GetBool( p_input, "record"* );
610	return VLC_SUCCESS;
611
612	case INPUT_RESTART_ES:
613	val.i_int = (int)va_arg( args, int );
614	input_ControlPush( p_input, INPUT_CONTROL_RESTART_ES, &val );
615	return VLC_SUCCESS;
616
617	default:
618	msg_Err( p_input, "unknown query in input_vaControl" );
619	return VLC_EGENERIC;
620	}
621	}
622
623	static void UpdateBookmarksOption( input_thread_t *p_input )
624	{
625	int i, i_len = 0;
626	char psz_value = NULL, psz_next = NULL;
627
628	vlc_mutex_lock( &p_input->p->input.p_item->lock );
629	if( p_input->p->i_bookmark > 0 )
630	{
631	for( i = 0; i < p_input->p->i_bookmark; i++ )
632	{
633	i_len += snprintf( NULL, 0, "{name=%s,bytes=%"PRId64",time=%"PRId64"}",
634	p_input->p->bookmark[i]->psz_name,
635	p_input->p->bookmark[i]->i_byte_offset,
636	p_input->p->bookmark[i]->i_time_offset/1000000 );
637	}
638	psz_value = psz_next = malloc( i_len + p_input->p->i_bookmark );
639
640	for( i = 0; i < p_input->p->i_bookmark; i++ )
641	{
642	sprintf( psz_next, "{name=%s,bytes=%"PRId64",time=%"PRId64"}",
643	p_input->p->bookmark[i]->psz_name,
644	p_input->p->bookmark[i]->i_byte_offset,
645	p_input->p->bookmark[i]->i_time_offset/1000000 );
646
647	psz_next += strlen( psz_next );
648	if( i < p_input->p->i_bookmark - 1)
649	psz_next = ','*; psz_next++;
650	}
651	}
652	vlc_mutex_unlock( &p_input->p->input.p_item->lock );
653
654	input_Control( p_input, INPUT_ADD_OPTION, "bookmarks",
655	psz_value ? psz_value : "" );
656	free( psz_value );
657	}
658

Note: See TracBrowser for help on using the browser.

root/src/input/control.c

Download in other formats: