~ubuntu-dev/mplayer/ubuntu-feisty

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