/* 
 *
 *  This file is part of libmpeg3
 *	
 * LibMPEG3
 * Author: Adam Williams <broadcast@earthling.net>
 * Page: heroine.linuxbox.com
 * Page: http://www.smalltalkconsulting.com/html/mpeg3source.html (for Squeak)
 *
    LibMPEG3 was originally licenced under GPL. It was relicensed by
    the author under the LGPL and the Squeak license on Nov 1st, 2000
    
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser 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 
    
    Also licensed under the Squeak license.
    http://www.squeak.org/license.html
 */
 
 /*  Changed Sept 15th by John M McIntosh to support Macintosh & Squeak
 */
#include "libmpeg3.h"
#include "mpeg3io.h"
#include "mpeg3protos.h"

#include <math.h>
#include <stdlib.h>
#include <string.h>

#define ABS(x) ((x) >= 0 ? (x) : -(x))

/* Don't advance pointer */
static inline unsigned char mpeg3packet_next_char(mpeg3_demuxer_t *demuxer)
{
	return demuxer->raw_data[demuxer->raw_offset];
}

unsigned char mpeg3packet_read_char(mpeg3_demuxer_t *demuxer)
{
	unsigned char result = demuxer->raw_data[demuxer->raw_offset++];
	return result;
}

static inline unsigned int mpeg3packet_read_int16(mpeg3_demuxer_t *demuxer)
{
	unsigned int a, b, result;
	a = demuxer->raw_data[demuxer->raw_offset++];
	b = demuxer->raw_data[demuxer->raw_offset++];
	result = (a << 8) | b;

	return result;
}

static inline unsigned int mpeg3packet_next_int24(mpeg3_demuxer_t *demuxer)
{
	unsigned int a, b, c, result;
	a = demuxer->raw_data[demuxer->raw_offset];
	b = demuxer->raw_data[demuxer->raw_offset + 1];
	c = demuxer->raw_data[demuxer->raw_offset + 2];
	result = (a << 16) | (b << 8) | c;

	return result;
}

static inline unsigned int mpeg3packet_read_int24(mpeg3_demuxer_t *demuxer)
{
	unsigned int a, b, c, result;
	a = demuxer->raw_data[demuxer->raw_offset++];
	b = demuxer->raw_data[demuxer->raw_offset++];
	c = demuxer->raw_data[demuxer->raw_offset++];
	result = (a << 16) | (b << 8) | c;

	return result;
}

static inline unsigned int mpeg3packet_read_int32(mpeg3_demuxer_t *demuxer)
{
	unsigned int a, b, c, d, result;
	a = demuxer->raw_data[demuxer->raw_offset++];
	b = demuxer->raw_data[demuxer->raw_offset++];
	c = demuxer->raw_data[demuxer->raw_offset++];
	d = demuxer->raw_data[demuxer->raw_offset++];
	result = (a << 24) | (b << 16) | (c << 8) | d;

	return result;
}

static inline unsigned int mpeg3packet_skip(mpeg3_demuxer_t *demuxer, long length)
{
	demuxer->raw_offset += length;
	return 0;
}

int mpeg3_get_adaptation_field(mpeg3_demuxer_t *demuxer)
{
	long length;
	int pcr_flag;

	demuxer->adaptation_fields++;
/* get adaptation field length */
	length = mpeg3packet_read_char(demuxer);
/* get first byte */
  	pcr_flag = (mpeg3packet_read_char(demuxer) >> 4) & 1;           

	if(pcr_flag)
	{
    	unsigned long clk_ref_base = mpeg3packet_read_int32(demuxer);
    	unsigned int clk_ref_ext = mpeg3packet_read_int16(demuxer);

		if (clk_ref_base > 0x7fffffff)
		{   /* correct for invalid numbers */
			clk_ref_base = 0;               /* ie. longer than 32 bits when multiplied by 2 */
			clk_ref_ext = 0;                /* multiplied by 2 corresponds to shift left 1 (<<=1) */
		}
		else 
		{
			clk_ref_base <<= 1; /* Create space for bit */
			clk_ref_base |= (clk_ref_ext >> 15);          /* Take bit */
			clk_ref_ext &= 0x01ff;                        /* Only lower 9 bits */
		}
		demuxer->time = clk_ref_base + clk_ref_ext / 300;
	    if(length) mpeg3packet_skip(demuxer, length - 7);
	}
	else
	mpeg3packet_skip(demuxer, length - 1);

	return 0;
}

int mpeg3_get_program_association_table(mpeg3_demuxer_t *demuxer)
{
	demuxer->program_association_tables++;
	demuxer->table_id = mpeg3packet_read_char(demuxer);
	demuxer->section_length = mpeg3packet_read_int16(demuxer) & 0xfff;
	demuxer->transport_stream_id = mpeg3packet_read_int16(demuxer);
	mpeg3packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
	return 0;
}

int mpeg3packet_get_data_buffer(mpeg3_demuxer_t *demuxer)
{
	while(demuxer->raw_offset < demuxer->raw_size && demuxer->data_size < demuxer->data_allocated)
	{
		demuxer->data_buffer[demuxer->data_size++] = demuxer->raw_data[demuxer->raw_offset++];
	}
	return 0;
}

int mpeg3_get_pes_packet_header(mpeg3_demuxer_t *demuxer, unsigned long *pts, unsigned long *dts)
{
	unsigned int pes_header_bytes = 0;
	unsigned int pts_dts_flags;
	int pes_header_data_length;

/* drop first 8 bits */
	mpeg3packet_read_char(demuxer);  
	pts_dts_flags = (mpeg3packet_read_char(demuxer) >> 6) & 0x3;
	pes_header_data_length = mpeg3packet_read_char(demuxer);

/* Get Presentation Time stamps and Decoding Time Stamps */
	if(pts_dts_flags == 2)
	{
		*pts = (mpeg3packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
		*pts <<= 15;
		*pts |= (mpeg3packet_read_int16(demuxer) >> 1);
		*pts <<= 15;
		*pts |= (mpeg3packet_read_int16(demuxer) >> 1);
		pes_header_bytes += 5;
	}
	else if(pts_dts_flags == 3)
	{      
		*pts = (mpeg3packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
		*pts <<= 15;
		*pts |= (mpeg3packet_read_int16(demuxer) >> 1);
		*pts <<= 15;
		*pts |= (mpeg3packet_read_int16(demuxer) >> 1);
		*dts = (mpeg3packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
		*dts <<= 15;
		*dts |= (mpeg3packet_read_int16(demuxer) >> 1);
		*dts <<= 15;
		*dts |= (mpeg3packet_read_int16(demuxer) >> 1);
		pes_header_bytes += 10;
  }
/* extract other stuff here! */
  
	mpeg3packet_skip(demuxer, pes_header_data_length - pes_header_bytes);
	return 0;
}

int get_unknown_data(mpeg3_demuxer_t *demuxer)
{
	mpeg3packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
	return 0;
}

int mpeg3_get_pes_packet_data(mpeg3_demuxer_t *demuxer, unsigned int stream_id)
{
	unsigned long pts = 0, dts = 0;

	if((stream_id >> 4) == 12 || (stream_id >> 4) == 13)
	{
/* Just pick the first available stream if no ID is set */
		if(demuxer->astream == -1)
		    demuxer->astream = (stream_id & 0x0f);

    	if((stream_id & 0x0f) == demuxer->astream && demuxer->do_audio)
		{
			mpeg3_get_pes_packet_header(demuxer, &pts, &dts);
			demuxer->pes_audio_time = pts;
			demuxer->audio_pid = demuxer->pid;
			return mpeg3packet_get_data_buffer(demuxer);
    	}
	}
	else 
	if((stream_id >> 4)==14)
	{
/* Just pick the first available stream if no ID is set */
		if(demuxer->vstream == -1)
			demuxer->vstream = (stream_id & 0x0f);

		if((stream_id & 0x0f) == demuxer->vstream && demuxer->do_video)
		{
			mpeg3_get_pes_packet_header(demuxer, &pts, &dts);
			demuxer->pes_video_time = pts;
			demuxer->video_pid = demuxer->pid;
			return mpeg3packet_get_data_buffer(demuxer);
		}
	}
	else 
	{
		return get_unknown_data(demuxer);
	}

	mpeg3packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);

	return 0;
}

int mpeg3_get_pes_packet(mpeg3_demuxer_t *demuxer)
{
	unsigned int stream_id;

	demuxer->pes_packets++;
	stream_id = mpeg3packet_read_char(demuxer);
/* Skip startcode */
	mpeg3packet_read_int24(demuxer);
/* Skip pes packet length */
	mpeg3packet_read_int16(demuxer);

	if(stream_id != MPEG3_PRIVATE_STREAM_2 && stream_id != MPEG3_PADDING_STREAM)
	{
		return mpeg3_get_pes_packet_data(demuxer, stream_id);
	}
	else
	if(stream_id == MPEG3_PRIVATE_STREAM_2)
	{
/* Dump private data! */
		fprintf(stderr, "stream_id == MPEG3_PRIVATE_STREAM_2\n");
		mpeg3packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
		return 0;
	}
	else
	if(stream_id == MPEG3_PADDING_STREAM)
	{
		mpeg3packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
		return 0;
	}
	else
	{
    	fprintf(stderr, "unknown stream_id in pes packet");
		return 1;
	}
	return 0;
}

int mpeg3_get_payload(mpeg3_demuxer_t *demuxer)
{
	if(demuxer->payload_unit_start_indicator)
	{
    	if(demuxer->pid==0) mpeg3_get_program_association_table(demuxer);
    	else 
		if(mpeg3packet_next_int24(demuxer) == MPEG3_PACKET_START_CODE_PREFIX) mpeg3_get_pes_packet(demuxer);
    	else 
		mpeg3packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
	}
	else
	{
    	if(demuxer->pid == demuxer->audio_pid && demuxer->do_audio)
		{
			mpeg3packet_get_data_buffer(demuxer);
		}
    	else 
		if(demuxer->pid == demuxer->video_pid && demuxer->do_video)
		{
			mpeg3packet_get_data_buffer(demuxer);
		}
    	else 
		mpeg3packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
	}
	return 0;
}

/* Read a transport packet */
int mpeg3_read_transport(mpeg3_demuxer_t *demuxer)
{
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
	int result = mpeg3io_read_data(demuxer->raw_data, demuxer->packet_size, title->fs);
	unsigned int bits;
	int table_entry;

	demuxer->raw_size = demuxer->packet_size;
	demuxer->raw_offset = 0;
	if(result)
	{
		perror("mpeg3_read_transport");
		return 1;
	}

/* Sync byte */
	if(mpeg3packet_read_char(demuxer) != MPEG3_SYNC_BYTE)
	{
		fprintf(stderr, "mpeg3packet_read_char(demuxer) != MPEG3_SYNC_BYTE\n");
		return 1;
	}

/* 	bits = 	mpeg3packet_read_int24(demuxer) & 0x0000ffff; */
/* 	demuxer->transport_error_indicator = bits >> 15; */
/* 	demuxer->payload_unit_start_indicator = (bits >> 14) & 1; */
/* 	demuxer->pid = bits & 0x00001fff; */
/* 	demuxer->transport_scrambling_control = (mpeg3packet_next_char(demuxer) >> 6) & 0x3; */
/* 	demuxer->adaptation_field_control = (mpeg3packet_next_char(demuxer) >> 4) & 0x3; */
/* 	demuxer->continuity_counter = (mpeg3packet_read_char(demuxer) & 0xf); */

    bits =  mpeg3packet_read_int24(demuxer) & 0x00ffffff;
    demuxer->transport_error_indicator = (bits >> 23) & 0x1;
    demuxer->payload_unit_start_indicator = (bits >> 22) & 0x1;
    demuxer->pid = (bits >> 8) & 0x00001fff;
    demuxer->transport_scrambling_control = (bits >> 6) & 0x3;
    demuxer->adaptation_field_control = (bits >> 4) & 0x3;
    demuxer->continuity_counter = bits & 0xf;

	if(demuxer->transport_error_indicator)
	{
		fprintf(stderr, "demuxer->transport_error_indicator\n");
		return 1;
	}
 
    if (demuxer->pid == 0x1fff)
	{
		demuxer->is_padding = 1;  /* padding; just go to next */
		return 0;
    }
	else
	{
		demuxer->is_padding = 0;
	}

/* Get pid */
	for(table_entry = 0, result = 0; table_entry < demuxer->total_pids; table_entry++)
	{
		if(demuxer->pid == demuxer->pid_table[table_entry])
		{
			result = 1;
			break;
		}
	}

/* Not in pid table */
	if(!result)
	{
		demuxer->pid_table[table_entry] = demuxer->pid;
		demuxer->continuity_counters[table_entry] = demuxer->continuity_counter;  /* init */
		demuxer->total_pids++;
	}
	result = 0;

/* Check counters */
    if(demuxer->pid != MPEG3_PROGRAM_ASSOCIATION_TABLE && 
		demuxer->pid != MPEG3_CONDITIONAL_ACCESS_TABLE &&
        (demuxer->adaptation_field_control == 1 || demuxer->adaptation_field_control == 3))
	{
		if(demuxer->continuity_counters[table_entry] != demuxer->continuity_counter)
		{
			fprintf(stderr, "demuxer->continuity_counters[table_entry] != demuxer->continuity_counter\n");
/* Reset it */
			demuxer->continuity_counters[table_entry] = demuxer->continuity_counter;
		}
		if(++(demuxer->continuity_counters[table_entry]) > 15) demuxer->continuity_counters[table_entry] = 0;
	}

    if(demuxer->adaptation_field_control == 2 || demuxer->adaptation_field_control == 3)
    	result = mpeg3_get_adaptation_field(demuxer);

    if(demuxer->adaptation_field_control == 1 || demuxer->adaptation_field_control == 3)
    	result = mpeg3_get_payload(demuxer);

	return result;
}

int mpeg3_get_system_header(mpeg3_demuxer_t *demuxer)
{
	int length = mpeg3packet_read_int16(demuxer);
	mpeg3packet_skip(demuxer, length);
	return 0;
}

unsigned long mpeg3_get_timestamp(mpeg3_demuxer_t *demuxer)
{
	unsigned long timestamp;
/* Only low 4 bits (7==1111) */
	timestamp = (mpeg3packet_read_char(demuxer) >> 1) & 7;  
	timestamp <<= 15;
	timestamp |= (mpeg3packet_read_int16(demuxer) >> 1);
	timestamp <<= 15;
	timestamp |= (mpeg3packet_read_int16(demuxer) >> 1);
	return timestamp;
}

int mpeg3_get_pack_header(mpeg3_demuxer_t *demuxer, unsigned int *header)
{
	unsigned long i, j;
	unsigned long clock_ref, clock_ref_ext;

/* Get the time code */
	if((mpeg3packet_next_char(demuxer) >> 4) == 2)
	{
/* MPEG-1 */
			demuxer->time = (double)mpeg3_get_timestamp(demuxer) / 90000;
/* Skip 3 bytes */
			mpeg3packet_read_int24(demuxer);
	}
	else
	if(mpeg3packet_next_char(demuxer) & 0x40)
	{
		i = mpeg3packet_read_int32(demuxer);
		j = mpeg3packet_read_int16(demuxer);
		if(i & 0x40000000 || (i >> 28) == 2)
		{
    		clock_ref = ((i & 0x38000000) << 3); // JMM fix was 0x31 see http://sourceforge.net/tracker/index.php?func=detail&aid=439528&group_id=13554&atid=313554
    		clock_ref |= ((i & 0x03fff800) << 4);
    		clock_ref |= ((i & 0x000003ff) << 5);
    		clock_ref |= ((j & 0xf800) >> 11);
    		clock_ref_ext = (j >> 1) & 0x1ff;

   			demuxer->time = (double)(clock_ref + clock_ref_ext / 300) / 90000;
/* Skip 3 bytes */
			mpeg3packet_read_int24(demuxer);
			i = mpeg3packet_read_char(demuxer) & 0x7;

/* stuffing */
			mpeg3packet_skip(demuxer, i);  
		}
	}
	else
	{
		mpeg3packet_skip(demuxer, 2);
	}

	*header = mpeg3packet_read_int32(demuxer);
	if(*header == MPEG3_SYSTEM_START_CODE)
	{
    	mpeg3_get_system_header(demuxer);
    	*header = mpeg3packet_read_int32(demuxer);
	}
	return 0;
}

/* Program packet reading core */
int mpeg3_get_ps_pes_packet(mpeg3_demuxer_t *demuxer, unsigned int *header)
{
	unsigned long pts = 0, dts = 0;
	int stream_id;
	int pes_packet_length;
	int pes_packet_start;
	int i;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;

	stream_id = *header & 0xff;
	pes_packet_length = mpeg3packet_read_int16(demuxer);
	pes_packet_start = demuxer->raw_offset;

	if(stream_id != MPEG3_PRIVATE_STREAM_2 && 
		stream_id != MPEG3_PADDING_STREAM)
	{
		if((mpeg3packet_next_char(demuxer) >> 6) == 0x02)
		{
/* Get MPEG-2 packet */
			int pes_header_bytes = 0;
			int scrambling = (mpeg3packet_read_char(demuxer) >> 4) & 0x3;
    		int pts_dts_flags = (mpeg3packet_read_char(demuxer) >> 6) & 0x3;
			int pes_header_data_length = mpeg3packet_read_char(demuxer);

			if(scrambling && (demuxer->do_audio || demuxer->do_video))
			{
/* Decrypt it */
				if(mpeg3_decrypt_packet(demuxer->titles[demuxer->current_title]->fs->css, 
					demuxer->raw_data))
				{
					fprintf(stderr, "mpeg3_get_ps_pes_packet: Decryption not available\n");
					return 1;
				}
			}

/* Get Presentation and Decoding Time Stamps */
			if(pts_dts_flags == 2)
			{
				pts = (mpeg3packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
				pts <<= 15;
				pts |= (mpeg3packet_read_int16(demuxer) >> 1);
				pts <<= 15;
				pts |= (mpeg3packet_read_int16(demuxer) >> 1);
				pes_header_bytes += 5;
			}
    		else 
			if(pts_dts_flags == 3)
			{
        		pts = (mpeg3packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
        		pts <<= 15;
        		pts |= (mpeg3packet_read_int16(demuxer) >> 1);
        		pts <<= 15;
        		pts |= (mpeg3packet_read_int16(demuxer) >> 1);
        		dts = (mpeg3packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
        		dts <<= 15;
        		dts |= (mpeg3packet_read_int16(demuxer) >> 1);
        		dts <<= 15;
        		dts |= (mpeg3packet_read_int16(demuxer) >> 1);
        		pes_header_bytes += 10;
    		}

/* Skip unknown */
        	mpeg3packet_skip(demuxer, pes_header_data_length - pes_header_bytes);
		}
		else
		{
			int pts_dts_flags;
/* Get MPEG-1 packet */
			while(mpeg3packet_next_char(demuxer) == 0xff)
			{
				mpeg3packet_read_char(demuxer);
			}

/* Skip STD buffer scale */
			if((mpeg3packet_next_char(demuxer) & 0x40) == 0x40)
			{
				mpeg3packet_skip(demuxer, 2);
			}

/* Decide which timestamps are available */
			pts_dts_flags = mpeg3packet_next_char(demuxer);

			if(pts_dts_flags >= 0x30)
			{
/* Get the presentation and decoding time stamp */
				pts = mpeg3_get_timestamp(demuxer);
				dts = mpeg3_get_timestamp(demuxer);
			}
			else
			if(pts_dts_flags >= 0x20)
			{
/* Get just the presentation time stamp */
				pts = mpeg3_get_timestamp(demuxer);
			}
			else
			if(pts_dts_flags == 0x0f)
			{
/* End of timestamps */
				mpeg3packet_read_char(demuxer);
			}
			else
			{
				return 1;     /* Error */
			}
		}

/* Now extract the payload. */
		if((stream_id >> 4) == 0xc || (stream_id >> 4) == 0xd)
		{
/* Audio data */
/* Take first stream ID if -1 */
			pes_packet_length -= demuxer->raw_offset - pes_packet_start;
			if(!demuxer->do_audio && !demuxer->do_video)
				demuxer->astream_table[stream_id & 0x0f] = AUDIO_MPEG;
			else
			if(demuxer->astream == -1) 
				demuxer->astream = stream_id & 0x0f;

			if((stream_id & 0x0f) == demuxer->astream && demuxer->do_audio)
			{
				if(pts) demuxer->pes_audio_time = pts;

				memcpy(&demuxer->data_buffer[demuxer->data_size],
					&demuxer->raw_data[demuxer->raw_offset],
					pes_packet_length);
				demuxer->data_size += pes_packet_length;
				demuxer->raw_offset += pes_packet_length;
		  	}
			else 
			{
    			mpeg3packet_skip(demuxer, pes_packet_length);
			}
		}
    	else 
		if((stream_id >> 4) == 0xe)
		{
/* Video data */
/* Take first stream ID if -1 */
			if(!demuxer->do_audio && !demuxer->do_video) 
				demuxer->vstream_table[stream_id & 0x0f] = 1;
			else
			if(demuxer->vstream == -1) 
				demuxer->vstream = stream_id & 0x0f;

			pes_packet_length -= demuxer->raw_offset - pes_packet_start;
    	    if((stream_id & 0x0f) == demuxer->vstream && demuxer->do_video)
			{
        		if(pts) demuxer->pes_video_time = pts;

				memcpy(&demuxer->data_buffer[demuxer->data_size], 
					&demuxer->raw_data[demuxer->raw_offset],
					pes_packet_length);
				demuxer->data_size += pes_packet_length;
				demuxer->raw_offset += pes_packet_length;
    	  	}
    		else 
			{
        	    mpeg3packet_skip(demuxer, pes_packet_length);
    		}
    	}
    	else 
		if(stream_id == 0xbd && demuxer->raw_data[demuxer->raw_offset] != 0xff)
		{
/* DVD audio data */
/* Get the audio format */
			int format;
			if((demuxer->raw_data[demuxer->raw_offset] & 0xf0) == 0xa0)
				format = AUDIO_PCM;
			else
				format = AUDIO_AC3;

			stream_id = demuxer->raw_data[demuxer->raw_offset] - 0x80;

/* Take first stream ID if not building TOC. */
			if(!demuxer->do_audio && !demuxer->do_video)
				demuxer->astream_table[stream_id] = format;
			else
			if(demuxer->astream == -1)
				demuxer->astream = stream_id;

      		if(stream_id == demuxer->astream && demuxer->do_audio)
			{
				demuxer->aformat = format;
        		if(pts) demuxer->pes_audio_time = pts;
				mpeg3packet_read_int32(demuxer);
				pes_packet_length -= demuxer->raw_offset - pes_packet_start;

				memcpy(&demuxer->data_buffer[demuxer->data_size],
					&demuxer->raw_data[demuxer->raw_offset],
					pes_packet_length);
				demuxer->data_size += pes_packet_length;
				demuxer->raw_offset += pes_packet_length;
      		}
      		else
			{
				pes_packet_length -= demuxer->raw_offset - pes_packet_start;
        	    mpeg3packet_skip(demuxer, pes_packet_length);
      		}
    	}
    	else 
		if(stream_id == 0xbc || 1)
		{
			pes_packet_length -= demuxer->raw_offset - pes_packet_start;
        	mpeg3packet_skip(demuxer, pes_packet_length);
    	}
	}
  	else 
	if(stream_id == MPEG3_PRIVATE_STREAM_2 || stream_id == MPEG3_PADDING_STREAM)
	{
		pes_packet_length -= demuxer->raw_offset - pes_packet_start;
        mpeg3packet_skip(demuxer, pes_packet_length);
  	}

	while(demuxer->raw_offset + 4 < demuxer->raw_size)
	{
		*header = mpeg3packet_read_int32(demuxer);
		if((*header >> 8) != MPEG3_PACKET_START_CODE_PREFIX)
			demuxer->raw_offset -= 3;
		else
			break;
	}

	return 0;
}

int mpeg3_read_program(mpeg3_demuxer_t *demuxer)
{
	int result = 0, count = 0;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
	unsigned int header;
	demuxer->raw_size = demuxer->packet_size;
	demuxer->raw_offset = 0;
	demuxer->data_size = 0;
	
/* Search backward for it. */
	header = mpeg3io_read_int32(title->fs);
	result = mpeg3io_eof(title->fs);

	if(!result) result = mpeg3io_seek_relative(title->fs, -4);

	// Search backwards for header
	while(header != MPEG3_PACK_START_CODE && !result && count < (demuxer->packet_size))
	{
		result = mpeg3io_seek_relative(title->fs, -1);
		if(!result)
		{
			header >>= 8;
			header |= mpeg3io_read_char(title->fs) << 24;
			result = mpeg3io_seek_relative(title->fs, -1);
		}
		count++;
	}

	if ((header != MPEG3_PACK_START_CODE) || (result) ) {
// couldn't find MPEG3_PACK_START_CODE
		return 1;
	}
	
	result = mpeg3io_read_data(demuxer->raw_data, demuxer->packet_size, title->fs);
	if(result)
	{
		perror("mpeg3_read_program");
		return 1;
	}
	// fprintf(stderr, "Got data %ld\n", title->fs->current_byte);

	header = mpeg3packet_read_int32(demuxer);

	while(demuxer->raw_offset + 4 < demuxer->raw_size && !result)
	{
		if(header == MPEG3_PACK_START_CODE)
		{
			result = mpeg3_get_pack_header(demuxer, &header);
		}
		else
		if((header >> 8) == MPEG3_PACKET_START_CODE_PREFIX)
		{
			result = mpeg3_get_ps_pes_packet(demuxer, &header);
		}
	}
	return result;
}

double mpeg3_lookup_time_offset(mpeg3_demuxer_t *demuxer, long byte)
{
	int i;
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];

	if(!title->timecode_table_size) return 0;

	for(i = title->timecode_table_size - 1; 
		i >= 0 && title->timecode_table[i].start_byte > byte;
		i--)
		;
	if(i < 0) i = 0;
	return title->timecode_table[i].absolute_start_time - title->timecode_table[i].start_time;
}

int mpeg3_advance_timecode(mpeg3_demuxer_t *demuxer, int reverse)
{
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
	int result = 0;
	int do_seek = 0;

/* Skip timecode advancing when constructing timecode table */
	if(!title->timecode_table || 
		!title->timecode_table_size || 
		demuxer->generating_timecode) return 0;

	if(!reverse)
	{
/* Get inside the current timecode */
		if(mpeg3io_tell(title->fs) < title->timecode_table[demuxer->current_timecode].start_byte)
		{
			mpeg3io_seek(title->fs, title->timecode_table[demuxer->current_timecode].start_byte);
		}
		
/* Get the next timecode */
		while(!result && 
			(mpeg3io_tell(title->fs) >= title->timecode_table[demuxer->current_timecode].end_byte ||
				demuxer->current_program != title->timecode_table[demuxer->current_timecode].program))
		{

/*
 * printf("mpeg3_advance_timecode %d %d %d %d\n", mpeg3io_tell(title->fs), title->timecode_table[demuxer->current_timecode].end_byte,
 *  demuxer->current_program, title->timecode_table[demuxer->current_timecode].program);
 */

			demuxer->current_timecode++;
			if(demuxer->current_timecode >= title->timecode_table_size)
			{
				demuxer->current_timecode = 0;
				if(demuxer->current_title + 1 < demuxer->total_titles)
				{
					mpeg3demux_open_title(demuxer, demuxer->current_title + 1);
					do_seek = 1;
				}
				else
				{
					mpeg3io_seek(title->fs, mpeg3io_total_bytes(title->fs));
			 		result = 1;
				}
			}
			title = demuxer->titles[demuxer->current_title];
		}

		if(!result && do_seek)
		{
			mpeg3io_seek(title->fs, title->timecode_table[demuxer->current_timecode].start_byte);
		}
	}
	else
	{
/* Get the previous timecode */
		while(!result && 
			(mpeg3io_tell(title->fs) < title->timecode_table[demuxer->current_timecode].start_byte ||
				demuxer->current_program != title->timecode_table[demuxer->current_timecode].program))
		{
/*
 * if(demuxer->do_audio) printf("mpeg3_reverse_timecode %d %d %d %d\n", mpeg3io_tell(title->fs), title->timecode_table[demuxer->current_timecode].end_byte,
 * 	demuxer->current_program, title->timecode_table[demuxer->current_timecode].program);
 */
			demuxer->current_timecode--;
			if(demuxer->current_timecode < 0)
			{
				if(demuxer->current_title > 0)
				{
					mpeg3demux_open_title(demuxer, demuxer->current_title - 1);
					title = demuxer->titles[demuxer->current_title];
					demuxer->current_timecode = title->timecode_table_size - 1;
					do_seek = 1;
				}
				else
				{
					mpeg3io_seek(title->fs, 0);
					demuxer->current_timecode = 0;
					result = 1;
				}
			}
		}

		if(!result && do_seek) 
			mpeg3io_seek(title->fs, title->timecode_table[demuxer->current_timecode].start_byte);
	}

	return result;
}

/* Read packet in the forward direction */
int mpeg3_read_next_packet(mpeg3_demuxer_t *demuxer)
{
	int result = 0;
	long current_position;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
	demuxer->data_size = 0;
	demuxer->data_position = 0;

/* Flip the file descriptor back to the end of the packet for forward */
/* reading. */
	if(demuxer->reverse)
	{
		result = mpeg3io_seek_relative(title->fs, demuxer->packet_size);
		demuxer->reverse = 0;
	}

/* Read packets until the output buffer is full */
	if(!result)
	{
		long p1;	// BGF added this protection against infinite-looping here.
		do
		{
			p1 = title->fs->current_byte;
			
			result = mpeg3_advance_timecode(demuxer, 0);

			if(!result)
			{
				demuxer->time_offset = mpeg3_lookup_time_offset(demuxer, mpeg3io_tell(title->fs));

				if(file->is_transport_stream)
				{
					result = mpeg3_read_transport(demuxer);
				}
				else
				if(file->is_program_stream)
				{
					result = mpeg3_read_program(demuxer);
				}
				else
				{
/* Read elementary stream. */
					result = mpeg3io_read_data(demuxer->data_buffer, demuxer->packet_size, title->fs);
					if(!result) demuxer->data_size = demuxer->packet_size;
				}
				
				// We can spin out on attempts to read the last packet over and over.
				if (p1 >= title->fs->current_byte) {
					result = -1;
					title->fs->current_byte = title->fs->total_bytes;	// So EOF checks start to fire.
					fprintf(stderr, "Stopping demux-stream to prevent spin.");
				}
			}
		} while (!result && demuxer->data_size == 0 && (demuxer->do_audio || demuxer->do_video));
	}

	return result;
}

/* Read the packet right before the packet we're currently on. */
int mpeg3_read_prev_packet(mpeg3_demuxer_t *demuxer)
{
	int result = 0;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;
	long current_position;
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];

	demuxer->data_size = 0;
	demuxer->data_position = 0;

	do
	{
/* Rewind to the start of the packet to be read. */
		result = mpeg3io_seek_relative(title->fs, -demuxer->packet_size);

		if(!result) result = mpeg3_advance_timecode(demuxer, 1);
		if(!result) demuxer->time_offset = mpeg3_lookup_time_offset(demuxer, mpeg3io_tell(title->fs));

		if(file->is_transport_stream && !result)
		{
			result = mpeg3_read_transport(demuxer);
			if(!mpeg3io_bof(title->fs))
			/* if(!result)  */result = mpeg3io_seek_relative(title->fs, -demuxer->packet_size);
		}
		else
		if(file->is_program_stream && !result)
		{

			result = mpeg3_read_program(demuxer);
			if(!mpeg3io_bof(title->fs))
			/* if(!result)  */result = mpeg3io_seek_relative(title->fs, -demuxer->packet_size);
		}
		else
		if(!result)
		{
/* Elementary stream */
/* Read the packet forwards and seek back to the start */
			result = mpeg3io_read_data(demuxer->data_buffer, demuxer->packet_size, title->fs);
			if(!result) 
			{
				demuxer->data_size = demuxer->packet_size;
				result = mpeg3io_seek_relative(title->fs, -demuxer->packet_size);
			}
		}
	}while(!result && demuxer->data_size == 0 && (demuxer->do_audio || demuxer->do_video));

/* Remember that the file descriptor is at the beginning of the packet just read. */
	demuxer->reverse = 1;
	demuxer->error_flag = result;
	return result;
}


/* Used for audio */
int mpeg3demux_read_data(mpeg3_demuxer_t *demuxer, 
		unsigned char *output, 
		long size)
{
	long i;
	int result = 0;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;
	demuxer->error_flag = 0;
	
	if(demuxer->data_position >= 0)
	{
/* Read forwards */
		for(i = 0; i < size && !result; )
		{
			int fragment_size = size - i;
			if(fragment_size > demuxer->data_size - demuxer->data_position)
				fragment_size = demuxer->data_size - demuxer->data_position;
			memcpy(output + i, demuxer->data_buffer + demuxer->data_position, fragment_size);
			demuxer->data_position += fragment_size;
			i += fragment_size;

			if(i < size)
			{
				result = mpeg3_read_next_packet(demuxer);
			}
		}
	}
	else
	{
/* Read backwards a full packet. */
/* Only good for reading less than the size of a full packet, but */
/* this routine should only be used for searching for previous markers. */
		long current_position = demuxer->data_position;
		result = mpeg3_read_prev_packet(demuxer);
		if(!result) demuxer->data_position = demuxer->data_size + current_position;
		memcpy(output, demuxer->data_buffer + demuxer->data_position, size);
		demuxer->data_position += size;
	}

	demuxer->error_flag = result;
	return result;
}

unsigned int mpeg3demux_read_char_packet(mpeg3_demuxer_t *demuxer)
{
	demuxer->error_flag = 0;
	if(demuxer->data_position >= demuxer->data_size)
		demuxer->error_flag = mpeg3_read_next_packet(demuxer);
	demuxer->next_char = demuxer->data_buffer[demuxer->data_position++];
	return demuxer->next_char;
}

unsigned int mpeg3demux_read_prev_char_packet(mpeg3_demuxer_t *demuxer)
{
	demuxer->error_flag = 0;
	demuxer->data_position--;
	if(demuxer->data_position < 0)
	{
		demuxer->error_flag = mpeg3_read_prev_packet(demuxer);
		if(!demuxer->error_flag) demuxer->data_position = demuxer->data_size - 1;
	}
	demuxer->next_char = demuxer->data_buffer[demuxer->data_position];
	return demuxer->next_char;
}

mpeg3demux_timecode_t* mpeg3_append_timecode(mpeg3_demuxer_t *demuxer, 
		mpeg3_title_t *title, 
		long prev_byte, 
		double prev_time, 
		long next_byte, 
		double next_time,
		int dont_store)
{
	mpeg3demux_timecode_t *new_table;
	mpeg3demux_timecode_t *new_timecode = NULL, *old_timecode = NULL;
	long i;

	if(!title->timecode_table || 
		title->timecode_table_allocation <= title->timecode_table_size)
	{
		if(title->timecode_table_allocation == 0) 
			title->timecode_table_allocation = 1;
		else
			title->timecode_table_allocation *= 2;

		new_table = (mpeg3demux_timecode_t *) memoryAllocate(1, sizeof(mpeg3demux_timecode_t) * title->timecode_table_allocation);
		if(title->timecode_table)
		{
			for(i = 0; i < title->timecode_table_size; i++)
			{
				new_table[i] = title->timecode_table[i];
			}

			memoryFree(title->timecode_table);
		}
		title->timecode_table = new_table;
	}

	if(!dont_store)
	{
		new_timecode = &title->timecode_table[title->timecode_table_size];
		new_timecode->start_byte = next_byte;
		new_timecode->start_time = next_time;
		new_timecode->absolute_start_time = 0;

		if(title->timecode_table_size > 0)
		{
			old_timecode = &title->timecode_table[title->timecode_table_size - 1];
			old_timecode->end_byte = prev_byte;
			old_timecode->end_time = prev_time;
			new_timecode->absolute_start_time = 
				prev_time - 
				old_timecode->start_time + 
				old_timecode->absolute_start_time;
			new_timecode->absolute_end_time = next_time;
		}
	}

	title->timecode_table_size++;
	return new_timecode;
}

mpeg3demux_timecode_t* mpeg3demux_next_timecode(mpeg3_demuxer_t *demuxer, 
		int *current_title, 
		int *current_timecode,
		int current_program)
{
	int done = 0;
	while(!done)
	{
/* Increase timecode number */
		if(*current_timecode < demuxer->titles[*current_title]->timecode_table_size - 1) 
		{
			(*current_timecode)++;
			if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
				return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
		}
		else
/* Increase title number */
		if(*current_title < demuxer->total_titles - 1)
		{
			(*current_title)++;
			(*current_timecode) = 0;
			if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
				return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
		}
		else
/* End of disk */
			done = 1;
	}
	return 0;
}

mpeg3demux_timecode_t* mpeg3demux_prev_timecode(mpeg3_demuxer_t *demuxer, 
		int *current_title, 
		int *current_timecode,
		int current_program)
{
	int done = 0;
	while(!done)
	{
/* Increase timecode number */
		if(*current_timecode > 0)
		{
			(*current_timecode)--;
			if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
				return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
		}
		else
/* Increase title number */
		if(*current_title > 0)
		{
			(*current_title)--;
			(*current_timecode) = demuxer->titles[*current_title]->timecode_table_size - 1;
			if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
				return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
		}
		else
/* End of disk */
			done = 1;
		
	}
	return 0;
}

int mpeg3demux_open_title(mpeg3_demuxer_t *demuxer, int title_number)
{
	mpeg3_title_t *title;

	if(title_number < demuxer->total_titles)
	{
		if(demuxer->current_title >= 0)
		{
			mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
			demuxer->current_title = -1;
		}

		title = demuxer->titles[title_number];
		if(mpeg3io_open_file(title->fs))
		{
			demuxer->error_flag = 1;
			perror("mpeg3demux_open_title");
		}
		else
		{
			demuxer->current_title = title_number;
		}
	}

	demuxer->current_timecode = 0;

	return demuxer->error_flag;
}

/* Assign program numbers to interleaved programs */
int mpeg3demux_assign_programs(mpeg3_demuxer_t *demuxer)
{
	int current_program = 0;
	int current_title = 0, previous_title;
	int current_timecode = 0, previous_timecode;
	double current_time, current_length;
	int done = 0;
	int interleaved = 0;
	mpeg3demux_timecode_t *timecode1, *timecode2;
	double program_times[MPEG3_MAX_STREAMS];
	int total_programs = 1;
	int i, j;
	int program_exists, last_program_assigned = 0;
	int total_timecodes;
	mpeg3_title_t **titles = demuxer->titles;

	for(i = 0, total_timecodes = 0; i < demuxer->total_titles; i++)
		total_timecodes += demuxer->titles[i]->timecode_table_size;

//	if(total_timecodes < 3) return 0;

/*
 * // Assign programs based on length of contiguous timecode 
 * 	timecode1 = demuxer->titles[current_title]->timecode_table;
 * 	while(!done)
 * 	{
 * 		if(!timecode1) done = 1;
 * 		else
 * 		if(timecode1->end_time - timecode1->start_time < MPEG3_PROGRAM_THRESHOLD)
 * 		{
 * // Got interleaved section 
 * 			interleaved = 1;
 * 			program_times[0] = timecode1->end_time;
 * 
 * 			while(interleaved && !done)
 * 			{
 * 				timecode2 = mpeg3demux_next_timecode(demuxer, 
 * 					&current_title, 
 * 					&current_timecode,
 * 					0);
 * 
 * 				if(!timecode2) done = 1;
 * 				else
 * 				{
 * // Another segment of interleaved data 
 * 					if(timecode2->end_time - timecode2->start_time < MPEG3_PROGRAM_THRESHOLD)
 * 					{
 * // Search program times for where the previous instance of the program left off 
 * 						for(program_exists = 0, i = 0; 
 * 							i < total_programs && !program_exists; 
 * 							i++)
 * 						{
 * // Got a previous instance of the program 
 * 							if(program_times[i] + 0.5 > timecode2->start_time &&
 * 								program_times[i] - 0.5 < timecode2->start_time)
 * 							{
 * 								program_times[i] = timecode2->end_time;
 * 								timecode2->program = i;
 * 								program_exists = 1;
 * 
 * // Programs must always start at 0 for an interleaved section 
 * 								if(i < last_program_assigned && i != 0)
 * 								{
 * // Shift programs in the interleaved section down until they start at 0 
 * 									for(j = 0; j < total_programs - 1; j++)
 * 										program_times[j] = program_times[j + 1];
 * 									
 * 									for(previous_title = current_title, previous_timecode = current_timecode;
 * 										titles[previous_title]->timecode_table[previous_timecode].program > 0 && 
 * 										(previous_title >= 0 || previous_timecode >= 0); )
 * 									{
 * 										titles[previous_title]->timecode_table[previous_timecode].program--;
 * 										previous_timecode--;
 * 										if(previous_timecode < 0 && previous_title > 0)
 * 										{
 * 											previous_title--;
 * 											previous_timecode = titles[previous_title]->timecode_table_size - 1;
 * 										}
 * 									}
 * 								}
 * 							}
 * 						}
 * 
 * // Didn't get one 
 * 						if(!program_exists)
 * 						{
 * 							program_times[total_programs] = timecode2->end_time;
 * 							timecode2->program = total_programs++;
 * 						}
 * 						last_program_assigned = timecode2->program;
 * 					}
 * // No more interleaved section 
 * 					else
 * 					{
 * 						interleaved = 0;
 * // Restart program table from the beginning 
 * 						total_programs = 1;
 * 						last_program_assigned = 0;
 * 						timecode1 = mpeg3demux_next_timecode(demuxer, 
 * 							&current_title, 
 * 							&current_timecode,
 * 							0);
 * 					}
 * 				}
 * 			}
 * 		}
 * 		else
 * // Get next timecode 
 * 			timecode1 = mpeg3demux_next_timecode(demuxer, 
 * 				&current_title, 
 * 				&current_timecode,
 * 				0);
 * 	}
 * 	
 * 	demuxer->total_programs = total_programs;
 */

/* Assign absolute timecodes in each program. */
	for(current_program = 0; 
		current_program < total_programs; 
		current_program++)
	{
		current_time = 0;
		current_title = 0;
		current_timecode = -1;
		while(timecode1 = mpeg3demux_next_timecode(demuxer, 
		    &current_title, 
			&current_timecode, 
			current_program))
		{
			timecode1->absolute_start_time = current_time;
			current_time += timecode1->end_time - timecode1->start_time;
			timecode1->absolute_end_time = current_time;
		}
	}
//for(i = 0; i < demuxer->total_titles; i++) mpeg3_dump_title(demuxer->titles[i]);
	demuxer->current_program = 0;
	return 0;
}

/* ==================================================================== */
/*                            Entry points */
/* ==================================================================== */

mpeg3_demuxer_t* mpeg3_new_demuxer(mpeg3_t *file, int do_audio, int do_video, int stream_id)
{
	mpeg3_demuxer_t *demuxer = (mpeg3_demuxer_t *) memoryAllocate(1, sizeof(mpeg3_demuxer_t));
	int i;

/* The demuxer will change the default packet size for its own use. */
	demuxer->file = file;
	demuxer->packet_size = file->packet_size;
	demuxer->do_audio = do_audio;
	demuxer->do_video = do_video;

/* Allocate buffer + padding */
	demuxer->raw_data = (unsigned char*)memoryAllocate(1, MPEG3_MAX_PACKSIZE);
	demuxer->data_buffer = (unsigned char*)memoryAllocate(1, MPEG3_MAX_PACKSIZE);
	demuxer->data_allocated = MPEG3_MAX_PACKSIZE;
/* System specific variables */
	demuxer->audio_pid = stream_id;
	demuxer->video_pid = stream_id;
	demuxer->astream = stream_id;
	demuxer->vstream = stream_id;
	demuxer->current_title = -1;
	return demuxer;
}

int mpeg3_delete_demuxer(mpeg3_demuxer_t *demuxer)
{
	int i;

	if(demuxer->current_title >= 0)
	{
		mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
	}

	for(i = 0; i < demuxer->total_titles; i++)
	{
		mpeg3_delete_title(demuxer->titles[i]);
	}

	if(demuxer->data_buffer) memoryFree(demuxer->data_buffer);
	memoryFree(demuxer->raw_data);
	memoryFree(demuxer);
}

/* Create a title. */
/* Build a table of timecodes contained in the program stream. */
/* If toc is 0 just read the first and last timecode. */
int mpeg3demux_create_title(mpeg3_demuxer_t *demuxer, int timecode_search, FILE *toc)
{
	int result = 0, done = 0, counter_start, counter;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;
	long next_byte=0, prev_byte=0;
	double next_time, prev_time, absolute_time;
	long i;
	mpeg3_title_t *title;
	unsigned long test_header = 0;
	mpeg3demux_timecode_t *timecode = 0;

	demuxer->error_flag = 0;
	demuxer->generating_timecode = 1;

/* Create a single title */
	if(!demuxer->total_titles)
	{
		demuxer->titles[0] = mpeg3_new_title(file, file->fs->path);
		demuxer->total_titles = 1;
		mpeg3demux_open_title(demuxer, 0);
	}
	title = demuxer->titles[0];
	title->total_bytes = mpeg3io_total_bytes(title->fs);


/* Get the packet size from the file */
	if(file->is_program_stream)
	{
		mpeg3io_seek(title->fs, 4);
		for(i = 0; i < MPEG3_MAX_PACKSIZE && 
			test_header != MPEG3_PACK_START_CODE; i++)
		{
			test_header <<= 8;
			test_header |= mpeg3io_read_char(title->fs);
		}
		if(i < MPEG3_MAX_PACKSIZE) demuxer->packet_size = i;
		mpeg3io_seek(title->fs, 0);
	}
	else
		demuxer->packet_size = file->packet_size;

/* Get timecodes for the title */
	if(file->is_transport_stream || file->is_program_stream)
	{
		mpeg3io_seek(title->fs, 0);
		while(!done && !result && !mpeg3io_eof(title->fs))
		{
			next_byte = mpeg3io_tell(title->fs);
			result = mpeg3_read_next_packet(demuxer);

			if(!result)
			{
				next_time = demuxer->time;
//printf("%f %f\n", next_time, prev_time);
				if(next_time < prev_time || 
					next_time - prev_time > MPEG3_CONTIGUOUS_THRESHOLD ||
					!title->timecode_table_size)
				{
/* Discontinuous */
					timecode = mpeg3_append_timecode(demuxer, 
						title, 
						prev_byte, 
						prev_time, 
						next_byte, 
						next_time,
						0);
/*
 * printf("timecode: %ld %ld %f %f\n",
 * 				timecode->start_byte,
 * 				timecode->end_byte,
 * 				timecode->start_time,
 * 				timecode->end_time);
 */

					counter_start = next_time;
				}
				prev_time = next_time;
				prev_byte = next_byte;
				counter = next_time;
			}

/* Just get the first bytes if not building a toc to get the stream ID's. */
			if(next_byte > 0x100000 && 
				(!timecode_search || !toc)) done = 1;
		}

/* Get the last timecode */
		if(!toc || !timecode_search)
		{
			result = mpeg3io_seek(title->fs, title->total_bytes);
			if(!result) result = mpeg3_read_prev_packet(demuxer);
		}

		if(title->timecode_table && timecode)
		{
			timecode->end_byte = title->total_bytes;
//			timecode->end_byte = mpeg3io_tell(title->fs)/*  + demuxer->packet_size */;
			timecode->end_time = demuxer->time;
			timecode->absolute_end_time = timecode->end_time - timecode->start_time;
		}
	}

	mpeg3io_seek(title->fs, 0);
	demuxer->generating_timecode = 0;
	return 0;
}

int mpeg3demux_print_timecodes(mpeg3_title_t *title, FILE *output)
{
	mpeg3demux_timecode_t *timecode;
	int i;

	if(title->timecode_table)
	{
		for(i = 0; i < title->timecode_table_size; i++)
		{
			timecode = &title->timecode_table[i];

			fprintf(output, "REGION: %ld %ld %f %f\n",
				timecode->start_byte,
				timecode->end_byte,
				timecode->start_time,
				timecode->end_time);
		}
	}
	return 0;
}

/* Read the title information from a toc */
int mpeg3demux_read_titles(mpeg3_demuxer_t *demuxer)
{
	char string1[MPEG3_STRLEN], string2[MPEG3_STRLEN];
	long start_byte, end_byte;
	float start_time, end_time;
	mpeg3_title_t *title = 0;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;

// Eventually use IFO file to generate titles
	while(!mpeg3io_end_of_file(file->fs))   //JMM use accessors 
	{
		mpeg3io_scanf5(file->fs, "%s %s %ld %f %f %f", 
			string1,
			string2,
			&end_byte, 
			&start_time, 
			&end_time); //JMM use accessors

		if(!strncasecmp(string1, "PATH:", 5))
		{
			title = demuxer->titles[demuxer->total_titles++] = mpeg3_new_title(file, string2);

			if(demuxer->current_title < 0)
					mpeg3demux_open_title(demuxer, 0);
		}
		else
		if(title)
		{
			start_byte = atol(string2);
			if(!strcasecmp(string1, "REGION:"))
			{
				mpeg3_append_timecode(demuxer, 
					title, 
					0, 
					0, 
					0, 
					0,
					1);
				title->timecode_table[title->timecode_table_size - 1].start_byte = start_byte;
				title->timecode_table[title->timecode_table_size - 1].end_byte = end_byte;
				title->timecode_table[title->timecode_table_size - 1].start_time = start_time;
				title->timecode_table[title->timecode_table_size - 1].end_time = end_time;
			}
			else
			if(!strcasecmp(string1, "ASTREAM:"))
				demuxer->astream_table[start_byte] = end_byte;
			else
			if(!strcasecmp(string1, "VSTREAM:"))
				demuxer->vstream_table[start_byte] = end_byte;
			else
			if(!strcasecmp(string1, "SIZE:"))
				title->total_bytes = start_byte;
			else
			if(!strcasecmp(string1, "PACKETSIZE:"))
				demuxer->packet_size = start_byte;
		}
	}

	mpeg3demux_assign_programs(demuxer);
	return 0;
}

int mpeg3demux_copy_titles(mpeg3_demuxer_t *dst, mpeg3_demuxer_t *src)
{
	long i;
	mpeg3_t *file = (mpeg3_t *)dst->file;
	mpeg3_title_t *dst_title, *src_title;

	dst->packet_size = src->packet_size;
	dst->total_titles = src->total_titles;
	dst->total_programs = src->total_programs;
	for(i = 0; i < MPEG3_MAX_STREAMS; i++)
	{
		dst->astream_table[i] = src->astream_table[i];
		dst->vstream_table[i] = src->vstream_table[i];
	}
	for(i = 0; i < src->total_titles; i++)
	{
		src_title = src->titles[i];
		dst_title = dst->titles[i] = mpeg3_new_title(file, src->titles[i]->fs->path);
		mpeg3_copy_title(dst_title, src_title);
	}

	mpeg3demux_open_title(dst, src->current_title);
	return 0;
}

int mpeg3demux_print_streams(mpeg3_demuxer_t *demuxer, FILE *toc)
{
	int i;
/* Print the stream information */
	for(i = 0; i < MPEG3_MAX_STREAMS; i++)
	{
		if(demuxer->astream_table[i])
			fprintf(toc, "ASTREAM: %d %d\n", i, demuxer->astream_table[i]);

		if(demuxer->vstream_table[i])
			fprintf(toc, "VSTREAM: %d %d\n", i, demuxer->vstream_table[i]);
	}
	return 0;
}

/* Need a timecode table to do this */
double mpeg3demux_length(mpeg3_demuxer_t *demuxer)
{
	mpeg3_title_t *title;
	int i, j;
	double length;
	
	for(i = demuxer->total_titles - 1; i >= 0; i--)
	{
		title = demuxer->titles[i];
		for(j = title->timecode_table_size - 1; j >= 0; j--)
		{
			if(title->timecode_table[j].program == demuxer->current_program)
			{
				return title->timecode_table[j].end_time - 
					title->timecode_table[j].start_time + 
					title->timecode_table[j].absolute_start_time;
			}
		}
	}

	return 1;
}

int mpeg3demux_eof(mpeg3_demuxer_t *demuxer)
{
	if(demuxer->current_title >= 0)
	{
		if(mpeg3io_eof(demuxer->titles[demuxer->current_title]->fs) &&
			demuxer->current_title >= demuxer->total_titles - 1)
			return 1;
	}

	return 0;
}

int mpeg3demux_bof(mpeg3_demuxer_t *demuxer)
{
	if(demuxer->current_title >= 0)
	{
		if(mpeg3io_bof(demuxer->titles[demuxer->current_title]->fs) &&
			demuxer->current_title <= 0)
			return 1;
	}
	return 0;
}


/* For elemental streams seek to a byte */
int mpeg3demux_seek_byte(mpeg3_demuxer_t *demuxer, long byte)
{
	long current_position;
	mpeg3_t *file = (mpeg3_t *) demuxer->file;
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
	
	demuxer->data_position = 0;
	demuxer->data_size = 0;

	demuxer->error_flag = mpeg3io_seek(title->fs, byte);

	if(!demuxer->error_flag && (file->is_transport_stream || file->is_program_stream))
	{
/* Get on a packet boundary only for system streams. */
		current_position = mpeg3io_tell(title->fs);
		if(byte % demuxer->packet_size)
		{
			demuxer->error_flag |= mpeg3io_seek(title->fs, current_position - (current_position % demuxer->packet_size));
		}
	}
	return demuxer->error_flag;
}

/* For programs streams and toc seek to a time */
int mpeg3demux_seek_time(mpeg3_demuxer_t *demuxer, double new_time)
{
	int i, j, done = 0, result = 0;
	double byte_offset, new_byte_offset;
	double guess = 0, minimum = 65535;
	mpeg3_title_t *title;
	mpeg3demux_timecode_t *timecode;

	demuxer->error_flag = 0;

	i = 0;
	j = 0;
	title = demuxer->titles[i];
	timecode = &title->timecode_table[j];

/* Get the title and timecode of the new position */
	while(!demuxer->error_flag &&
		!(timecode->absolute_start_time <= new_time &&
		timecode->absolute_end_time > new_time &&
		timecode->program == demuxer->current_program))
	{
/* Next timecode */
		j++;
		if(j >= title->timecode_table_size)
		{
			i++;
			j = 0;
			if(i >= demuxer->total_titles)
			{
				demuxer->error_flag = 1;
				return 1;
			}
			else
			{
				mpeg3demux_open_title(demuxer, i);
			}
		}

		title = demuxer->titles[i];
		timecode = &title->timecode_table[j];
	}

/* Guess the new byte position */
	demuxer->current_timecode = j;

	byte_offset = ((new_time - timecode->absolute_start_time) /
		(timecode->absolute_end_time - timecode->absolute_start_time) *
		(timecode->end_byte - timecode->start_byte) +
		timecode->start_byte);
//printf("mpeg3demux_seek_time %f %f\n", new_time, byte_offset);

	while(!done && !result && byte_offset >= 0)
	{
		result = mpeg3demux_seek_byte(demuxer, (long)byte_offset);
//printf("seek_time 0 byte %.0f want %f result %d\n", byte_offset, new_time, result); 

		if(!result)
		{
			result = mpeg3_read_next_packet(demuxer);
// printf("seek_time 1 guess %f want %f\n", guess, new_time); 
			guess = demuxer->time + demuxer->time_offset;

			if(fabs(new_time - guess) >= fabs(minimum)) done = 1;
			else
			{
				minimum = guess - new_time;
				new_byte_offset = byte_offset + ((new_time - guess) / 
					(timecode->end_time - timecode->start_time) *
					(timecode->end_byte - timecode->start_byte));
				if(labs((long)new_byte_offset - (long)byte_offset) < demuxer->packet_size) done = 1;
				byte_offset = new_byte_offset;
			}
		}
	}

/* Get one packet before the packet just read */
	if(!result && byte_offset > demuxer->packet_size && minimum > 0)
	{
		mpeg3_read_prev_packet(demuxer);
		mpeg3_read_prev_packet(demuxer);
	}
//printf("seek_time %d %d %d\n", demuxer->current_title, demuxer->current_timecode, mpeg3demux_tell(demuxer));
	demuxer->error_flag = result;
	return result;
}

int mpeg3demux_seek_percentage(mpeg3_demuxer_t *demuxer, double percentage)
{
	double total_bytes = 0;
	double absolute_position;
	long relative_position;
	int i, new_title;
	mpeg3_title_t *title;

	demuxer->error_flag = 0;

/* Get the absolute byte position; */
	for(i = 0; i < demuxer->total_titles; i++)
		total_bytes += demuxer->titles[i]->total_bytes;

	absolute_position = percentage * total_bytes;

/* Get the title the byte is inside */
	for(new_title = 0, total_bytes = 0; new_title < demuxer->total_titles; new_title++)
	{
		total_bytes += demuxer->titles[new_title]->total_bytes;
		if(absolute_position < total_bytes) break;
	}

	if(new_title >= demuxer->total_titles)
	{
		new_title = demuxer->total_titles - 1;
	}

/* Got a title */
	title = demuxer->titles[new_title];
	total_bytes -= title->total_bytes;
	relative_position = (long)(absolute_position - total_bytes);

/* Get the timecode the byte is inside */
	for(demuxer->current_timecode = 0; 
		demuxer->current_timecode < title->timecode_table_size; 
		demuxer->current_timecode++)
	{
		if(title->timecode_table[demuxer->current_timecode].start_byte <= relative_position &&
			title->timecode_table[demuxer->current_timecode].end_byte > relative_position)
		{
			break;
		}
	}

	if(demuxer->current_timecode >= title->timecode_table_size)
		demuxer->current_timecode = title->timecode_table_size - 1;

/* Get the nearest timecode in the same program */
	while(demuxer->current_timecode < title->timecode_table_size - 1 &&
			title->timecode_table[demuxer->current_timecode].program != demuxer->current_program)
	{
		demuxer->current_timecode++;
	}

/* Open the new title and seek to the correct byte */
	if(new_title != demuxer->current_title)
	{
		demuxer->error_flag = mpeg3demux_open_title(demuxer, new_title);
	}

	if(!demuxer->error_flag)
		demuxer->error_flag = mpeg3io_seek(title->fs, relative_position);

	return demuxer->error_flag;
}

double mpeg3demux_tell_percentage(mpeg3_demuxer_t *demuxer)
{
	double total_bytes = 0;
	double position = 0;
	int i;

	demuxer->error_flag = 0;
	position = mpeg3io_tell(demuxer->titles[demuxer->current_title]->fs);
	for(i = 0; i < demuxer->total_titles; i++)
	{
		if(i == demuxer->current_title)
		{
			position += total_bytes;
		}
		total_bytes += demuxer->titles[i]->total_bytes;
	}
	return position / total_bytes;
}

double mpeg3demux_get_time(mpeg3_demuxer_t *demuxer)
{
	return demuxer->time;
}

long mpeg3demux_tell(mpeg3_demuxer_t *demuxer)
{
	return mpeg3io_tell(demuxer->titles[demuxer->current_title]->fs);
}

long mpeg3demuxer_total_bytes(mpeg3_demuxer_t *demuxer)
{
	mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
	return title->total_bytes;
}

mpeg3_demuxer_t* mpeg3_get_demuxer(mpeg3_t *file)
{
	if(file->is_program_stream || file->is_transport_stream)
	{
		if(file->has_audio) return file->atrack[0]->demuxer;
		else
		if(file->has_video) return file->vtrack[0]->demuxer;
	}
	return 0;
}