From 786be7e4a8be66bdfcc3459496156ca5028b672d Mon Sep 17 00:00:00 2001
From: Michael Roitzsch <mroi@users.sourceforge.net>
Date: Sun, 29 Dec 2002 16:39:38 +0000
Subject: first draft of a sputext demuxer This does not work at all yet. TODO:
 - make demuxer send subtitle text in buffers and tag them with useful  
 timestamps - adjust decoder to new API: it should read the text from the
 buffers   and render them into overlays using OSD renderer

CVS patchset: 3717
CVS date: 2002/12/29 16:39:38
---
 src/libsputext/Makefile.am     |  14 +-
 src/libsputext/demux_sputext.c | 977 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 987 insertions(+), 4 deletions(-)
 create mode 100644 src/libsputext/demux_sputext.c

(limited to 'src')

diff --git a/src/libsputext/Makefile.am b/src/libsputext/Makefile.am
index fd001f9e8..642586265 100644
--- a/src/libsputext/Makefile.am
+++ b/src/libsputext/Makefile.am
@@ -3,15 +3,21 @@ LIBTOOL = $(SHELL) $(top_builddir)/libtool-nofpic
 libdir = $(XINE_PLUGINDIR)
 
 if HAVE_GICONV
-sputext_decoder = xineplug_decode_sputext.la
+#sputext_decoder = xineplug_decode_sputext.la xineplug_dmx_sputext.la
+sputext_decoder = xineplug_dmx_sputext.la
 endif
 
 lib_LTLIBRARIES = $(sputext_decoder)
 
-xineplug_decode_sputext_la_SOURCES = xine_decoder.c 
-xineplug_decode_sputext_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@
+xineplug_dmx_sputext_la_SOURCES = demux_sputext.c
 ## libgiconv is only needed with FreeBSD
-xineplug_decode_sputext_la_LIBADD  = $(GICONV_BSD_LIBS)
+xineplug_dmx_sputext_la_LIBADD  = $(XINELIB) $(GICONV_BSD_LIBS)
+xineplug_dmx_sputext_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@
+
+#xineplug_decode_sputext_la_SOURCES = xine_decoder.c 
+## libgiconv is only needed with FreeBSD
+#xineplug_decode_sputext_la_LIBADD  = $(XINELIB)
+#xineplug_decode_sputext_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@
 
 ##
 ## Install header files (default=$includedir/xine)
diff --git a/src/libsputext/demux_sputext.c b/src/libsputext/demux_sputext.c
new file mode 100644
index 000000000..d316e2bf3
--- /dev/null
+++ b/src/libsputext/demux_sputext.c
@@ -0,0 +1,977 @@
+/*
+ * Copyright (C) 2000-2002 the xine project
+ * 
+ * This file is part of xine, a free video player.
+ * 
+ * xine is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * xine 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 General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
+ *
+ * $Id: demux_sputext.c,v 1.1 2002/12/29 16:39:38 mroi Exp $
+ *
+ * code based on old libsputext/xine_decoder.c
+ *
+ * code based on mplayer module:
+ *
+ * Subtitle reader with format autodetection
+ *
+ * Written by laaz
+ * Some code cleanup & realloc() by A'rpi/ESP-team
+ * dunnowhat sub format by szabi
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <iconv.h>
+
+#include "xine_internal.h"
+#include "xineutils.h"
+#include "../demuxers/demux.h"
+#include "osd.h"
+
+#define LOG 1
+
+#define ERR (void *)-1
+
+#define SUB_MAX_TEXT  5
+
+#define SUB_BUFSIZE 1024
+
+/*
+ *  Demuxer typedefs
+ */
+
+
+typedef struct {
+
+  int lines;
+
+  unsigned long start;
+  unsigned long end;
+    
+  char *text[SUB_MAX_TEXT];
+
+} subtitle_t;
+
+
+typedef struct {
+
+  demux_plugin_t     demux_plugin;
+  xine_stream_t     *stream;
+  input_plugin_t    *input;
+
+  int                status;
+
+  char               buf[SUB_BUFSIZE];
+  off_t              buflen;
+
+  float              mpsub_position;  
+
+  int                uses_time;  
+  int                errs;  
+  subtitle_t        *subtitles;
+  int                num;            /* number of subtitle structs */
+  int                cur;            /* current subtitle           */
+  int                format;         /* constants see below        */     
+  subtitle_t        *previous_aqt_sub ;
+
+} demux_sputext_t;
+
+typedef struct demux_sputext_class_s {
+
+  demux_class_t      demux_class;
+
+  xine_t            *xine;
+  config_values_t   *config;
+
+  char              *src_encoding;
+  char              *dst_encoding;
+
+} demux_sputext_class_t;
+
+/*
+ * Demuxer code start
+ */
+
+#define FORMAT_MICRODVD  0
+#define FORMAT_SUBRIP    1
+#define FORMAT_SUBVIEWER 2
+#define FORMAT_SAMI      3
+#define FORMAT_VPLAYER   4
+#define FORMAT_RT        5
+#define FORMAT_SSA       6 /* Sub Station Alpha */
+#define FORMAT_DUNNO     7 /*... erm ... dunnowhat. tell me if you know */
+#define FORMAT_MPSUB     8 
+#define FORMAT_AQTITLE   9 
+
+static int eol(char p) {
+  return (p=='\r' || p=='\n' || p=='\0');
+}
+
+static inline void trail_space(char *s) {
+  int i;
+  while (isspace(*s)) 
+    strcpy(s, s + 1);
+  i = strlen(s) - 1;
+  while (i > 0 && isspace(s[i])) 
+    s[i--] = '\0';
+}
+
+/*
+ * Reimplementation of fgets() using the input->read() method.
+ */
+static char *read_line_from_input(demux_sputext_t *this, char *line, off_t len) {
+  off_t nread = 0;
+  char *s;
+  int linelen;
+
+  if ((len - this->buflen) >512)
+    nread = this->input->read(this->input, &this->buf[this->buflen], len - this->buflen);
+
+  this->buflen += nread;
+  this->buf[this->buflen] = '\0';
+
+  s = strstr(this->buf, "\n");
+  if (line && (s || this->buflen)) {
+
+    linelen = s ? (s - this->buf) + 1 : this->buflen;
+    
+    memcpy(line, this->buf, linelen);
+    line[linelen] = '\0';
+
+    memmove(this->buf, &this->buf[linelen], SUB_BUFSIZE - linelen);
+    this->buflen -= linelen;
+
+    return line;
+  }
+
+  return NULL;
+}
+
+
+static subtitle_t *sub_read_line_sami(demux_sputext_t *this, subtitle_t *current) {
+
+  static char line[1001];
+  static char *s = NULL;
+  char text[1000], *p, *q;
+  int state;
+
+  p = NULL;
+  current->lines = current->start = current->end = 0;
+  state = 0;
+  
+  /* read the first line */
+  if (!s)
+    if (!(s = read_line_from_input(this, line, 1000))) return 0;
+  
+  do {
+    switch (state) {
+      
+    case 0: /* find "START=" */
+      s = strstr (s, "Start=");
+      if (s) {
+	current->start = strtol (s + 6, &s, 0) / 10;
+	state = 1; continue;
+      }
+      break;
+      
+    case 1: /* find "<P" */
+      if ((s = strstr (s, "<P"))) { s += 2; state = 2; continue; }
+      break;
+      
+    case 2: /* find ">" */
+      if ((s = strchr (s, '>'))) { s++; state = 3; p = text; continue; }
+      break;
+      
+    case 3: /* get all text until '<' appears */
+      if (*s == '\0') { break; }
+      else if (*s == '<') { state = 4; }
+      else if (!strncasecmp (s, "&nbsp;", 6)) { *p++ = ' '; s += 6; }
+      else if (*s == '\r') { s++; }
+      else if (!strncasecmp (s, "<br>", 4) || *s == '\n') {
+	*p = '\0'; p = text; trail_space (text);
+	if (text[0] != '\0')
+	  current->text[current->lines++] = strdup (text);
+	if (*s == '\n') s++; else s += 4;
+      }
+      else *p++ = *s++;
+      continue;
+      
+    case 4: /* get current->end or skip <TAG> */
+      q = strstr (s, "Start=");
+      if (q) {
+	current->end = strtol (q + 6, &q, 0) / 10 - 1;
+	*p = '\0'; trail_space (text);
+	if (text[0] != '\0')
+	  current->text[current->lines++] = strdup (text);
+	if (current->lines > 0) { state = 99; break; }
+	state = 0; continue;
+      }
+      s = strchr (s, '>');
+      if (s) { s++; state = 3; continue; }
+      break;
+    }
+    
+    /* read next line */
+    if (state != 99 && !(s = read_line_from_input (this, line, 1000))) 
+      return 0;
+    
+  } while (state != 99);
+  
+  return current;
+}
+
+
+static char *sub_readtext(char *source, char **dest) {
+  int len=0;
+  char *p=source;
+  
+  while ( !eol(*p) && *p!= '|' ) {
+    p++,len++;
+  }
+  
+  *dest= (char *)xine_xmalloc (len+1);
+  if (!dest) 
+    return ERR;
+  
+  strncpy(*dest, source, len);
+  (*dest)[len]=0;
+  
+  while (*p=='\r' || *p=='\n' || *p=='|')
+    p++;
+  
+  if (*p)  return p;  /* not-last text field */
+  else return NULL;   /* last text field     */
+}
+
+static subtitle_t *sub_read_line_microdvd(demux_sputext_t *this, subtitle_t *current) {
+
+  char line[1001];
+  char line2[1001];
+  char *p, *next;
+  int i;
+  
+  bzero (current, sizeof(subtitle_t));
+  
+  current->end=-1;
+  do {
+    if (!read_line_from_input (this, line, 1000)) return NULL;
+  } while ((sscanf (line, "{%ld}{}%[^\r\n]", &(current->start), line2) !=2) &&
+           (sscanf (line, "{%ld}{%ld}%[^\r\n]", &(current->start), &(current->end),line2) !=3)
+	  );
+  
+  p=line2;
+  
+  next=p, i=0;
+  while ((next =sub_readtext (next, &(current->text[i])))) {
+    if (current->text[i]==ERR) return ERR;
+    i++;
+    if (i>=SUB_MAX_TEXT) { 
+      printf ("Too many lines in a subtitle\n");
+      current->lines=i;
+      return current;
+    }
+  }
+  current->lines= ++i;
+  
+  return current;
+}
+
+static subtitle_t *sub_read_line_subrip(demux_sputext_t *this, subtitle_t *current) {
+
+  char line[1001];
+  int a1,a2,a3,a4,b1,b2,b3,b4;
+  char *p=NULL, *q=NULL;
+  int len;
+  
+  bzero (current, sizeof(subtitle_t));
+  
+  while (1) {
+    if (!read_line_from_input(this, line, 1000)) return NULL;
+    if (sscanf (line, "%d:%d:%d.%d,%d:%d:%d.%d",&a1,&a2,&a3,&a4,&b1,&b2,&b3,&b4) < 8) continue;
+    current->start = a1*360000+a2*6000+a3*100+a4;
+    current->end   = b1*360000+b2*6000+b3*100+b4;
+    
+    if (!read_line_from_input(this, line, 1000)) return NULL;
+    
+    p=q=line;
+    for (current->lines=1; current->lines < SUB_MAX_TEXT; current->lines++) {
+      for (q=p,len=0; *p && *p!='\r' && *p!='\n' && strncmp(p,"[br]",4); p++,len++);
+      current->text[current->lines-1]=(char *)xine_xmalloc (len+1);
+      if (!current->text[current->lines-1]) return ERR;
+      strncpy (current->text[current->lines-1], q, len);
+      current->text[current->lines-1][len]='\0';
+      if (!*p || *p=='\r' || *p=='\n') break;
+      while (*p++!=']');
+    }
+    break;
+  }
+  return current;
+}
+
+static subtitle_t *sub_read_line_third(demux_sputext_t *this,subtitle_t *current) {
+  char line[1001];
+  int a1,a2,a3,a4,b1,b2,b3,b4;
+  char *p=NULL;
+  int i,len;
+  
+  bzero (current, sizeof(subtitle_t));
+  
+  while (!current->text[0]) {
+    if (!read_line_from_input(this, line, 1000)) return NULL;
+  
+    if ((len=sscanf (line, "%d:%d:%d,%d --> %d:%d:%d,%d",&a1,&a2,&a3,&a4,&b1,&b2,&b3,&b4)) < 8)
+      continue;
+    current->start = a1*360000+a2*6000+a3*100+a4/10;
+    current->end   = b1*360000+b2*6000+b3*100+b4/10;
+    for (i=0; i<SUB_MAX_TEXT;) {
+      if (!read_line_from_input(this, line, 1000)) break;
+      len=0;
+      for (p=line; *p!='\n' && *p!='\r' && *p; p++,len++);
+      if (len) {
+	current->text[i]=(char *)xine_xmalloc (len+1);
+	if (!current->text[i]) return ERR;
+	strncpy (current->text[i], line, len); current->text[i][len]='\0';
+	i++;
+      } else {
+	break;
+      }
+    }
+    current->lines=i;
+  }
+  
+  return current;
+}
+
+static subtitle_t *sub_read_line_vplayer(demux_sputext_t *this,subtitle_t *current) {
+  char line[1001];
+  char line2[1001];
+  int a1,a2,a3,b1,b2,b3;
+  char *p=NULL, *next;
+  int i,len,len2,plen;
+
+  bzero (current, sizeof(subtitle_t));
+  
+  while (!current->text[0]) {
+    if (!read_line_from_input(this, line, 1000)) return NULL;
+    if ((len=sscanf (line, "%d:%d:%d:%n",&a1,&a2,&a3,&plen)) < 3)
+      continue;
+    if (!read_line_from_input(this, line2, 1000)) return NULL;
+    if ((len2=sscanf (line2, "%d:%d:%d:",&b1,&b2,&b3)) < 3)
+      continue;
+    /* przewiń o linijkę do tyłu: */
+    this->input->seek(this->input, -strlen(line2), SEEK_CUR);
+    
+    current->start = a1*360000+a2*6000+a3*100;
+    current->end   = b1*360000+b2*6000+b3*100;
+    if ((current->end - current->start) > 1000) 
+      current->end = current->start + 1000; /* not too long though.  */
+    /* teraz czas na wkopiowanie stringu */
+    p=line;	
+    /* finds the body of the subtitle_t */
+    for (i=0; i<3; i++){              
+      p=strchr(p,':')+1;
+    } 
+    i=0;
+    
+    if (*p!='|') {
+      next = p,i=0;
+      while ((next =sub_readtext (next, &(current->text[i])))) {
+	if (current->text[i]==ERR) 
+	  return ERR;
+	i++;
+	if (i>=SUB_MAX_TEXT) { 
+	  printf ("Too many lines in a subtitle\n");
+	  current->lines=i;
+	  return current;
+	}
+      }
+      current->lines=i+1;
+    }
+  }
+  return current;
+}
+
+static subtitle_t *sub_read_line_rt(demux_sputext_t *this,subtitle_t *current) {
+  /*
+   * TODO: This format uses quite rich (sub/super)set of xhtml 
+   * I couldn't check it since DTD is not included.
+   * WARNING: full XML parses can be required for proper parsing 
+   */
+  char line[1001];
+  int a1,a2,a3,a4,b1,b2,b3,b4;
+  char *p=NULL,*next=NULL;
+  int i,len,plen;
+  
+  bzero (current, sizeof(subtitle_t));
+  
+  while (!current->text[0]) {
+    if (!read_line_from_input(this, line, 1000)) return NULL;
+    /*
+     * TODO: it seems that format of time is not easily determined, it may be 1:12, 1:12.0 or 0:1:12.0
+     * to describe the same moment in time. Maybe there are even more formats in use.
+     */
+    if ((len=sscanf (line, "<Time Begin=\"%d:%d:%d.%d\" End=\"%d:%d:%d.%d\"",&a1,&a2,&a3,&a4,&b1,&b2,&b3,&b4)) < 8)
+     
+      plen=a1=a2=a3=a4=b1=b2=b3=b4=0;
+    if (
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d\" %*[Ee]nd=\"%d:%d\"%*[^<]<clear/>%n",&a2,&a3,&b2,&b3,&plen)) < 4) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d\" %*[Ee]nd=\"%d:%d.%d\"%*[^<]<clear/>%n",&a2,&a3,&b2,&b3,&b4,&plen)) < 5) &&
+	/*	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d.%d\" %*[Ee]nd=\"%d:%d\"%*[^<]<clear/>%n",&a2,&a3,&a4,&b2,&b3,&plen)) < 5) && */
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d.%d\" %*[Ee]nd=\"%d:%d.%d\"%*[^<]<clear/>%n",&a2,&a3,&a4,&b2,&b3,&b4,&plen)) < 6) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d:%d.%d\" %*[Ee]nd=\"%d:%d:%d.%d\"%*[^<]<clear/>%n",&a1,&a2,&a3,&a4,&b1,&b2,&b3,&b4,&plen)) < 8) 
+	)
+      continue;
+    current->start = a1*360000+a2*6000+a3*100+a4/10;
+    current->end   = b1*360000+b2*6000+b3*100+b4/10;
+    p=line;	p+=plen;i=0;
+    /* TODO: I don't know what kind of convention is here for marking multiline subs, maybe <br/> like in xml? */
+    next = strstr(line,"<clear/>")+8;i=0;
+    while ((next =sub_readtext (next, &(current->text[i])))) {
+      if (current->text[i]==ERR) 
+	return ERR;
+      i++;
+      if (i>=SUB_MAX_TEXT) { 
+	printf ("Too many lines in a subtitle\n");
+	current->lines=i;
+	return current;
+      }
+    }
+    current->lines=i+1;
+  }
+  return current;
+}
+
+static subtitle_t *sub_read_line_ssa(demux_sputext_t *this,subtitle_t *current) {
+
+  int hour1, min1, sec1, hunsec1,
+    hour2, min2, sec2, hunsec2, nothing;
+  int num;
+  
+  char line[1000],
+    line3[1000],
+    *line2;
+  char *tmp;
+  
+  do {
+    if (!read_line_from_input(this, line, 1000)) 
+      return NULL;
+  } while (sscanf (line, "Dialogue: Marked=%d,%d:%d:%d.%d,%d:%d:%d.%d,"
+		   "%[^\n\r]", &nothing,
+		   &hour1, &min1, &sec1, &hunsec1, 
+		   &hour2, &min2, &sec2, &hunsec2,
+		   line3) < 9);
+  line2=strstr(line3,",,");
+  if (!line2) return NULL;
+  line2 ++;
+  line2 ++;
+
+  current->lines=1;num=0;
+  current->start = 360000*hour1 + 6000*min1 + 100*sec1 + hunsec1;
+  current->end   = 360000*hour2 + 6000*min2 + 100*sec2 + hunsec2;
+  
+  while ( (tmp=strstr(line2, "\\n")) ) {
+    current->text[num]=(char *)xine_xmalloc(tmp-line2+1);
+    strncpy (current->text[num], line2, tmp-line2);
+    current->text[num][tmp-line2]='\0';
+    line2=tmp+2;
+    num++;
+    current->lines++;
+    if (current->lines >=  SUB_MAX_TEXT) return current;
+  }
+  
+  
+  current->text[num]=(char *) xine_xmalloc(strlen(line2)+1);
+  strcpy(current->text[num],line2);
+  
+  return current;
+}
+
+static subtitle_t *sub_read_line_dunnowhat (demux_sputext_t *this, subtitle_t *current) {
+  char line[1001];
+  char text[1001];
+  
+  bzero (current, sizeof(subtitle_t));
+  
+  if (!read_line_from_input(this, line, 1000))
+    return NULL;
+  if (sscanf (line, "%ld,%ld,\"%[^\"]", &(current->start),
+	      &(current->end), text) <3)
+    return ERR;
+  current->text[0] = strdup(text);
+  current->lines = 1;
+  
+  return current;
+}
+
+static subtitle_t *sub_read_line_mpsub (demux_sputext_t *this, subtitle_t *current) {
+  char line[1000];
+  float a,b;
+  int num=0;
+  char *p, *q;
+  
+  do {
+    if (!read_line_from_input(this, line, 1000)) 
+      return NULL;
+  } while (sscanf (line, "%f %f", &a, &b) !=2);
+
+  this->mpsub_position += (a*100.0);
+  current->start = (int) this->mpsub_position;
+  this->mpsub_position += (b*100.0);
+  current->end = (int) this->mpsub_position;
+  
+  while (num < SUB_MAX_TEXT) {
+    if (!read_line_from_input(this, line, 1000)) 
+      return NULL;
+
+    p=line;
+    while (isspace(*p)) 
+      p++;
+
+    if (eol(*p) && num > 0) 
+      return current;
+
+    if (eol(*p)) 
+      return NULL;
+    
+    for (q=p; !eol(*q); q++);
+    *q='\0';
+    if (strlen(p)) {
+      current->text[num]=strdup(p);
+      printf (">%s<\n",p);
+      current->lines = ++num;
+    } else {
+      if (num) 
+	return current;
+      else 
+	return NULL;
+    }
+  }
+
+  return NULL;
+}
+
+static subtitle_t *sub_read_line_aqt (demux_sputext_t *this, subtitle_t *current) {
+  char line[1001];
+
+  bzero (current, sizeof(subtitle_t));
+
+  while (1) {
+    /* try to locate next subtitle_t */
+    if (!read_line_from_input(this, line, 1000))
+      return NULL;
+    if (!(sscanf (line, "-->> %ld", &(current->start)) <1))
+      break;
+  }
+  
+  if (this->previous_aqt_sub != NULL) 
+    this->previous_aqt_sub->end = current->start-1;
+  
+  this->previous_aqt_sub = current;
+  
+  if (!read_line_from_input(this, line, 1000))
+    return NULL;
+  
+  sub_readtext((char *) &line,&current->text[0]);
+  current->lines = 1;
+  current->end = current->start; /* will be corrected by next subtitle_t */
+  
+  if (!read_line_from_input(this, line, 1000))
+    return current;;
+  
+  sub_readtext((char *) &line,&current->text[1]);
+  current->lines = 2;
+  
+  if ((current->text[0]=="") && (current->text[1]=="")) {
+    /* void subtitle -> end of previous marked and exit */
+    this->previous_aqt_sub = NULL;
+    return NULL;
+  }
+  
+  return current;
+}
+
+static int sub_autodetect (demux_sputext_t *this) {
+
+  char line[1001];
+  int i,j=0;
+  char p;
+  
+  while (j < 100) {
+    j++;
+    if (!read_line_from_input(this, line, 1000))
+      return -1;
+    
+    if ((sscanf (line, "{%d}{}", &i)==1) ||
+        (sscanf (line, "{%d}{%d}", &i, &i)==2)) {
+      this->uses_time=0;
+      printf ("demux_sputext: microdvd subtitle format detected\n");
+      return FORMAT_MICRODVD;
+    }
+
+    if (sscanf (line, "%d:%d:%d.%d,%d:%d:%d.%d",     &i, &i, &i, &i, &i, &i, &i, &i)==8){
+      this->uses_time=1;
+      printf ("demux_sputext: subrip subtitle format detected\n");
+      return FORMAT_SUBRIP;
+    }
+
+    if (sscanf (line, "%d:%d:%d,%d --> %d:%d:%d,%d", &i, &i, &i, &i, &i, &i, &i, &i)==8) {
+      this->uses_time=1;
+      printf ("demux_sputext: subviewer subtitle format detected\n");
+      return FORMAT_SUBVIEWER;
+    }
+    if (strstr (line, "<SAMI>")) {
+      this->uses_time=1; 
+      printf ("demux_sputext: sami subtitle format detected\n");
+      return FORMAT_SAMI;
+    }
+    if (sscanf (line, "%d:%d:%d:",     &i, &i, &i )==3) {
+      this->uses_time=1;
+      printf ("demux_sputext: vplayer subtitle format detected\n");
+      return FORMAT_VPLAYER;
+    }
+    /*
+     * A RealText format is a markup language, starts with <window> tag,
+     * options (behaviour modifiers) are possible.
+     */
+    if ( !strcasecmp(line, "<window") ) {
+      this->uses_time=1;
+      printf ("demux_sputext: rt subtitle format detected\n");
+      return FORMAT_RT;
+    }
+    if (!memcmp(line, "Dialogue: Marked", 16)){
+      this->uses_time=1; 
+      printf ("demux_sputext: ssa subtitle format detected\n");
+      return FORMAT_SSA;
+    }
+    if (sscanf (line, "%d,%d,\"%c", &i, &i, (char *) &i) == 3) {
+      this->uses_time=0;
+      printf ("demux_sputext: (dunno) subtitle format detected\n");
+      return FORMAT_DUNNO;
+    }
+    if (sscanf (line, "FORMAT=%d", &i) == 1) {
+      this->uses_time=0; 
+      printf ("demux_sputext: mpsub subtitle format detected\n");
+      return FORMAT_MPSUB;
+    }
+    if (sscanf (line, "FORMAT=TIM%c", &p)==1 && p=='E') {
+      this->uses_time=1; 
+      printf ("demux_sputext: mpsub subtitle format detected\n");
+      return FORMAT_MPSUB;
+    }
+    if (strstr (line, "-->>")) {
+      this->uses_time=0; 
+      printf ("demux_sputext: aqtitle subtitle format detected\n");
+      return FORMAT_AQTITLE;
+    }
+  }
+  
+  return -1;  /* too many bad lines */
+}
+
+static subtitle_t *sub_read_file (demux_sputext_t *this) {
+
+  demux_sputext_class_t *class = (demux_sputext_class_t *)this->demux_plugin.demux_class;
+  int n_max;
+  subtitle_t *first;
+  subtitle_t * (*func[])(demux_sputext_t *this,subtitle_t *dest)=
+  {
+    sub_read_line_microdvd,
+    sub_read_line_subrip,
+    sub_read_line_third,
+    sub_read_line_sami,
+    sub_read_line_vplayer,
+    sub_read_line_rt,
+    sub_read_line_ssa,
+    sub_read_line_dunnowhat,
+    sub_read_line_mpsub,
+    sub_read_line_aqt
+    
+  };
+  iconv_t iconv_descr;
+
+  this->format=sub_autodetect (this);
+  if (this->format==-1) {
+    printf ("demux_sputext: Could not determine file format\n");
+    return NULL;
+  }
+
+  printf ("demux_sputext: Detected subtitle file format: %d\n",this->format);
+    
+  /* Rewind */
+  this->input->seek(this->input, 0, SEEK_SET);
+  this->buflen = 0;
+
+  this->num=0;n_max=32;
+  first = (subtitle_t *) xine_xmalloc(n_max*sizeof(subtitle_t));
+  if(!first) return NULL;
+    
+  iconv_descr=iconv_open(class->dst_encoding,class->src_encoding);
+
+  while(1){
+    subtitle_t *sub;
+    if(this->num>=n_max){
+      n_max+=16;
+      first=realloc(first,n_max*sizeof(subtitle_t));
+    }
+
+    sub = func[this->format] (this, &first[this->num]);
+
+    if (!sub) 
+      break;   /* EOF */
+
+    if (sub==ERR) 
+      ++this->errs; 
+    else {
+      int i;
+      if (this->num > 0 && first[this->num-1].end == -1) {
+	first[this->num-1].end = sub->start;
+      }
+      for(i=0; i<first[this->num].lines; i++)
+      { char *tmp;
+	char *in_buff, *out_buff;
+	int   in_len, out_len;
+
+	in_len=strlen(first[this->num].text[i])+1;
+	tmp=malloc(in_len);
+	in_buff=first[this->num].text[i];
+	out_buff=tmp;
+	out_len=in_len;
+	if ((size_t)(-1)!=iconv(iconv_descr,&in_buff,&in_len,&out_buff,&out_len))
+	{ free(first[this->num].text[i]);
+	  first[this->num].text[i]=tmp;
+	}
+	else
+        { printf("demux_sputext: Can't convert subtitle text\n"); }
+      }
+      ++this->num; /* Error vs. Valid */
+    }
+  }
+  iconv_close(iconv_descr);
+
+  printf ("demux_sputext: Read %i subtitles", this->num);
+  if (this->errs) 
+    printf (", %i bad line(s).\n", this->errs);
+  else 	  
+    printf (".\n");
+  
+  return first;
+}
+
+static void update_osd_src_encoding(void *this_gen, xine_cfg_entry_t *entry)
+{
+  demux_sputext_t *this = (demux_sputext_t *)this_gen;
+  demux_sputext_class_t *class = (demux_sputext_class_t *)this->demux_plugin.demux_class;
+
+  class->src_encoding = entry->str_value;
+  
+  printf("demux_sputext: spu_src_encoding = %s\n", class->src_encoding );
+}
+
+static void update_osd_dst_encoding(void *this_gen, xine_cfg_entry_t *entry)
+{
+  demux_sputext_t *this = (demux_sputext_t *)this_gen;
+  demux_sputext_class_t *class = (demux_sputext_class_t *)this->demux_plugin.demux_class;
+
+  class->dst_encoding = entry->str_value;
+  
+  printf("demux_sputext: spu_dst_encoding = %s\n", class->dst_encoding );
+}
+
+static int demux_sputext_next (demux_sputext_t *this) {
+  /* FIXME: send something out here */
+  return 1;
+}
+
+static void demux_sputext_dispose (demux_plugin_t *this_gen) {
+  free (this_gen);
+}
+
+static int demux_sputext_get_status (demux_plugin_t *this_gen) {
+  demux_sputext_t *this = (demux_sputext_t *) this_gen;
+  return this->status;
+}
+
+static int demux_sputext_get_stream_length (demux_plugin_t *this_gen) {
+  /* FIXME: what to return? */
+  return 0;
+}
+
+static int demux_sputext_send_chunk (demux_plugin_t *this_gen) {
+  demux_sputext_t   *this = (demux_sputext_t *) this_gen;
+  
+  if (!demux_sputext_next (this)) {
+    this->status = DEMUX_FINISHED;
+  }
+
+  return this->status;
+}
+
+static int demux_sputext_seek (demux_plugin_t *this_gen,
+                            off_t start_pos, int start_time) {
+  demux_sputext_t *this = (demux_sputext_t*)this_gen;
+  return this->status;
+}
+
+static void demux_sputext_send_headers(demux_plugin_t *this_gen) {
+  demux_sputext_t *this = (demux_sputext_t*)this_gen;
+  xine_demux_control_start(this->stream);
+  this->stream->stream_info[XINE_STREAM_INFO_HAS_VIDEO] = 0;
+  this->stream->stream_info[XINE_STREAM_INFO_HAS_AUDIO] = 0;
+}
+
+static uint32_t demux_sputext_get_capabilities(demux_plugin_t *this_gen) {
+  return DEMUX_CAP_NOCAP;
+}
+
+static demux_plugin_t *open_demux_plugin (demux_class_t *class_gen, xine_stream_t *stream,
+                                    input_plugin_t *input_gen) {
+
+  input_plugin_t        *input = (input_plugin_t *) input_gen;
+  demux_sputext_t       *this;
+
+  printf("demux_sputext: open_plugin() called\n");
+
+  this = xine_xmalloc (sizeof (demux_sputext_t));
+  this->stream = stream;
+  this->input  = input;
+
+  this->demux_plugin.send_headers      = demux_sputext_send_headers;
+  this->demux_plugin.send_chunk        = demux_sputext_send_chunk;
+  this->demux_plugin.seek              = demux_sputext_seek;
+  this->demux_plugin.dispose           = demux_sputext_dispose;
+  this->demux_plugin.get_status        = demux_sputext_get_status;
+  this->demux_plugin.get_stream_length = demux_sputext_get_stream_length;
+  this->demux_plugin.get_video_frame   = NULL;
+  this->demux_plugin.got_video_frame_cb= NULL;
+  this->demux_plugin.get_capabilities  = demux_sputext_get_capabilities;
+  this->demux_plugin.get_optional_data = NULL;
+  this->demux_plugin.demux_class       = class_gen;
+  this->status = DEMUX_OK;
+
+  this->buflen = 0;
+
+  switch (stream->content_detection_method) {
+  case METHOD_BY_EXTENSION:
+    {
+      char *mrl, *ending;
+      
+      mrl = input->get_mrl(input);
+      ending = strrchr(mrl, '.');
+
+      if (!ending || (
+	  (strncasecmp(ending, ".asc", 4) != 0) &&
+	  (strncasecmp(ending, ".txt", 4) != 0) &&
+	  (strncasecmp(ending, ".sub", 4) != 0) &&
+	  (strncasecmp(ending, ".srt", 4) != 0))) {
+        free (this);
+        return NULL;
+      }
+    }
+    /* falling through is intended */
+    
+  case METHOD_EXPLICIT:
+  /* case METHOD_BY_CONTENT: */
+  
+    /* FIXME: for now this demuxer only works when requested explicitly
+     * to make sure it does not interfere with others;
+     * If this is found too inconvenient, this may be changed after making
+     * sure the content detection does not produce any false positives.
+     */
+    
+    if ((input->get_capabilities(input) & INPUT_CAP_SEEKABLE) != 0) {
+      
+      this->subtitles = sub_read_file (this);
+
+      this->cur = 0;
+
+      if (this->subtitles) {
+        printf ("demux_sputext: subtitle format %s time.\n", this->uses_time?"uses":"doesn't use");
+        printf ("demux_sputext: read %i subtitles, %i errors.\n", this->num, this->errs);
+        return &this->demux_plugin;
+      }
+    }
+    /* falling through is intended */
+  }
+
+  free (this);
+  return NULL;
+}
+  
+static char *get_demux_description (demux_class_t *this_gen) {
+  return "sputext demuxer plugin";
+}
+
+static char *get_demux_identifier (demux_class_t *this_gen) {
+  return "sputext";
+}
+
+static char *get_demux_extensions (demux_class_t *this_gen) {
+  return "asc txt sub srt";
+}
+
+static char *get_demux_mimetypes (demux_class_t *this_gen) {
+  return "text/plain: asc txt sub srt: VIDEO subtitles;";
+}
+
+static void demux_class_dispose (demux_class_t *this_gen) {
+  demux_sputext_class_t *this = (demux_sputext_class_t *) this_gen;
+
+  free (this);
+}
+
+static void *init_sputext_demux_class (xine_t *xine, void *data) {
+
+  demux_sputext_class_t *this ;
+
+  printf("demux_sputext: initializing\n");
+
+  this = xine_xmalloc (sizeof (demux_sputext_class_t));
+  this->config = xine->config;
+
+  this->demux_class.open_plugin     = open_demux_plugin;
+  this->demux_class.get_description = get_demux_description;
+  this->demux_class.get_identifier  = get_demux_identifier;
+  this->demux_class.get_mimetypes   = get_demux_mimetypes;
+  this->demux_class.get_extensions  = get_demux_extensions;
+  this->demux_class.dispose         = demux_class_dispose;
+
+  this->src_encoding  = xine->config->register_string(xine->config, 
+				"misc.spu_src_encoding", 
+				"windows-1250", 
+				_("source encoding of subtitles"), 
+				NULL, 10, update_osd_src_encoding, this);
+  this->dst_encoding  = xine->config->register_string(xine->config, 
+				"misc.spu_dst_encoding", 
+				"iso-8859-2", 
+				_("target encoding for subtitles (have to match font encoding)"), 
+				NULL, 10, update_osd_dst_encoding, this);
+
+  return this;
+}
+
+plugin_info_t xine_plugin_info[] = {
+  /* type, API, "name", version, special_info, init_function */  
+  { PLUGIN_DEMUX, 19, "sputext", XINE_VERSION_CODE, NULL, &init_sputext_demux_class },
+  { PLUGIN_NONE, 0, "", 0, NULL, NULL }
+};
-- 
cgit v1.2.3