/* 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 <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 gboolean sdp_check_header (GstTypeFind * tf);

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 */

  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;

  /* leave sdp to the sdp typefinders */

  if (sdp_check_header (tf))

    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/sdp *********************************************************/

static GstStaticCaps sdp_caps = GST_STATIC_CAPS ("application/sdp");

#define SDP_CAPS (gst_static_caps_get(&sdp_caps))

static gboolean

sdp_check_header (GstTypeFind * tf)

{

  guint8 *data;

  data = gst_type_find_peek (tf, 0, 5);

  if (!data)

    return FALSE;

  /* sdp must start with v=0[\r]\n */

  if (memcmp (data, "v=0", 3))

    return FALSE;

  if (data[3] == '\r' && data[4] != '\n')

    return FALSE;

  if (data[3] != '\n')

    return FALSE;

  return TRUE;

}

static void

sdp_type_find (GstTypeFind * tf, gpointer unused)

{

  if (sdp_check_header (tf))

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, SDP_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);

    }

  }

}

/*** audio/midi ***/

static GstStaticCaps mid_caps = GST_STATIC_CAPS ("audio/midi");

#define MID_CAPS gst_static_caps_get(&mid_caps)

static void

mid_type_find (GstTypeFind * tf, gpointer unused)

{

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

  /* http://jedi.ks.uiuc.edu/~johns/links/music/midifile.html */

  if (data && data[0] == 'M' && data[1] == 'T' && data[2] == 'h'

      && data[3] == 'd')

    gst_type_find_suggest (tf, GST_TYPE_FIND_MAXIMUM, MID_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 */