/* GStreamer

 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

 * Copyright (C) 2004 Ronald S. Bultje <rbultje@ronald.bitfreak.net>

 * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>

 *

 * 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 <string.h>

#include <stdlib.h>

#include <sys/types.h>

#include <regex.h>

#include "gstsubparse.h"

#include "gstssaparse.h"

#include "samiparse.h"

#include "tmplayerparse.h"

#include "mpl2parse.h"

GST_DEBUG_CATEGORY (sub_parse_debug);

#define DEFAULT_ENCODING   NULL

enum

{

  PROP_0,

  PROP_ENCODING

};

static void

gst_sub_parse_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void

gst_sub_parse_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static const GstElementDetails sub_parse_details =

GST_ELEMENT_DETAILS ("Subtitle parser",

    "Codec/Parser/Subtitle",

    "Parses subtitle (.sub) files into text streams",

    "Gustavo J. A. M. Carneiro <gjc@inescporto.pt>\n"

    "Ronald S. Bultje <rbultje@ronald.bitfreak.net>");

#ifndef GST_DISABLE_XML

static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("application/x-subtitle; application/x-subtitle-sami; "

        "application/x-subtitle-tmplayer; application/x-subtitle-mpl2")

    );

#else

static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("application/x-subtitle")

    );

#endif

static GstStaticPadTemplate src_templ = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("text/plain; text/x-pango-markup")

    );

static void gst_sub_parse_base_init (GstSubParseClass * klass);

static void gst_sub_parse_class_init (GstSubParseClass * klass);

static void gst_sub_parse_init (GstSubParse * subparse);

static gboolean gst_sub_parse_src_event (GstPad * pad, GstEvent * event);

static gboolean gst_sub_parse_sink_event (GstPad * pad, GstEvent * event);

static GstStateChangeReturn gst_sub_parse_change_state (GstElement * element,

    GstStateChange transition);

static GstFlowReturn gst_sub_parse_chain (GstPad * sinkpad, GstBuffer * buf);

static GstElementClass *parent_class = NULL;

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GType

gst_sub_parse_get_type (void)

{

  static GType sub_parse_type = 0;

  if (!sub_parse_type) {

    static const GTypeInfo sub_parse_info = {

      sizeof (GstSubParseClass),

      (GBaseInitFunc) gst_sub_parse_base_init,

      NULL,

      (GClassInitFunc) gst_sub_parse_class_init,

      NULL,

      NULL,

      sizeof (GstSubParse),

      0,

      (GInstanceInitFunc) gst_sub_parse_init,

    };

    sub_parse_type = g_type_register_static (GST_TYPE_ELEMENT,

        "GstSubParse", &sub_parse_info, 0);

  }

  return sub_parse_type;

}

static void

gst_sub_parse_base_init (GstSubParseClass * klass)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&sink_templ));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&src_templ));

  gst_element_class_set_details (element_class, &sub_parse_details);

}

static void

gst_sub_parse_dispose (GObject * object)

{

  GstSubParse *subparse = GST_SUBPARSE (object);

  GST_DEBUG_OBJECT (subparse, "cleaning up subtitle parser");

  if (subparse->encoding) {

    g_free (subparse->encoding);

    subparse->encoding = NULL;

  }

  if (subparse->textbuf) {

    g_string_free (subparse->textbuf, TRUE);

    subparse->textbuf = NULL;

  }

  sami_context_deinit (&subparse->state);

  GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));

}

static void

gst_sub_parse_class_init (GstSubParseClass * klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  object_class->dispose = gst_sub_parse_dispose;

  object_class->set_property = gst_sub_parse_set_property;

  object_class->get_property = gst_sub_parse_get_property;

  element_class->change_state = gst_sub_parse_change_state;

  g_object_class_install_property (object_class, PROP_ENCODING,

      g_param_spec_string ("subtitle-encoding", "subtitle charset encoding",

}

static void

gst_sub_parse_init (GstSubParse * subparse)

{

  subparse->sinkpad = gst_pad_new_from_static_template (&sink_templ, "sink");

  gst_pad_set_chain_function (subparse->sinkpad,

      GST_DEBUG_FUNCPTR (gst_sub_parse_chain));

  gst_pad_set_event_function (subparse->sinkpad,

      GST_DEBUG_FUNCPTR (gst_sub_parse_sink_event));

  gst_element_add_pad (GST_ELEMENT (subparse), subparse->sinkpad);

  subparse->srcpad = gst_pad_new_from_static_template (&src_templ, "src");

  gst_pad_set_event_function (subparse->srcpad,

      GST_DEBUG_FUNCPTR (gst_sub_parse_src_event));

  gst_element_add_pad (GST_ELEMENT (subparse), subparse->srcpad);

  subparse->textbuf = g_string_new (NULL);

  subparse->parser_type = GST_SUB_PARSE_FORMAT_UNKNOWN;

  subparse->flushing = FALSE;

  gst_segment_init (&subparse->segment, GST_FORMAT_TIME);

  subparse->need_segment = TRUE;

  subparse->encoding = g_strdup (DEFAULT_ENCODING);

}

/*

 * Source pad functions.

 */

static gboolean

gst_sub_parse_src_event (GstPad * pad, GstEvent * event)

{

  GstSubParse *self = GST_SUBPARSE (gst_pad_get_parent (pad));

  gboolean ret = FALSE;

  GST_DEBUG ("Handling %s event", GST_EVENT_TYPE_NAME (event));

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_SEEK:

    {

      GstFormat format;

      GstSeekType start_type, stop_type;

      gint64 start, stop;

      gdouble rate;

      gboolean update;

      gst_event_parse_seek (event, &rate, &format, &self->segment_flags,

          &start_type, &start, &stop_type, &stop);

      if (format != GST_FORMAT_TIME) {

        GST_WARNING_OBJECT (self, "we only support seeking in TIME format");

        gst_event_unref (event);

        goto beach;

      }

      /* Convert that seek to a seeking in bytes at position 0,

         FIXME: could use an index */

      ret = gst_pad_push_event (self->sinkpad,

          gst_event_new_seek (rate, GST_FORMAT_BYTES, self->segment_flags,

              GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, 0));

      if (ret) {

        /* Apply the seek to our segment */

        gst_segment_set_seek (&self->segment, rate, format, self->segment_flags,

            start_type, start, stop_type, stop, &update);

#ifndef __SYMBIAN32__

        GST_DEBUG_OBJECT (self, "segment after seek: %" GST_SEGMENT_FORMAT,

            &self->segment);

#endif

        self->next_offset = 0;

        self->need_segment = TRUE;

      } else {

        GST_WARNING_OBJECT (self, "seek to 0 bytes failed");

      }

      gst_event_unref (event);

      break;

    }

    default:

      ret = gst_pad_event_default (pad, event);

      break;

  }

beach:

  gst_object_unref (self);

  return ret;

}

static void

gst_sub_parse_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstSubParse *subparse = GST_SUBPARSE (object);

  GST_OBJECT_LOCK (subparse);

  switch (prop_id) {

    case PROP_ENCODING:

      g_free (subparse->encoding);

      subparse->encoding = g_value_dup_string (value);

      GST_LOG_OBJECT (object, "subtitle encoding set to %s",

          GST_STR_NULL (subparse->encoding));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

  GST_OBJECT_UNLOCK (subparse);

}

static void

gst_sub_parse_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstSubParse *subparse = GST_SUBPARSE (object);

  GST_OBJECT_LOCK (subparse);

  switch (prop_id) {

    case PROP_ENCODING:

      g_value_set_string (value, subparse->encoding);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

  GST_OBJECT_UNLOCK (subparse);

}

static gchar *

{

  const gchar *encoding;

  GError *err = NULL;

  if (self->valid_utf8) {

    if (g_utf8_validate (str, len, NULL)) {

      GST_LOG_OBJECT (self, "valid UTF-8, no conversion needed");

      return g_strndup (str, len);

    }

    GST_INFO_OBJECT (self, "invalid UTF-8!");

    self->valid_utf8 = FALSE;

  }

  encoding = self->encoding;

  if (encoding == NULL || *encoding == '\0') {

    encoding = g_getenv ("GST_SUBTITLE_ENCODING");

  }

  if (encoding == NULL || *encoding == '\0') {

    /* if local encoding is UTF-8 and no encoding specified

     * via the environment variable, assume ISO-8859-15 */

    if (g_get_charset (&encoding)) {

      encoding = "ISO-8859-15";

    }

  }

  if (err) {

    GST_WARNING_OBJECT (self, "could not convert string from '%s' to UTF-8: %s",

        encoding, err->message);

    g_error_free (err);

    /* invalid input encoding, fall back to ISO-8859-15 (always succeeds) */

  }

  GST_LOG_OBJECT (self,

      "successfully converted %" G_GSIZE_FORMAT " characters from %s to UTF-8"

      "%s", len, encoding, (err) ? " , using ISO-8859-15 as fallback" : "");

  return ret;

}

static gchar *

get_next_line (GstSubParse * self)

{

  char *line = NULL;

  const char *line_end;

  int line_len;

  gboolean have_r = FALSE;

  line_end = strchr (self->textbuf->str, '\n');

  if (!line_end) {

    /* end-of-line not found; return for more data */

    return NULL;

  }

  /* get rid of '\r' */

  if (line_end != self->textbuf->str && *(line_end - 1) == '\r') {

    line_end--;

    have_r = TRUE;

  }

  line_len = line_end - self->textbuf->str;

  self->textbuf = g_string_erase (self->textbuf, 0,

      line_len + (have_r ? 2 : 1));

  return line;

}

static gchar *

parse_mdvdsub (ParserState * state, const gchar * line)

{

  const gchar *line_split;

  gchar *line_chunk;

  guint start_frame, end_frame;

  gint64 clip_start = 0, clip_stop = 0;

  gboolean in_seg = FALSE;

  GString *markup;

  gchar *ret;

  /* style variables */

  gboolean italic;

  gboolean bold;

  guint fontsize;

  if (sscanf (line, "{%u}{%u}", &start_frame, &end_frame) != 2) {

    g_warning ("Parse of the following line, assumed to be in microdvd .sub"

        " format, failed:\n%s", line);

    return NULL;

  }

  /* skip the {%u}{%u} part */

  line = strchr (line, '}') + 1;

  line = strchr (line, '}') + 1;

  /* see if there's a first line with a framerate */

  if (state->fps == 0.0 && start_frame == 1 && end_frame == 1) {

    gchar *rest, *end = NULL;

    rest = g_strdup (line);

    g_strdelimit (rest, ",", '.');

    state->fps = g_ascii_strtod (rest, &end);

    if (end == rest)

      state->fps = 0.0;

    GST_INFO ("framerate from file: %f ('%s')", state->fps, rest);

    g_free (rest);

    return NULL;

  }

  if (state->fps == 0.0) {

    /* FIXME: hardcoded for now, is there a better way/assumption? */

    state->fps = 24000.0 / 1001.0;

    GST_INFO ("no framerate specified, assuming %f", state->fps);

  }

  state->start_time = start_frame / state->fps * GST_SECOND;

  state->duration = (end_frame - start_frame) / state->fps * GST_SECOND;

  /* Check our segment start/stop */

  in_seg = gst_segment_clip (state->segment, GST_FORMAT_TIME,

      state->start_time, state->start_time + state->duration, &clip_start,

      &clip_stop);

  /* No need to parse that text if it's out of segment */

  if (in_seg) {

    state->start_time = clip_start;

    state->duration = clip_stop - clip_start;

  } else {

    return NULL;

  }

  markup = g_string_new (NULL);

  while (1) {

    italic = FALSE;

    bold = FALSE;

    fontsize = 0;

    /* parse style markup */

    if (strncmp (line, "{y:i}", 5) == 0) {

      italic = TRUE;

      line = strchr (line, '}') + 1;

    }

    if (strncmp (line, "{y:b}", 5) == 0) {

      bold = TRUE;

      line = strchr (line, '}') + 1;

    }

    if (sscanf (line, "{s:%u}", &fontsize) == 1) {

      line = strchr (line, '}') + 1;

    }

    /* forward slashes at beginning/end signify italics too */

    if (g_str_has_prefix (line, "/")) {

      italic = TRUE;

      ++line;

    }

    if ((line_split = strchr (line, '|')))

      line_chunk = g_markup_escape_text (line, line_split - line);

    else

      line_chunk = g_markup_escape_text (line, strlen (line));

    /* Remove italics markers at end of line/stanza (CHECKME: are end slashes

     * always at the end of a line or can they span multiple lines?) */

    if (g_str_has_suffix (line_chunk, "/")) {

      line_chunk[strlen (line_chunk) - 1] = '\0';

    }

    markup = g_string_append (markup, "<span");

    if (italic)

      g_string_append (markup, " style=\"italic\"");

    if (bold)

      g_string_append (markup, " weight=\"bold\"");

    if (fontsize)

      g_string_append_printf (markup, " size=\"%u\"", fontsize * 1000);

    g_string_append_printf (markup, ">%s</span>", line_chunk);

    g_free (line_chunk);

    if (line_split) {

      g_string_append (markup, "\n");

      line = line_split + 1;

    } else {

      break;

    }

  }

  ret = markup->str;

  g_string_free (markup, FALSE);

  GST_DEBUG ("parse_mdvdsub returning (%f+%f): %s",

      state->start_time / (double) GST_SECOND,

      state->duration / (double) GST_SECOND, ret);

  return ret;

}

static void

strip_trailing_newlines (gchar * txt)

{

  if (txt) {

    guint len;

    len = strlen (txt);

    while (len > 1 && txt[len - 1] == '\n') {

      txt[len - 1] = '\0';

      --len;

    }

  }

}

/* we want to escape text in general, but retain basic markup like

 * <i></i>, <u></u>, and <b></b>. The easiest and safest way is to

 * just unescape a white list of allowed markups again after

 * escaping everything (the text between these simple markers isn't

 * necessarily escaped, so it seems best to do it like this) */

static void

subrip_unescape_formatting (gchar * txt)

{