/***************************************************************
**
** Broadcom Corp. Confidential
** Copyright 1998-2001 Broadcom Corp. All Rights Reserved.
**
** THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED
** SOFTWARE LICENSE AGREEMENT BETWEEN THE USER AND BROADCOM.
** YOU HAVE NO RIGHT TO USE OR EXPLOIT THIS MATERIAL EXCEPT
** SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
**
** File:		main.c
** Description: Broadcom Stream Indexer Main
**
** Created: 05/16/2001 by Marcus Kellerman
**
** REVISION:
**
** $Log: $
**
**
****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>		/* strcmp() */
#include <sys/stat.h>
#if !defined(__vxworks)
#include <sys/timeb.h>	/* ftime() */
#endif
#include "tsindexer.h"
#include "bcmindexer.h"
#include "brcm_dbg.h"

#define NUM_STREAM_BYTES_TO_READ	(188*1024)
#define NUM_SC_BYTES_TO_READ		(sizeof(sIndexEntry)*1024)

void TimetoString( long ctime, char *outStr )
{
	long	hh,mm,ss;
	char 	*p;
	
	ss = ctime % 60;
	mm = (ctime/60) % 60;
	hh = (ctime/3600) % 24;

	p = outStr;	
	*p++ = (hh/10) + 0x30;
	*p++ = (hh%10) + 0x30;
	*p++ = ':';
	*p++ = (mm/10) + 0x30;
	*p++ = (mm%10) + 0x30;
	*p++ = ':';
	*p++ = (ss/10) + 0x30;
	*p++ = (ss%10) + 0x30;
	*p++ = 0;
}

double getms( void )
{
#if defined(__vxworks)
	return 0;
#else
	double  usec1;
	struct timeb t;

	ftime( &t );

	usec1 = t.time + t.millitm/1000.0;
	return usec1;
#endif
}

void OffsetToString( long offset, char *outStr )
{
	long mb, kb, b;

	b = offset % 1000;
	kb = (offset/1000)%1000;
	mb = (offset/(1000*1000)) % (1000*1000);

	sprintf( outStr, "%ld,%03ld,%03ld", mb, kb, b );
}

/**
* Feed from tsindexer to bcmindexer.
**/
static unsigned long write_to_bcmindexer( const void *p_bfr, unsigned long entrySize,
	unsigned long numEntries, void *fp )
{
	return
		BNAV_Indexer_Feed(
			(BNAV_Indexer_Handle)fp,
			(BSCT_Entry *)p_bfr,
			(numEntries * entrySize) / sizeof(BSCT_Entry))
		* sizeof(BSCT_Entry) / entrySize;
}

void printHeader()
{
	printf("\ncreateindex, built on %s\n\n", __DATE__);
	printf("Broadcom Corp. Confidential\n");
	printf("Copyright 1998-2003 Broadcom Corp. All Rights Reserved.\n\n");
}

/**
* This is a modification of createindex which allows
* the stuff of gigabytes of bogus MPEG into the
* index in order to test wrap-detection.
*
* This was needed to test PR7218.
**/
#define FAKE_GAP

#ifdef FAKE_GAP
off_t fake_data_sent = 0;
#endif

static FILE *g_mpegFile = NULL; // global hack
int mpegSizeCallback(BNAV_Indexer_Handle handle, unsigned long *hi, unsigned long *lo)
{
	off_t o = ftello(g_mpegFile);
	if (o == -1)
		return -1;

#ifdef FAKE_GAP
	o += fake_data_sent;
#endif
	*hi = o >> 32;
	*lo = o & 0xFFFFFFFF;
	return 0;
}

/**
* This is the entry point for VxWorks.
*
* input: 0=ts,1=pes,2=sct
* output: 0=sct,1=bcm
**/
int createindex(const char *inputfile, const char *outputfile, int pid,
	int input, int output, BNAV_Version navVersion)
{
	unsigned char *bfr;
	FILE	*fin, *fout;
	sTsIndexer *indexer = NULL;
	BNAV_Indexer_Handle bcmindexer = NULL;
	unsigned long readBytes;
	unsigned long totalBytes = 0;
	double	time1, time2;
	int pesId = 0;
	int generateBcmIndex = 0;
	int sctInput = 0;
	unsigned long numBytesToRead;

	printHeader();

	time1 = getms();

	if (input == 1)
		pesId = pid;
	else if (input == 2)
		sctInput = 1;
	if (sctInput)
		numBytesToRead = NUM_SC_BYTES_TO_READ;
	else
		numBytesToRead = NUM_STREAM_BYTES_TO_READ;
	if (output == 1)
		generateBcmIndex = 1;

	if (pid == 0 && !sctInput)
		printf(
		"WARNING\n"
		"WARNING\n"
		"WARNING: Are you sure you want PID == 0 ??????????????\n"
		"WARNING\n"
		"WARNING\n"
		"\n"
		);
	if (sctInput && !generateBcmIndex) {
		printf("If your input is a start code index, then -bcm is required.\n");
		exit(1);
	}

	bfr = malloc( numBytesToRead );

	if (!strcmp(inputfile, "-")) {
		fin = stdin;
		inputfile = "stdin";
	}
	else if( (fin = fopen(inputfile, "rb" )) == NULL )
	{
		printf("Unable to open input file %s\n", inputfile);
		exit(255);
	}

	if (!strcmp(outputfile, "-")) {
		fout = stdout;
		outputfile = "stdout";
	}
	else if( (fout = fopen(outputfile, "wb" )) == NULL )
	{
		printf("Unable to open output file %s\n", outputfile);
		fclose(fin);
		exit(255);
	}

	printf("Processing %s 0x%X from %s input file '%s'.\n",
		pesId?"StreamID":"PID",
		pesId?pesId:pid,
		pesId?"MPEG PES":sctInput?"SCT":"MPEG TS",
		inputfile);
	if (generateBcmIndex)
		printf("Writing BCM index (ver %d) to '%s'.\n", navVersion, outputfile);
	else
		printf("Writing SCT index to '%s'.\n", outputfile);

	if (generateBcmIndex)
	{
		BNAV_Indexer_Settings settings;
		BNAV_Indexer_GetDefaultSettings(&settings);
		settings.writeCallback = (INDEX_WRITE_CB)fwrite;
		settings.filePointer = (void *)fout;
		settings.navVersion = navVersion;
		if (!sctInput) {
			settings.mpegSizeCallback = mpegSizeCallback;
			g_mpegFile = fin;
		}
		if (BNAV_Indexer_Open(&bcmindexer, &settings))
		{
			exit(1);
		}
	}
	if (!sctInput)
	{
		if (generateBcmIndex)
			/* pass through to bcmindex */
			indexer = tsindex_allocate( (INDEX_WRITE_CB)write_to_bcmindexer, (void *)bcmindexer, (unsigned short)pid, -1 );
		else
			indexer = tsindex_allocate( (INDEX_WRITE_CB)fwrite, (void *)fout, (unsigned short)pid, -1 );
		if( pesId )
			tsindex_setPesId( indexer, (unsigned char)pesId );
	}

	while( (readBytes = fread( bfr, 1, numBytesToRead, fin )) != 0 )
	{
		totalBytes += readBytes;

		if ( totalBytes%(1*numBytesToRead) == 0 )
		{
			double rate1; char timeStr[32], offsetStr[32];
			time2 = getms() - time1;
			rate1 = (totalBytes/1024)/time2;
			TimetoString( (long)time2, timeStr );
			OffsetToString( totalBytes, offsetStr );
			printf( "Byte Offset: %s Rate: %0.1fK/s, Elapsed Time: %s      \r", offsetStr, rate1, timeStr );
		}

		if (sctInput)
		{
			BNAV_Indexer_Feed(bcmindexer, (BSCT_Entry*)bfr, readBytes/sizeof(BSCT_Entry) );
		}
		else if( pesId )
		{
			tsindex_feedPes( indexer, bfr, readBytes );
		}
		else
		{
			tsindex_feed( indexer, bfr, readBytes );
		}

#ifdef FAKE_GAP
#define START_OF_JUNK (10 * 1024 * 1024)
#define AMOUNT_OF_JUNK1 ((unsigned long)1024 * 1024 * 1024)
#define AMOUNT_OF_JUNK2 16
		{
		static int doonce = 0;
		if (sctInput || pesId) {
			BRCM_DBG_ERR(("FAKE_GAP must use TS in"));
			exit(1);
		}
		if (!doonce && totalBytes >= START_OF_JUNK) {
			int i,j;
			unsigned char junkbuf[188];

			doonce = 1;
			junkbuf[0] = 0x47; // just enough to fake it out
			printf("\nFeeding junk\n");
			for (j=0;j<AMOUNT_OF_JUNK2;j++)
			for (i=0;i<AMOUNT_OF_JUNK1;i+=188) {
				tsindex_feed(indexer, junkbuf, 188);
				fake_data_sent += 188;
			}
		}
		}
#endif
	}

	if (bcmindexer)
		BNAV_Indexer_Close( bcmindexer );
	if (indexer)
		tsindex_free( indexer );

	fclose( fin );
	fclose( fout );
	free( bfr );
	printf("\n");
	exit(0);
}

#if !defined(__vxworks)
void printUsage()
{
	printf(
	"Parses an MPEG stream or SCT index and creates either a SCT index\n"
	"  or Broadcom index.\n"
	"\n"
	"Usage: createindex inputfile outputfile [pid] [-ts|-pes|-sct] [-bcm [-bcmver VERSION]]\n"
	"\n"
	"  inputfile    Filename of input mpeg (either TS or PES stream), or\n"
	"                 input startcode index (if -sct is specified or ends with\n"
	"                 .sct or .idx)\n"
	"  outputfile   Filename of output index file that will be created.\n"
	"                 If -bcm option is used, or file ends with .nav, it will be\n"
	"                 a NAV table, otherwise a start code index.\n"
	"  pid          Pid (or stream id in PES mode). Not needed if inputfile is\n"
	"                 a startcode index. Prefix with 0x for hex, otherwise decimal.\n"
	"\n"
	"Optional Parameters:\n"
	"  -ts          Inputfile is a TS stream\n"
	"  -pes         Inputfile is a PES stream\n"
	"  -sct         Inputfile is a startcode index\n"
	"  -bcm         Generate a BCM index file from either\n"
	"                 a TS stream or startcode index.\n"
	"  -bcmver VERSION   Specify the BCM index format. See eBcmNavVersion.\n"
	);
}

int main( int argc, char **argv )
{
	brcmDbgSetOutputLevel(kBrcmDbgOutputWrn);

	if (argc < 3) {
		printHeader();
		printUsage();
		return 1;
	}
	else {
		int pid = 0;
		int nextparam = 3;
		int input = -1;
		int output = -1;
		const char *source = argv[1];
		const char *dest = argv[2];
		BNAV_Version navVersion = BNAV_VersionLatest;

		if (argc>3 && argv[3][0] != '-') {
			if (strstr(argv[3], "0x") == argv[3])
				sscanf( argv[3], "0x%X", &pid );
			else
				pid = atoi( argv[3] );
			++nextparam;
		}

		while (nextparam < argc) {
			if (!strcmp(argv[nextparam], "-ts"))
				input = 0;
			else if (!strcmp(argv[nextparam], "-pes"))
				input = 1;
			else if (!strcmp(argv[nextparam], "-sct"))
				input = 2;
			else if (!strcmp(argv[nextparam], "-bcm"))
				output = 1;
			else if (!strcmp(argv[nextparam], "-bcmver") && nextparam+1 < argc)
				navVersion = atoi(argv[++nextparam]);
			nextparam++;
		}

		if (input == -1) {
			char *s;
			// check the suffix of the inputfile
			if (((s = strstr(source, ".sct")) && !s[4]) ||
				((s = strstr(source, ".idx")) && !s[4]))
			{
				input = 2;
			}
			else if ((s = strstr(source, ".pes")) && !s[4])
			{
				input = 1;
			}
			else
				input = 0;
		}
		if (output == -1) {
			char *s;
			if (((s = strstr(dest, ".nav")) && !s[4]) ||
				((s = strstr(dest, ".bcm")) && !s[4]))
				output = 1;
			else
				output = 0;
		}

		return createindex(source,dest,pid,input,output,navVersion);
	}
}
#endif