diff options
Diffstat (limited to 'src/libmpg123/common.c')
| -rwxr-xr-x | src/libmpg123/common.c | 746 |
1 files changed, 746 insertions, 0 deletions
diff --git a/src/libmpg123/common.c b/src/libmpg123/common.c new file mode 100755 index 0000000..80c299d --- /dev/null +++ b/src/libmpg123/common.c @@ -0,0 +1,746 @@ +/*** +#include <ctype.h> +#include <stdlib.h> +#include <signal.h> + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include "config.h" +***/ + +/* #ifdef HAVE_MMAP */ +/*** +# if 0 +#include <sys/mman.h> +#ifndef MAP_FAILED +#define MAP_FAILED ( (void *) -1 ) +#endif +#endif +***/ + +#include "mpg123.h" +/*** +#include "id3.h" +#include "id3_header.h" +***/ + +/* max = 1728 */ +#define MAXFRAMESIZE 1792 + +int tabsel_123[2][3][16] = +{ + { + {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,}, + {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,}, + {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}}, + + { + {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,}, + {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}, + {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}} +}; + +long mpg123_freqs[9] = +{44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000}; + +struct bitstream_info bsi; + +extern gint mpg123_bitrate, mpg123_frequency, mpg123_length; +extern gchar *mpg123_title, *mpg123_filename; +extern gboolean mpg123_stereo; + +static int fsizeold = 0, ssize; +static unsigned char bsspace[2][MAXFRAMESIZE + 512]; /* MAXFRAMESIZE */ +static unsigned char *bsbuf = bsspace[1], *bsbufold; +///static int bsnum = 0; + +unsigned char *mpg123_pcm_sample; +int mpg123_pcm_point = 0; + +static FILE *filept; +///static int filept_opened; + +///static int get_fileinfo(void); + +/*** +static int fullread(FILE * fd, unsigned char *buf, int count) +{ + int ret, cnt = 0; + + while (cnt < count) + { + if (fd) + ret = fread(buf + cnt, 1, count - cnt, fd); + else + ret = mpg123_http_read(buf + cnt, count - cnt); + if (ret < 0) + return ret; + if (ret == 0) + break; + cnt += ret; + } + return cnt; +} + +#define HDRCMPMASK 0xfffffd00 +***/ + +/* #ifdef HAVE_MMAP */ +# if 0 +/*** +static unsigned char *mapbuf; +static unsigned char *mappnt; +static unsigned char *mapend; + +static int stream_init(void) +{ + long len; + + len = get_fileinfo(); + if (len < 0) + return -1; + + mappnt = mapbuf = + mmap(NULL, len, PROT_READ, MAP_SHARED, filept, 0); + if (!mapbuf || mapbuf == MAP_FAILED) + return -1; + + mapend = mapbuf + len; + + return 0; +} + +static void stream_rewind(void) +{ + mappnt = mapbuf; +} + +void mpg123_stream_close(void) +{ + if (filept) + { + munmap(mapbuf, mapend - mapbuf); + close(filept); + } + else + mpg123_http_close(); + +} + +static int stream_head_read(unsigned long *newhead) +{ + unsigned long nh; + + if (filept) + { + + if (mappnt + 4 > mapend) + return FALSE; + + nh = (*mappnt++) << 24; + nh |= (*mappnt++) << 16; + nh |= (*mappnt++) << 8; + nh |= (*mappnt++); + + *newhead = nh; + + } + else + { + unsigned char hbuf[4]; + + if (fullread(filept, hbuf, 4) != 4) + return FALSE; + + *newhead = ((unsigned long) hbuf[0] << 24) | + ((unsigned long) hbuf[1] << 16) | + ((unsigned long) hbuf[2] << 8) | + (unsigned long) hbuf[3]; + } + return TRUE; + +} + +static int stream_head_shift(unsigned long *head) +{ + + if (filept) + { + if (mappnt + 1 > mapend) + return FALSE; + *head <<= 8; + *head |= *mappnt++; + *head &= 0xffffffff; + } + else + { + unsigned char hbuf; + + if (fullread(filept, &hbuf, 1) != 1) + return 0; + *head <<= 8; + *head |= hbuf; + *head &= 0xffffffff; + } + return TRUE; +} + +static int stream_mpg123_read_frame_body(unsigned char *buf, + int size) +{ + if (filept) + { +#if 1 + if (mappnt + size > mapend) + return FALSE; +#else + long l; + + if (size > (mapend - mappnt)) + { + l = mapend - mappnt; + memcpy(buf, mappnt, l); + memset(buf + l, 0, size - l); + } + else +#endif + memcpy(buf, mappnt, size); + + mappnt += size; + } + else + { + long l; + + if ((l = fullread(filept, buf, size)) != size) + { + if (l <= 0) + return 0; + memset(buf + l, 0, size - l); + } + } + + return TRUE; +} + +static int stream_back_bytes(int bytes) +{ + if ((mappnt - bytes) < mapbuf || (mappnt - bytes + 4) > mapend) + return -1; + mappnt -= bytes; + return 0; +} + +static long stream_tell(void) +{ + return mappnt - mapbuf; +} + +void mpg123_stream_jump_to_frame(struct frame *fr, int frame) +{ + if (mapbuf + frame * (fr->framesize + 4) < mapend) + { + mpg123__init(); + stream_rewind(); + mpg123_read_frame(fr); + mappnt = mapbuf + frame * (fr->framesize + 4); + + mpg123_read_frame(fr); + } +} + +void mpg123_stream_jump_to_byte(struct frame *fr, int byte) +{ + if (mapbuf + byte < mapend) + { + mappnt = mapbuf + byte; + mpg123_read_frame(fr); + } +} + +int mpg123_stream_check_for_xing_header(struct frame *fr, XHEADDATA * xhead) +{ + unsigned char *head_data; + int ret = 0; + + stream_back_bytes(fr->framesize + 4); + + if (mappnt + (fr->framesize + 4) < mapend) + { + ret = mpg123_get_xing_header(xhead, mappnt); + mappnt += fr->framesize + 4; + } + return ret; +} +***/ +#else +/*** +static int stream_init(void) +{ + if (get_fileinfo() < 0) + return -1; + return 0; +} + +void mpg123_stream_close(void) +{ +*//* if (flags & READER_FD_OPENED) *//* + if (filept) + fclose(filept); + else + mpg123_http_close(); +} +***/ + +/**************************************** + * HACK,HACK,HACK: step back <num> frames + * can only work if the 'stream' isn't a real stream but a file + */ +/*** +static int stream_back_bytes(int bytes) +{ + if (fseek(filept, -bytes, SEEK_CUR) < 0) + return -1; + return 0; +} + +static int stream_head_read(unsigned long *newhead) +{ + unsigned char hbuf[4]; + + if (fullread(filept, hbuf, 4) != 4) + return FALSE; + + *newhead = ((unsigned long) hbuf[0] << 24) | + ((unsigned long) hbuf[1] << 16) | + ((unsigned long) hbuf[2] << 8) | + (unsigned long) hbuf[3]; + + return TRUE; +} + +static int stream_head_shift(unsigned long *head) +{ + unsigned char hbuf; + + if (fullread(filept, &hbuf, 1) != 1) + return 0; + *head <<= 8; + *head |= hbuf; + *head &= 0xffffffff; + return 1; +} + +static int stream_mpg123_read_frame_body(unsigned char *buf, + int size) +{ + long l; + + if ((l = fullread(filept, buf, size)) != size) + { + if (l <= 0) + return 0; + memset(buf + l, 0, size - l); + } + return 1; +} + +static long stream_tell(void) +{ + return ftell(filept); +} + +static void stream_rewind(void) +{ + fseek(filept, 0, SEEK_SET); +} + +int mpg123_stream_jump_to_frame(struct frame *fr, int frame) +{ + if (!filept) + return -1; + mpg123_read_frame_init(); + fseek(filept, frame * (fr->framesize + 4), SEEK_SET); + mpg123_read_frame(fr); + return 0; +} + +int mpg123_stream_jump_to_byte(struct frame *fr, int byte) +{ + if (!filept) + return -1; + fseek(filept, byte, SEEK_SET); + mpg123_read_frame(fr); + return 0; +} +***/ + +int mpg123_stream_check_for_xing_header(struct frame *fr, XHEADDATA * xhead) +{ + unsigned char *head_data; + int ret; + + fseek(filept, -(fr->framesize + 4), SEEK_CUR); + head_data = g_malloc(fr->framesize + 4); + fread(head_data, 1, fr->framesize + 4, filept); + ret = mpg123_get_xing_header(xhead, head_data); + g_free(head_data); + return ret; +} + +#endif + +/*** +static int get_fileinfo(void) +{ + guchar buf[3]; + + if (filept == NULL) + return -1; + if (fseek(filept, 0, SEEK_END) < 0) + return -1; + + mpg123_info->filesize = ftell(filept); + if (fseek(filept, -128, SEEK_END) < 0) + return -1; + if (fullread(filept, buf, 3) != 3) + return -1; + if (!strncmp(buf, "TAG", 3)) + mpg123_info->filesize -=128; + if (fseek(filept, 0, SEEK_SET) < 0) + return -1; + + if (mpg123_info->filesize <= 0) + return -1; + + return mpg123_info->filesize; +} +***/ + +/*** +void mpg123_read_frame_init(void) +{ + memset(bsspace[0],0,MAXFRAMESIZE + 512); + memset(bsspace[1],0,MAXFRAMESIZE + 512); + mpg123_info->output_audio = FALSE; +} +***/ + +/* + * Function read_id3v2_tag (head) + * + * Read ID3v2 tag from stream. Return TRUE upon success, or FALSE if + * an error occurred. + * + */ +/*** +static gboolean read_id3v2_tag(unsigned long head) +{ + struct + { + char id3[3]; + struct id3_taghdr_t tag; + } id3header; + char *id3buf; + int hdrsize; + id3_t *id3d; + struct id3tag_t tag; + *//* + * Read ID3tag header. + *//* + *(unsigned long *) &id3header = g_htonl(head); + if (fullread(filept, ((char *) &id3header) + sizeof (head), + sizeof (id3header) - sizeof (head)) + != sizeof (id3header) - sizeof (head)) + return FALSE; + + hdrsize = ID3_GET_SIZE28(g_ntohl(id3header.tag.th_size)); + + *//* + * A invalid header could fool us into requesting insane + * amounts of memory. Make sure the header size is + * reasonable. + *//* + if ((mpg123_info->filesize && hdrsize > mpg123_info->filesize) || + (!mpg123_info->filesize && hdrsize > 1000000)) + return FALSE; + + if (mpg123_cfg.disable_id3v2) + { + guint8 *tmp = g_malloc(hdrsize); + gboolean ret; + ret = (fullread(filept, tmp, hdrsize) == hdrsize); + g_free(tmp); + return ret; + } + + id3buf = g_malloc(hdrsize + sizeof (id3header)); + memcpy(id3buf, &id3header, sizeof (id3header)); + + *//* + * Read ID3tag body. + *//* + if (fullread(filept, id3buf + sizeof (id3header), hdrsize) != hdrsize) + { + g_free(id3buf); + return FALSE; + } + + *//* + * Get info from tag. + *//* + if ((id3d = id3_open_mem(id3buf, 0)) != NULL) + { + mpg123_get_id3v2(id3d, &tag); + if (!mpg123_info->first_frame) + { + char *songname = mpg123_title; + mpg123_title = + mpg123_format_song_title(&tag, mpg123_filename); + mpg123_ip.set_info(mpg123_title, mpg123_length, + mpg123_bitrate * 1000, + mpg123_frequency, mpg123_stereo); + if (songname) + g_free(songname); + } + else + { + mpg123_title = mpg123_format_song_title(&tag, + mpg123_filename); + } + id3_close(id3d); + } + g_free(id3buf); + + return TRUE; +} +***/ + +int mpg123_head_check(unsigned long head) +{ + if ((head & 0xffe00000) != 0xffe00000) + return FALSE; + if (!((head >> 17) & 3)) + return FALSE; + if (((head >> 12) & 0xf) == 0xf) + return FALSE; + if (!((head >> 12) & 0xf)) + return FALSE; + if (((head >> 10) & 0x3) == 0x3) + return FALSE; + if (((head >> 19) & 1) == 1 && ((head >> 17) & 3) == 3 && ((head >> 16) & 1) == 1) + return FALSE; + if ((head & 0xffff0000) == 0xfffe0000) + return FALSE; + + return TRUE; +} + +/***************************************************************** + * read next frame + */ +/*** +int mpg123_read_frame(struct frame *fr) +{ + unsigned long newhead; + + fsizeold = fr->framesize; *//* for Layer3 *//* + + if (!stream_head_read(&newhead)) + return FALSE; + + if (!mpg123_head_check(newhead) || !mpg123_decode_header(fr, newhead)) + { + int try = 0; + + do + { + try++; + if ((newhead & 0xffffff00) == ('I' << 24) + ('D' << 16) + ('3' << 8)) + { + read_id3v2_tag(newhead); + if (!stream_head_read(&newhead)) + return FALSE; + } + else if (!stream_head_shift(&newhead)) + return 0; + + } + while ((!mpg123_head_check(newhead) || + !mpg123_decode_header(fr,newhead)) && + try < (256 * 1024)); + if(try >= (256 * 1024)) + return FALSE; + + mpg123_info->filesize -= try; + } + *//* flip/init buffer for Layer 3 *//* + bsbufold = bsbuf; + bsbuf = bsspace[bsnum] + 512; + bsnum = (bsnum + 1) & 1; + + if (!stream_mpg123_read_frame_body(bsbuf, fr->framesize)) + return 0; + + bsi.bitindex = 0; + bsi.wordpointer = (unsigned char *) bsbuf; + + + return 1; + +} +***/ + +/* + * the code a header and write the information + * into the frame structure + */ +int mpg123_decode_header(struct frame *fr, unsigned long newhead) +{ + if (newhead & (1 << 20)) + { + fr->lsf = (newhead & (1 << 19)) ? 0x0 : 0x1; + fr->mpeg25 = 0; + } + else + { + fr->lsf = 1; + fr->mpeg25 = 1; + } + fr->lay = 4 - ((newhead >> 17) & 3); + if (fr->mpeg25) + { + fr->sampling_frequency = 6 + ((newhead >> 10) & 0x3); + } + else + fr->sampling_frequency = ((newhead >> 10) & 0x3) + (fr->lsf * 3); + fr->error_protection = ((newhead >> 16) & 0x1) ^ 0x1; + + if (fr->mpeg25) /* allow Bitrate change for 2.5 ... */ + fr->bitrate_index = ((newhead >> 12) & 0xf); + + fr->bitrate_index = ((newhead >> 12) & 0xf); + fr->padding = ((newhead >> 9) & 0x1); + fr->extension = ((newhead >> 8) & 0x1); + fr->mode = ((newhead >> 6) & 0x3); + fr->mode_ext = ((newhead >> 4) & 0x3); + fr->copyright = ((newhead >> 3) & 0x1); + fr->original = ((newhead >> 2) & 0x1); + fr->emphasis = newhead & 0x3; + + fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2; + + ssize = 0; + + if (!fr->bitrate_index) + return (0); + + switch (fr->lay) + { + case 1: + fr->do_layer = mpg123_do_layer1; + mpg123_init_layer2(); /* inits also shared tables with layer1 */ + fr->framesize = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000; + fr->framesize /= mpg123_freqs[fr->sampling_frequency]; + fr->framesize = ((fr->framesize + fr->padding) << 2) - 4; + break; + case 2: + fr->do_layer = mpg123_do_layer2; + mpg123_init_layer2(); /* inits also shared tables with layer1 */ + fr->framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000; + fr->framesize /= mpg123_freqs[fr->sampling_frequency]; + fr->framesize += fr->padding - 4; + break; + case 3: + fr->do_layer = mpg123_do_layer3; + if (fr->lsf) + ssize = (fr->stereo == 1) ? 9 : 17; + else + ssize = (fr->stereo == 1) ? 17 : 32; + if (fr->error_protection) + ssize += 2; + fr->framesize = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000; + fr->framesize /= mpg123_freqs[fr->sampling_frequency] << (fr->lsf); + fr->framesize = fr->framesize + fr->padding - 4; + break; + default: + return (0); + } + if(fr->framesize > MAXFRAMESIZE) + return 0; + return 1; +} + +/*** +void mpg123_open_stream(char *bs_filenam, int fd) +{ + filept_opened = 1; + if (!strncasecmp(bs_filenam, "http://", 7)) + { + filept = NULL; + mpg123_http_open(bs_filenam); + mpg123_info->filesize = 0; + } + else + { + if ((filept = fopen(bs_filenam, "rb")) != NULL) + { + if (stream_init() == -1) + { + mpg123_info->eof = 1; + } + } + else + mpg123_info->eof = 1; + } + +} +***/ + +void mpg123_set_pointer(long backstep) +{ + bsi.wordpointer = bsbuf + ssize - backstep; + if (backstep) + memcpy(bsi.wordpointer, bsbufold + fsizeold - backstep, backstep); + bsi.bitindex = 0; +} + +double mpg123_compute_bpf(struct frame *fr) +{ + double bpf; + + switch (fr->lay) + { + case 1: + bpf = tabsel_123[fr->lsf][0][fr->bitrate_index]; + bpf *= 12000.0 * 4.0; + bpf /= mpg123_freqs[fr->sampling_frequency] << (fr->lsf); + break; + case 2: + case 3: + bpf = tabsel_123[fr->lsf][fr->lay - 1][fr->bitrate_index]; + bpf *= 144000; + bpf /= mpg123_freqs[fr->sampling_frequency] << (fr->lsf); + break; + default: + bpf = 1.0; + } + + return bpf; +} + +/*** +int mpg123_calc_numframes(struct frame *fr) +{ + return (int) (mpg123_info->filesize / mpg123_compute_bpf(fr)); +} + +double mpg123_relative_pos(void) +{ + if (!filept || !mpg123_info->filesize) + return 0; + return ((double) stream_tell()) / mpg123_info->filesize; +} +***/ |