~ubuntu-dev/mplayer/ubuntu-feisty : contents of m

~ubuntu-dev/mplayer/ubuntu-feisty : (revision 24)

/// \file
/// \ingroup Properties

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <unistd.h>

#include "m_option.h"
#include "m_property.h"
#include "mp_msg.h"
#include "help_mp.h"

#define ROUND(x) ((int)((x)<0 ? (x)-0.5 : (x)+0.5))

int m_property_do(m_option_t* prop, int action, void* arg) {
    if(!prop) return M_PROPERTY_UNKNOWN;
    return ((m_property_ctrl_f)prop->p)(prop,action,arg);
}


char* m_property_print(m_option_t* prop) {
    m_property_ctrl_f ctrl;
    void* val;
    char* ret;
    
    if(!prop) return NULL;

    ctrl = prop->p;
    // look if the property have it's own print func
    if(ctrl(prop,M_PROPERTY_PRINT,&ret) >= 0)
        return ret;
    // fallback on the default print for this type
    val = calloc(1,prop->type->size);    
    if(ctrl(prop,M_PROPERTY_GET,val) <= 0) {
        free(val);
        return NULL;
    }
    ret = m_option_print(prop,val);
    free(val);
    return ret == (char*)-1 ? NULL : ret;
}

int m_property_parse(m_option_t* prop, char* txt) {
    m_property_ctrl_f ctrl;
    void* val;
    int r;
    
    if(!prop) return M_PROPERTY_UNKNOWN;

    ctrl = prop->p;
    // try the property own parsing func
    if((r = ctrl(prop,M_PROPERTY_PARSE,txt)) !=  M_PROPERTY_NOT_IMPLEMENTED)
        return r;
    // fallback on the default
    val = calloc(1,prop->type->size);
    if((r = m_option_parse(prop,prop->name,txt,val,M_CONFIG_FILE)) <= 0) {
        free(val);
        return r;
    }
    r = ctrl(prop,M_PROPERTY_SET,val);
    m_option_free(prop,val);
    free(val);
    return r;
}

char* m_properties_expand_string(m_option_t* prop_list,char* str) {
    int l,fr=0,pos=0,size=strlen(str)+512;
    char *p = NULL,*e,*ret = malloc(size), num_val;
    int skip = 0, lvl = 0, skip_lvl = 0;
    
    while(str[0]) {
        if(str[0] == '\\') {
            int sl = 1;
            switch(str[1]) {
            case 'e':
                p = "\x1b", l = 1; break;
            case 'n':
                p = "\n", l = 1; break;
            case 'r':
                p = "\r", l = 1; break;
            case 't':
                p = "\t", l = 1; break;
            case 'x': 
                if(str[2]) {
                    char num[3] = { str[2], str[3], 0 };
                    char* end = num;
                    num_val = strtol(num,&end,16);
                    sl = end-num;
                    l = 1;
                    p = &num_val;
                } else
                    l = 0;
                break;
            default:
                p = str+1, l = 1;
            }
            str+=1+sl;
        } else if(lvl > 0 && str[0] == ')') {
            if(skip && lvl <= skip_lvl) skip = 0;
            lvl--, str++, l = 0;
        } else if(str[0] == '$' && str[1] == '{' && (e = strchr(str+2,'}'))) {
            int pl = e-str-2;
            char pname[pl+1];
            m_option_t* prop;
            memcpy(pname,str+2,pl);
            pname[pl] = 0;
            if((prop = m_option_list_find(prop_list,pname)) &&
               (p = m_property_print(prop)))
                l = strlen(p), fr = 1;
            else
                l = 0;
            str = e+1;
        } else if(str[0] == '?' && str[1] == '(' && (e = strchr(str+2,':'))) {
            int pl = e-str-2;
            char pname[pl+1];
            m_option_t* prop;
            lvl++;
            if(!skip) {            
                memcpy(pname,str+2,pl);
                pname[pl] = 0;
                if(!(prop = m_option_list_find(prop_list,pname)) ||
                   m_property_do(prop,M_PROPERTY_GET,NULL) < 0)
                    skip = 1, skip_lvl = lvl;
            }
            str = e+1, l = 0;
        } else
            p = str, l = 1, str++;
        
        if(skip || l <= 0) continue;
        
        if(pos+l+1 > size) {
            size = pos+l+512;
            ret = realloc(ret,size);
        }
        memcpy(ret+pos,p,l);
        pos += l;
        if(fr) free(p), fr = 0;
    }
    
    ret[pos] = 0;
    return ret;
}

void m_properties_print_help_list(m_option_t* list) {
    char min[50],max[50];
    int i,count = 0;
    
    mp_msg(MSGT_CFGPARSER, MSGL_INFO, MSGTR_PropertyListHeader);
    for(i = 0 ; list[i].name ; i++) {
        m_option_t* opt = &list[i];
        if(opt->flags & M_OPT_MIN)
            sprintf(min,"%-8.0f",opt->min);
        else
            strcpy(min,"No");
        if(opt->flags & M_OPT_MAX)
            sprintf(max,"%-8.0f",opt->max);
        else
            strcpy(max,"No");
        mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %-20.20s %-15.15s %-10.10s %-10.10s\n",
               opt->name,
               opt->type->name,
               min,
               max);
        count++;
    }
    mp_msg(MSGT_CFGPARSER, MSGL_INFO, MSGTR_TotalProperties, count);
}

// Some generic property implementations

int m_property_int_ro(m_option_t* prop,int action,
                      void* arg,int var) {
    switch(action) {
    case M_PROPERTY_GET:
        if(!arg) return 0;
        *(int*)arg = var;
        return 1;
    }
    return M_PROPERTY_NOT_IMPLEMENTED;
}

int m_property_int_range(m_option_t* prop,int action,
                         void* arg,int* var) {
    switch(action) {
    case M_PROPERTY_SET:
        if(!arg) return 0;
        M_PROPERTY_CLAMP(prop,*(int*)arg);
        *var = *(int*)arg;
        return 1;
    case M_PROPERTY_STEP_UP:
    case M_PROPERTY_STEP_DOWN:
        *var += (arg ? *(int*)arg : 1) *
            (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
        M_PROPERTY_CLAMP(prop,*var);
        return 1;
    }
    return m_property_int_ro(prop,action,arg,*var);
}

int m_property_choice(m_option_t* prop,int action,
                      void* arg,int* var) {
    switch(action) {
    case M_PROPERTY_STEP_UP:
    case M_PROPERTY_STEP_DOWN:
        *var += action == M_PROPERTY_STEP_UP ? 1 : prop->max;
        *var %= (int)prop->max+1;
        return 1;
    }
    return m_property_int_range(prop,action,arg,var);
}

int m_property_flag(m_option_t* prop,int action,
                    void* arg,int* var) {
    switch(action) {
    case M_PROPERTY_STEP_UP:
    case M_PROPERTY_STEP_DOWN:
        *var = *var == prop->min ? prop->max : prop->min;
        return 1;
    case M_PROPERTY_PRINT:
        if(!arg) return 0;
        *(char**)arg = strdup((*var > prop->min) ? MSGTR_Enabled : MSGTR_Disabled);
        return 1;
    }
    return m_property_int_range(prop,action,arg,var);
}

int m_property_float_ro(m_option_t* prop,int action,
                        void* arg,float var) {
    switch(action) {
    case M_PROPERTY_GET:
        if(!arg) return 0;
        *(float*)arg = var;
        return 1;
    case M_PROPERTY_PRINT:
        if(!arg) return 0;
        *(char**)arg = malloc(20);
        sprintf(*(char**)arg,"%.2f",var);
        return 1;
    }
    return M_PROPERTY_NOT_IMPLEMENTED;
}

int m_property_float_range(m_option_t* prop,int action,
                           void* arg,float* var) {
    switch(action) {
    case M_PROPERTY_SET:
        if(!arg) return 0;
        M_PROPERTY_CLAMP(prop,*(float*)arg);
        *var = *(float*)arg;
        return 1;
    case M_PROPERTY_STEP_UP:
    case M_PROPERTY_STEP_DOWN:
        *var += (arg ? *(float*)arg : 0.1) *
            (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
        M_PROPERTY_CLAMP(prop,*var);
        return 1;
    }
    return m_property_float_ro(prop,action,arg,*var);
}

int m_property_delay(m_option_t* prop,int action,
                     void* arg,float* var) {
    switch(action) {
    case M_PROPERTY_PRINT:
        if(!arg) return 0;
        *(char**)arg = malloc(20);
        sprintf(*(char**)arg,"%d ms",ROUND((*var)*1000));
        return 1;
    default:
        return m_property_float_range(prop,action,arg,var);
    }
}

int m_property_double_ro(m_option_t* prop,int action,
                         void* arg,double var) {
    switch(action) {
    case M_PROPERTY_GET:
        if(!arg) return 0;
        *(double*)arg = var;
        return 1;
    case M_PROPERTY_PRINT:
        if(!arg) return 0;
        *(char**)arg = malloc(20);
        sprintf(*(char**)arg,"%.2f",var);
        return 1;
    }
    return M_PROPERTY_NOT_IMPLEMENTED;
}

int m_property_string_ro(m_option_t* prop,int action,void* arg,char* str) {
    switch(action) {
    case M_PROPERTY_GET:
        if(!arg) return 0;
        *(char**)arg = str;
        return 1;
    case M_PROPERTY_PRINT:
        if(!arg) return 0;
        *(char**)arg = str ? strdup(str) : NULL;
        return 1;
    }
    return M_PROPERTY_NOT_IMPLEMENTED;
}


2 by Reinhard Tartler upgrade to pre8	1	/// \file
	2	/// \ingroup Properties
	3
	4	#include "config.h"
	5
	6	#include <stdlib.h>
	7	#include <stdio.h>
	8	#include <string.h>
	9	#include <inttypes.h>
	10	#include <unistd.h>
	11
	12	#include "m_option.h"
	13	#include "m_property.h"
	14	#include "mp_msg.h"
	15	#include "help_mp.h"
	16
	17	#define ROUND(x) ((int)((x)<0 ? (x)-0.5 : (x)+0.5))
	18
	19	int m_property_do(m_option_t* prop, int action, void* arg) {
	20	if(!prop) return M_PROPERTY_UNKNOWN;
	21	return ((m_property_ctrl_f)prop->p)(prop,action,arg);
	22	}
	23
	24
	25	char* m_property_print(m_option_t* prop) {
	26	m_property_ctrl_f ctrl;
	27	void* val;
	28	char* ret;
	29
	30	if(!prop) return NULL;
	31
	32	ctrl = prop->p;
	33	// look if the property have it's own print func
	34	if(ctrl(prop,M_PROPERTY_PRINT,&ret) >= 0)
	35	return ret;
	36	// fallback on the default print for this type
	37	val = calloc(1,prop->type->size);
	38	if(ctrl(prop,M_PROPERTY_GET,val) <= 0) {
	39	free(val);
	40	return NULL;
	41	}
	42	ret = m_option_print(prop,val);
	43	free(val);
	44	return ret == (char*)-1 ? NULL : ret;
	45	}
	46
	47	int m_property_parse(m_option_t* prop, char* txt) {
	48	m_property_ctrl_f ctrl;
	49	void* val;
	50	int r;
	51
	52	if(!prop) return M_PROPERTY_UNKNOWN;
	53
	54	ctrl = prop->p;
	55	// try the property own parsing func
	56	if((r = ctrl(prop,M_PROPERTY_PARSE,txt)) != M_PROPERTY_NOT_IMPLEMENTED)
	57	return r;
	58	// fallback on the default
	59	val = calloc(1,prop->type->size);
	60	if((r = m_option_parse(prop,prop->name,txt,val,M_CONFIG_FILE)) <= 0) {
	61	free(val);
	62	return r;
	63	}
	64	r = ctrl(prop,M_PROPERTY_SET,val);
65	m_option_free(prop,val);
66	free(val);
67	return r;
68	}
69
70	char* m_properties_expand_string(m_option_t* prop_list,char* str) {
71	int l,fr=0,pos=0,size=strlen(str)+512;
72	char p = NULL,e,*ret = malloc(size), num_val;
73	int skip = 0, lvl = 0, skip_lvl = 0;
74
75	while(str[0]) {
76	if(str[0] == '\\') {
77	int sl = 1;
78	switch(str[1]) {
79	case 'e':
80	p = "\x1b", l = 1; break;
81	case 'n':
82	p = "\n", l = 1; break;
83	case 'r':
84	p = "\r", l = 1; break;
85	case 't':
86	p = "\t", l = 1; break;
87	case 'x':
88	if(str[2]) {
89	char num[3] = { str[2], str[3], 0 };
90	char* end = num;
91	num_val = strtol(num,&end,16);
92	sl = end-num;
93	l = 1;
94	p = &num_val;
95	} else
96	l = 0;
97	break;
98	default:
99	p = str+1, l = 1;
100	}
101	str+=1+sl;
102	} else if(lvl > 0 && str[0] == ')') {
103	if(skip && lvl <= skip_lvl) skip = 0;
104	lvl--, str++, l = 0;
105	} else if(str[0] == '$' && str[1] == '{' && (e = strchr(str+2,'}'))) {
106	int pl = e-str-2;
107	char pname[pl+1];
108	m_option_t* prop;
109	memcpy(pname,str+2,pl);
110	pname[pl] = 0;
111	if((prop = m_option_list_find(prop_list,pname)) &&
112	(p = m_property_print(prop)))
113	l = strlen(p), fr = 1;
114	else
115	l = 0;
116	str = e+1;
117	} else if(str[0] == '?' && str[1] == '(' && (e = strchr(str+2,':'))) {
118	int pl = e-str-2;
119	char pname[pl+1];
120	m_option_t* prop;
121	lvl++;
122	if(!skip) {
123	memcpy(pname,str+2,pl);
124	pname[pl] = 0;
125	if(!(prop = m_option_list_find(prop_list,pname)) \|\|
126	m_property_do(prop,M_PROPERTY_GET,NULL) < 0)
127	skip = 1, skip_lvl = lvl;
128	}
129	str = e+1, l = 0;
130	} else
131	p = str, l = 1, str++;
132
133	if(skip \|\| l <= 0) continue;
134
135	if(pos+l+1 > size) {
136	size = pos+l+512;
137	ret = realloc(ret,size);
138	}
139	memcpy(ret+pos,p,l);
140	pos += l;
141	if(fr) free(p), fr = 0;
142	}
143
144	ret[pos] = 0;
145	return ret;
146	}
147
148	void m_properties_print_help_list(m_option_t* list) {
149	char min[50],max[50];
150	int i,count = 0;
151
152	mp_msg(MSGT_CFGPARSER, MSGL_INFO, MSGTR_PropertyListHeader);
153	for(i = 0 ; list[i].name ; i++) {
154	m_option_t* opt = &list[i];
155	if(opt->flags & M_OPT_MIN)
156	sprintf(min,"%-8.0f",opt->min);
157	else
158	strcpy(min,"No");
159	if(opt->flags & M_OPT_MAX)
160	sprintf(max,"%-8.0f",opt->max);
161	else
162	strcpy(max,"No");
163	mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %-20.20s %-15.15s %-10.10s %-10.10s\n",
164	opt->name,
165	opt->type->name,
166	min,
167	max);
168	count++;
169	}
170	mp_msg(MSGT_CFGPARSER, MSGL_INFO, MSGTR_TotalProperties, count);
171	}
172
173	// Some generic property implementations
174
175	int m_property_int_ro(m_option_t* prop,int action,
176	void* arg,int var) {
177	switch(action) {
178	case M_PROPERTY_GET:
179	if(!arg) return 0;
180	(int)arg = var;
181	return 1;
182	}
183	return M_PROPERTY_NOT_IMPLEMENTED;
184	}
185
186	int m_property_int_range(m_option_t* prop,int action,
187	void* arg,int* var) {
188	switch(action) {
189	case M_PROPERTY_SET:
190	if(!arg) return 0;
191	M_PROPERTY_CLAMP(prop,(int)arg);
192	var = (int*)arg;
193	return 1;
194	case M_PROPERTY_STEP_UP:
195	case M_PROPERTY_STEP_DOWN:
196	var += (arg ? (int)arg : 1)
197	(action == M_PROPERTY_STEP_DOWN ? -1 : 1);
198	M_PROPERTY_CLAMP(prop,*var);
199	return 1;
200	}
201	return m_property_int_ro(prop,action,arg,*var);
202	}
203
204	int m_property_choice(m_option_t* prop,int action,
205	void* arg,int* var) {
206	switch(action) {
207	case M_PROPERTY_STEP_UP:
208	case M_PROPERTY_STEP_DOWN:
209	*var += action == M_PROPERTY_STEP_UP ? 1 : prop->max;
210	*var %= (int)prop->max+1;
211	return 1;
212	}
213	return m_property_int_range(prop,action,arg,var);
214	}
215
216	int m_property_flag(m_option_t* prop,int action,
217	void* arg,int* var) {
218	switch(action) {
219	case M_PROPERTY_STEP_UP:
220	case M_PROPERTY_STEP_DOWN:
221	var = var == prop->min ? prop->max : prop->min;
222	return 1;
223	case M_PROPERTY_PRINT:
224	if(!arg) return 0;
225	(char)arg = strdup((var > prop->min) ? MSGTR_Enabled : MSGTR_Disabled);
226	return 1;
227	}
228	return m_property_int_range(prop,action,arg,var);
229	}
230
231	int m_property_float_ro(m_option_t* prop,int action,
232	void* arg,float var) {
233	switch(action) {
234	case M_PROPERTY_GET:
235	if(!arg) return 0;
236	(float)arg = var;
237	return 1;
238	case M_PROPERTY_PRINT:
239	if(!arg) return 0;
240	(char*)arg = malloc(20);
241	sprintf((char*)arg,"%.2f",var);
242	return 1;
243	}
244	return M_PROPERTY_NOT_IMPLEMENTED;
245	}
246
247	int m_property_float_range(m_option_t* prop,int action,
248	void* arg,float* var) {
249	switch(action) {
250	case M_PROPERTY_SET:
251	if(!arg) return 0;
252	M_PROPERTY_CLAMP(prop,(float)arg);
253	var = (float*)arg;
254	return 1;
255	case M_PROPERTY_STEP_UP:
256	case M_PROPERTY_STEP_DOWN:
257	var += (arg ? (float)arg : 0.1)
258	(action == M_PROPERTY_STEP_DOWN ? -1 : 1);
259	M_PROPERTY_CLAMP(prop,*var);
260	return 1;
261	}
262	return m_property_float_ro(prop,action,arg,*var);
263	}
264
265	int m_property_delay(m_option_t* prop,int action,
266	void* arg,float* var) {
267	switch(action) {
268	case M_PROPERTY_PRINT:
269	if(!arg) return 0;
270	(char*)arg = malloc(20);
271	sprintf((char)arg,"%d ms",ROUND((var)*1000));
272	return 1;
273	default:
274	return m_property_float_range(prop,action,arg,var);
275	}
276	}
277
278	int m_property_double_ro(m_option_t* prop,int action,
279	void* arg,double var) {
280	switch(action) {
281	case M_PROPERTY_GET:
282	if(!arg) return 0;
283	(double)arg = var;
284	return 1;
285	case M_PROPERTY_PRINT:
286	if(!arg) return 0;
287	(char*)arg = malloc(20);
288	sprintf((char*)arg,"%.2f",var);
289	return 1;
290	}
291	return M_PROPERTY_NOT_IMPLEMENTED;
292	}
293
294	int m_property_string_ro(m_option_t* prop,int action,void* arg,char* str) {
295	switch(action) {
296	case M_PROPERTY_GET:
297	if(!arg) return 0;
298	(char*)arg = str;
299	return 1;
300	case M_PROPERTY_PRINT:
301	if(!arg) return 0;
302	(char*)arg = str ? strdup(str) : NULL;
303	return 1;
304	}
305	return M_PROPERTY_NOT_IMPLEMENTED;
306	}
307