common.c

MPEG 2的音频编码软件。喜欢多媒体的开发人员可以看看。

register SANE_EXT       *p_ext;
SANE_EXT ext_align;
char *c_align;
int i;

   p_dbl = (IEEE_DBL *) pd;
   p_ext = &ext_align;
   top2bits = p_dbl->hi & 0xc0000000;
   p_ext->l1 = ((p_dbl->hi >> 4) & 0x3ff0000) | top2bits;
   p_ext->l1 |= ((p_dbl->hi >> 5) & 0x7fff) | 0x8000;
   p_ext->l2 = (p_dbl->hi << 27) & 0xf8000000;
   p_ext->l2 |= ((p_dbl->lo >> 5) & 0x07ffffff);
   ps2 = (unsigned short *) & (p_dbl->lo);
   ps2++;
   p_ext->s1 = (*ps2 << 11) & 0xf800;

   c_align = (char *) p_ext;
   for (i=0;i<10;i++)
     ps[i] = c_align[i];

#endif

}


/*****************************************************************************
*
*  extended_to_double()
*
*  Purpose:     Convert from SANE extended format to IEEE double precision
*               format.
*
*  Passed:      Pointer to the Apple SANE extended format value and a pointer
*               to what will hold the the IEEE double precision number.
*
*  Outputs:     The IEEE double precision format pointer will be filled with
*               the converted value.
*
*  Returned:    Nothing.
*
*****************************************************************************/

void    extended_to_double(char *ps, double *pd)
{

#ifdef  MACINTOSH

   x80tox96((extended *) ps, pd);

#else

/* fixed bus alignment error, HP 27-may-93 */

register unsigned long  top2bits;

register IEEE_DBL       *p_dbl;
register SANE_EXT       *p_ext;
SANE_EXT ext_align;
char *c_align;
int i;

   p_dbl = (IEEE_DBL *) pd;
   p_ext = &ext_align;

   c_align = (char *) p_ext;
   for (i=0;i<10;i++)
     c_align[i] = ps[i];

   top2bits = p_ext->l1 & 0xc0000000;
   p_dbl->hi = ((p_ext->l1 << 4) & 0x3ff00000) | top2bits;
   p_dbl->hi |= (p_ext->l1 << 5) & 0xffff0;
   p_dbl->hi |= (p_ext->l2 >> 27) & 0x1f;
   p_dbl->lo = (p_ext->l2 << 5) & 0xffffffe0;
   p_dbl->lo |= (unsigned long) ((p_ext->s1 >> 11) & 0x1f);

#endif

}

/*****************************************************************************
*
*  Read Audio Interchange File Format (AIFF) headers.
*
*****************************************************************************/

int aiff_read_headers (FILE *file_ptr, IFF_AIFF *aiff_ptr, int *byte_per_sample)
{

    register char   i;
    register long   seek_offset;
    
    char				 temp_sampleRate[10];
    char				 *dummy;
    char				 holder;
    Chunk           FormChunk;
    CommonChunk     CommChunk;
    SoundDataChunk  SndDChunk;
    identifier		 ident;

    if (fseek (file_ptr, 0, SEEK_SET) != 0)
	return (-1);

    if (fread (&FormChunk, sizeof (Chunk), 1, file_ptr) != 1)
	return (-1);

#ifdef MSDOS
    holder = FormChunk.ckID[0];
    FormChunk.ckID[0] = FormChunk.ckID[3];
    FormChunk.ckID[3] = holder;
    holder = FormChunk.ckID[1];
    FormChunk.ckID[1] = FormChunk.ckID[2];
    FormChunk.ckID[2] = holder;
/* fixed bug in next line, HP 27-may-93 */
    holder = FormChunk.formType[0];
    FormChunk.formType[0] = FormChunk.formType[3];
    FormChunk.formType[3] = holder;
    holder = FormChunk.formType[1];
    FormChunk.formType[1] = FormChunk.formType[2];
    FormChunk.formType[2] = holder;
    FormChunk.ckSize = _lrotl(FormChunk.ckSize, 8);
#endif


/* fixed bug in next line, HP 27-may-93 */
    if (strncmp (FormChunk.ckID, IFF_ID_FORM, 4) != 0 ||
	strncmp (FormChunk.formType, IFF_ID_AIFF, 4) != 0)
	return (-1); 	/* warning: different levels of indirection.7/8/92.sr*/

    if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
	return (-1);

#ifdef MSDOS
    holder = ident.name[0];
    ident.name[0] = ident.name[3];
    ident.name[3] = holder;
    holder = ident.name[1];
    ident.name[1] = ident.name[2];
    ident.name[2] = holder;
    ident.ck_length = _lrotl (ident.ck_length, 8);
#endif

/* fixed bug in next line, HP 27-may-93 */
    while (strncmp (ident.name, IFF_ID_COMM, 4) != 0)
    {
	dummy = (char *) mem_alloc (ident.ck_length * sizeof (char),  "dummy");
	if (fread (dummy, ident.ck_length, 1, file_ptr) != 1)
	    return (-1);
	mem_free ((void **) &dummy);
/* fixed bug in next line, HP 27-may-93 */
	if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
	   return (-1);

#ifdef MSDOS
	holder = ident.name[0];
	ident.name[0] = ident.name[3];
	ident.name[3] = holder;
	holder = ident.name[1];
	ident.name[1] = ident.name[2];
	ident.name[2] = holder;
	ident.ck_length = _lrotl(ident.ck_length, 8);
#endif
    }

    for (i = 0; i < 4; ++i)
	CommChunk.ckID[i] = ident.name[i];

    CommChunk.ckSize = ident.ck_length;

    if (fread (&CommChunk.numChannels, sizeof (short), 1, file_ptr) != 1)
	return (-1);

    if (fread (&CommChunk.numSampleFrames, sizeof (unsigned long), 1, file_ptr) != 1)
	return (-1);

    if (fread (&CommChunk.sampleSize, sizeof (short), 1, file_ptr) != 1)
	return (-1);

    if (fread (CommChunk.sampleRate, sizeof (char[10]), 1, file_ptr) != 1)
	return (-1);

#ifdef MSDOS
    CommChunk.sampleSize = _rotl (CommChunk.sampleSize, 8);
    CommChunk.ckSize = _lrotl (CommChunk.ckSize, 8);
    CommChunk.numChannels = _rotl (CommChunk.numChannels, 8);
    CommChunk.numSampleFrames = _lrotl (CommChunk.numSampleFrames, 8);
#endif

    *byte_per_sample = ceil ((double) CommChunk.sampleSize / 8);

    for (i = 0; i < sizeof (char[10]); i++)
	temp_sampleRate[i] = CommChunk.sampleRate[i];

    extended_to_double (temp_sampleRate, &aiff_ptr->sampleRate);

/* to start the search again from the beginning, HP 27-may-93 */
    fseek (file_ptr, sizeof (Chunk), SEEK_SET);

    if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
	return (-1);

#ifdef MSDOS
    holder = ident.name[0];
    ident.name[0] = ident.name[3];
    ident.name[3] = holder;
    holder = ident.name[1];
    ident.name[1] = ident.name[2];
    ident.name[2] = holder;
    ident.ck_length = _lrotl (ident.ck_length, 8);
#endif

/* fixed bug in next line, HP 27-may-93 */
    while (strncmp (ident.name, IFF_ID_SSND, 4) != 0)
    {
	dummy = (char *) mem_alloc (ident.ck_length * sizeof (char),  "dummy");
	if (fread (dummy, ident.ck_length, 1, file_ptr) != 1)
	    return (-1);
	mem_free ((void **) &dummy);
	if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
	    return (-1);
/* the following lines are not necessary, HP 27-may-93 */
/*
	{
	fseek (file_ptr, 0, SEEK_SET);
	if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
	return (-1);
	}
*/

#ifdef MSDOS
	holder = ident.name[0];
	ident.name[0] = ident.name[3];
	ident.name[3] = holder;
	holder = ident.name[1];
	ident.name[1] = ident.name[2];
	ident.name[2] = holder;
	ident.ck_length = _lrotl (ident.ck_length, 8);
#endif
    }

    for (i = 0; i < 4; ++i)
	SndDChunk.ckID[i] = ident.name[i];
    SndDChunk.ckSize = ident.ck_length;

    if (fread (&SndDChunk.offset, sizeof (unsigned long), 1, file_ptr) != 1)
	return (-1);

    if (fread (&SndDChunk.blockSize, sizeof (unsigned long), 1, file_ptr) != 1)
	return (-1);

#ifdef MSDOS
    SndDChunk.offset = _lrotl (SndDChunk.offset, 8);
    SndDChunk.blockSize = _lrotl (SndDChunk.blockSize, 8);
#endif

/* why seek behinde the SSND Chunk ????, HP 27-may-93 */
/*
    seek_offset = SndDChunk.ckSize - sizeof (SoundDataChunk) + sizeof (ChunkHeader);

    if (fseek (file_ptr, seek_offset, SEEK_CUR) != 0)
	return (-1);
*/

    aiff_ptr->numChannels       = CommChunk.numChannels;
    aiff_ptr->numSampleFrames   = CommChunk.numSampleFrames;
    aiff_ptr->sampleSize        = CommChunk.sampleSize;
    aiff_ptr->blkAlgn.offset    = SndDChunk.offset;
    aiff_ptr->blkAlgn.blockSize = SndDChunk.blockSize;
    strncpy (aiff_ptr->sampleType, SndDChunk.ckID, 4);
 
    return (0);
}


/*****************************************************************************
*
*  Seek past some Audio Interchange File Format (AIFF) headers to sound data.
*
*****************************************************************************/

int aiff_seek_to_sound_data (FILE *file_ptr)
{
    if (fseek (file_ptr, sizeof (Chunk) + sizeof (SoundDataChunk), SEEK_SET) != 0)
	return (-1);
    else
	return (0);
}

/*******************************************************************************
*
*  Write Audio Interchange File Format (AIFF) headers.
*
*******************************************************************************/

int aiff_write_headers (FILE *file_ptr, IFF_AIFF *aiff_ptr)
{
    register char   i;
    register long   seek_offset;
    
    char            temp_sampleRate[10];
    
    Chunk           FormChunk;
    CommonChunk     CommChunk;
    SoundDataChunk  SndDChunk;

    strcpy (FormChunk.ckID, IFF_ID_FORM);
    strcpy (FormChunk.formType, IFF_ID_AIFF);
    strcpy (CommChunk.ckID, IFF_ID_COMM);  /*7/7/93,SR,changed FormChunk to CommChunk*/

    double_to_extended (&aiff_ptr->sampleRate, temp_sampleRate);

    for (i = 0; i < sizeof (char[10]); i++)
	CommChunk.sampleRate[i] = temp_sampleRate[i];

    CommChunk.numChannels             = aiff_ptr->numChannels;
    CommChunk.numSampleFrames         = aiff_ptr->numSampleFrames;
    CommChunk.sampleSize              = aiff_ptr->sampleSize;
    SndDChunk.offset                  = aiff_ptr->blkAlgn.offset;
    SndDChunk.blockSize               = aiff_ptr->blkAlgn.blockSize;
    strncpy (SndDChunk.ckID, aiff_ptr->sampleType,  4);
 
    CommChunk.ckSize = sizeof (CommChunk.numChannels) +
		       sizeof (CommChunk.numSampleFrames) +
		       sizeof (CommChunk.sampleSize) +
		       sizeof (CommChunk.sampleRate);
 
    SndDChunk.ckSize = sizeof (SoundDataChunk) - sizeof (ChunkHeader) +
	(CommChunk.sampleSize + BITS_IN_A_BYTE - 1) / BITS_IN_A_BYTE *
	CommChunk.numChannels * CommChunk.numSampleFrames;
 
    FormChunk.ckSize = sizeof (Chunk) + SndDChunk.ckSize + sizeof (ChunkHeader) +
	CommChunk.ckSize;
 
    if (fseek (file_ptr, 0, SEEK_SET) != 0)
	return (-1);
 
    if (fwrite (&FormChunk, sizeof (Chunk), 1, file_ptr) != 1)
	return (-1);
 
    if (fwrite (&SndDChunk, sizeof (SoundDataChunk), 1, file_ptr) != 1)
	return (-1);
 
    seek_offset = SndDChunk.ckSize - sizeof (SoundDataChunk) + sizeof (ChunkHeader);
 
    if (fseek (file_ptr, seek_offset, SEEK_CUR) != 0)
	return (-1);
 
    if (fwrite (CommChunk.ckID, sizeof (ID), 1, file_ptr) != 1)
	return (-1);
 
    if (fwrite (&CommChunk.ckSize, sizeof (long), 1, file_ptr) != 1)
	return (-1);
 
    if (fwrite (&CommChunk.numChannels, sizeof (short), 1, file_ptr) != 1)
	return (-1);
 
    if (fwrite (&CommChunk.numSampleFrames, sizeof (unsigned long), 1, file_ptr) != 1)
	return (-1);
 
    if (fwrite (&CommChunk.sampleSize, sizeof (short), 1, file_ptr) != 1)
	return (-1);
 
    if (fwrite (CommChunk.sampleRate, sizeof (char[10]), 1, file_ptr) != 1)
	return (-1);
 
    return (0);
}

/*****************************************************************************
*
*  bit_stream.c package
*  Author:  Jean-Georges Fritsch, C-Cube Microsystems
*
*****************************************************************************/

/********************************************************************
  This package provides functions to write (exclusive or read)
  information from (exclusive or to) the bit stream.

  If the bit stream is opened in read mode only the get functions are
  available. If the bit stream is opened in write mode only the put
  functions are available.
********************************************************************/

/* refill the buffer from the input device when the buffer becomes empty    */
int refill_buffer(Bit_stream_struc *bs)
                        /* bit stream structure */
{
   register int i=bs->buf_size-2-bs->buf_byte_idx;
   register unsigned long n;
   register int index=0;
   char val[2];

   while ((i>=0) && (!bs->eob)) {

      if (bs->format == BINARY)
         n = fread(&bs->buf[i--], sizeof(unsigned char), 1, bs->pt);

      else {
	  while((index < 2) && n) {
		n = fread(&val[index], sizeof(char), 1, bs->pt);
		switch (val[index]) {
			case 0x30: