initial_parse.cpp

/* 
 *  Copyright (C) 2005, Donald Graft
 *
 *  This file 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.
 *   
 *  This file 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. 
 */

#include <windows.h>
#include "resource.h"
#include <stdio.h> 
#include <io.h> 
#include <fcntl.h>
#include "global.h"

// Defines for the start code detection state machine.
#define NEED_FIRST_0  0
#define NEED_SECOND_0 1
#define NEED_1        2

static void determine_stream_type(void);
static void video_parser(int *);
static void pack_parser(void);
static unsigned char get_byte(void);

static int file;
static int state, found;
// Should hold maximum size PES packet.
static unsigned char buffer[256000];
static int buffer_length, buffer_ndx;
static int EOF_reached;

int initial_parse(char *input_file, int *mpeg_type_p, int *is_program_stream_p)
{
	// Open the input file.
	if (input_file[0] == 0 || (file = _open(input_file, _O_RDONLY | _O_BINARY | _O_SEQUENTIAL)) == -1)
	{
		return -1;
	}

	// Determine the stream type: ES or program.
	determine_stream_type();

	// Re-open the input file.
	_close(file);
	file = _open(input_file, _O_RDONLY | _O_BINARY | _O_SEQUENTIAL);
	if (file == -1)
	{
		return -1;
	}

	// Determine MPEG type and find location of first video sequence header.
	EOF_reached = 0;
	video_parser(mpeg_type_p);
	_close(file);
	if (EOF_reached)
	{
		return -1;
	}
	*is_program_stream_p = program_stream_type;
	return 0;
}

static unsigned char get_byte(void)
{
	unsigned char val;

	if (program_stream_type != ELEMENTARY_STREAM)
	{
		if (buffer_ndx >= buffer_length)
		{
			// Need more data. Fill buffer with the next
			// packet's worth of elementary data.
			pack_parser();
		}
		if (EOF_reached == 1) 
		{
			return 0;
		}
		return buffer[buffer_ndx++];
	}
	else
	{
		// No program stream parsing needed. Just read from
		// the input file.
		if (_read(file, &val, 1) != 1)
		{
			EOF_reached = 1;
			return 0;
		}
		return val;
	}
}

static void video_parser(int *mpeg_type_p)
{
	unsigned char val;
	int sequence_header_active = 0;

	buffer_length = buffer_ndx = 0;

	// Inits.
	state = NEED_FIRST_0;
	found = 0;

	// Let's go! Start by assuming it's not MPEG at all.
	*mpeg_type_p = IS_NOT_MPEG;
	for (;;)
	{
		// Parse for start codes.
		val = get_byte();
		if (EOF_reached) return;
		switch (state)
		{
		case NEED_FIRST_0:
			if (val == 0)
				state = NEED_SECOND_0;
			break;
		case NEED_SECOND_0:
			if (val == 0)
				state = NEED_1;
			else
				state = NEED_FIRST_0;
			break;
		case NEED_1:
			if (val == 1)
			{
				found = 1;
				state = NEED_FIRST_0;
			}
			else if (val != 0)
				state = NEED_FIRST_0;
			break;
		}
		if (found == 1)
		{
			// Found a start code.
			found = 0;
			val = get_byte();
			if (EOF_reached) return;

			if (val == 0xB3)
			{
				// Found a sequence header, so it's at least MPEG1.
				*mpeg_type_p = IS_MPEG1;
				// Sequence header.
				if (sequence_header_active)
				{
					// Got another sequence header but didn't see a
					// sequence header extension, so it's MPEG1.
					return;
				}
				sequence_header_active = 1;
			}
			else if (val == 0xB5)
			{
				val = get_byte();
				if (EOF_reached) return;
				if ((val & 0xf0) == 0x10)
				{
					// Sequence extension.
					if (sequence_header_active)
					{
						// Must be MPEG2.
						*mpeg_type_p = IS_MPEG2;
						return;
					}
				}
				else if (sequence_header_active)
				{
					// Got some other extension. Must be MPEG1.
					*mpeg_type_p = IS_MPEG1;
					return;
				}
			}
			else
			{
				if (sequence_header_active)
				{
					// No sequence header extension. Must be MPEG1.
					*mpeg_type_p = IS_MPEG1;
					return;
				}
			}
		}
	}
	return;
}

static void pack_parser(void)
{
	unsigned char val, val2;
	int state, found = 0;
	int length;
	unsigned short pes_packet_length, system_header_length;
	unsigned char pes_packet_header_length, pack_stuffing_length;
	unsigned char code;


	// Look for start codes.
	state = NEED_FIRST_0;
	for (;;)
	{
		if (_read(file, &val, 1) != 1) { EOF_reached = 1; return; }
		switch (state)
		{
		case NEED_FIRST_0:
			if (val == 0)
				state = NEED_SECOND_0;
			break;
		case NEED_SECOND_0:
			if (val == 0)
				state = NEED_1;
			else
				state = NEED_FIRST_0;
			break;
		case NEED_1:
			if (val == 1)
			{
				found = 1;
				state = NEED_FIRST_0;
			}
			else if (val != 0)
				state = NEED_FIRST_0;
			break;
		}
		if (found == 1)
		{
			// Found a start code.
			found = 0;
			// Get the start code.
			if (_read(file, &val, 1) != 1) { EOF_reached = 1; return; }
//			dprintf("DGIndex: code = %x\n", val);
			if (val == 0xba)
			{
				// Pack header. Skip it.
				if (_read(file, &val, 1) != 1) { EOF_reached = 1; return; }
				if (program_stream_type == MPEG1_PROGRAM_STREAM)
				{
					// MPEG1 program stream.
					if (_read(file, buffer, 7) != 7) { EOF_reached = 1; return; }
				}
				else
				{
					// MPEG2 program stream.
					if (_read(file, buffer, 8) != 8) { EOF_reached = 1; return; }
					if (_read(file, &pack_stuffing_length, 1) != 1) { EOF_reached = 1; return; }
					pack_stuffing_length &= 0x03;
					if (_read(file, buffer, pack_stuffing_length) != pack_stuffing_length) { EOF_reached = 1; return; }
				}
			}
			if (val == 0xbb)
			{
				// System header. Skip it.
				if (_read(file, &val, 1) != 1)  { EOF_reached = 1; return; }
				system_header_length = (unsigned short) (val << 8);
				if (_read(file, &val2, 1) != 1)  { EOF_reached = 1; return; }
				system_header_length |= val2;
				if (_read(file, buffer, system_header_length) != system_header_length) { EOF_reached = 1; return; }
			}
			else if (val >= 0xE0 && val <= 0xEF)
			{
				// Video stream.
				// Packet length.
				if (_read(file, &val, 1) != 1)  { EOF_reached = 1; return; }
				pes_packet_length = (unsigned short) (val << 8);
				if (_read(file, &val2, 1) != 1)  { EOF_reached = 1; return; }
				pes_packet_length |= val2;
 //               if (pes_packet_length == 0)
 //                   pes_packet_length = 256;
				if (program_stream_type == MPEG1_PROGRAM_STREAM)
				{
					// MPEG1 program stream.
					pes_packet_header_length = 0;
					// Stuffing bytes.
					do 
					{
						if (_read(file, &val, 1) != 1)  { EOF_reached = 1; return; }
						pes_packet_header_length += 1;
					} while (val == 0xff);
					if ((val & 0xc0) == 0x40)
					{
						// STD bytes.
						if (_read(file, &val, 1) != 1)  { EOF_reached = 1; return; }
						if (_read(file, &val, 1) != 1)  { EOF_reached = 1; return; }
						pes_packet_header_length += 2;
					}
					if ((val & 0xf0) == 0x20)
					{
						// PTS bytes.
						if (_read(file, buffer, 4) != 4)  { EOF_reached = 1; return; }
						pes_packet_header_length += 4;
					}
					else if ((val & 0xf0) == 0x30)
					{
						// PTS/DTS bytes.
						if (_read(file, buffer, 9) != 9)  { EOF_reached = 1; return; }
						pes_packet_header_length += 9;
					}
					// Send the video elementary data down the pipe to the video parser.
					buffer_length = pes_packet_length - pes_packet_header_length;
					if (buffer_length)
					{
						buffer_ndx = 0;
						if (_read(file, buffer, buffer_length) != buffer_length)  { EOF_reached = 1; return; }
						return;
					}
				}
				else
				{
					// MPEG2 program stream.
					// Flags.
					if (_read(file, &code, 1) != 1)  { EOF_reached = 1; return; }
					if ((code & 0xc0) == 0x80)
					{
						if (_read(file, &code, 1) != 1)  { EOF_reached = 1; return; }
						if (_read(file, &pes_packet_header_length, 1) != 1) { EOF_reached = 1; return; }
						// Skip the PES packet header.
						if (_read(file, buffer, pes_packet_header_length) != pes_packet_header_length)  { EOF_reached = 1; return; }
						// Send the video elementary data down the pipe to the video parser.
						buffer_length = pes_packet_length - pes_packet_header_length - 3;
						buffer_ndx = 0;
						if (_read(file, buffer, buffer_length) != buffer_length)  { EOF_reached = 1; return; }
						return;
					}
					else
					{
						// No video data here. Skip it.
						length = pes_packet_length - 1;
						if (_read(file, buffer, length) != length)  { EOF_reached = 1; return; }
					}
				}
			}
			else if (val > 0xbb)
			{
				// Not a stream that we are interested in. Skip it.
				if (_read(file, &val, 1) != 1)  { EOF_reached = 1; return; }
				pes_packet_length = (unsigned short) (val << 8);
				if (_read(file, &val2, 1) != 1)  { EOF_reached = 1; return; }
				pes_packet_length |= val2;
				length = pes_packet_length;
				if (_read(file, buffer, length) != length)  { EOF_reached = 1; return; }
			}
		}
	}
}

unsigned char stream[2500000];
static void determine_stream_type(void)
{
	unsigned char val;
	int num_sequence_header = 0;
	int num_picture_header = 0;
	unsigned char *p;
	unsigned int code, Read;

	// Start by assuming ES. Then look for a valid pack start. If one
	// is found declare a program stream.
	program_stream_type = ELEMENTARY_STREAM;

	Read = _read(file, stream, 2500000);
	p = stream;
	code = (p[0] << 16) + (p[1] << 8) + p[2];
	p += 3;
	while (p < stream + Read)
	{
		code = ((code << 8) + *p++);
		switch (code)
		{
		case 0x1ba:
			val = *p++;
			if ((val & 0xf0) == 0x20)
			{
				// Check all the marker bits just to be sure.
				if (!(val & 1)) continue;
				val = *p++;
				val = *p++;
				if (!(val & 1)) continue;
				val = *p++;
				val = *p++;
				if (!(val & 1)) continue;
				val = *p++;
				if (!(val & 0x80)) continue;
				val = *p++;
				val = *p++;
				if (!(val & 1)) continue;
				// MPEG1 program stream.
				program_stream_type = MPEG1_PROGRAM_STREAM;
				return;
			}
			else if ((val & 0xc0) == 0x40)
			{
				// Check all the marker bits just to be sure.
				if (!(val & 0x04)) continue;
				val = *p++;
				val = *p++;
				if (!(val & 0x04)) continue;
				val = *p++;
				val = *p++;
				if (!(val & 0x04)) continue;
				val = *p++;
				if (!(val & 0x01)) continue;
				val = *p++;
				val = *p++;
				val = *p++;
				if (!(val & 0x03)) continue;
				// MPEG2 program stream.
				program_stream_type = MPEG2_PROGRAM_STREAM;
				return;
			}
			break;
		case 0x1b3:
			// Sequence header.
			num_sequence_header++;
			break;
		case 0x100:
			// Picture header.
			num_picture_header++;
			break;
		}
		if (num_sequence_header >= 2 && num_picture_header >= 2)
		{
			// We're seeing a lot of elementary stream data but we haven't seen
			// a pack header yet. Declare ES.
			return;
		}
	}
}