]> git.sesse.net Git - vlc/blob - modules/access/rtsp/real_asmrp.c
Add MJPEG support to the v4l2 access (and simplify the buffer size handling code...
[vlc] / modules / access / rtsp / real_asmrp.c
1 /*
2  * Copyright (C) 2002-2004 the xine project
3  *
4  * This file is part of xine, a free video player.
5  *
6  * xine is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * xine is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
19  *
20  * $Id$
21  *
22  * a parser for real's asm rules
23  *
24  * grammar for these rules:
25  *
26
27    rule_book  = { rule }
28    rule       = ( '#' condition { ',' assignment } | [ assignment {',' assignment} ]) ';'
29    assignment = id '=' const
30    const      = ( number | string )
31    condition  = comp_expr { ( '&&' | '||' ) comp_expr }
32    comp_expr  = operand { ( '<' | '<=' | '==' | '>=' | '>' ) operand }
33    operand    = ( '$' id | num | '(' condition ')' )
34
35  */
36
37 #include "real.h"
38
39 #define ASMRP_SYM_NONE         0
40 #define ASMRP_SYM_EOF          1
41
42 #define ASMRP_SYM_NUM          2
43 #define ASMRP_SYM_ID           3
44 #define ASMRP_SYM_STRING       4
45
46 #define ASMRP_SYM_HASH         10
47 #define ASMRP_SYM_SEMICOLON    11
48 #define ASMRP_SYM_COMMA        12
49 #define ASMRP_SYM_EQUALS       13
50 #define ASMRP_SYM_AND          14
51 #define ASMRP_SYM_OR           15
52 #define ASMRP_SYM_LESS         16
53 #define ASMRP_SYM_LEQ          17
54 #define ASMRP_SYM_GEQ          18
55 #define ASMRP_SYM_GREATER      19
56 #define ASMRP_SYM_DOLLAR       20
57 #define ASMRP_SYM_LPAREN       21
58 #define ASMRP_SYM_RPAREN       22
59
60 #define ASMRP_MAX_ID         1024
61
62 #define ASMRP_MAX_SYMTAB       10
63
64 typedef struct {
65   char *id;
66   int   v;
67 } asmrp_sym_t;
68
69 typedef struct {
70
71   /* public part */
72
73   int         sym;
74   int         num;
75  
76   char        str[ASMRP_MAX_ID];
77
78   /* private part */
79
80   char       *buf;
81   int         pos;
82   char        ch;
83
84   asmrp_sym_t sym_tab[ASMRP_MAX_SYMTAB];
85   int         sym_tab_num;
86
87 } asmrp_t;
88
89 static asmrp_t *asmrp_new (void ) {
90
91   asmrp_t *p;
92
93   p = malloc (sizeof (asmrp_t));
94
95   p->sym_tab_num = 0;
96   p->sym         = ASMRP_SYM_NONE;
97   p->buf         = 0;
98
99   return p;
100 }
101
102 static void asmrp_dispose (asmrp_t *p) {
103
104   int i;
105
106   for (i=0; i<p->sym_tab_num; i++)
107     free (p->sym_tab[i].id);
108
109   if (p->buf) free (p->buf);
110   free (p);
111 }
112
113 static void asmrp_getch (asmrp_t *p) {
114   p->ch = p->buf[p->pos];
115   p->pos++;
116
117   lprintf ("%c\n", p->ch);
118
119 }
120
121 static void asmrp_init (asmrp_t *p, const char *str) {
122
123   p->buf = strdup (str);
124   p->pos = 0;
125  
126   asmrp_getch (p);
127 }
128
129 static void asmrp_number (asmrp_t *p) {
130
131   int num;
132
133   num = 0;
134   while ( (p->ch>='0') && (p->ch<='9') ) {
135
136     num = num*10 + (p->ch - '0');
137
138     asmrp_getch (p);
139   }
140
141   p->sym = ASMRP_SYM_NUM;
142   p->num = num;
143 }
144
145 static void asmrp_string (asmrp_t *p) {
146
147   int l;
148
149   l = 0;
150
151   while ( (p->ch!='"') && (p->ch>=32) ) {
152
153     p->str[l] = p->ch;
154
155     l++;
156     asmrp_getch (p);
157   }
158   p->str[l]=0;
159  
160   if (p->ch=='"')
161     asmrp_getch (p);
162  
163   p->sym = ASMRP_SYM_STRING;
164 }
165
166 static void asmrp_identifier (asmrp_t *p) {
167
168   int l;
169
170   l = 0;
171
172   while ( ((p->ch>='A') && (p->ch<='z'))
173       || ((p->ch>='0') && (p->ch<='9'))) {
174
175     p->str[l] = p->ch;
176
177     l++;
178     asmrp_getch (p);
179   }
180   p->str[l]=0;
181  
182   p->sym = ASMRP_SYM_ID;
183 }
184
185 #ifdef LOG
186 static void asmrp_print_sym (asmrp_t *p) {
187
188   printf ("symbol: ");
189
190   switch (p->sym) {
191
192   case ASMRP_SYM_NONE:
193     printf ("NONE\n");
194     break;
195
196   case ASMRP_SYM_EOF:
197     printf ("EOF\n");
198     break;
199
200   case ASMRP_SYM_NUM:
201     printf ("NUM %d\n", p->num);
202     break;
203
204   case ASMRP_SYM_ID:
205     printf ("ID '%s'\n", p->str);
206     break;
207
208   case ASMRP_SYM_STRING:
209     printf ("STRING \"%s\"\n", p->str);
210     break;
211
212   case ASMRP_SYM_HASH:
213     printf ("#\n");
214     break;
215
216   case ASMRP_SYM_SEMICOLON:
217     printf (";\n");
218     break;
219   case ASMRP_SYM_COMMA:
220     printf (",\n");
221     break;
222   case ASMRP_SYM_EQUALS:
223     printf ("==\n");
224     break;
225   case ASMRP_SYM_AND:
226     printf ("&&\n");
227     break;
228   case ASMRP_SYM_OR:
229     printf ("||\n");
230     break;
231   case ASMRP_SYM_LESS:
232     printf ("<\n");
233     break;
234   case ASMRP_SYM_LEQ:
235     printf ("<=\n");
236     break;
237   case ASMRP_SYM_GEQ:
238     printf (">=\n");
239     break;
240   case ASMRP_SYM_GREATER:
241     printf (">\n");
242     break;
243   case ASMRP_SYM_DOLLAR:
244     printf ("$\n");
245     break;
246   case ASMRP_SYM_LPAREN:
247     printf ("(\n");
248     break;
249   case ASMRP_SYM_RPAREN:
250     printf (")\n");
251     break;
252
253   default:
254     printf ("unknown symbol %d\n", p->sym);
255   }
256 }
257 #endif
258
259 static void asmrp_get_sym (asmrp_t *p) {
260
261   while (p->ch <= 32) {
262     if (p->ch == 0) {
263       p->sym = ASMRP_SYM_EOF;
264       return;
265     }
266
267     asmrp_getch (p);
268   }
269
270   if (p->ch == '\\')
271     asmrp_getch (p);
272
273   switch (p->ch) {
274
275   case '#':
276     p->sym = ASMRP_SYM_HASH;
277     asmrp_getch (p);
278     break;
279   case ';':
280     p->sym = ASMRP_SYM_SEMICOLON;
281     asmrp_getch (p);
282     break;
283   case ',':
284     p->sym = ASMRP_SYM_COMMA;
285     asmrp_getch (p);
286     break;
287   case '=':
288     p->sym = ASMRP_SYM_EQUALS;
289     asmrp_getch (p);
290     if (p->ch=='=')
291       asmrp_getch (p);
292     break;
293   case '&':
294     p->sym = ASMRP_SYM_AND;
295     asmrp_getch (p);
296     if (p->ch=='&')
297       asmrp_getch (p);
298     break;
299   case '|':
300     p->sym = ASMRP_SYM_OR;
301     asmrp_getch (p);
302     if (p->ch=='|')
303       asmrp_getch (p);
304     break;
305   case '<':
306     p->sym = ASMRP_SYM_LESS;
307     asmrp_getch (p);
308     if (p->ch=='=') {
309       p->sym = ASMRP_SYM_LEQ;
310       asmrp_getch (p);
311     }
312     break;
313   case '>':
314     p->sym = ASMRP_SYM_GREATER;
315     asmrp_getch (p);
316     if (p->ch=='=') {
317       p->sym = ASMRP_SYM_GEQ;
318       asmrp_getch (p);
319     }
320     break;
321   case '$':
322     p->sym = ASMRP_SYM_DOLLAR;
323     asmrp_getch (p);
324     break;
325   case '(':
326     p->sym = ASMRP_SYM_LPAREN;
327     asmrp_getch (p);
328     break;
329   case ')':
330     p->sym = ASMRP_SYM_RPAREN;
331     asmrp_getch (p);
332     break;
333
334   case '"':
335     asmrp_getch (p);
336     asmrp_string (p);
337     break;
338
339   case '0': case '1': case '2': case '3': case '4':
340   case '5': case '6': case '7': case '8': case '9':
341     asmrp_number (p);
342     break;
343
344   default:
345     asmrp_identifier (p);
346   }
347
348 #ifdef LOG
349   asmrp_print_sym (p);
350 #endif
351
352 }
353
354 static int asmrp_find_id (asmrp_t *p, const char *s) {
355
356   int i;
357
358   for (i=0; i<p->sym_tab_num; i++) {
359     if (!strcmp (s, p->sym_tab[i].id))
360       return i;
361   }
362
363   return -1;
364 }
365
366 static int asmrp_set_id (asmrp_t *p, const char *s, int v) {
367
368   int i;
369
370   i = asmrp_find_id (p, s);
371
372   if (i<0) {
373     i = p->sym_tab_num;
374     p->sym_tab_num++;
375     p->sym_tab[i].id = strdup (s);
376
377     lprintf ("new symbol '%s'\n", s);
378
379   }
380
381   p->sym_tab[i].v = v;
382  
383   lprintf ("symbol '%s' assigned %d\n", s, v);
384
385   return i;
386 }
387
388 static int asmrp_condition (asmrp_t *p) ;
389
390 static int asmrp_operand (asmrp_t *p) {
391
392   int i, ret;
393  
394   lprintf ("operand\n");
395
396   ret = 0;
397
398   switch (p->sym) {
399
400   case ASMRP_SYM_DOLLAR:
401
402     asmrp_get_sym (p);
403  
404     if (p->sym != ASMRP_SYM_ID) {
405       printf ("error: identifier expected.\n");
406       break;
407     }
408
409     i = asmrp_find_id (p, p->str);
410     if (i<0) {
411       lprintf ("error: unknown identifier %s\n", p->str);
412     }
413     ret = p->sym_tab[i].v;
414
415     asmrp_get_sym (p);
416     break;
417
418   case ASMRP_SYM_NUM:
419     ret = p->num;
420
421     asmrp_get_sym (p);
422     break;
423
424   case ASMRP_SYM_LPAREN:
425     asmrp_get_sym (p);
426
427     ret = asmrp_condition (p);
428
429     if (p->sym != ASMRP_SYM_RPAREN) {
430       printf ("error: ) expected.\n");
431       break;
432     }
433
434     asmrp_get_sym (p);
435     break;
436
437   default:
438     lprintf ("syntax error, $ number or ( expected\n");
439     break;
440   }
441
442   lprintf ("operand done, =%d\n", ret);
443  
444   return ret;
445 }
446
447 static int asmrp_comp_expression (asmrp_t *p) {
448
449   int a;
450
451   lprintf ("comp_expression\n");
452
453   a = asmrp_operand (p);
454
455   while ( (p->sym == ASMRP_SYM_LESS)
456       || (p->sym == ASMRP_SYM_LEQ)
457       || (p->sym == ASMRP_SYM_EQUALS)
458       || (p->sym == ASMRP_SYM_GEQ)
459       || (p->sym == ASMRP_SYM_GREATER) ) {
460     int op = p->sym;
461     int b;
462
463     asmrp_get_sym (p);
464
465     b = asmrp_operand (p);
466
467     switch (op) {
468     case ASMRP_SYM_LESS:
469       a = a<b;
470       break;
471     case ASMRP_SYM_LEQ:
472       a = a<=b;
473       break;
474     case ASMRP_SYM_EQUALS:
475       a = a==b;
476       break;
477     case ASMRP_SYM_GEQ:
478       a = a>=b;
479       break;
480     case ASMRP_SYM_GREATER:
481       a = a>b;
482       break;
483     }
484
485   }
486
487   lprintf ("comp_expression done = %d\n", a);
488
489   return a;
490 }
491
492 static int asmrp_condition (asmrp_t *p) {
493  
494   int a;
495
496   lprintf ("condition\n");
497
498   a = asmrp_comp_expression (p);
499
500   while ( (p->sym == ASMRP_SYM_AND) || (p->sym == ASMRP_SYM_OR) ) {
501     int op, b;
502
503     op = p->sym;
504
505     asmrp_get_sym (p);
506
507     b = asmrp_comp_expression (p);
508
509     switch (op) {
510     case ASMRP_SYM_AND:
511       a = a & b;
512       break;
513     case ASMRP_SYM_OR:
514       a = a | b;
515       break;
516     }
517   }
518
519   lprintf ("condition done = %d\n", a);
520
521   return a;
522 }
523
524 static void asmrp_assignment (asmrp_t *p) {
525
526   lprintf ("assignment\n");
527
528   if (p->sym == ASMRP_SYM_COMMA || p->sym == ASMRP_SYM_SEMICOLON) {
529     lprintf ("empty assignment\n");
530     return;
531   }
532  
533   if (p->sym != ASMRP_SYM_ID) {
534     printf ("error: identifier expected\n");
535     return;
536   }
537   asmrp_get_sym (p);
538
539   if (p->sym != ASMRP_SYM_EQUALS) {
540     printf ("error: = expected\n");
541     return;
542   }
543   asmrp_get_sym (p);
544
545   if ( (p->sym != ASMRP_SYM_NUM) && (p->sym != ASMRP_SYM_STRING)
546        && (p->sym != ASMRP_SYM_ID)) {
547     printf ("error: number or string expected\n");
548     return;
549   }
550   asmrp_get_sym (p);
551
552   lprintf ("assignment done\n");
553 }
554
555 static int asmrp_rule (asmrp_t *p) {
556  
557   int ret;
558
559   lprintf ("rule\n");
560
561   ret = 1;
562  
563   if (p->sym == ASMRP_SYM_HASH) {
564
565     asmrp_get_sym (p);
566     ret = asmrp_condition (p);
567
568     while (p->sym == ASMRP_SYM_COMMA) {
569  
570       asmrp_get_sym (p);
571  
572       asmrp_assignment (p);
573     }
574
575   } else if (p->sym != ASMRP_SYM_SEMICOLON) {
576
577     asmrp_assignment (p);
578
579     while (p->sym == ASMRP_SYM_COMMA) {
580
581       asmrp_get_sym (p);
582       asmrp_assignment (p);
583     }
584   }
585
586   lprintf ("rule done = %d\n", ret);
587
588   if (p->sym != ASMRP_SYM_SEMICOLON) {
589     printf ("semicolon expected.\n");
590     return ret;
591   }
592
593   asmrp_get_sym (p);
594
595   return ret;
596 }
597
598 static int asmrp_eval (asmrp_t *p, int *matches) {
599
600   int rule_num, num_matches;
601
602   lprintf ("eval\n");
603
604   asmrp_get_sym (p);
605
606   rule_num = 0; num_matches = 0;
607   while (p->sym != ASMRP_SYM_EOF) {
608
609     if (asmrp_rule (p)) {
610       lprintf ("rule #%d is true\n", rule_num);
611
612       matches[num_matches] = rule_num;
613       num_matches++;
614     }
615
616     rule_num++;
617   }
618
619   matches[num_matches] = -1;
620   return num_matches;
621 }
622
623 int asmrp_match (const char *rules, int bandwidth, int *matches) {
624
625   asmrp_t *p;
626   int      num_matches;
627
628   p = asmrp_new ();
629
630   asmrp_init (p, rules);
631
632   asmrp_set_id (p, "Bandwidth", bandwidth);
633   asmrp_set_id (p, "OldPNMPlayer", 0);
634
635   num_matches = asmrp_eval (p, matches);
636
637   asmrp_dispose (p);
638
639   return num_matches;
640 }
641