Merge commit '69e7336b8e16ee65226fc20381baf537f4b125e6'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 29 Jul 2014 18:09:15 +0000 (20:09 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 29 Jul 2014 18:24:42 +0000 (20:24 +0200)
* commit '69e7336b8e16ee65226fc20381baf537f4b125e6':
  avstring: Expose the simple name match function

Conflicts:
libavutil/avstring.c
libavutil/avstring.h
libavutil/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
doc/APIchanges
libavformat/format.c
libavutil/avstring.c
libavutil/avstring.h
libavutil/version.h

diff --cc doc/APIchanges
Simple merge
@@@ -141,7 -119,7 +123,7 @@@ AVOutputFormat *av_guess_format(const c
      score_max = 0;
      while ((fmt = av_oformat_next(fmt))) {
          score = 0;
-         if (fmt->name && short_name && match_format(short_name, fmt->name))
 -        if (fmt->name && short_name && !av_strcasecmp(fmt->name, short_name))
++        if (fmt->name && short_name && av_match_name(short_name, fmt->name))
              score += 100;
          if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
              score += 10;
@@@ -307,69 -234,25 +307,87 @@@ int av_isxdigit(int c
      return av_isdigit(c) || (c >= 'a' && c <= 'f');
  }
  
+ int av_match_name(const char *name, const char *names)
+ {
+     const char *p;
+     int len, namelen;
+     if (!name || !names)
+         return 0;
+     namelen = strlen(name);
+     while ((p = strchr(names, ','))) {
+         len = FFMAX(p - names, namelen);
+         if (!av_strncasecmp(name, names, len))
+             return 1;
+         names = p + 1;
+     }
+     return !av_strcasecmp(name, names);
+ }
 +int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,
 +                   unsigned int flags)
 +{
 +    const uint8_t *p = *bufp;
 +    uint32_t top;
 +    uint64_t code;
 +    int ret = 0;
 +
 +    if (p >= buf_end)
 +        return 0;
 +
 +    code = *p++;
 +
 +    /* first sequence byte starts with 10, or is 1111-1110 or 1111-1111,
 +       which is not admitted */
 +    if ((code & 0xc0) == 0x80 || code >= 0xFE) {
 +        ret = AVERROR(EILSEQ);
 +        goto end;
 +    }
 +    top = (code & 128) >> 1;
 +
 +    while (code & top) {
 +        int tmp;
 +        if (p >= buf_end) {
 +            (*bufp) ++;
 +            return AVERROR(EILSEQ); /* incomplete sequence */
 +        }
 +
 +        /* we assume the byte to be in the form 10xx-xxxx */
 +        tmp = *p++ - 128;   /* strip leading 1 */
 +        if (tmp>>6) {
 +            (*bufp) ++;
 +            return AVERROR(EILSEQ);
 +        }
 +        code = (code<<6) + tmp;
 +        top <<= 5;
 +    }
 +    code &= (top << 1) - 1;
 +
 +    if (code >= 1<<31) {
 +        ret = AVERROR(EILSEQ);  /* out-of-range value */
 +        goto end;
 +    }
  
 +    *codep = code;
 +
 +    if (code > 0x10FFFF &&
 +        !(flags & AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES))
 +        ret = AVERROR(EILSEQ);
 +    if (code < 0x20 && code != 0x9 && code != 0xA && code != 0xD &&
 +        flags & AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES)
 +        ret = AVERROR(EILSEQ);
 +    if (code >= 0xD800 && code <= 0xDFFF &&
 +        !(flags & AV_UTF8_FLAG_ACCEPT_SURROGATES))
 +        ret = AVERROR(EILSEQ);
 +    if ((code == 0xFFFE || code == 0xFFFF) &&
 +        !(flags & AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS))
 +        ret = AVERROR(EILSEQ);
 +
 +end:
 +    *bufp = p;
 +    return ret;
 +}
  
  #ifdef TEST
  
@@@ -268,87 -219,15 +268,95 @@@ const char *av_basename(const char *pat
   */
  const char *av_dirname(char *path);
  
 -
+ /**
+  * Match instances of a name in a comma-separated list of names.
+  * @param name  Name to look for.
+  * @param names List of names.
+  * @return 1 on match, 0 otherwise.
+  */
+ int av_match_name(const char *name, const char *names);
 +enum AVEscapeMode {
 +    AV_ESCAPE_MODE_AUTO,      ///< Use auto-selected escaping mode.
 +    AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping.
 +    AV_ESCAPE_MODE_QUOTE,     ///< Use single-quote escaping.
 +};
 +
 +/**
 + * Consider spaces special and escape them even in the middle of the
 + * string.
 + *
 + * This is equivalent to adding the whitespace characters to the special
 + * characters lists, except it is guaranteed to use the exact same list
 + * of whitespace characters as the rest of libavutil.
 + */
 +#define AV_ESCAPE_FLAG_WHITESPACE 0x01
 +
 +/**
 + * Escape only specified special characters.
 + * Without this flag, escape also any characters that may be considered
 + * special by av_get_token(), such as the single quote.
 + */
 +#define AV_ESCAPE_FLAG_STRICT 0x02
 +
 +/**
 + * Escape string in src, and put the escaped string in an allocated
 + * string in *dst, which must be freed with av_free().
 + *
 + * @param dst           pointer where an allocated string is put
 + * @param src           string to escape, must be non-NULL
 + * @param special_chars string containing the special characters which
 + *                      need to be escaped, can be NULL
 + * @param mode          escape mode to employ, see AV_ESCAPE_MODE_* macros.
 + *                      Any unknown value for mode will be considered equivalent to
 + *                      AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without
 + *                      notice.
 + * @param flags         flags which control how to escape, see AV_ESCAPE_FLAG_ macros
 + * @return the length of the allocated string, or a negative error code in case of error
 + * @see av_bprint_escape()
 + */
 +int av_escape(char **dst, const char *src, const char *special_chars,
 +              enum AVEscapeMode mode, int flags);
 +
 +#define AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES          1 ///< accept codepoints over 0x10FFFF
 +#define AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS             2 ///< accept non-characters - 0xFFFE and 0xFFFF
 +#define AV_UTF8_FLAG_ACCEPT_SURROGATES                 4 ///< accept UTF-16 surrogates codes
 +#define AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES 8 ///< exclude control codes not accepted by XML
 +
 +#define AV_UTF8_FLAG_ACCEPT_ALL \
 +    AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES|AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS|AV_UTF8_FLAG_ACCEPT_SURROGATES
 +
 +/**
 + * Read and decode a single UTF-8 code point (character) from the
 + * buffer in *buf, and update *buf to point to the next byte to
 + * decode.
 + *
 + * In case of an invalid byte sequence, the pointer will be updated to
 + * the next byte after the invalid sequence and the function will
 + * return an error code.
 + *
 + * Depending on the specified flags, the function will also fail in
 + * case the decoded code point does not belong to a valid range.
 + *
 + * @note For speed-relevant code a carefully implemented use of
 + * GET_UTF8() may be preferred.
 + *
 + * @param codep   pointer used to return the parsed code in case of success.
 + *                The value in *codep is set even in case the range check fails.
 + * @param bufp    pointer to the address the first byte of the sequence
 + *                to decode, updated by the function to point to the
 + *                byte next after the decoded sequence
 + * @param buf_end pointer to the end of the buffer, points to the next
 + *                byte past the last in the buffer. This is used to
 + *                avoid buffer overreads (in case of an unfinished
 + *                UTF-8 sequence towards the end of the buffer).
 + * @param flags   a collection of AV_UTF8_FLAG_* flags
 + * @return >= 0 in case a sequence was successfully read, a negative
 + * value in case of invalid sequence
 + */
 +int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,
 +                   unsigned int flags);
 +
  /**
   * @}
   */
@@@ -55,9 -53,9 +55,9 @@@
   * @{
   */
  
 -#define LIBAVUTIL_VERSION_MAJOR 53
 -#define LIBAVUTIL_VERSION_MINOR 19
 -#define LIBAVUTIL_VERSION_MICRO  0
 +#define LIBAVUTIL_VERSION_MAJOR  52
- #define LIBAVUTIL_VERSION_MINOR  92
- #define LIBAVUTIL_VERSION_MICRO 101
++#define LIBAVUTIL_VERSION_MINOR  93
++#define LIBAVUTIL_VERSION_MICRO 100
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                 LIBAVUTIL_VERSION_MINOR, \