vcd.c

ESS3890+SL原代码（1*16内存）

/* Copyright 1996, ESS Technology, Inc.					*/
/* SCCSID @(#)vcd.c	4.7 11/10/03 */ 

/*
 * $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 "memmap.h"

#ifdef TWO_FIELDS_OSD
#include "cg.h"
#else
#include "fsosd.h"
#endif


#define GOOD			1
#define BAD			0

/* global variables */
unsigned int *TrackInfoAdr;
int PSD_start_addr;	/* start offset of PSD data in dram. */
int PSD_end_addr;	/* end offset of PSD data in dram. */
int PSD_size;			/* The size of PSD in bytes. */
unsigned char track_map[13];	/* track map for motion picture */

/*-----------------------------------------------------------
  Function: dump_info_vcd
-----------------------------------------------------------*/
int dump_info_vcd(uchar *infovcd_ptr)
{
    /* get the infovcd to system buffer */
    sram_to_dram(INFO_VCD_OFFSET, (int *)(infovcd_ptr + 56),
		 INFO_VCD_SIZE/4);

    return (GOOD);
}

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

    /* get the infovcd to system buffer */
    /*
     * Find out how many AV tracks are there. Any track higher than
     * that is a CDDA track!
     */
    ptr = (unsigned int *) ((unsigned char *) entries_ptr + 8);
    tmp1 = *ptr & 0xffff;		/* Number of entries used	*/
    ptr = (unsigned int *) ((unsigned char *) entries_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;
    }

    sram_to_dram(ENTRIES_VCD_OFFSET, (int *)entries_ptr,
		 ENTRIES_VCD_SIZE/4);

    return (GOOD);
}


/*-----------------------------------------------------------
  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. */
	/* Check neighboring bytes for valid segment start content */
	if (!(*(ptr-1) & 0x20)) ptr--;
	else if (!(*(ptr+1) & 0x20)) ptr++;
	else 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) {
	ptr = (char *) (dram_cached(INFO_VCD_start) + start_seg);
	end_ptr = (char *) (dram_cached(INFO_VCD_start) + INFO_VCD_SIZE);
	*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 = dram_cached(ENTRIES_VCD_OFFSET) + 8;

    /* get 4 bytes starting at addr */
    scratch_buf = (char *)(addr);

    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 = dram_cached(ENTRY_START_OFFSET) + 
	(entry_num - 1) * 4; /* 0 base */
    
    /* get 8 bytes starting at addr */
    scratch_buf = (char *)(addr);
    
    /* 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 = dram_cached(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);

	/* 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 = dram_cached(ENTRY_START_OFFSET);
    entry_number = 1;

    scratch_buf = (char *)(addr);

    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++;
	    }

	    time = *((unsigned int *)&scratch_buf[index]) & x00ffffff;
	    if (time > CDtime) {
		entry_number = previous_number;
		break;