www.pudn.com > MyPlayerbylqh.rar > interface.cpp

 
#include  
#include  
 
#include  
 
#include "mpg123.h" 
#include "mpglib.h" 
 
struct mpstr *gmp; 
 
extern int head_check(unsigned long head); 
 
/** 
 * 
 **/ 
 
BOOL InitMP3 (struct mpstr *mp)  
{ 
	static int init = 0; 
 
	memset (mp, 0, sizeof (struct mpstr)); 
 
	mp->framesize = 0; 
	mp->fsizeold = -1; 
	mp->bsize = 0; 
	mp->head = mp->tail = NULL; 
	mp->fr.single = -1; 
	mp->bsnum = 0; 
	mp->synth_bo = 1; 
	mp->tail = NULL; 
 
	if (!init) { 
		init = 1; 
		make_decode_tables (32767); 
		init_layer2 (); 
		init_layer3 (SBLIMIT); 
	} 
 
	return 0; 
} 
 
 
/** 
 * 
 **/ 
 
void ExitMP3 (struct mpstr *mp) 
{ 
	struct buf *b,*bn; 
 
	b = mp->tail; 
	 
	while(b != NULL) { 
		 
		if(b->pnt != NULL) { 
			 
			free(b->pnt); 
		} 
		 
		bn = b->next; 
		free(b); 
		 
		b = bn; 
	} 
 
	mp->tail = NULL; 
} 
 
 
/** 
 * 
 **/ 
 
static struct buf *addbuf (struct mpstr *mp,char *buf,int size) 
{ 
	struct buf *nbuf; 
 
	if (!(nbuf = (struct buf *) new char[sizeof(struct buf)])) { 
	  return NULL; 
	} 
 
	if (!(nbuf->pnt = (unsigned char *) new char[size])) { 
		free (nbuf); 
		return NULL; 
	} 
	nbuf->size = size; 
	memcpy (nbuf->pnt,buf,size); 
	nbuf->next = NULL; 
	nbuf->prev = mp->head; 
	nbuf->pos = 0; 
 
	if(!mp->tail) 
		mp->tail = nbuf; 
	else 
		mp->head->next = nbuf; 
 
	mp->head = nbuf; 
	mp->bsize += size; 
 
	return nbuf; 
} 
 
 
/** 
 * 
 **/ 
 
static void remove_buf(struct mpstr *mp) 
{ 
	struct buf *buf = mp->tail; 
   
	if ((mp->tail = buf->next)) 
		mp->tail->prev = NULL; 
	else  
		mp->tail = mp->head = NULL; 
   
	free (buf->pnt); 
	free (buf); 
} 
 
 
/** 
 * 
 **/ 
 
static int _read_buf_byte (struct mpstr *mp) 
{ 
	unsigned int b; 
 
	int pos; 
 
	if(mp == NULL || mp->tail == NULL) { 
	  return -1; 
	} 
 
	pos = mp->tail->pos; 
	while (pos >= mp->tail->size) { 
		remove_buf (mp); 
		 
		if(mp == NULL || mp->tail == NULL) { 
		  return -1; 
		} 
		 
		pos = mp->tail->pos; 
		if (!mp->tail) { 
		  return -1; 
		} 
	} 
 
	b = mp->tail->pnt[pos]; 
	mp->bsize--; 
	mp->tail->pos++; 
	 
 
	return b; 
} 
 
 
/** 
 * 
 **/ 
 
 
static void read_head (struct mpstr *mp) 
{ 
  uint32_t head; 
 
  head = _read_buf_byte (mp) & 0xFF; 
 
  mp->header <<= 8; 
  mp->header |= head; 
} 
 
 
/** 
 * 
 **/ 
 
int decodeMP3(struct mpstr *mp,char *in,int isize,char *out, 
		int osize,int *done) 
{ 
	int len; 
 
	gmp = mp; 
 
 
	if(osize < 4608) { 
	  return MP3_ERR; 
	} 
 
	if(in  && !addbuf(mp, in, isize)) { 
	  return MP3_ERR; 
	} 
 
 
	if (!mp->framesize) { 
	   
	  if(mp->bsize < 4) 
	    return MP3_NEED_MORE; 
	   
	  read_head(mp); 
	   
	  while(!head_check(mp->header)) { 
	    read_head(mp); 
	  } 
 
 
	  if(decode_header(&mp->fr,mp->header) == -1) { 
	    return MP3_ERR; 
	  } 
	   
	  mp->framesize = mp->fr.framesize; 
	} 
 
 
	if(mp->fr.framesize > mp->bsize) 
		return MP3_NEED_MORE; 
 
	wordpointer = mp->bsspace[mp->bsnum] + 512; 
	mp->bsnum = (mp->bsnum + 1) & 0x1; 
	bitindex = 0; 
 
	len = 0; 
	while (len < mp->framesize) { 
		int nlen; 
		int blen = mp->tail->size - mp->tail->pos; 
 
		if ((mp->framesize - len) <= blen) { 
			nlen = mp->framesize-len; 
		} else { 
			nlen = blen; 
                } 
 
		memcpy (wordpointer+len,mp->tail->pnt+mp->tail->pos,nlen); 
                len += nlen; 
                mp->tail->pos += nlen; 
		mp->bsize -= nlen; 
 
                if(mp->tail->pos == mp->tail->size) 
                   remove_buf(mp); 
	} 
 
 
	*done = 0; 
	if(mp->fr.error_protection) 
		getbits(16); 
 
        switch(mp->fr.lay) { 
	case 1: 
 
		do_layer1 (&mp->fr, (uint8_t *) out, done); 
		break; 
	case 2: 
 
		do_layer2 (&mp->fr, (uint8_t *) out, done); 
		break; 
	case 3: 
 
		do_layer3 (&mp->fr, (uint8_t *) out, done); 
		break; 
	} 
 
 
	mp->fsizeold = mp->framesize; 
	mp->framesize = 0; 
 
	return MP3_OK; 
} 
 
 
/** 
 * 
 **/ 
 
int set_pointer(long backstep) 
{ 
	uint8_t *bsbufold; 
 
	if(gmp->fsizeold < 0 && backstep > 0) { 
	  return MP3_ERR; 
	} 
 
	bsbufold = gmp->bsspace[gmp->bsnum] + 512; 
	wordpointer -= backstep; 
 
	if (backstep) 
		memcpy(wordpointer,bsbufold+gmp->fsizeold-backstep,backstep); 
 
	bitindex = 0; 
	return MP3_OK; 
}