/* Copyright 1996, ESS Technology, Inc.					*/
/* SCCSID @(#)vcd.c	1.39 3/24/98 */

/*
 * $Log$
 */

#include <stdio.h>
#include "util.h"
#include "const.h"
#include "constvar.h"
#include "drammem.h"
#include "vcd.h"
#include "dsa.h"
#include "tdm.h"
#include "echo.h"
#include "custom.h"

#ifdef SCENE
#include "fsosd.h"
#endif
/* Peter I moved INFO_VCD_OFFSET to vcd.h - Ming */

#if 1 

#define INFO_VCD_SIZE		400	/* bytes */
#define ENTRIES_VCD_SIZE	800
#define PSD_SIZE		1024
#define TRACK_SIZE		400
#define MAX_ENTRY_NUM		195
#else
#define INFO_VCD_SIZE		800	/* bytes */
#define ENTRIES_VCD_SIZE	2048
#define PSD_SIZE		2048
#define TRACK_SIZE		400
#define MAX_ENTRY_NUM		500

#endif

#define MAC_ENTRIES_VCD_OFFSET	(MAC_INFO_VCD_OFFSET + INFO_VCD_SIZE)
int ENTRIES_VCD_OFFSET     =	(MAC_INFO_VCD_OFFSET + INFO_VCD_SIZE);

#define PSD_SECTOR_SIZE		2048
#define MAC_PSD_START_OFFSET	(MAC_ENTRIES_VCD_OFFSET + ENTRIES_VCD_SIZE)
int PSD_START_OFFSET	   =    (MAC_ENTRIES_VCD_OFFSET + ENTRIES_VCD_SIZE);

#define MAC_TRACK_INFO_OFFSET	(PSD_SIZE + MAC_PSD_START_OFFSET)
int TRACK_INFO_OFFSET	   =	(PSD_SIZE + MAC_PSD_START_OFFSET);

#define MAX_SEGMENT_NUM	1980	/* from 1 to 1980 */
#define ENTRY_START_OFFSET	(12 + MAC_ENTRIES_VCD_OFFSET)

#ifdef SCENE
#define LOT_VCD_SIZE		4992
#define LOT_VCD_OFFSET		((OSD_DRAM_START << 2) + 4608/*OSD_SIZE*/)
#endif /*SCENE*/

#define GOOD			1
#define BAD			0

unsigned int *TrackInfoAdr = (unsigned int *)(MAC_TRACK_INFO_OFFSET | 0x12000000);

#ifdef  CUST6
unsigned int *toc_data = (unsigned int *)(MAC_TRACK_INFO_OFFSET | 0x12000000);
#endif /* CUST6 */

int PSD_start_addr;	/* start offset of PAD data in dram. */
int PSD_end_addr;	/* end offset of PAD data in dram. */
short numAVtrack;	/* Number of MPEG track. CDDA follows */
unsigned int x0fffffff = 0x0fffffff;
unsigned int x2000000 = 0x2000000;

/*-----------------------------------------------------------
  Function: dump_info_vcd
-----------------------------------------------------------*/
int dump_info_vcd()
{
    /* get the infovcd to system buffer */
    if (!getSectors(0x000400, 1, 2048))
	return (BAD);
    
    if (put_scratch(INFO_VCD_OFFSET, CDI_ptr + 56, INFO_VCD_SIZE) != INFO_VCD_SIZE)
	return (BAD);

    return (GOOD);
}

/*-----------------------------------------------------------
  Function: dump_entries_vcd
-----------------------------------------------------------*/
int dump_entries_vcd()
{
    int tmp, tmp1, tmp2, maxtrack;
    unsigned int * ptr;

    numAVtrack = 99;	/* Initialize to no AV track */

    /* get the infovcd to system buffer */
    if (!getSectors(0x000401, 1, 2048))
	return (BAD);
    
    /*
     * Find out how many AV tracks are there. Any track higher than
     * that is a CDDA track!
     */
    ptr = (unsigned int *) ((unsigned char *) CDI_ptr + 8);
    tmp1 = *ptr & 0xffff;		/* Number of entries used	*/
    ptr = (unsigned int *) ((unsigned char *) CDI_ptr + 12);
    for (maxtrack = 0, tmp = 1; tmp <= tmp1; tmp++, ptr++) {
	/* Translate BCD track number to HEX track number */
	tmp2 = (*ptr >> 28) & 0xf;
	tmp2 = (tmp2 << 3) + (tmp2 << 1) + ((*ptr >> 24) & 0xf);
	if (tmp2 > maxtrack) maxtrack = tmp2;
    }
    numAVtrack = maxtrack - 1;

    if (put_scratch(ENTRIES_VCD_OFFSET, CDI_ptr, ENTRIES_VCD_SIZE) != ENTRIES_VCD_SIZE)
	return (BAD);

    return (GOOD);
}

#ifdef SCENE
/*-----------------------------------------------------------
  Function: dump_lot_vcd
-----------------------------------------------------------*/
int dump_lot_vcd(void)
{
    /* get the lot.vcd to system buffer */
    if (!getSectors(0x000402, 3, 2048))
	return (BAD);

    if (put_scratch(LOT_VCD_OFFSET, CDI_ptr, LOT_VCD_SIZE) != LOT_VCD_SIZE)
	return (BAD);

    return (GOOD);
}
#endif /*SCENE*/

/*-----------------------------------------------------------
  Function: get_segment_info
  Description: Given a segment number, it returns the
     segment content and the number of segments that it
     contains.
  
  Return Value:
     GOOD -> sucess.
     BAD -> failure.
-----------------------------------------------------------*/
int get_segment_length(char *ptr, char *end_ptr, unsigned char *content)
{
    int len;
    int found_end_seg;
    unsigned char	test_content;

    if (((*ptr & 0x20) != 0) ||(*ptr == 0x0))	/* check valid seg. */
	return (0);

    *content = *ptr++;
    len = 1;	
    test_content = (*content | 0x20);	/* second or later seg. */

    found_end_seg = 0;
    for (; ptr < end_ptr; ptr++) {
	if (*ptr == test_content)
	    len ++;
	else return (len); /* found */
    }

    return (0);
}

int get_segment_info(int seg_num, unsigned char *content, int *len)
{
    int start_seg;
    int start_addr;
    unsigned char	*ptr, *end_ptr;

    /* check whether the seg_num is a good one */
    if (seg_num < 1 || seg_num > MAX_SEGMENT_NUM)
	return (BAD);

    start_seg = seg_num - 1; 	 /* 0 base */
    
    /* if the start_seg is not in the segment cache, we need to get the whole
       segment info */
    if (start_seg < INFO_VCD_SIZE) {
#ifdef DVD_VCD
	ptr = (char *) ((INFO_VCD_OFFSET + start_seg) | 0x12000000);
	end_ptr = (char *) (INFO_VCD_OFFSET + INFO_VCD_SIZE + 0x12000000);
#else
	ptr = (char *) (INFO_VCD_OFFSET + start_seg);
	end_ptr = (char *) (INFO_VCD_OFFSET + INFO_VCD_SIZE);
#endif
	*len = get_segment_length(ptr, end_ptr, content);
	if (*len)
	    return (GOOD);
    }

    if (!getSectors(0x000400, 1, 2048))
	return (BAD);

    ptr = CDI_ptr + 56 + start_seg;
    end_ptr = CDI_ptr + 2048;
    *len = get_segment_length(ptr, end_ptr, content);
    if (*len)
	return (GOOD);

    return (BAD);
}

/*-----------------------------------------------------------
  Function: get_total_entry_number
-----------------------------------------------------------*/
int get_total_entry_number()
{
    int addr;
    int last_entry;
    unsigned char *scratch_buf;

    addr = ENTRIES_VCD_OFFSET + 8;

    /* get 4 bytes starting at addr */
    scratch_buf = (char *)((addr | x2000000)& x0fffffff);

    last_entry = 0;
    last_entry = (scratch_buf[2] << 8) + scratch_buf[3];
    return (last_entry);
}

/*-----------------------------------------------------------
  Function: get_entry_info
  Return Value:
    GOOD -> success
    BAD -> failure
-----------------------------------------------------------*/
int get_entry_info(int entry_num, unsigned char *track_num,
		   unsigned int *start_mmssff,
		   int *end_mmssff)
{
    int addr;
    int last_entry;
    unsigned char *scratch_buf; 

    /* check whether the seg_num is a good one */
    last_entry = get_total_entry_number();
    if (entry_num < 1 || entry_num > last_entry)
	return (BAD);

    addr = ENTRY_START_OFFSET + (entry_num - 1) * 4; /* 0 base */
    
    /* get 8 bytes starting at addr */
    scratch_buf = (char *)((addr | x2000000)& x0fffffff);
    
    /* get the track and start mmssff info */
    *track_num = bcd2hex[scratch_buf[0]];
    *start_mmssff = *((unsigned int *)scratch_buf) & x00ffffff;
    
    if (entry_num == last_entry)
	*end_mmssff =  CDinfo.leadout & x00ffffff;
    else
	*end_mmssff = *((unsigned int *)&scratch_buf[4]) & x00ffffff;

    return (GOOD);
}

/*------------------------------------------------------------------------
  Function:

  Parameters:
      INPUT:
          track_number

      OUTPUT
          *beg 	The beginning entry number of the input track.
	  *end  The end entry number of the input track.

      RETURN:
          The number of entries of the input track.

  Description:
------------------------------------------------------------------------*/
int get_track_entries(unsigned char track_number, unsigned int *beg,
		      unsigned int *end)
{
    int entry_number;
    int last_entry;
    int total_entry_size;
    int addr;
    int entry;
    int i;
    int done = 0;
    unsigned char *scratch_buf; 

    last_entry = get_total_entry_number();

    total_entry_size = last_entry * 4; /* 4 bytes per entry */

    /* init variables */
    *beg = 0;
    *end = last_entry;
    addr = ENTRY_START_OFFSET;
    entry_number = 1;

    track_number += 1;	/* physical track = user logical track + 1 */
    track_number = hex2bcd[track_number]; /* entry is bcd format */

	    /* get entry data */
    scratch_buf = (char *)((addr | x2000000)& x0fffffff);

	/* Go through each entry and find beg and end entry of the track */
    for (i = 0; i < total_entry_size; i++) {
	    /* check if we change track */
	    if ((track_number == scratch_buf[4*i]) && (*beg == 0)) {
		*beg = entry_number;
	    } else if (track_number < scratch_buf[4*i]) {
		*end = entry_number - 1;
		break;
	    }

	    entry_number++;
    }

    if (!(*beg))
	return (0);

    return ((*end - *beg) + 1);	/* total number of entries */
}

/*------------------------------------------------------------------------
  Function:

  Parameters:

  Description:
    Given a mmssff CDtime, find out the the entry number in the track
    that CDtime is in the entry play period.
------------------------------------------------------------------------*/
int get_entry_number(int CDtime)
{
    int last_entry;
    int total_entry_size;
    unsigned char track_number = 0;
    int entry_number;
    int previous_number;
    int i, index;
    int entry;
    int addr;
    int time;
    unsigned char *scratch_buf;


    if (CDtime == 0) /* In trick modes currCDtime often gets reset */
	CDtime = stopCDtime;

    last_entry = get_total_entry_number();
    total_entry_size = last_entry * 4; /* 4 bytes per entry */

    addr = ENTRY_START_OFFSET;
    entry_number = 1;

    scratch_buf = (char *)((addr | x2000000)& x0fffffff);

    for (i = 0; i < total_entry_size; i++) {
	    index = i<<2;
	    previous_number = entry_number;

	    /* check if we change track */
	    if (track_number != scratch_buf[index]) {
		entry_number = 1;
		track_number = scratch_buf[index];
	    } else {
		entry_number++;
	    }