Re: [PATCH] Better subtitling control (v1.1.0)

diff -ruN old/filter/extsub/Makefile.am new/filter/extsub/Makefile.am
--- old/filter/extsub/Makefile.am	2007-03-11 22:25:51.000000000 -0400
+++ new/filter/extsub/Makefile.am	2007-03-11 22:24:26.000000000 -0400
@@ -7,12 +7,12 @@
 
 pkgdir = $(MOD_PATH)
 
-pkg_LTLIBRARIES = filter_extsub.la filter_extsub2.la
+pkg_LTLIBRARIES = filter_extsub.la filter_nextsub.la
 
 filter_extsub_la_SOURCES = filter_extsub.c subproc.c subtitle_buffer.c
 filter_extsub_la_LDFLAGS = -module -avoid-version
 
-filter_extsub2_la_SOURCES = filter_extsub.c subproc.c subtitle_buffer.c
-filter_extsub2_la_LDFLAGS = -module -avoid-version
+filter_nextsub_la_SOURCES = filter_nextsub.c subproc.c subtitle_buffer.c
+filter_nextsub_la_LDFLAGS = -module -avoid-version
 
-EXTRA_DIST = subproc.h subtitle_buffer.h
+EXTRA_DIST = subproc.h subtitle_buffer.h nextsub.h
diff -ruN old/filter/extsub/filter_nextsub.c new/filter/extsub/filter_nextsub.c
--- old/filter/extsub/filter_nextsub.c	1969-12-31 19:00:00.000000000 -0500
+++ new/filter/extsub/filter_nextsub.c	2007-03-11 22:43:35.000000000 -0400
@@ -0,0 +1,1272 @@
+/*
+ *  filter_nextsub.c
+ *
+ *  Copyright (C) Thomas Oestreich - January 2002
+ *  Copyright (C) Allan Snider     - March 2007
+ *
+ *  This file is part of transcode, a video stream processing tool
+ *
+ *  transcode 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, or (at your option)
+ *  any later version.
+ *
+ *  transcode 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 GNU Make; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+/*
+ * 	v0.3.5 -> v0.4.0:	(Allan Snider)
+ * 		- code style cleanup
+ * 		- add opacity and rendering color for each index
+ * 		- add zoom flag
+ * 		- crop subtitle, (for consistent placement)
+ * 		- modified positioning behaviour
+ * 		- better (?) index guessing
+ */
+
+#define MOD_NAME	"filter_nextsub.so"
+#define MOD_VERSION	"0.4.0 (2007-03-01)"
+#define MOD_CAP		"DVD subtitle overlay plugin"
+#define MOD_AUTHOR	"Thomas Oestreich / Allan Snider"
+
+#include "nextsub.h"
+
+static MyFilterData *mfd;
+
+
+/*
+ *	help_opstr:
+ */
+
+static void
+help_optstr( void )
+{
+    tc_log_info( MOD_NAME, "(%s) help:\n\n"
+	 "* Overview:\n"
+	 "\n"
+	 "      DVD subtitle overlay plugin.\n"
+	 "          Original code by Thomas Destreich,\n"
+	 "          Enhancements added by Allan Snider.\n"
+	 "\n"
+	 "      A subtitle bitmap contains 4 index values, background, text body,\n"
+	 "      inner outline, and outer outline.  The ordering of the indices vary\n"
+	 "      from DVD to DVD.  The background will always be transparent.  One can\n"
+	 "      specify opacity values (0-1) and rendering colors (hex rrggbb) for each\n"
+	 "      index (1-3).  The bitmap can be anti-aliased, and zoomed (XxY).  The\n"
+	 "      resulting bitmap is then cropped giving control of where the subtitle\n"
+	 "      is located, regardless of where the original bitmap had placed it.\n"
+	 "\n"
+	 "      Occasionally, a subtitle component (eg. text body), will be composed\n"
+	 "      of more than one index.  One could assign them the same opacity and\n"
+	 "      color, however, each index is anti-aliased and zoomed individually\n"
+	 "      which would produce poor results.  Therefore, the 'map' option was\n"
+	 "      added, which allows one index value to be remapped to another.  This\n"
+	 "      provides a mechanism to join two index values into one component.\n"
+	 "\n"
+	 "      If no opacity arguments are given, the highest frequency (non-background)\n"
+	 "      subtitle index is assumed to be the body of the text, and the next\n"
+	 "      highest, the inner text outline.  Both indices are assigned an opacity\n"
+	 "      of 1.0.  The text body is assigned the default color and the outline is\n"
+	 "      assigned as black.  The index frequencies are calculated from the first\n"
+	 "      subtitle rendered.\n"
+	 "\n"
+	 "      For positioning, the default (pos=0,topalign=0) places the bottom line of\n"
+	 "      the subtitle at the bottom line of the video frame.  Positive values move\n"
+	 "      the subtitle up by the given number of rows.  If topalign=1, then the\n"
+	 "      top line of the subtitle is placed at the position given (and should be\n"
+	 "      at least the height of the subtitle, else it will be clipped).\n"
+	 "\n"
+	 "      For boolean arguments, a value of TRUE is assumed if the option is\n"
+	 "      present but no value is given.  For opacity arguments, a value\n"
+	 "      of 1.0 is assumed if the option is given with no value.\n"
+	 "\n"
+	 "* Options:\n"
+	 "\n"
+	 "        'track'   Subtitle track (0-255) [0]\n"
+	 "        'forced'  Render only forced subtitles (0=off, 1=on) [0]\n"
+	 "        'pos'     Vertical position of subtitle (0-height) [0]\n"
+	 "        'tshift'  Start time correction (msec) [0]\n"
+	 "        'pre'     Run as a pre filter (0=no, 1=yes) [0]\n"
+	 "        'aalias'  Anti-aliasing (0=off, 1=on) [0]\n"
+	 "        'zoom'    Zoom subtitle image (X[xY]) [1x1]\n"
+	 "        'o1'      Index 1 opacity (0-1) [0]\n"
+	 "        'o2'      Index 2 opacity (0-1) [0]\n"
+	 "        'o3'      Index 3 opacity (0-1) [0]\n"
+	 "        'c1'      Index 1 rendering color (rr[ggbb]) [clr]\n"
+	 "        'c2'      Index 2 rendering color (rr[ggbb]) [clr]\n"
+	 "        'c3'      Index 3 rendering color (rr[ggbb]) [clr]\n"
+	 "        'clr'     Default rendering color (rr[ggbb]) [ffffff]\n"
+	 "        'map'     Remap an index value (ItoJ) [0to0]\n"
+	 "\n"
+	 "* Examples:\n"
+	 "\n"
+	 "      -J nextsub\n"
+	 "\n"
+	 "          Let the filter guess the indices, rendering text with the default\n"
+	 "          color (white) and the outline as black.  Both are assigned an\n"
+	 "          opacity of 1.0.  You should get something visible, either solid or\n"
+	 "          outlined text, rendered white, and at the very bottom of the screen.\n"
+	 "\n"
+	 "      -J nextsub=clr=d0d000:zoom=0.8\n"
+	 "\n"
+	 "          Similar to the above, but use yellow as the default color and shrink\n"
+	 "          the subtitle by 0.8 x 0.8.\n"
+	 "\n"
+	 "      -J nextsub=o1:o2=0.9:c1=d0d000:c2=00:pos=75:top:aalias:zoom=0.9x0.75\n"
+	 "\n"
+	 "          Specify explicit subtitle indices to use.  Index 1 assumes an\n"
+	 "          opacity of 1.0, and index 2 is specified as 0.9.  Render index 1\n"
+	 "          with yellow, and index 2 with black.  Top align the subtitle at\n"
+	 "          row 75.  Anti-alias it, and zoom to 0.9 x 0.75.\n"
+	 "\n"
+	 "          The above zoom factors can be a good choice for some 16:9 films\n"
+	 "          when zooming a 720x480 frame.  The subtitle is overlayed in the post\n"
+	 "          filter phase and sometimes we need a similar aspect ratio correction\n"
+	 "          applied to the subtitle bitmap as well.  Alternatively, run it as\n"
+	 "          a pre-filter.\n"
+	 "\n"
+	 "      -J nextsub=o2:map=3to2:forced\n"
+	 "\n"
+	 "          Join indices 2 and 3 together to render the text body as index 2.\n"
+	 "          In addition, only render subtitles which have the forced flag set.\n"
+	 "\n"
+	 "      -J nextsub=o1:o2:o3:c1=ff0000:c2=00ff00:c3=0000ff\n"
+	 "\n"
+	 "          Render all indices with a different color.  Encoding just a small\n"
+	 "          number of frames where a subtitle is present, this can be useful\n"
+	 "          for determining what components of the subtitle each index has\n"
+	 "          been assigned for a particular DVD.\n"
+	 "\n"
+	 , MOD_CAP );
+}
+
+
+/*
+ *	tc_filter:
+ *		Single function interface.
+ */
+
+int
+tc_filter( frame_list_t *ptr_, char *opt )
+{
+    vframe_list_t *ptr = (vframe_list_t*) ptr_;
+
+
+    //----------------------------------
+    //
+    // filter init
+    //
+    //----------------------------------
+
+    if ( ptr->tag & TC_FILTER_INIT ) {
+        int n, i;
+
+        mfd = tc_zalloc( sizeof(MyFilterData) );
+        if ( !mfd ) {
+            tc_log_perror( MOD_NAME, "out of memory" );
+            return( TC_EXPORT_ERROR );
+        }
+
+        mfd->vob = tc_get_vob();
+        if ( !mfd->vob )
+            return( -1 );
+
+        mfd->tcvhandle = tcv_init();
+        if ( !mfd->tcvhandle ) {
+            tc_log_error( MOD_NAME, "tcv initialization failed" );
+            return( TC_EXPORT_ERROR );
+        }
+
+        mfd->sub = tc_malloc( SIZE_RGB_FRAME );
+        mfd->tmp = tc_malloc( SIZE_RGB_FRAME );
+        if ( !mfd->sub || !mfd->tmp ) {
+            tc_log_perror( MOD_NAME, "out of memory" );
+            return( TC_EXPORT_ERROR );
+        }
+
+        /* split sub and tmp into individual planes */
+        n = TC_MAX_V_FRAME_WIDTH * TC_MAX_V_FRAME_HEIGHT;
+        for ( i=0; i<3; i++ ) {
+            mfd->sp[i] = mfd->sub + i*n;
+            mfd->dp[i] = mfd->tmp + i*n;
+        }
+
+        mfd->clr_def.r = 255;
+        mfd->clr_def.g = 255;
+        mfd->clr_def.b = 255;
+        for ( i=0; i<3; i++ ) {
+            mfd->clr[i].r = -1;
+            mfd->clr[i].g = -1;
+            mfd->clr[i].b = -1;
+        }
+
+        mfd->pts1 = -1;
+        mfd->pts2 = -1;
+
+        if ( opt != NULL ) {
+            char buf[100];
+            int n;
+
+            if ( verbose )
+                tc_log_info( MOD_NAME, "options=%s", opt );
+
+            /* booleans, default to TRUE if no value is given */
+            n = optstr_get( opt, "forced", "%d", &mfd->forced );
+            if ( !n )
+                mfd->forced = TC_TRUE;
+            n = optstr_get( opt, "top", "%d", &mfd->topalign );
+            if ( !n )
+                mfd->topalign = TC_TRUE;
+            n = optstr_get( opt, "pre", "%d", &mfd->prefilter );
+            if ( !n )
+                mfd->prefilter = TC_TRUE;
+            n = optstr_get( opt, "aalias", "%d", &mfd->antialias );
+            if ( !n )
+                mfd->antialias = TC_TRUE;
+
+            optstr_get( opt, "track", "%d", &mfd->vob->s_track );
+            optstr_get( opt, "pos", "%d", &mfd->pos );
+            optstr_get( opt, "tshift", "%d", &mfd->tshift );
+
+            if ( optstr_get(opt,"zoom","%[^:]",buf) >= 0 ) {
+                if ( get_zoom(buf,&mfd->z_x,&mfd->z_y) )
+                    mfd->do_zoom = 1;
+            }
+
+            /* default these to 1.0 if no value is given */
+            n = optstr_get( opt, "o1", "%lf", &mfd->fopc[0] );
+            if ( !n )
+                mfd->fopc[0] = 1.0;
+            n = optstr_get( opt, "o2", "%lf", &mfd->fopc[1] );
+            if ( !n )
+                mfd->fopc[1] = 1.0;
+            n = optstr_get( opt, "o3", "%lf", &mfd->fopc[2] );
+            if ( !n )
+                mfd->fopc[2] = 1.0;
+
+            if ( optstr_lookup(opt,"o1") ||
+                    optstr_lookup(opt,"o2") ||
+                    optstr_lookup(opt,"o3") )
+                mfd->have_indices = 1;
+
+            if ( optstr_get(opt,"c1","%[^:]",buf) > 0 )
+                mfd->clr[0] = get_rgb( buf );
+            if ( optstr_get(opt,"c2","%[^:]",buf) > 0 )
+                mfd->clr[1] = get_rgb( buf );
+            if ( optstr_get(opt,"c3","%[^:]",buf) > 0 )
+                mfd->clr[2] = get_rgb( buf );
+            if ( optstr_get(opt,"clr","%[^:]",buf) > 0 )
+                mfd->clr_def = get_rgb( buf );
+
+            optstr_get( opt, "map", "%dto%d", &mfd->remap[0], &mfd->remap[1] );
+
+            if ( optstr_lookup(opt,"help") )
+                help_optstr();
+        }
+
+        /* assign default for unset colors */
+        for ( i=0; i<3; i++ )
+            if ( mfd->clr[i].r == -1 )
+                mfd->clr[i] = mfd->clr_def;
+
+        /* convert opacities from 0-1 to 0-255 */
+        for ( i=0; i<3; i++ ) {
+            int o;
+
+            o = mfd->fopc[i] * 255;
+            if ( o < 0 )
+                o = 0;
+            if ( o > 255 )
+                o = 255;
+
+            mfd->opc[i] = o;
+        }
+
+        if ( verbose & TC_DEBUG ) {
+            tc_log_info( MOD_NAME, "Option values:" );
+            tc_log_info( MOD_NAME, "     forced: %d", mfd->forced );
+            tc_log_info( MOD_NAME, "     pos: %d", mfd->pos );
+            tc_log_info( MOD_NAME, "     top: %d", mfd->topalign );
+            tc_log_info( MOD_NAME, "     tshift: %d", mfd->tshift );
+            tc_log_info( MOD_NAME, "     pre: %d", mfd->prefilter );
+            tc_log_info( MOD_NAME, "     aalias: %d", mfd->antialias );
+            tc_log_info( MOD_NAME, "     zoom: %s", pr_zoom() );
+            for ( i=0; i<3; i++ )
+                tc_log_info( MOD_NAME, "     o%d: %g", i+1, mfd->fopc[i] );
+            for ( i=0; i<3; i++ )
+                tc_log_info( MOD_NAME, "     c%d: %s", i+1, pr_clr(mfd->clr[i]) );
+            tc_log_info( MOD_NAME, "     clr: %s", pr_clr(mfd->clr_def) );
+            tc_log_info( MOD_NAME, "     map: %d to %d", mfd->remap[0], mfd->remap[1] );
+        }
+
+        // start subtitle stream
+        mfd->import.flag = TC_SUBEX;
+        if ( tcv_import(TC_IMPORT_OPEN,&mfd->import,mfd->vob) < 0 )
+            tc_log_error( MOD_NAME, "popen subtitle stream" );
+
+        subproc_init( NULL, "title", 0, (unsigned short) mfd->vob->s_track );
+        sframe_alloc( SUBTITLE_BUFFER, mfd->import.fd );
+
+        // start thread
+        if ( pthread_create(&mfd->thread,NULL,(void*)subtitle_reader,NULL) != 0 )
+            tc_log_error( MOD_NAME, "failed to start subtitle import thread" );
+
+        mfd->f_time = 1.0 / (mfd->prefilter ? mfd->vob->fps : mfd->vob->ex_fps);
+
+        if ( verbose )
+            tc_log_info( MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP );
+
+        return( 0 );
+    }
+
+    if ( ptr->tag & TC_FILTER_GET_CONFIG ) {
+        optstr_filter_desc( opt, MOD_NAME, MOD_CAP, MOD_VERSION, MOD_AUTHOR, "VRYOE", "1" );
+        optstr_param( opt, "track", "Subtitle track", "%d", "0", "0", "255" );
+        optstr_param( opt, "forced", "Render only forced subtitles", "%d", "0", "0", "1" );
+        optstr_param( opt, "pos", "Vertical position of subtitle", "%d", "0", "0", "height" );
+        optstr_param( opt, "tshift", "Start time correction (msec)", "%d", "0", "0", "-1" );
+        optstr_param( opt, "pre", "Run as a pre filter", "%d", "0", "0", "1" );
+        optstr_param( opt, "aalias", "Anti-aliasing", "%d", "1", "0", "1" );
+        optstr_param( opt, "zoom", "Zoom subtitle image (XxY)", "%s", "1x1" );
+        optstr_param( opt, "o1", "Index 1 opacity", "%f", "1", "0", "1" );
+        optstr_param( opt, "o2", "Index 2 opacity", "%f", "1", "0", "1" );
+        optstr_param( opt, "o3", "Index 3 opacity", "%f", "1", "0", "1" );
+        optstr_param( opt, "c1", "Index 1 rendering color", "%s", "ffffff" );
+        optstr_param( opt, "c2", "Index 2 rendering color", "%s", "ffffff" );
+        optstr_param( opt, "c3", "Index 3 rendering color", "%s", "ffffff" );
+        optstr_param( opt, "clr", "Default rendering color (hex rrggbb)", "%s", "ffffff" );
+        optstr_param( opt, "map", "Remap an index value (ItoJ)", "%dto%d", "0to0" );
+
+        return( 0 );
+    }
+
+
+    //----------------------------------
+    //
+    // filter close
+    //
+    //----------------------------------
+
+    if ( ptr->tag & TC_FILTER_CLOSE ) {
+        static int close_done;
+        void *status;
+
+        if ( !close_done ) {
+            pthread_cancel( mfd->thread );
+
+#ifdef BROKEN_PTHREADS
+            pthread_cond_signal( &sframe_list_full_cv );
+#endif
+
+            pthread_join( mfd->thread, &status );
+
+            mfd->import.flag = TC_SUBEX;
+            if ( mfd->import.fd != NULL )
+                pclose( mfd->import.fd );
+
+            tcv_free( mfd->tcvhandle );
+            free( mfd->sub );
+            free( mfd->tmp );
+
+            free( mfd );
+
+            close_done = TC_TRUE;
+        }
+
+        return( 0 );
+    }
+
+    //----------------------------------
+    //
+    // filter frame routine
+    //
+    //----------------------------------
+
+    if ( ptr->tag & TC_VIDEO ) {
+        double f_pts;
+
+        if ( mfd->prefilter ) {
+            if ( !(ptr->tag & TC_PRE_S_PROCESS) )
+                return( 0 );
+        } else {
+            if ( !(ptr->tag & TC_POST_S_PROCESS) )
+                return( 0 );
+        }
+
+        if ( verbose & TC_STATS )
+            tc_log_info( MOD_NAME, "%s/%s %s %s",
+                         mfd->vob->mod_path, MOD_NAME, MOD_VERSION, MOD_CAP );
+
+
+        //-------------------------------------------------------------------------
+        //
+        // below is a very fuzzy concept of rendering the subtitle on the movie
+        //
+        // (1) check if we have a valid subtitle and render it
+        // (2) if (1) fails try to get a new one
+        // (3) buffer and display the new one if it's showtime, if not return
+        //
+        // repeat steps throughout the movie
+
+        // calculate current frame video PTS in [s]
+        // adjust for dropped frames so far
+        // adjust for user shift (in milliseconds)
+
+        f_pts = mfd->f_time * (ptr->id-tc_get_frames_dropped()+mfd->vob->psu_offset)
+                + mfd->tshift / 1000.0;
+
+        if ( verbose & TC_DEBUG )
+            tc_log_info( MOD_NAME, "frame=%06d pts=%.3f sub1=%.3f sub2=%.3f",
+                         ptr->id, f_pts, mfd->pts1, mfd->pts2 );
+
+        /* TODO: weird logic here, but going to leave it for now */
+
+        // overlay now?
+        if ( mfd->pts1<=f_pts && f_pts<=mfd->pts2 ) {
+            if ( !mfd->forced || mfd->fflg )
+                subtitle_overlay( ptr->video_buf, ptr->v_width, ptr->v_height );
+            return( 0 );
+        }
+
+        // get a new subtitle, if the last one has expired:
+        if ( f_pts > mfd->pts2 ) {
+            mfd->made_subtitle = 0;
+            if ( subtitle_retrieve() < 0 ) {
+                if ( verbose & TC_DEBUG )
+                    tc_log_info( MOD_NAME, "no subtitle available at this time" );
+                return( 0 );
+            }
+        }
+
+        // overlay now?
+        if ( mfd->pts1<f_pts && f_pts<mfd->pts2 )
+            if ( !mfd->forced || mfd->fflg )
+                subtitle_overlay( ptr->video_buf, ptr->v_width, ptr->v_height );
+    }
+
+    return( 0 );
+}
+
+
+/*
+ *	get_zoom:
+ *		Given a string of the form XxY, where X and Y are floating point
+ *	numbers, return (via parameter) the two scaling values supplied as doubles.
+ *	If only a single value is given, Y assumes the value of X.
+ */
+
+static int
+get_zoom( char *buf, double *px, double *py )
+{
+    double x, y;
+    char *p;
+
+    x = atof( buf );
+    if ( x <= 0 )
+        return( TC_FALSE );
+
+    p = strchr( buf, 'x' );
+    if ( p ) {
+        y = atof( p + 1 );
+        if ( y <= 0 )
+            return( TC_FALSE );
+    } else
+        y = x;
+
+    *px = x;
+    *py = y;
+
+    return( TC_TRUE );
+}
+
+
+/*
+ *	get_rgb:
+ *		Given a string of the form (hex) "rrggbb", return an Rgb structure
+ *	containing the (integer) tuplet [r,g,b].  If only an "rr" component is
+ *	given, gg, and bb, assume the value of rr.  For example, "ff" would be
+ *	interpreted as white (ffffff).  Return the structure by function value.
+ */
+
+static Rgb
+get_rgb( char *buf )
+{
+    Rgb c;
+    int v;
+
+    if ( strlen(buf) < 6 ) {
+        if ( strlen(buf) < 2 )
+            v = 255;
+        else
+            v = htoi( buf );
+        c.r = v;
+        c.g = v;
+        c.b = v;
+
+        return( c );
+    }
+
+    c.r = htoi( buf+0 );
+    c.g = htoi( buf+2 );
+    c.b = htoi( buf+4 );
+
+    return( c );
+}
+
+
+/*
+ *	htoi:
+ *		Convert a 2 digit hex number to integer, and return via function
+ *	value.
+ */
+
+static int
+htoi( char *buf )
+{
+    return( (htob(buf[0]) << 4) + htob(buf[1]) );
+}
+
+
+/*
+ *	htob:
+ *		Convert a hex digit to integer, and return via function value.
+ */
+
+static int
+htob( char c )
+{
+    c = tolower( c );
+    if ( c>='a' && c<='f' )
+        return( c-'a'+10 );
+    return( c-'0' );
+}
+
+
+/*
+ *	pr_zoom:
+ *		Return the zoom x, and y scaling values as a (static) string of
+ *	the form "XxY", via function value.
+ */
+
+static char *
+pr_zoom( void )
+{
+    static char buf[100];
+
+    if ( mfd->do_zoom )
+        tc_snprintf( buf, 100, "%gx%g", mfd->z_x, mfd->z_y );
+    else
+        strcpy( buf, "none" );
+
+    return( buf );
+}
+
+
+/*
+ *	pr_clr:
+ *		Return the given Rgb structure as a string of the form (hex) "rrggbb".
+ */
+
+static char *
+pr_clr( Rgb c )
+{
+    static char buf[100];
+
+    tc_snprintf( buf, 100, "%02x%02x%02x", c.r, c.g, c.b );
+    return( buf );
+}
+
+
+/*
+ *	subtitle_retrieve:
+ *		Retrieve the next subtitle from the subtitle reader thread.
+ *	Store the results in mfd:
+ *
+ *		sub	- subtitle bitmap
+ *		id	- frame number
+ *		pts1	- start time
+ *		pts2	- end time
+ *		fflg	- forced flag
+ *		xp	- suggested x position
+ *		xp	- suggested y position
+ *		sw	- subtitle width
+ *		sh	- subtitle height
+ *
+ *	The function returns 0 if successful, -1 otherwise.
+ */
+
+static int
+subtitle_retrieve( void )
+{
+    sframe_list_t *sptr = NULL;
+    sub_info_t sub;
+
+    // get a subtitle from buffer
+    pthread_mutex_lock( &sframe_list_lock );
+    if ( sframe_fill_level(TC_BUFFER_EMPTY) ) {
+        pthread_mutex_unlock( &sframe_list_lock );
+        return( -1 );
+    }
+
+    // not being empty does not mean ready to go!!!!!
+    if ( sframe_fill_level(TC_BUFFER_READY) ) {
+        pthread_mutex_unlock( &sframe_list_lock );
+        if ( (sptr=sframe_retrieve()) == NULL ) {
+            // this shouldn't happen
+            tc_log_error( MOD_NAME, "internal error (S)" );
+            return( -1 );
+        }
+    } else {
+        pthread_mutex_unlock( &sframe_list_lock );
+        return( -1 );
+    }
+
+    // conversion
+    sub.frame = mfd->sub;
+    if ( subproc_feedme(sptr->video_buf,sptr->video_size,sptr->id,sptr->pts,&sub) < 0 ) {
+        // problems, drop this subtitle
+        if ( verbose & TC_DEBUG )
+            tc_log_warn( MOD_NAME, "subtitle dropped" );
+        sframe_remove( sptr );
+        pthread_cond_signal( &sframe_list_full_cv );
+        return( -1 );
+    }
+
+    // save data
+    mfd->id = sptr->id;
+    mfd->pts1 = sptr->pts * mfd->f_time;
+    mfd->pts2 = mfd->pts1 + sub.time / 100.0;
+
+    mfd->fflg = sub.forced;
+    mfd->orig.x = sub.x;
+    mfd->orig.y = sub.y;
+    mfd->sz.x = sub.w;
+    mfd->sz.y = sub.h;
+
+    // release packet buffer
+    sframe_remove( sptr );
+    pthread_cond_signal( &sframe_list_full_cv );
+
+    if ( verbose & TC_DEBUG )
+        tc_log_info( MOD_NAME, "got SUBTITLE %d with forced=%d, pts=%.3f dtime=%.3f",
+                     mfd->id, mfd->fflg, mfd->pts1, mfd->pts2-mfd->pts1 );
+
+    return( 0 );
+}
+
+
+/*
+ *	subtitle_overlay:
+ *		The current subtitle is within the time window of the current
+ *	video frame.  Overlay it into the image.  If this is the first time
+ *	the subtitle is being rendered, anti-alias it, zoom it, and crop it.
+ *	If this is the very first subtitle rendered, and no opacity arguments
+ *	were given, then guess appropriate indices to use.  Finally, determine
+ *	the subtitle position and overlay the resulting bitmap by blending pixel
+ *	values according to opacity.
+ */
+
+static void
+subtitle_overlay( uint8_t *vid, int w, int h )
+{
+    if ( verbose & TC_DEBUG )
+        tc_log_info( MOD_NAME, "SUBTITLE id=%d, x=%d, y=%d, w=%d, h=%d, t=%f",
+                     mfd->id, mfd->orig.x, mfd->orig.y, mfd->sz.x, mfd->sz.y,
+                     mfd->pts2 - mfd->pts1 );
+
+    if ( !mfd->have_indices ) {
+        /* this is only ever done once, for the first subtitle rendered */
+        mfd->have_indices = TC_TRUE;
+        guess_indices();
+    }
+
+    /* anti-alias, zoom, and crop the subtitle */
+    if ( !mfd->made_subtitle ) {
+        /* this is done once for each subtitle rendered */
+        mfd->made_subtitle = TC_TRUE;
+        make_subtitle( w, h );
+    }
+
+    if ( mfd->vob->im_v_codec == CODEC_RGB )
+        subtitle_overlay_rgb( vid, w, h );
+
+    if ( mfd->vob->im_v_codec == CODEC_YUV )
+        subtitle_overlay_yuv( vid, w, h );
+}
+
+
+/*
+ *	guess_indices:
+ *		This is called if no opacity arguments were given.  The highest
+ *	frequency (non-background) subtitle index is assumed to be the body of
+ *	the text, and the next highest the inner text outline.  Both indices
+ *	are assigned an opacity of 1.0.  The text body is assigned the default
+ *	color, and the outline is assigned as black.
+ */
+
+static void
+guess_indices( void )
+{
+    int subi[4];
+    int ib, io;
+    int n, i;
+
+    for ( i=0; i<4; i++ )
+        subi[i] = 0;
+
+    n = mfd->sz.x * mfd->sz.y;
+    for ( i=0; i<n; i++ )
+        subi[ get_sub_index(i) ]++;
+
+    ib = 1;
+    io = 2;
+    if ( subi[1]>subi[2] && subi[1]>subi[3] ) {
+        ib = 1;
+        io = (subi[2]>subi[3]) ? 2 : 3;
+    }
+    if ( subi[2]>subi[1] && subi[2]>subi[3] ) {
+        ib = 2;
+        io = (subi[1]>subi[3]) ? 1 : 3;
+    }
+    if ( subi[3]>subi[1] && subi[3]>subi[2] ) {
+        ib = 3;
+        io = (subi[1]>subi[2]) ? 1 : 2;
+    }
+
+    --ib;
+    --io;
+
+    mfd->opc[ib] = 255;
+    mfd->opc[io] = 255;
+
+    mfd->clr[io].r = 0;
+    mfd->clr[io].g = 0;
+    mfd->clr[io].b = 0;
+
+    if ( verbose & TC_INFO )
+        tc_log_info( MOD_NAME, "index counts: 0=%d, 1=%d, 2=%d, 3=%d, body=%d, outline=%d",
+                     subi[0], subi[1], subi[2], subi[3],
+                     ib+1, io+1 );
+}
+
+
+/*
+ *	get_sub_index:
+ *		Return, via function value,  the subtitle index value at element i.
+ *	Check for a remapped index, and clamp the result to [0,3].
+ */
+
+static int
+get_sub_index( int i )
+{
+    int c;
+
+    c = mfd->sub[i];
+    if ( c == mfd->remap[0] )
+        c = mfd->remap[1];
+
+    if ( c < 0 )
+        c = 0;
+    if ( c > 3 )
+        c = 3;
+
+    return( c );
+}
+
+
+/*
+ *	make_subtitle:
+ * 		We are given a single NxM plane of indices whose values can be 0 to 3.
+ * 	A value of 0 is always considered background and transparent.  The values 1, 2,
+ * 	and 3 correspond to the text body, inner outline, and outer outline, (non resp).
+ * 	First, the indices are replaced by their corresponding opacity values, with each
+ * 	index written to a separate plane.  These planes are then anti-aliased, and
+ * 	zoomed, Then, a minimum bounding box is computed over all planes (UxV), and the
+ * 	subtitle frame is replaced with the UxV frame (three planes).  We are now capable
+ * 	of rendering the subtitle using different opacity values and rendering colors for
+ * 	each index.  Since the frame has been cropped, we also control where the subtitle
+ * 	is located, regardless of where the original bitmap had placed it.
+ */
+
+static void
+make_subtitle( int w, int h )
+{
+    uint8_t **sp, **dp;
+    Dim sz, p;
+    int n, c, i;
+
+    sp = mfd->sp;
+    dp = mfd->dp;
+
+    /* plane 0 is current subtitle */
+    /* zero planes 1 and 2 */
+    n = mfd->sz.x * mfd->sz.y;
+    memset( sp[1], 0, n );
+    memset( sp[2], 0, n );
+
+    /* replace index values with opacity values */
+    /* store opacities for each index in separate planes */
+    for ( i=0; i<n; i++ ) {
+        c = get_sub_index( i );
+        if ( c ) {
+            --c;
+            sp[c][i] = mfd->opc[c];
+        }
+    }
+
+    /* if anti-aliasing or zooming, crop to reduce work */
+    if ( mfd->antialias || mfd->do_zoom ) {
+        /* crop, with margin 6 */
+        crop_subtitle( sp, dp, mfd->sz, &sz, 6 );
+        cpy3( sp, dp, sz );
+        mfd->sz = sz;
+    }
+
+    if ( mfd->antialias ) {
+        /* anti-alias each plane (individually) */
+        for ( i=0; i<3; i++ )
+            tcv_antialias( mfd->tcvhandle, sp[i], dp[i], mfd->sz.x, mfd->sz.y, 1,
+                           mfd->vob->aa_weight, mfd->vob->aa_bias );
+        cpy3( sp, dp, sz );
+    }
+
+    if ( mfd->do_zoom ) {
+        /* compute zoomed dimensions */
+        sz.x = mfd->sz.x * mfd->z_x + 0.5;
+        sz.y = mfd->sz.y * mfd->z_y + 0.5;
+
+        /* odd dimensions is probably not a good thing */
+        if ( sz.x % 2 )
+            sz.x++;
+        if ( sz.y % 2 )
+            sz.y++;
+
+        /* do not allow the zoom to exceed the dimensions of the video frame */
+        if ( sz.x > w )
+            sz.x = w;
+        if ( sz.y > h )
+            sz.y = h;
+
+        /* zoom each plane (individually) */
+        for ( i=0; i<3; i++ )
+            tcv_zoom( mfd->tcvhandle, sp[i], dp[i], mfd->sz.x, mfd->sz.y,
+                      1, sz.x, sz.y, mfd->vob->zoom_filter );
+
+        cpy3( sp, dp, sz );
+        mfd->sz = sz;
+    }
+
+    /* crop, with margin 0 */
+    crop_subtitle( sp, dp, mfd->sz, &sz, 0 );
+    cpy3( sp, dp, sz );
+    mfd->sz = sz;
+
+    /* find position of overlay region within frame */
+    /*     - zero corresponds to the bottom line of the frame */
+    /*     - if topalign is true, position the top line at pos */
+    /*       (pos should be at least the height of the subtitle) */
+    /*     - if topalign is false, position the bottom line at pos */
+    p.x = (w - mfd->sz.x) / 2;
+    p.y = h - mfd->pos;
+    if ( !mfd->topalign )
+        p.y -= mfd->sz.y;
+
+    /* make the region even aligned */
+    p.x -= p.x % 2;
+    p.y -= p.y % 2;
+
+    /* top clip */
+    mfd->ys = 0;
+    mfd->yn = mfd->sz.y;
+    if ( p.y < 0 ) {
+        mfd->ys = -p.y;
+        mfd->yn += p.y;
+        p.y = 0;
+    }
+
+    /* bottom clip */
+    n = p.y + mfd->sz.y - h;
+    if ( n > 0 )
+        mfd->yn -= n;
+
+    if ( mfd->yn <= 0 )
+        tc_log_warn( MOD_NAME, "Subtitle is complety clipped.  Check the 'pos' option." );
+
+    mfd->orig.x = p.x;
+    mfd->orig.y = p.y;
+}
+
+
+/*
+ *	crop_subtitle:
+ *		Find the minimum bounding box over the three opacity planes
+ *	and copy that region into the dst buffer, (effectively cropping
+ *	the image).  Force both width and height to be a even dimension.
+ *	Return the dimensions of the cropped image via parameter.
+ */
+
+static void
+crop_subtitle( uint8_t **sp, uint8_t **dp, Dim sd, Dim *dd, int margin )
+{
+    Dim ll, ur;
+    int x, y, n, m;
+    int flg, v, i;
+
+    ll.x = 0;
+    ll.y = 0;
+    ur.x = 0;
+    ur.y = 0;
+
+    flg = TC_FALSE;
+    n = 0;
+    for ( y=0; y<sd.y; y++ )
+        for ( x=0; x<sd.x; x++ ) {
+            v = sum3( sp, n );
+            n++;
+
+            if ( !v )
+                continue;
+
+            if ( !flg ) {
+                ll.x = x;
+                ur.x = x;
+                ll.y = y;
+                ur.y = y;
+
+                flg = TC_TRUE;
+                continue;
+            }
+
+            if ( x < ll.x )
+                ll.x = x;
+            if ( x > ur.x )
+                ur.x = x;
+            if ( y < ll.y )
+                ll.y = y;
+            if ( y > ur.y )
+                ur.y = y;
+        }
+
+    /* add margin */
+    ll.x -= margin;
+    ll.y -= margin;
+    ur.x += margin;
+    ur.y += margin;
+
+    /* force even dimensions */
+    dd->x = ur.x - ll.x + 1;
+    dd->y = ur.y - ll.y + 1;
+    if ( dd->x % 2 ) {
+        ur.x++;
+        dd->x++;
+    }
+
+    if ( dd->y % 2 ) {
+        ur.y++;
+        dd->y++;
+    }
+
+    /* extract bounded region to tmp, cropping, possibly padding */
+    m = 0;
+    for ( y=ll.y; y<=ur.y; y++ )
+        for ( x=ll.x; x<=ur.x; x++, m++ ) {
+            if ( x<0 || x>=sd.x || y<0 || y>=sd.y )
+                n = -1;
+            else
+                n = y*sd.x + x;
+
+            for ( i=0; i<3; i++ )
+                dp[i][m] = (n<0) ? 0 : sp[i][n];
+        }
+}
+
+
+/*
+ *	sum3:
+ *		Return the sum of the three opacity planes for element n.
+ */
+
+static int
+sum3( uint8_t **sp, int n )
+{
+    int s, i;
+
+    s = 0;
+    for ( i=0; i<3; i++ )
+        s += sp[i][n];
+
+    return( s );
+}
+
+
+/*
+ *	max3:
+ *		Return the maximum opacity value for element n, over the three
+ *	opacity planes.
+ */
+
+static int
+max3( uint8_t **sp, int n )
+{
+    int v, i;
+
+    v = 0;
+    for ( i=0; i<3; i++ )
+        if ( sp[i][n] > v )
+            v = sp[i][n];
+
+    return( v );
+}
+
+
+/*
+ *	avg3:
+ *		Return the weighted average for the RGB rendering colors at element n,
+ *	as determined by the contributing opacity values on each plane.
+ */
+
+static Rgb
+avg3( uint8_t **sp, int n )
+{
+    Rgb clr;
+    double s[3];
+    int w, i;
+
+    w = sum3( sp, n );
+    for ( i=0; i<3; i++ )
+        s[i] = sp[i][n] / (double) w;
+
+    /* I'm thinking Rgb would have been better as an array */
+    clr.r = 0;
+    clr.g = 0;
+    clr.b = 0;
+    for ( i=0; i<3; i++ ) {
+        clr.r += mfd->clr[i].r * s[i] + 0.5;
+        clr.g += mfd->clr[i].g * s[i] + 0.5;
+        clr.b += mfd->clr[i].b * s[i] + 0.5;
+    }
+
+    if ( clr.r > 255 )
+        clr.r = 255;
+    if ( clr.g > 255 )
+        clr.g = 255;
+    if ( clr.b > 255 )
+        clr.b = 255;
+
+    return( clr );
+}
+
+
+/*
+ *	cpy3:
+ *		Copy src to dst, for each of the three planes.
+ */
+
+static void
+cpy3( uint8_t **sp, uint8_t **dp, Dim sz )
+{
+    int n, i;
+
+    n = sz.x * sz.y;
+    for ( i=0; i<3; i++ )
+        ac_memcpy( sp[i], dp[i], n );
+}
+
+
+/*
+ *	subtitle_overlay_rgb:
+ *		Overlay the subtitle bitmap into the given video frame.  For each pixel,
+ *	the opacity used is the maximum value over all index planes.  The color used is
+ *	a weighted average as determined by the contributing opacity values on each
+ *	plane.  The resulting color is then blended with the pixel, ie:
+ *
+ *		(1-opacity) * pixel_color + opacity * subtitle_color
+ */
+
+static void
+subtitle_overlay_rgb( uint8_t *vid, int w, int h )
+{
+    uint8_t *v;
+    Rgb clr;
+    double s;
+    int x, y, n, m;
+    int opc, yo;
+
+    for ( y=0; y<mfd->yn; y++ ) {
+        yo = mfd->orig.y + y;
+        m = (yo*w + mfd->orig.x) * 3;
+
+        n = (mfd->ys + y) * mfd->sz.x;
+        for ( x=0; x<mfd->sz.x; x++ ) {
+            opc = max3( mfd->sp, n );
+            if ( opc ) {
+                clr = avg3( mfd->sp, n );
+                s = opc / 255.0;
+                if ( s > 1.0 )
+                    s = 1.0;
+
+                v = vid + m;
+                blend_pixel( v+0, s, clr.r );
+                blend_pixel( v+1, s, clr.g );
+                blend_pixel( v+2, s, clr.b );
+            }
+
+            m += 3;
+            n++;
+        }
+    }
+}
+
+
+/*
+ *	subtitle_overlay_yuv:
+ *		Trying to blend in pixels in a non-linear color space just doesn't
+ *	produce aesthetically pleasing results.  Many variations were attempted.
+ *	At edges of the text, even a slightly opaque pixel would cause the UV component
+ *	for the entire 4x4 pixel cell to be modified, which generated very visable
+ *	artifacts.  Therefore, although quite expensive, the overlay region of the
+ *	video frame is extracted to a temporary buffer, converted to rgb, overlayed
+ *	with the subtitle, converted back to yuv, and re-inserted back into the
+ *	video frame.  The results are better, but still not as good as just running
+ *	with -V rgb24.  When the sub region is converted back to yuv, you still get
+ *	some color blurring around edges of sharp contrast.  You really have to be
+ *	looking for it to notice though.
+ */
+
+static void
+subtitle_overlay_yuv( uint8_t *vid, int w, int h )
+{
+    uint8_t *sp, *dp, *v;
+    Rgb clr;
+    double s;
+    int sw, sh, sn, sy, su, sv;
+    int dw, dh, dn, dy, du, dv;
+    int x, y, r;
+    int opc, n, m;
+
+    if ( mfd->yn <= 0 )
+        /* completely clipped */
+        return;
+
+    /* src, video frame */
+    sp = vid;
+    sw = w;
+    sh = h;
+    sn = sw * sh;
+
+    sy = mfd->orig.y * sw + mfd->orig.x;
+    su = sn + mfd->orig.y/2 * sw/2 + mfd->orig.x/2;
+    sv = su + sn/4;
+
+    /* dst, extracted region */
+    dp = mfd->tmp;
+    dw = mfd->sz.x;
+    dh = mfd->yn;
+    dn = dw * dh;
+
+    dy = 0;
+    du = dn;
+    dv = du + dn/4;
+
+    /* extract subtitle region */
+    for ( y=0; y<dh; y++, sy+=sw, dy+=dw ) {
+        ac_memcpy( dp+dy, sp+sy, dw );
+
+        if ( !(y % 2) ) {
+            ac_memcpy( dp+du, sp+su, dw/2 );
+            ac_memcpy( dp+dv, sp+sv, dw/2 );
+
+            su += sw/2;
+            sv += sw/2;
+
+            du += dw/2;
+            dv += dw/2;
+        }
+    }
+
+    /* convert to rgb */
+    r = tcv_convert( mfd->tcvhandle, dp, dp, dw, dh,
+                     IMG_YUV_DEFAULT, IMG_RGB_DEFAULT );
+    if ( !r ) {
+        tc_log_error( MOD_NAME, "overlay, yuv to rgb conversion failed" );
+        return;
+    }
+
+    /* overlay subtitle */
+    m = 0;
+    n = mfd->ys * dw;
+    for ( y=0; y<dh; y++ )
+        for ( x=0; x<dw; x++, m+=3, n++ ) {
+            opc = max3( mfd->sp, n );
+            if ( opc ) {
+                clr = avg3( mfd->sp, n );
+                s = opc / 255.0;
+                if ( s > 1.0 )
+                    s = 1.0;
+
+                v = dp + m;
+                blend_pixel( v+0, s, clr.r );
+                blend_pixel( v+1, s, clr.g );
+                blend_pixel( v+2, s, clr.b );
+            }
+        }
+
+    /* convert back to yuv */
+    r = tcv_convert( mfd->tcvhandle, dp, dp, dw, dh,
+                     IMG_RGB_DEFAULT, IMG_YUV_DEFAULT );
+    if ( !r ) {
+        tc_log_error( MOD_NAME, "overlay, rgb to yuv conversion failed" );
+        return;
+    }
+
+    /* re-insert extracted region */
+    sy -= dh * sw;
+    su -= dh * sw / 4;
+    sv -= dh * sw / 4;
+
+    dy -= dh * dw;
+    du -= dh * dw / 4;
+    dv -= dh * dw / 4;
+
+    for ( y=0; y<dh; y++, sy+=sw, dy+=dw ) {
+        ac_memcpy( sp+sy, dp+dy, dw );
+
+        if ( !(y % 2) ) {
+            ac_memcpy( sp+su, dp+du, dw/2 );
+            ac_memcpy( sp+sv, dp+dv, dw/2 );
+
+            su += sw/2;
+            sv += sw/2;
+
+            du += dw/2;
+            dv += dw/2;
+        }
+    }
+}
+
+
+/*
+ *	blend_pixel:
+ *		Blend in a subtitle color component against the current pixel color
+ *	component, according to the subtitle opacity value.
+ */
+
+static void
+blend_pixel( uint8_t *v, double s, int color )
+{
+    int t;
+
+    t = (1-s)*(*v) + s*color + 0.5;
+    if ( t > 255 )
+        t = 255;
+
+    *v = t;
+}
diff -ruN old/filter/extsub/nextsub.h new/filter/extsub/nextsub.h
--- old/filter/extsub/nextsub.h	1969-12-31 19:00:00.000000000 -0500
+++ new/filter/extsub/nextsub.h	2007-03-11 22:24:26.000000000 -0400
@@ -0,0 +1,105 @@
+#include "transcode.h"
+#include "encoder.h"
+#include "filter.h"
+#include "libtc/optstr.h"
+#include "libtcvideo/tcvideo.h"
+
+#include <stdint.h>
+#include <ctype.h>
+
+#include "dl_loader.h"
+#include "import/magic.h"
+
+#include "subtitle_buffer.h"
+#include "subproc.h"
+
+#define BUFFER_SIZE SIZE_RGB_FRAME
+#define SUBTITLE_BUFFER 100
+
+
+typedef struct rgb_t Rgb;
+struct rgb_t
+    {
+    int	r;
+    int	g;
+    int	b;
+    };
+
+typedef struct dim_t Dim;
+struct dim_t
+	{
+	int x;
+	int y;
+	};
+
+typedef struct MyFilterData_t MyFilterData;
+struct MyFilterData_t
+    {
+    /* filter options */
+    int	forced;			/* render only forced subtitles */
+    int	pos;			/* position, vertical offset */
+    int	topalign;		/* align via top (not bottom) row of the subtitle */
+    int	tshift;			/* time shift */
+    int	prefilter;		/* run as a pre-filter */
+    int	antialias;		/* anti-alias */
+    int	do_zoom;		/* zoom the subtitle */
+    double z_x, z_y;		/* zoom factors */
+    double fopc[3];		/* index opacities [0-1] */
+    Rgb	clr[3];			/* index rendering colors */
+    Rgb	clr_def;		/* default rendering color */
+    int remap[2];		/* remap an index value to a different index */
+
+    /* private data */
+    transfer_t import;
+    pthread_t thread;
+    double f_time;
+    double pts1;
+    double pts2;
+
+    uint8_t *sub;		/* subtitle frame */
+    uint8_t *tmp;		/* temp buffer */
+
+    uint8_t *sp[3];		/* sub, decomposed to three planes */
+    uint8_t *dp[3];		/* tmp, decomposed to three planes */
+
+    Dim orig;			/* origin of clipped overlay region in video */
+    Dim sz;			/* dimension of subtitle */
+    int ys;			/* starting on-screen row of subtitle */
+    int yn;			/* number of on-screen subtitle rows */
+
+    int id;			/* frame number */
+    int fflg;			/* subtitle has forced flag set */
+    int opc[3];			/* opacities [0-255] */
+
+    int have_indices;		/* indices to render are known */
+    int made_subtitle;		/* subtitle has been prepared (zoomed, etc) */
+
+    vob_t *vob;
+    TCVHandle tcvhandle;
+    };
+
+
+/*
+ *	prototypes:
+ */
+
+static int get_zoom( char*, double*, double* );
+static Rgb get_rgb( char* );
+static int htoi( char* );
+static int htob( char );
+static char *pr_zoom( void );
+static char *pr_clr( Rgb );
+static int subtitle_retrieve( void );
+static void subtitle_overlay( uint8_t*, int, int );
+static void guess_indices( void );
+static int get_sub_index( int );
+static void make_subtitle( int, int );
+static void crop_subtitle( uint8_t**, uint8_t**, Dim, Dim*, int );
+static int sum3( uint8_t**, int );
+static int max3( uint8_t**, int );
+static Rgb avg3( uint8_t**, int );
+static void cpy3( uint8_t**, uint8_t**, Dim );
+static void subtitle_overlay_rgb( uint8_t*, int, int );
+static void subtitle_overlay_yuv( uint8_t*, int, int );
+static void blend_pixel( uint8_t*, double, int );
+
diff -ruN old/filter/extsub/subproc.c new/filter/extsub/subproc.c
--- old/filter/extsub/subproc.c	2007-03-11 22:25:51.000000000 -0400
+++ new/filter/extsub/subproc.c	2007-03-11 22:24:26.000000000 -0400
@@ -178,7 +178,7 @@
   //char filename[16];
 
   //buffer for plugin
-  unsigned char *picture;
+  uint8_t *picture;
 
   picture = config.sub.frame;
 
diff -ruN old/filter/extsub/subproc.h new/filter/extsub/subproc.h
--- old/filter/extsub/subproc.h	2007-03-11 22:25:51.000000000 -0400
+++ new/filter/extsub/subproc.h	2007-03-11 22:24:26.000000000 -0400
@@ -39,7 +39,7 @@
   int x, y;
   int w, h;
 
-  char *frame;
+  uint8_t *frame;
 
   int colour[4];
   int alpha[4];