srvmat.c

本程序为ST公司开发的源代码

/**************************************************
 *
 * srvmat.c
 *
 * CVS ID:   $Id: srvmat.c,v 1.14 2007/04/11 14:21:04 belardi Exp $
 * Author:   Fabio Dell'Orto [FD] - STM
 * Date:     $Date: 2007/04/11 14:21:04 $
 * Revision: $Revision: 1.14 $
 *
 * Description:
 *
 *
 ***************************************************
 *
 * COPYRIGHT (C) ST Microelectronics  2005
 *            All Rights Reserved
 *
 ***************************************************
 *
 * STM CVS Log:
 *
 * $Log: srvmat.c,v $
 * Revision 1.14  2007/04/11 14:21:04  belardi
 * Integration of HAVE_CD_MECHA modification by [GP]
 *
 * Revision 1.13  2007/01/09 08:32:12  chlapik
 * hex_2_bcd() function enabled - it is used in capture.c
 *
 * Revision 1.12  2006/11/25 08:15:44  belardi
 * Ununsed function removal to free code space
 *
 * Revision 1.11  2006/11/10 16:31:56  dellorto
 * sector_2_trk() function moved to srvctr.c/h
 *
 * Revision 1.10  2006/09/18 09:55:25  belardi
 * Corrected CVS keyword usage
 *
 * Revision 1.9  2006/09/18 09:25:37  belardi
 * Added Log CVS keyword into file header
 *
 *
 ***************************************************/

#include "gendef.h"
#include "hwreg.h"
#include "osal.h"
#include "srvact.h"
#include "srvdsp.h"
#include "srvmat.h"
#include "srvopu.h"

#if (HAVE_CD_MECHA == 1)

/******************************************************************************/
/* Function:  absi                                                            */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

uint16 absi(sint16 val)
{
  if ((val < 0) && (val != (sint16)(0x8000)))
  {
    val = -val;
  }

  return (uint16)(val);
}


/******************************************************************************/
/* Function:  sign                                                            */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

sint16 sign(sint16 val)
{
  if (val < 0)
  {
    return (-1);
  }
  if (val == 0)
  {
    return 0;
  }
  else
  {
    return 1;
  }
}


/******************************************************************************/
/* Function:  aux_mult                                                        */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

sint16 aux_mult(sint16 factor1, uint16 factor2)
{
  return (sign(factor1) * ((absi(factor1) * factor2) >> 16));
}


/******************************************************************************/
/* Function:  aux_divide                                                      */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

sint16 aux_divide(sint16 dividend, uint16 divisor)
{
  if ((absi(dividend) << 1) < divisor)
  {
    return (sign(dividend) * ((absi(dividend) << 16) / divisor));
  }
  else if (sign(dividend) == 1)
  {
    return ((sint16)(0x7FFF));
  }
  else
  {
    return ((sint16)(0x8000));
  }
}


/******************************************************************************/
/* Function:  square_root                                                     */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

uint16 square_root(uint32 x)
{
  uint32 y;
  uint32 t;
  sint8  n;

  y = 0;

  for (n = 15; n >= 0; n--)
  {
    t = y + (1 << n);
    if (x >= (t << n))
    {
      x -= (t << n);
      y |= (2 << n);
    }
  }

  y = y >> 1;

  if ((x > y) && (y != 0xFFFF))
  {
    y++;
  }

  return (y);
}

#endif // #if (HAVE_CD_MECHA == 1)

/******************************************************************************/
/* Function:  bcd_2_hex                                                       */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

uint8 bcd_2_hex(uint8 bcd_val)
{
  return  (uint8)((bcd_val & 0x0F) + ((bcd_val >> 4) * 10));
}


/******************************************************************************/
/* Function:  hex_2_bcd                                                       */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
#if 1 // [RB] unused
uint8 hex_2_bcd(uint8 hex_val)
{
  return  (uint8)(((hex_val / 10) << 4) + (hex_val % 10));
}
#endif

/******************************************************************************/
/* Function:  msf_2_sid                                                       */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

uint32 msf_2_sid(uint8 min, uint8 sec, uint8 frame, tHexBcdSelector format)
{
  uint32 sid;

  if (HEX != format)
  {
    min = bcd_2_hex(min);
    sec = bcd_2_hex(sec);
    frame = bcd_2_hex(frame);
  }

  sid  = frame;
  sid += sec * 75;
  sid += min * 4500L;

  return sid;
}


/******************************************************************************/
/* Function:  sid_2_msf                                                       */
/*                                                                            */
/*! \brief
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
#if 0 // [RB] unused
void sid_2_msf(uint8 *msf, uint32 sid)
{
  msf[MIN] = sid / 4500;
  msf[SEC] = (sid - msf[MIN] * 4500) / 75;
  msf[FRAME] = sid - msf[MIN] * 4500 - msf[SEC] * 75;

  /* alternative implementation: */
  /* msf[FRAME] = sid % 75;      */
  /* msf[SEC] = (sid / 75) % 60; */
  /* msf[MIN] = sid / 4500;      */
}
#endif