Improve animation-string detection in mlt_property_is_anim

Fix false positives where plain strings containing '=' were treated as
animated properties.

- replace the naive "contains '='" check with keyframe-aware parsing
- require an unquoted key=value token whose key parses as a frame/time token
- support optional single-character keyframe-type markers before '='
  (e.g. |, !, ~, $, -, and easing markers A-D/a-z)
- ignore separators inside quoted payloads so normal string values remain valid
- document the updated detection rules in the API comment

This preserves valid animation strings while preventing non-animated text
(such as URL/query-like values) from being misclassified as animation.

Author: bmatherly

src/framework/mlt_property.c

@@ -29,6 +29,7 @@
 #include "mlt_animation.h"
 #include "mlt_properties.h"
 
+#include <ctype.h>
 #include <float.h>
 #include <locale.h>
 #include <math.h>
@@ -2106,18 +2107,94 @@ mlt_properties mlt_property_get_properties(mlt_property self)
     return properties;
 }
 
+static int is_keyframe_type_marker(char c)
+{
+    switch (c) {
+    case '|':
+    case '!':
+    case '~':
+    case '$':
+    case '-':
+        return 1;
+    default:
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'D');
+    }
+}
+
+static int is_keyframe_token(const char *begin, const char *end)
+{
+    while (begin < end && isspace((unsigned char) *begin))
+        ++begin;
+    while (end > begin && isspace((unsigned char) end[-1]))
+        --end;
+    if (begin >= end)
+        return 0;
+
+    if (end - begin > 1 && is_keyframe_type_marker(end[-1]))
+        --end;
+
+    int has_digit = 0;
+    int trailing_unit_seen = 0;
+    for (const char *p = begin; p < end; ++p) {
+        unsigned char c = (unsigned char) *p;
+        if (isdigit(c)) {
+            has_digit = 1;
+            continue;
+        }
+        if (c == ':' || c == '.' || c == ',' || c == '-' || c == '+')
+            continue;
+        if (isalpha(c) && p == end - 1 && !trailing_unit_seen && has_digit) {
+            trailing_unit_seen = 1;
+            continue;
+        }
+        return 0;
+    }
+    return has_digit;
+}
+
 /** Check if a property is animated.
  *
  * This is not a thread-safe function because it is used internally by
  * mlt_property_s under a lock. However, external callers should protect it.
+ *
+ * A property counts as animated when it already has an animation object or
+ * when its serialized string contains at least one unquoted keyframe item of
+ * the form key=value, where key looks like a frame or time token. This also
+ * accepts the optional single-character keyframe-type marker that serialized
+ * animations place immediately before '='.
+ *
+ * This intentionally does not treat every '=' as animation syntax. Plain
+ * strings may legitimately contain '=' or ';' characters, and those continue
+ * to work as ordinary string values. Quoted string payloads inside animation
+ * strings also continue to work: text between double quotes is ignored while
+ * scanning for separators, matching the documented requirement to quote string
+ * values that contain animation delimiters.
+ *
  * \public \memberof mlt_property_s
  * \param self a property
  * \return true if the property is animated
  */
 
 int mlt_property_is_anim(mlt_property self)
 {
-    return self->animation || (self->prop_string && strchr(self->prop_string, '='));
+    if (self->animation)
+        return 1;
+    if (!self->prop_string)
+        return 0;
+
+    const char *token_start = self->prop_string;
+    int in_quotes = 0;
+    for (const char *p = self->prop_string; *p; ++p) {
+        if (*p == '"' && (p == self->prop_string || p[-1] != '\\')) {
+            in_quotes = !in_quotes;
+            continue;
+        }
+        if (!in_quotes && *p == '=')
+            return is_keyframe_token(token_start, p);
+        if (!in_quotes && *p == ';')
+            token_start = p + 1;
+    }
+    return 0;
 }
 
 /** Check if a property is a color.