/* GStreamer

 * Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>

 *

 * gsttypefindfunctions.c: collection of various typefind functions

 *

 * 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <glib/gstrfuncs.h>

#include <gst/gsttypefind.h>

#include <gst/gstelement.h>

#include <gst/gstversion.h>

#include <gst/gstinfo.h>

#include <gst/gstutils.h>

#include <string.h>

#include <ctype.h>

GST_DEBUG_CATEGORY_STATIC (type_find_debug);

#define GST_CAT_DEFAULT type_find_debug

/*** text/plain ***/

static gboolean xml_check_first_element (GstTypeFind * tf,

    const gchar * element, guint elen, gboolean strict);

static GstStaticCaps utf8_caps = GST_STATIC_CAPS ("text/plain");

#define UTF8_CAPS gst_static_caps_get(&utf8_caps)

static gboolean

utf8_type_find_have_valid_utf8_at_offset (GstTypeFind * tf, guint64 offset,

    GstTypeFindProbability * prob)

{

  guint8 *data;

  /* randomly decided values */

  guint min_size = 16;          /* minimum size  */

  guint size = 32 * 1024;       /* starting size */

  guint probability = 95;       /* starting probability */

  guint step = 10;              /* how much we reduce probability in each

                                 * iteration */

  while (probability > step && size > min_size) {

    data = gst_type_find_peek (tf, offset, size);

    if (data) {

      gchar *end;

      gchar *start = (gchar *) data;

      if (g_utf8_validate (start, size, (const gchar **) &end) || (end - start + 4 > size)) {   /* allow last char to be cut off */

        *prob = probability;

        return TRUE;

      }

      *prob = 0;

      return FALSE;

    }

    size /= 2;

    probability -= step;

  }

  *prob = 0;

  return FALSE;

}

static void

utf8_type_find (GstTypeFind * tf, gpointer unused)

{

  GstTypeFindProbability start_prob, mid_prob;

  guint64 length;

  /* leave xml to the xml typefinders */

  if (xml_check_first_element (tf, "", 0, TRUE))

    return;

  /* check beginning of stream */

  if (!utf8_type_find_have_valid_utf8_at_offset (tf, 0, &start_prob))

    return;

  GST_LOG ("start is plain text with probability of %u", start_prob);

  /* POSSIBLE is the highest probability we ever return if we can't

   * probe into the middle of the file and don't know its length */

  length = gst_type_find_get_length (tf);

  if (length == 0 || length == (guint64) - 1) {

    gst_type_find_suggest (tf, MIN (start_prob, GST_TYPE_FIND_POSSIBLE),

        UTF8_CAPS);

    return;

  }

  if (length < 64 * 1024) {

    gst_type_find_suggest (tf, start_prob, UTF8_CAPS);

    return;

  }

  /* check middle of stream */

  if (!utf8_type_find_have_valid_utf8_at_offset (tf, length / 2, &mid_prob))

    return;

  GST_LOG ("middle is plain text with probability of %u", mid_prob);

  gst_type_find_suggest (tf, (start_prob + mid_prob) / 2, UTF8_CAPS);

}

/*** text/uri-list ***/

static GstStaticCaps uri_caps = GST_STATIC_CAPS ("text/uri-list");

#define URI_CAPS (gst_static_caps_get(&uri_caps))

#define BUFFER_SIZE 16          /* If the string is < 16 bytes we're screwed */

#define INC_BUFFER {                                                    \

  pos++;                                                                \

  if (pos == BUFFER_SIZE) {                                             \

    pos = 0;                                                            \

    offset += BUFFER_SIZE;                                              \

    data = gst_type_find_peek (tf, offset, BUFFER_SIZE);                \

    if (data == NULL) return;                                           \

  } else {                                                              \

    data++;                                                             \

  }                                                                     \

}

static void

uri_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, 0, BUFFER_SIZE);

  guint pos = 0;

  guint offset = 0;

  if (data) {

    /* Search for # comment lines */

    while (*data == '#') {

      /* Goto end of line */

      while (*data != '\n') {

        INC_BUFFER;

      }

      INC_BUFFER;

    }

    if (!g_ascii_isalpha (*data)) {

      /* Had a non alpha char - can't be uri-list */

      return;

    }

    INC_BUFFER;

    while (g_ascii_isalnum (*data)) {

      INC_BUFFER;

    }

    if (*data != ':') {

      /* First non alpha char is not a : */

      return;

    }

    /* Get the next 2 bytes as well */

    data = gst_type_find_peek (tf, offset + pos, 3);

    if (data == NULL)

      return;

    if (data[1] != '/' && data[2] != '/') {

      return;

    }

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, URI_CAPS);

  }

}

/*** application/xml **********************************************************/

#define XML_BUFFER_SIZE 16

#define XML_INC_BUFFER {                                                \

  pos++;                                                                \

  if (pos == XML_BUFFER_SIZE) {                                         \

    pos = 0;                                                            \

    offset += XML_BUFFER_SIZE;                                          \

    data = gst_type_find_peek (tf, offset, XML_BUFFER_SIZE);            \

    if (data == NULL) return FALSE;                                     \

  } else {                                                              \

    data++;                                                             \

  }                                                                     \

}

static gboolean

xml_check_first_element (GstTypeFind * tf, const gchar * element, guint elen,

    gboolean strict)

{

  gboolean got_xmldec;

  guint8 *data;

  guint offset = 0;

  guint pos = 0;

  data = gst_type_find_peek (tf, 0, XML_BUFFER_SIZE);

  if (!data)

    return FALSE;

  /* look for the XMLDec

   * see XML spec 2.8, Prolog and Document Type Declaration

   * http://www.w3.org/TR/2004/REC-xml-20040204/#sec-prolog-dtd */

  got_xmldec = (memcmp (data, "<?xml", 5) == 0);

  if (strict && !got_xmldec)

    return FALSE;

  /* skip XMLDec in any case if we've got one */

  if (got_xmldec) {

    pos += 5;

    data += 5;

  }

  /* look for the first element, it has to be the requested element. Bail

   * out if it is not within the first 4kB. */

  while (data && (offset + pos) < 4096) {

    while (*data != '<' && (offset + pos) < 4096) {

      XML_INC_BUFFER;

    }

    XML_INC_BUFFER;

    if (!g_ascii_isalpha (*data)) {

      /* if not alphabetic, it's a PI or an element / attribute declaration

       * like <?xxx or <!xxx */

      XML_INC_BUFFER;

      continue;

    }

    /* the first normal element, check if it's the one asked for */

    data = gst_type_find_peek (tf, offset + pos, elen + 1);

    return (data && element && strncmp ((char *) data, element, elen) == 0);

  }

  return FALSE;

}

static GstStaticCaps generic_xml_caps = GST_STATIC_CAPS ("application/xml");

#define GENERIC_XML_CAPS (gst_static_caps_get(&generic_xml_caps))

static void

xml_type_find (GstTypeFind * tf, gpointer unused)

{

  if (xml_check_first_element (tf, "", 0, TRUE)) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MINIMUM, GENERIC_XML_CAPS);

  }

}

/*** application/smil *********************************************************/

static GstStaticCaps smil_caps = GST_STATIC_CAPS ("application/smil");

#define SMIL_CAPS (gst_static_caps_get(&smil_caps))

static void

smil_type_find (GstTypeFind * tf, gpointer unused)

{

  if (xml_check_first_element (tf, "smil", 4, FALSE)) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, SMIL_CAPS);

  }

}

/*** text/html ***/

static GstStaticCaps html_caps = GST_STATIC_CAPS ("text/html");

#define HTML_CAPS gst_static_caps_get (&html_caps)

static void

html_type_find (GstTypeFind * tf, gpointer unused)

{

  gchar *d, *data;

  data = (gchar *) gst_type_find_peek (tf, 0, 16);

  if (!data)

    return;

  if (!g_ascii_strncasecmp (data, "<!DOCTYPE HTML", 14)) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, HTML_CAPS);

  } else if (xml_check_first_element (tf, "html", 4, FALSE)) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, HTML_CAPS);

  } else if ((d = memchr (data, '<', 16))) {

    data = (gchar *) gst_type_find_peek (tf, d - data, 6);

    if (data && g_ascii_strncasecmp (data, "<html>", 6) == 0) {

      gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, HTML_CAPS);

    }

  }

}

/*** video/x-fli ***/

static GstStaticCaps flx_caps = GST_STATIC_CAPS ("video/x-fli");

#define FLX_CAPS gst_static_caps_get(&flx_caps)

static void

flx_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, 0, 134);

  if (data) {

    /* check magic and the frame type of the first frame */

    if ((data[4] == 0x11 || data[4] == 0x12 ||

            data[4] == 0x30 || data[4] == 0x44) &&

        data[5] == 0xaf &&

        ((data[132] == 0x00 || data[132] == 0xfa) && data[133] == 0xf1)) {

      gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, FLX_CAPS);

    }

    return;

  }

  data = gst_type_find_peek (tf, 0, 6);

  if (data) {

    /* check magic only */

    if ((data[4] == 0x11 || data[4] == 0x12 ||

            data[4] == 0x30 || data[4] == 0x44) && data[5] == 0xaf) {

      gst_type_find_suggest (tf, GST_TYPE_FIND_LIKELY, FLX_CAPS);

    }

    return;

  }

}

/*** application/x-id3 ***/

static GstStaticCaps id3_caps = GST_STATIC_CAPS ("application/x-id3");

#define ID3_CAPS gst_static_caps_get(&id3_caps)

static void

id3v2_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, 0, 10);

  if (data && memcmp (data, "ID3", 3) == 0 &&

      data[3] != 0xFF && data[4] != 0xFF &&

      (data[6] & 0x80) == 0 && (data[7] & 0x80) == 0 &&

      (data[8] & 0x80) == 0 && (data[9] & 0x80) == 0) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, ID3_CAPS);

  }

}

static void

id3v1_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, -128, 3);

  if (data && memcmp (data, "TAG", 3) == 0) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, ID3_CAPS);

  }

}

/*** application/x-ape ***/

static GstStaticCaps apetag_caps = GST_STATIC_CAPS ("application/x-apetag");

#define APETAG_CAPS gst_static_caps_get(&apetag_caps)

static void

apetag_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data;

  /* APEv1/2 at start of file */

  data = gst_type_find_peek (tf, 0, 8);

  if (data && !memcmp (data, "APETAGEX", 8)) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, APETAG_CAPS);

    return;

  }

  /* APEv1/2 at end of file */

  data = gst_type_find_peek (tf, -32, 8);

  if (data && !memcmp (data, "APETAGEX", 8)) {

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, APETAG_CAPS);

    return;

  }

}

/*** audio/x-ttafile ***/

static GstStaticCaps tta_caps = GST_STATIC_CAPS ("audio/x-ttafile");

#define TTA_CAPS gst_static_caps_get(&tta_caps)

static void

tta_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, 0, 3);

  if (data) {

    if (memcmp (data, "TTA", 3) == 0) {

      gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, TTA_CAPS);

      return;

    }

  }

}

/*** audio/mpeg version 2, 4 ***/

static GstStaticCaps aac_caps = GST_STATIC_CAPS ("audio/mpeg, "

    "mpegversion = (int) { 2, 4 }, framed = (bool) false");

#define AAC_CAPS (gst_static_caps_get(&aac_caps))

#define AAC_AMOUNT (4096)

static void

aac_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, 0, AAC_AMOUNT);

  gint snc;

  /* detect adts header or adif header.

   * The ADIF header is 4 bytes, that should be OK. The ADTS header, on

   * the other hand, is 14 bits only, so we require one valid frame with

   * again a valid syncpoint on the next one (28 bits) for certainty. We

   * require 4 kB, which is quite a lot, since frames are generally 200-400

   * bytes.

   */

  if (data) {

    gint n;

    for (n = 0; n < AAC_AMOUNT - 3; n++) {

      snc = GST_READ_UINT16_BE (&data[n]);

      if ((snc & 0xfff6) == 0xfff0) {

        /* ADTS header - find frame length */

        gint len;

        GST_DEBUG ("Found one ADTS syncpoint at offset 0x%x, tracing next...",

            n);

        if (AAC_AMOUNT - n < 5) {

          GST_DEBUG ("Not enough data to parse ADTS header");

          break;

        }

        len = ((data[n + 3] & 0x03) << 11) |

            (data[n + 4] << 3) | ((data[n + 5] & 0xe0) >> 5);

        if (n + len + 2 >= AAC_AMOUNT) {

          GST_DEBUG ("Next frame is not within reach");

          break;

        } else if (len == 0) {

          continue;

        }

        snc = GST_READ_UINT16_BE (&data[n + len]);

        if ((snc & 0xfff6) == 0xfff0) {

          gint mpegversion = (data[n + 1] & 0x08) ? 2 : 4;

          GstCaps *caps = gst_caps_new_simple ("audio/mpeg",

              "framed", G_TYPE_BOOLEAN, FALSE,

              "mpegversion", G_TYPE_INT, mpegversion,

              NULL);

          gst_type_find_suggest (tf, GST_TYPE_FIND_LIKELY, caps);

          gst_caps_unref (caps);

          GST_DEBUG ("Found ADTS-%d syncpoint at offset 0x%x (framelen %u)",

              mpegversion, n, len);

          break;

        }

        GST_DEBUG ("No next frame found... (should be at 0x%x)", n + len);

      } else if (!memcmp (&data[n], "ADIF", 4)) {

        /* ADIF header */

        GstCaps *caps = gst_caps_new_simple ("audio/mpeg",

            "framed", G_TYPE_BOOLEAN, FALSE,

            "mpegversion", G_TYPE_INT, 4,

            NULL);

        gst_type_find_suggest (tf, GST_TYPE_FIND_LIKELY, caps);

        gst_caps_unref (caps);

      }

    }

  }

}

/*** audio/mpeg version 1 ***/

/*

 * The chance that random data is identified as a valid mp3 header is 63 / 2^18

 * (0.024%) per try. This makes the function for calculating false positives

 *   1 - (1 - ((63 / 2 ^18) ^ GST_MP3_TYPEFIND_MIN_HEADERS)) ^ buffersize)

 * This has the following probabilities of false positives:

 * datasize               MIN_HEADERS

 * (bytes)      1       2       3       4

 * 4096         62.6%    0.02%   0%      0%

 * 16384        98%      0.09%   0%      0%

 * 1 MiB       100%      5.88%   0%      0%

 * 1 GiB       100%    100%      1.44%   0%

 * 1 TiB       100%    100%    100%      0.35%

 * This means that the current choice (3 headers by most of the time 4096 byte

 * buffers is pretty safe for now.

 *

 * The max. size of each frame is 1440 bytes, which means that for N frames to

 * be detected, we need 1440 * GST_MP3_TYPEFIND_MIN_HEADERS + 3 bytes of data.

 * Assuming we step into the stream right after the frame header, this

 * means we need 1440 * (GST_MP3_TYPEFIND_MIN_HEADERS + 1) - 1 + 3 bytes

 * of data (5762) to always detect any mp3.

 */

static const guint mp3types_bitrates[2][3][16] =

    { {{0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},

    {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},

    {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}},

{{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},

    {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},

    {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}},

};

static const guint mp3types_freqs[3][3] = { {11025, 12000, 8000},

{22050, 24000, 16000},

{44100, 48000, 32000}

};

static inline guint

mp3_type_frame_length_from_header (guint32 header, guint * put_layer,

    guint * put_channels, guint * put_bitrate, guint * put_samplerate,

    gboolean * may_be_free_format, gint possible_free_framelen)

{

  guint bitrate, layer, length, mode, samplerate, version, channels;

  if ((header & 0xffe00000) != 0xffe00000)

    return 0;

  /* we don't need extension, copyright, original or

   * emphasis for the frame length */

  header >>= 6;

  /* mode */

  mode = header & 0x3;

  header >>= 3;

  /* padding */

  length = header & 0x1;

  header >>= 1;

  /* sampling frequency */

  samplerate = header & 0x3;

  if (samplerate == 3)

    return 0;

  header >>= 2;

  /* bitrate index */

  bitrate = header & 0xF;

  if (bitrate == 0 && possible_free_framelen == -1) {

    GST_LOG ("Possibly a free format mp3 - signalling");

    *may_be_free_format = TRUE;

  }

  if (bitrate == 15 || (bitrate == 0 && possible_free_framelen == -1))

    return 0;

  /* ignore error correction, too */

  header >>= 5;

  /* layer */

  layer = 4 - (header & 0x3);

  if (layer == 4)

    return 0;

  header >>= 2;

  /* version 0=MPEG2.5; 2=MPEG2; 3=MPEG1 */

  version = header & 0x3;

  if (version == 1)

    return 0;

  /* lookup */

  channels = (mode == 3) ? 1 : 2;

  samplerate = mp3types_freqs[version > 0 ? version - 1 : 0][samplerate];

  if (bitrate == 0) {

    if (layer == 1) {

      length *= 4;

      length += possible_free_framelen;

      bitrate = length * samplerate / 48000;

    } else {

      length += possible_free_framelen;

      bitrate = length * samplerate /

          ((layer == 3 && version != 3) ? 72000 : 144000);

    }

  } else {

    /* calculating */

    bitrate = mp3types_bitrates[version == 3 ? 0 : 1][layer - 1][bitrate];

    if (layer == 1) {

      length = ((12000 * bitrate / samplerate) + length) * 4;

    } else {

      length += ((layer == 3

              && version != 3) ? 72000 : 144000) * bitrate / samplerate;

    }

  }

  GST_LOG ("mp3typefind: calculated mp3 frame length of %u bytes", length);

  GST_LOG

      ("mp3typefind: samplerate = %u - bitrate = %u - layer = %u - version = %u"

      " - channels = %u", samplerate, bitrate, layer, version, channels);

  if (put_layer)

    *put_layer = layer;

  if (put_channels)

    *put_channels = channels;

  if (put_bitrate)

    *put_bitrate = bitrate;

  if (put_samplerate)

    *put_samplerate = samplerate;

  return length;

}

static GstStaticCaps mp3_caps = GST_STATIC_CAPS ("audio/mpeg, "

    "mpegversion = (int) 1, layer = (int) [ 1, 3 ]");

#define MP3_CAPS (gst_static_caps_get(&mp3_caps))

/*

 * random values for typefinding

 * if no more data is available, we will return a probability of

 * (found_headers/TRY_HEADERS) * (MAXIMUM * (TRY_SYNC - bytes_skipped)

 *        / TRY_SYNC)

 * if found_headers >= MIN_HEADERS

 */

#define GST_MP3_TYPEFIND_MIN_HEADERS (2)

#define GST_MP3_TYPEFIND_TRY_HEADERS (5)

#define GST_MP3_TYPEFIND_TRY_SYNC (GST_TYPE_FIND_MAXIMUM * 100) /* 10kB */

#define GST_MP3_TYPEFIND_SYNC_SIZE (2048)

#define GST_MP3_WRONG_HEADER (10)

static void

mp3_type_find_at_offset (GstTypeFind * tf, guint64 start_off,

    guint * found_layer, GstTypeFindProbability * found_prob)

{

  guint8 *data = NULL;

  guint8 *data_end = NULL;

  guint size;

  guint64 skipped;

  gint last_free_offset = -1;

  gint last_free_framelen = -1;

  gboolean headerstart = TRUE;

  *found_layer = 0;

  *found_prob = 0;

  size = 0;

  skipped = 0;

  while (skipped < GST_MP3_TYPEFIND_TRY_SYNC) {

    if (size <= 0) {

      size = GST_MP3_TYPEFIND_SYNC_SIZE * 2;

      do {

        size /= 2;

        data = gst_type_find_peek (tf, skipped + start_off, size);

      } while (size > 10 && !data);

      if (!data)

        break;

      data_end = data + size;

    }

    if (*data == 0xFF) {

      guint8 *head_data = NULL;

      guint layer = 0, bitrate, samplerate, channels;

      guint found = 0;          /* number of valid headers found */

      guint64 offset = skipped;

      while (found < GST_MP3_TYPEFIND_TRY_HEADERS) {

        guint32 head;

        guint length;

        guint prev_layer = 0, prev_bitrate = 0;

        guint prev_channels = 0, prev_samplerate = 0;

        gboolean free = FALSE;

        if ((gint64) (offset - skipped + 4) >= 0 &&

            data + offset - skipped + 4 < data_end) {

          head_data = data + offset - skipped;

        } else {

          head_data = gst_type_find_peek (tf, offset + start_off, 4);

        }

        if (!head_data)

          break;

        head = GST_READ_UINT32_BE (head_data);

        if (!(length = mp3_type_frame_length_from_header (head, &layer,

                    &channels, &bitrate, &samplerate, &free,

                    last_free_framelen))) {

          if (free) {

            if (last_free_offset == -1)

              last_free_offset = offset;

            else {

              last_free_framelen = offset - last_free_offset;

              offset = last_free_offset;

              continue;

            }

          } else {

            last_free_framelen = -1;

          }

          /* Mark the fact that we didn't find a valid header at the beginning */

          if (found == 0)

            headerstart = FALSE;

          GST_LOG ("%d. header at offset %" G_GUINT64_FORMAT

              " (0x%" G_GINT64_MODIFIER "x) was not an mp3 header "

              "(possibly-free: %s)", found + 1, start_off + offset,

              start_off + offset, free ? "yes" : "no");

          break;

        }

        if ((prev_layer && prev_layer != layer) ||

            /* (prev_bitrate && prev_bitrate != bitrate) || <-- VBR */

            (prev_samplerate && prev_samplerate != samplerate) ||

            (prev_channels && prev_channels != channels)) {

          /* this means an invalid property, or a change, which might mean

           * that this is not a mp3 but just a random bytestream. It could

           * be a freaking funky encoded mp3 though. We'll just not count

           * this header*/

          prev_layer = layer;

          prev_bitrate = bitrate;

          prev_channels = channels;

          prev_samplerate = samplerate;

        } else {

          found++;

          GST_LOG ("found %d. header at offset %" G_GUINT64_FORMAT " (0x%"

              G_GINT64_MODIFIER "X)", found, start_off + offset,

              start_off + offset);

        }

        offset += length;

      }

      g_assert (found <= GST_MP3_TYPEFIND_TRY_HEADERS);

      if (found == GST_MP3_TYPEFIND_TRY_HEADERS ||

          (found >= GST_MP3_TYPEFIND_MIN_HEADERS && head_data == NULL)) {

        /* we can make a valid guess */

        guint probability = found * GST_TYPE_FIND_MAXIMUM *

            (GST_MP3_TYPEFIND_TRY_SYNC - skipped) /

            GST_MP3_TYPEFIND_TRY_HEADERS / GST_MP3_TYPEFIND_TRY_SYNC;

        if (!headerstart

            && ((probability - GST_MP3_WRONG_HEADER) > GST_TYPE_FIND_MINIMUM))

          probability -= GST_MP3_WRONG_HEADER;

        if (probability < GST_TYPE_FIND_MINIMUM)

          probability = GST_TYPE_FIND_MINIMUM;

        if (start_off > 0)

          probability /= 2;

        GST_INFO

            ("audio/mpeg calculated %u  =  %u  *  %u / %u  *  (%u - %"

            G_GUINT64_FORMAT ") / %u", probability, GST_TYPE_FIND_MAXIMUM,

            found, GST_MP3_TYPEFIND_TRY_HEADERS, GST_MP3_TYPEFIND_TRY_SYNC,

            (guint64) skipped, GST_MP3_TYPEFIND_TRY_SYNC);

        /* make sure we're not id3 tagged */

        head_data = gst_type_find_peek (tf, -128, 3);

        if (head_data && (memcmp (head_data, "TAG", 3) == 0)) {

          probability = 0;

        }

        g_assert (probability <= GST_TYPE_FIND_MAXIMUM);

        *found_prob = probability;

        if (probability > 0)

          *found_layer = layer;

        return;

      }

    }

    data++;

    skipped++;

    size--;

  }

}

static void

mp3_type_find (GstTypeFind * tf, gpointer unused)

{

  GstTypeFindProbability prob, mid_prob;

  guint8 *data;

  guint layer, mid_layer;

  guint64 length;

  mp3_type_find_at_offset (tf, 0, &layer, &prob);

  length = gst_type_find_get_length (tf);

  if (length == 0 || length == (guint64) - 1) {

    if (prob != 0)

      goto suggest;

    return;

  }

  /* if we're pretty certain already, skip the additional check */

  if (prob >= GST_TYPE_FIND_LIKELY)

    goto suggest;

  mp3_type_find_at_offset (tf, length / 2, &mid_layer, &mid_prob);

  if (mid_prob > 0) {

    if (prob == 0) {

      GST_LOG ("detected audio/mpeg only in the middle (p=%u)", mid_prob);

      layer = mid_layer;

      prob = mid_prob;

      goto suggest;

    }

    if (layer != mid_layer) {

      GST_WARNING ("audio/mpeg layer discrepancy: %u vs. %u", layer, mid_layer);

      return;                   /* FIXME: or should we just go with the one in the middle? */

    }

    /* detected mpeg audio both in middle of the file and at the start */

    prob = (prob + mid_prob) / 2;

    goto suggest;

  }

  /* let's see if there's a valid header right at the start */

  data = gst_type_find_peek (tf, 0, 4); /* use min. frame size? */

  if (data && mp3_type_frame_length_from_header (GST_READ_UINT32_BE (data),

          &layer, NULL, NULL, NULL, NULL, 0) != 0) {

    if (prob == 0)

      prob = GST_TYPE_FIND_POSSIBLE - 10;

    else

      prob = MAX (GST_TYPE_FIND_POSSIBLE - 10, prob + 10);

  }

  if (prob > 0)

    goto suggest;

  return;

suggest:

  {

    GstCaps *caps;

    g_assert (layer > 0);

    caps = gst_caps_make_writable (MP3_CAPS);

    gst_structure_set (gst_caps_get_structure (caps, 0), "layer",

        G_TYPE_INT, layer, NULL);

    gst_type_find_suggest (tf, prob, caps);

    gst_caps_unref (caps);

    return;

  }

}

/*** audio/x-musepack ***/

static GstStaticCaps musepack_caps = GST_STATIC_CAPS ("audio/x-musepack");

#define MUSEPACK_CAPS (gst_static_caps_get(&musepack_caps))

static void

musepack_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, 0, 4);

  if (data && memcmp (data, "MP+", 3) == 0) {

    if ((data[3] & 0x7f) == 7) {

      gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, MUSEPACK_CAPS);

    } else {

      gst_type_find_suggest (tf, GST_TYPE_FIND_LIKELY + 10, MUSEPACK_CAPS);

    }

  }

}

/*** audio/x-ac3 ***/

static GstStaticCaps ac3_caps = GST_STATIC_CAPS ("audio/x-ac3");

#define AC3_CAPS (gst_static_caps_get(&ac3_caps))

static void

ac3_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data = gst_type_find_peek (tf, 0, 2);

  if (data) {

    /* pretty lame method... */

    if (data[0] == 0x0b && data[1] == 0x77) {

      gst_type_find_suggest (tf, GST_TYPE_FIND_POSSIBLE, AC3_CAPS);

      return;

    }

  }

}

/*** wavpack ***/

static GstStaticCaps wavpack_caps =

GST_STATIC_CAPS ("audio/x-wavpack, framed = (boolean) false");

#define WAVPACK_CAPS (gst_static_caps_get(&wavpack_caps))

static GstStaticCaps wavpack_correction_caps =

GST_STATIC_CAPS ("audio/x-wavpack-correction, framed = (boolean) false");

#define WAVPACK_CORRECTION_CAPS (gst_static_caps_get(&wavpack_correction_caps))

static void

wavpack_type_find (GstTypeFind * tf, gpointer unused)

{

  guint64 offset;

  guint32 blocksize;

  guint8 *data;

  data = gst_type_find_peek (tf, 0, 32);

  if (!data)

    return;

  if (data[0] != 'w' || data[1] != 'v' || data[2] != 'p' || data[3] != 'k')

    return;

  /* Note: wavpack blocks can be fairly large (easily 60-110k), possibly

   * larger than the max. limits imposed by certain typefinding elements

   * like id3demux or apedemux, so typefinding is most likely only going to

   * work in pull-mode */

  blocksize = GST_READ_UINT32_LE (data + 4);

  GST_LOG ("wavpack header, blocksize=0x%04x", blocksize);

  offset = 32;

  while (offset < 32 + blocksize) {

    guint32 sublen;

    /* get chunk header */

    GST_LOG ("peeking at chunk at offset 0x%04x", (guint) offset);

    data = gst_type_find_peek (tf, offset, 4);

    if (data == NULL)

      break;

    sublen = ((guint32) data[1]) << 1;

    if (data[0] & 0x80) {

      sublen |= (((guint32) data[2]) << 9) | (((guint32) data[3]) << 17);

      sublen += 1 + 3;          /* id + length */

    } else {

      sublen += 1 + 1;          /* id + length */

    }

    if (sublen > blocksize - offset + 32) {

      GST_LOG ("chunk length too big (%u > %" G_GUINT64_FORMAT ")", sublen,

          blocksize - offset);

      break;

    }

    if ((data[0] & 0x20) == 0) {

      switch (data[0] & 0x0f) {

        case 0xa:              /* ID_WV_BITSTREAM  */

        case 0xc:              /* ID_WVX_BITSTREAM */

          gst_type_find_suggest (tf, GST_TYPE_FIND_LIKELY, WAVPACK_CAPS);

          return;

        case 0xb:              /* ID_WVC_BITSTREAM */

          gst_type_find_suggest (tf, GST_TYPE_FIND_LIKELY,

              WAVPACK_CORRECTION_CAPS);

          return;

        default:

          break;

      }

    }

    offset += sublen;

  }

}

/*** multipart/x-mixed-replace mimestream ***/

static GstStaticCaps multipart_caps =

GST_STATIC_CAPS ("multipart/x-mixed-replace");

#define MULTIPART_CAPS gst_static_caps_get(&multipart_caps)

/* multipart/x-mixed replace is: 

 *   <maybe some whitespace>--<some ascii chars>[\r]\n

 *   <more ascii chars>[\r]\nContent-type:<more ascii>[\r]\n */

static void

multipart_type_find (GstTypeFind * tf, gpointer unused)

{

  guint8 *data;

  guint8 *x;

#define MULTIPART_MAX_BOUNDARY_OFFSET 16

  data = gst_type_find_peek (tf, 0, MULTIPART_MAX_BOUNDARY_OFFSET);

  if (!data)

    return;

  for (x = data;

      x - data < MULTIPART_MAX_BOUNDARY_OFFSET - 2 && g_ascii_isspace (*x);

      x++);

  if (x[0] != '-' || x[1] != '-')

    return;

  /* Could be okay, peek what should be enough for a complete header */

#define MULTIPART_MAX_HEADER_SIZE 256

  data = gst_type_find_peek (tf, 0, MULTIPART_MAX_HEADER_SIZE);

  if (!data)

    return;

  for (x = data; x - data < MULTIPART_MAX_HEADER_SIZE - 14; x++) {

    if (!isascii (*x)) {

      return;

    }

    if (*x == '\n' &&

        !g_ascii_strncasecmp ("content-type:", (gchar *) x + 1, 13)) {

      GstCaps *caps = gst_caps_copy (MULTIPART_CAPS);

      gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, caps);

      gst_caps_unref (caps);

      return;

    }

  }

}

/*** video/mpeg systemstream ***/

static GstStaticCaps mpeg_sys_caps = GST_STATIC_CAPS ("video/mpeg, "

    "systemstream = (boolean) true, mpegversion = (int) [ 1, 2 ]");

#define MPEG_SYS_CAPS gst_static_caps_get(&mpeg_sys_caps)

#define IS_MPEG_HEADER(data)            ((((guint8 *)(data))[0] == 0x00) &&  \

                                         (((guint8 *)(data))[1] == 0x00) &&  \

                                         (((guint8 *)(data))[2] == 0x01))