gstreamer/subprojects/gst-plugins-ugly/gst/realmedia/asmrules.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

713 lines
18 KiB
C
Raw Normal View History

/* GStreamer
* Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <string.h>
#include <stdlib.h>
#include "asmrules.h"
#define MAX_RULE_LENGTH 2048
/* define to enable some more debug */
#undef DEBUG
static GstASMNode *
gst_asm_node_new (void)
{
GstASMNode *node;
node = g_new0 (GstASMNode, 1);
node->type = GST_ASM_NODE_UNKNOWN;
return node;
}
static void
gst_asm_node_free (GstASMNode * node)
{
if (node->left)
gst_asm_node_free (node->left);
if (node->right)
gst_asm_node_free (node->right);
if (node->type == GST_ASM_NODE_VARIABLE && node->data.varname)
g_free (node->data.varname);
g_free (node);
}
static gfloat
gst_asm_operator_eval (GstASMOp optype, gfloat left, gfloat right)
{
gfloat result = 0.0;
switch (optype) {
case GST_ASM_OP_GREATER:
result = (gfloat) (left > right);
break;
case GST_ASM_OP_LESS:
result = (gfloat) (left < right);
break;
case GST_ASM_OP_GREATEREQUAL:
result = (gfloat) (left >= right);
break;
case GST_ASM_OP_LESSEQUAL:
result = (gfloat) (left <= right);
break;
case GST_ASM_OP_EQUAL:
result = (gfloat) (left == right);
break;
case GST_ASM_OP_NOTEQUAL:
result = (gfloat) (left != right);
break;
case GST_ASM_OP_AND:
result = (gfloat) (left && right);
break;
case GST_ASM_OP_OR:
result = (gfloat) (left || right);
break;
default:
break;
}
return result;
}
static gfloat
gst_asm_node_evaluate (GstASMNode * node, GHashTable * vars)
{
gfloat result = 0.0;
if (node == NULL)
return 0.0;
switch (node->type) {
case GST_ASM_NODE_VARIABLE:
{
gchar *val;
val = g_hash_table_lookup (vars, node->data.varname);
if (val)
result = (gfloat) atof (val);
break;
}
case GST_ASM_NODE_INTEGER:
result = (gfloat) node->data.intval;
break;
case GST_ASM_NODE_FLOAT:
result = node->data.floatval;
break;
case GST_ASM_NODE_OPERATOR:
{
gfloat left, right;
left = gst_asm_node_evaluate (node->left, vars);
right = gst_asm_node_evaluate (node->right, vars);
result = gst_asm_operator_eval (node->data.optype, left, right);
break;
}
default:
break;
}
return result;
}
#define IS_SPACE(p) (((p) == ' ') || ((p) == '\n') || \
((p) == '\r') || ((p) == '\t'))
#define IS_RULE_DELIM(p) (((p) == ',') || ((p) == ';') || ((p) == ')'))
#define IS_OPERATOR(p) (((p) == '>') || ((p) == '<') || \
((p) == '=') || ((p) == '!') || \
((p) == '&') || ((p) == '|'))
#define IS_NUMBER(p) ((((p) >= '0') && ((p) <= '9')) || ((p) == '.'))
#define IS_CHAR(p) (!IS_OPERATOR(ch) && !IS_RULE_DELIM(ch) && (ch != '\0'))
#define IS_OP_TOKEN(t) (((t) == GST_ASM_TOKEN_AND) || ((t) == GST_ASM_TOKEN_OR))
#define IS_COND_TOKEN(t) (((t) == GST_ASM_TOKEN_LESS) || ((t) == GST_ASM_TOKEN_LESSEQUAL) || \
((t) == GST_ASM_TOKEN_GREATER) || ((t) == GST_ASM_TOKEN_GREATEREQUAL) || \
((t) == GST_ASM_TOKEN_EQUAL) || ((t) == GST_ASM_TOKEN_NOTEQUAL))
typedef struct
{
const gchar *buffer;
gint pos;
gchar ch;
GstASMToken token;
gchar val[MAX_RULE_LENGTH];
} GstASMScan;
#define NEXT_CHAR(scan) ((scan)->ch = (scan)->buffer[(scan)->pos++])
#define THIS_CHAR(scan) ((scan)->ch)
static GstASMScan *
gst_asm_scan_new (const gchar * buffer)
{
GstASMScan *scan;
scan = g_new0 (GstASMScan, 1);
scan->buffer = buffer;
NEXT_CHAR (scan);
return scan;
}
static void
gst_asm_scan_free (GstASMScan * scan)
{
g_free (scan);
}
static void
gst_asm_scan_string (GstASMScan * scan, gchar delim)
{
gchar ch;
gint i = 0;
ch = THIS_CHAR (scan);
while ((ch != delim) && (ch != '\0')) {
if (i < MAX_RULE_LENGTH - 1)
scan->val[i++] = ch;
ch = NEXT_CHAR (scan);
if (ch == '\\')
ch = NEXT_CHAR (scan);
}
scan->val[i] = '\0';
if (ch == delim)
NEXT_CHAR (scan);
scan->token = GST_ASM_TOKEN_STRING;
}
static void
gst_asm_scan_number (GstASMScan * scan)
{
gchar ch;
gint i = 0;
gboolean have_float = FALSE;
ch = THIS_CHAR (scan);
/* real strips all spaces that are not inside quotes for numbers */
while ((IS_NUMBER (ch) || IS_SPACE (ch))) {
if (i < (MAX_RULE_LENGTH - 1) && !IS_SPACE (ch))
scan->val[i++] = ch;
if (ch == '.')
have_float = TRUE;
ch = NEXT_CHAR (scan);
}
scan->val[i] = '\0';
if (have_float)
scan->token = GST_ASM_TOKEN_FLOAT;
else
scan->token = GST_ASM_TOKEN_INT;
}
static void
gst_asm_scan_identifier (GstASMScan * scan)
{
gchar ch;
gint i = 0;
ch = THIS_CHAR (scan);
/* real strips all spaces that are not inside quotes for identifiers */
while ((IS_CHAR (ch) || IS_SPACE (ch))) {
if (i < (MAX_RULE_LENGTH - 1) && !IS_SPACE (ch))
scan->val[i++] = ch;
ch = NEXT_CHAR (scan);
}
scan->val[i] = '\0';
scan->token = GST_ASM_TOKEN_IDENTIFIER;
}
static void
gst_asm_scan_print_token (GstASMScan * scan)
{
#ifdef DEBUG
switch (scan->token) {
case GST_ASM_TOKEN_NONE:
g_print ("none\n");
break;
case GST_ASM_TOKEN_EOF:
g_print ("EOF\n");
break;
case GST_ASM_TOKEN_INT:
g_print ("INT %d\n", atoi (scan->val));
break;
case GST_ASM_TOKEN_FLOAT:
g_print ("FLOAT %f\n", atof (scan->val));
break;
case GST_ASM_TOKEN_IDENTIFIER:
g_print ("ID %s\n", scan->val);
break;
case GST_ASM_TOKEN_STRING:
g_print ("STRING %s\n", scan->val);
break;
case GST_ASM_TOKEN_HASH:
g_print ("HASH\n");
break;
case GST_ASM_TOKEN_SEMICOLON:
g_print ("SEMICOLON\n");
break;
case GST_ASM_TOKEN_COMMA:
g_print ("COMMA\n");
break;
case GST_ASM_TOKEN_EQUAL:
g_print ("==\n");
break;
case GST_ASM_TOKEN_NOTEQUAL:
g_print ("!=\n");
break;
case GST_ASM_TOKEN_AND:
g_print ("&&\n");
break;
case GST_ASM_TOKEN_OR:
g_print ("||\n");
break;
case GST_ASM_TOKEN_LESS:
g_print ("<\n");
break;
case GST_ASM_TOKEN_LESSEQUAL:
g_print ("<=\n");
break;
case GST_ASM_TOKEN_GREATER:
g_print (">\n");
break;
case GST_ASM_TOKEN_GREATEREQUAL:
g_print (">=\n");
break;
case GST_ASM_TOKEN_DOLLAR:
g_print ("$\n");
break;
case GST_ASM_TOKEN_LPAREN:
g_print ("(\n");
break;
case GST_ASM_TOKEN_RPAREN:
g_print (")\n");
break;
default:
break;
}
#endif
}
static GstASMToken
gst_asm_scan_next_token (GstASMScan * scan)
{
gchar ch;
ch = THIS_CHAR (scan);
/* skip spaces */
while (IS_SPACE (ch))
ch = NEXT_CHAR (scan);
/* remove \ which is common in front of " */
while (ch == '\\')
ch = NEXT_CHAR (scan);
switch (ch) {
case '#':
scan->token = GST_ASM_TOKEN_HASH;
NEXT_CHAR (scan);
break;
case ';':
scan->token = GST_ASM_TOKEN_SEMICOLON;
NEXT_CHAR (scan);
break;
case ',':
scan->token = GST_ASM_TOKEN_COMMA;
NEXT_CHAR (scan);
break;
case '=':
scan->token = GST_ASM_TOKEN_EQUAL;
if (NEXT_CHAR (scan) == '=')
NEXT_CHAR (scan);
break;
case '!':
if (NEXT_CHAR (scan) == '=') {
scan->token = GST_ASM_TOKEN_NOTEQUAL;
NEXT_CHAR (scan);
}
break;
case '&':
scan->token = GST_ASM_TOKEN_AND;
if (NEXT_CHAR (scan) == '&')
NEXT_CHAR (scan);
break;
case '|':
scan->token = GST_ASM_TOKEN_OR;
if (NEXT_CHAR (scan) == '|')
NEXT_CHAR (scan);
break;
case '<':
scan->token = GST_ASM_TOKEN_LESS;
if (NEXT_CHAR (scan) == '=') {
scan->token = GST_ASM_TOKEN_LESSEQUAL;
NEXT_CHAR (scan);
}
break;
case '>':
scan->token = GST_ASM_TOKEN_GREATER;
if (NEXT_CHAR (scan) == '=') {
scan->token = GST_ASM_TOKEN_GREATEREQUAL;
NEXT_CHAR (scan);
}
break;
case '$':
scan->token = GST_ASM_TOKEN_DOLLAR;
NEXT_CHAR (scan);
break;
case '(':
scan->token = GST_ASM_TOKEN_LPAREN;
NEXT_CHAR (scan);
break;
case ')':
scan->token = GST_ASM_TOKEN_RPAREN;
NEXT_CHAR (scan);
break;
case '"':
NEXT_CHAR (scan);
gst_asm_scan_string (scan, '"');
break;
case '\'':
NEXT_CHAR (scan);
gst_asm_scan_string (scan, '\'');
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
gst_asm_scan_number (scan);
break;
case '\0':
scan->token = GST_ASM_TOKEN_EOF;
break;
default:
gst_asm_scan_identifier (scan);
break;
}
gst_asm_scan_print_token (scan);
return scan->token;
}
static GstASMRule *
gst_asm_rule_new (void)
{
GstASMRule *rule;
rule = g_new (GstASMRule, 1);
rule->root = NULL;
rule->props = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
return rule;
}
static void
gst_asm_rule_free (GstASMRule * rule)
{
g_hash_table_destroy (rule->props);
if (rule->root)
gst_asm_node_free (rule->root);
g_free (rule);
}
static void
gst_asm_rule_add_property (GstASMRule * rule, gchar * key, gchar * val)
{
g_hash_table_insert (rule->props, key, val);
}
static GstASMNode *gst_asm_scan_parse_condition (GstASMScan * scan);
static GstASMNode *
gst_asm_scan_parse_operand (GstASMScan * scan)
{
GstASMNode *node;
switch (scan->token) {
case GST_ASM_TOKEN_DOLLAR:
gst_asm_scan_next_token (scan);
if (scan->token != GST_ASM_TOKEN_IDENTIFIER)
g_warning ("identifier expected");
node = gst_asm_node_new ();
node->type = GST_ASM_NODE_VARIABLE;
node->data.varname = g_strdup (scan->val);
break;
case GST_ASM_TOKEN_INT:
node = gst_asm_node_new ();
node->type = GST_ASM_NODE_INTEGER;
node->data.intval = (gfloat) atof (scan->val);
break;
case GST_ASM_TOKEN_FLOAT:
node = gst_asm_node_new ();
node->type = GST_ASM_NODE_FLOAT;
node->data.floatval = atoi (scan->val);
break;
case GST_ASM_TOKEN_LPAREN:
gst_asm_scan_next_token (scan);
node = gst_asm_scan_parse_condition (scan);
if (scan->token != GST_ASM_TOKEN_RPAREN)
g_warning (") expected");
break;
default:
g_warning ("$ <number> or ) expected");
node = NULL;
break;
}
gst_asm_scan_next_token (scan);
return node;
}
static GstASMNode *
gst_asm_scan_parse_expression (GstASMScan * scan)
{
GstASMNode *node, *left;
node = gst_asm_scan_parse_operand (scan);
while (IS_COND_TOKEN (scan->token)) {
left = node;
node = gst_asm_node_new ();
node->type = GST_ASM_NODE_OPERATOR;
node->data.optype = (GstASMOp) scan->token;
gst_asm_scan_next_token (scan);
node->right = gst_asm_scan_parse_operand (scan);
node->left = left;
}
return node;
}
static GstASMNode *
gst_asm_scan_parse_condition (GstASMScan * scan)
{
GstASMNode *node, *left;
node = gst_asm_scan_parse_expression (scan);
while (IS_OP_TOKEN (scan->token)) {
left = node;
node = gst_asm_node_new ();
node->type = GST_ASM_NODE_OPERATOR;
node->data.optype = (GstASMOp) scan->token;
gst_asm_scan_next_token (scan);
node->right = gst_asm_scan_parse_expression (scan);
node->left = left;
}
return node;
}
static void
gst_asm_scan_parse_property (GstASMRule * rule, GstASMScan * scan)
{
gchar *key, *val;
if (scan->token != GST_ASM_TOKEN_IDENTIFIER) {
g_warning ("identifier expected");
return;
}
key = g_strdup (scan->val);
gst_asm_scan_next_token (scan);
if (scan->token != GST_ASM_TOKEN_EQUAL) {
g_warning ("= expected");
g_free (key);
return;
}
gst_asm_scan_next_token (scan);
val = g_strdup (scan->val);
gst_asm_rule_add_property (rule, key, val);
gst_asm_scan_next_token (scan);
}
static GstASMRule *
gst_asm_scan_parse_rule (GstASMScan * scan)
{
GstASMRule *rule;
rule = gst_asm_rule_new ();
if (scan->token == GST_ASM_TOKEN_HASH) {
gst_asm_scan_next_token (scan);
rule->root = gst_asm_scan_parse_condition (scan);
if (scan->token == GST_ASM_TOKEN_COMMA)
gst_asm_scan_next_token (scan);
}
if (scan->token != GST_ASM_TOKEN_SEMICOLON) {
gst_asm_scan_parse_property (rule, scan);
while (scan->token == GST_ASM_TOKEN_COMMA) {
gst_asm_scan_next_token (scan);
gst_asm_scan_parse_property (rule, scan);
}
gst_asm_scan_next_token (scan);
}
return rule;
}
static gboolean
gst_asm_rule_evaluate (GstASMRule * rule, GHashTable * vars)
{
gboolean res;
if (rule->root) {
res = (gboolean) gst_asm_node_evaluate (rule->root, vars);
} else
res = TRUE;
return res;
}
GstASMRuleBook *
gst_asm_rule_book_new (const gchar * rulebook)
{
GstASMRuleBook *book;
GstASMRule *rule = NULL;
GstASMScan *scan;
GstASMToken token;
book = g_new0 (GstASMRuleBook, 1);
book->rulebook = rulebook;
scan = gst_asm_scan_new (book->rulebook);
gst_asm_scan_next_token (scan);
do {
rule = gst_asm_scan_parse_rule (scan);
if (rule) {
book->rules = g_list_append (book->rules, rule);
book->n_rules++;
}
token = scan->token;
} while (token != GST_ASM_TOKEN_EOF);
gst_asm_scan_free (scan);
return book;
}
void
gst_asm_rule_book_free (GstASMRuleBook * book)
{
GList *walk;
for (walk = book->rules; walk; walk = g_list_next (walk)) {
GstASMRule *rule = (GstASMRule *) walk->data;
gst_asm_rule_free (rule);
}
g_list_free (book->rules);
g_free (book);
}
gint
gst_asm_rule_book_match (GstASMRuleBook * book, GHashTable * vars,
gint * rulematches)
{
GList *walk;
gint i, n = 0;
for (walk = book->rules, i = 0; walk; walk = g_list_next (walk), i++) {
GstASMRule *rule = (GstASMRule *) walk->data;
if (gst_asm_rule_evaluate (rule, vars)) {
rulematches[n++] = i;
}
}
return n;
}
#ifdef TEST
gint
main (gint argc, gchar * argv[])
{
GstASMRuleBook *book;
gint rulematch[MAX_RULEMATCHES];
GHashTable *vars;
gint i, n;
static const gchar rules1[] =
"#($Bandwidth < 67959),TimestampDelivery=T,DropByN=T,"
"priority=9;#($Bandwidth >= 67959) && ($Bandwidth < 167959),"
"AverageBandwidth=67959,Priority=9;#($Bandwidth >= 67959) && ($Bandwidth"
" < 167959),AverageBandwidth=0,Priority=5,OnDepend=\\\"1\\\";#($Bandwidth >= 167959)"
" && ($Bandwidth < 267959),AverageBandwidth=167959,Priority=9;#($Bandwidth >= 167959)"
" && ($Bandwidth < 267959),AverageBandwidth=0,Priority=5,OnDepend=\\\"3\\\";"
"#($Bandwidth >= 267959),AverageBandwidth=267959,Priority=9;#($Bandwidth >= 267959)"
",AverageBandwidth=0,Priority=5,OnDepend=\\\"5\\\";";
static const gchar rules2[] =
"AverageBandwidth=32041,Priority=5;AverageBandwidth=0,"
"Priority=5,OnDepend=\\\"0\\\", OffDepend=\\\"0\\\";";
static const gchar rules3[] =
"#(($Bandwidth >= 27500) && ($OldPNMPlayer)),AverageBandwidth=27500,priority=9,PNMKeyframeRule=T;#(($Bandwidth >= 27500) && ($OldPNMPlayer)),AverageBandwidth=0,priority=5,PNMNonKeyframeRule=T;#(($Bandwidth < 27500) && ($OldPNMPlayer)),TimestampDelivery=T,DropByN=T,priority=9,PNMThinningRule=T;#($Bandwidth < 13899),TimestampDelivery=T,DropByN=T,priority=9;#($Bandwidth >= 13899) && ($Bandwidth < 19000),AverageBandwidth=13899,Priority=9;#($Bandwidth >= 13899) && ($Bandwidth < 19000),AverageBandwidth=0,Priority=5,OnDepend=\\\"4\\\";#($Bandwidth >= 19000) && ($Bandwidth < 27500),AverageBandwidth=19000,Priority=9;#($Bandwidth >= 19000) && ($Bandwidth < 27500),AverageBandwidth=0,Priority=5,OnDepend=\\\"6\\\";#($Bandwidth >= 27500) && ($Bandwidth < 132958),AverageBandwidth=27500,Priority=9;#($Bandwidth >= 27500) && ($Bandwidth < 132958),AverageBandwidth=0,Priority=5,OnDepend=\\\"8\\\";#($Bandwidth >= 132958) && ($Bandwidth < 187958),AverageBandwidth=132958,Priority=9;#($Bandwidth >= 132958) && ($Bandwidth < 187958),AverageBandwidth=0,Priority=5,OnDepend=\\\"10\\\";#($Bandwidth >= 187958),AverageBandwidth=187958,Priority=9;#($Bandwidth >= 187958),AverageBandwidth=0,Priority=5,OnDepend=\\\"12\\\";";
vars = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (vars, (gchar *) "Bandwidth", (gchar *) "300000");
book = gst_asm_rule_book_new (rules1);
n = gst_asm_rule_book_match (book, vars, rulematch);
gst_asm_rule_book_free (book);
g_print ("%d rules matched\n", n);
for (i = 0; i < n; i++) {
g_print ("rule %d matched\n", rulematch[i]);
}
book = gst_asm_rule_book_new (rules2);
n = gst_asm_rule_book_match (book, vars, rulematch);
gst_asm_rule_book_free (book);
g_print ("%d rules matched\n", n);
for (i = 0; i < n; i++) {
g_print ("rule %d matched\n", rulematch[i]);
}
book = gst_asm_rule_book_new (rules3);
n = gst_asm_rule_book_match (book, vars, rulematch);
gst_asm_rule_book_free (book);
g_print ("%d rules matched\n", n);
for (i = 0; i < n; i++) {
g_print ("rule %d matched\n", rulematch[i]);
}
g_hash_table_destroy (vars);
return 0;
}
#endif