myminimad.c

[plain] 
/*  
 * 本程序是從 minimad 改進而來，如要更詳細的說明請參看 minimad.c 
 * 
 * MyMinimad.c , 2008/09/17 , SiChuan University , China 
 * 
 * 編譯： gcc MyMinimad.c -o MyMinimad -lmad -g -Wall 
 * 運行： ./MyMinimad filename.mp3 
 */ 
# include <stdio.h> 
# include <stdlib.h> 
# include <unistd.h> 
# include <sys/stat.h> 
# include <sys/mman.h> 
# include <sys/soundcard.h> 
# include <sys/ioctl.h> 
# include <sys/fcntl.h> 
# include <sys/types.h> 
# include <mad.h> 
struct buffer { 
    unsigned char const *start; 
    unsigned long length; 
}; 
static int sfd;         /*聲音設備的描述符 */ 
static int decode(unsigned char const *, unsigned long); 
int main(int argc, char *argv[]) 
{ 
    struct stat stat; 
    void *fdm; 
    char const *file; 
    int fd; 
    file = argv[1]; 
    fd = open(file, O_RDONLY); 
    if ((sfd = open("/dev/dsp", O_WRONLY)) < 0) { 
    printf("can not open device!!!/n"); 
    return 5; 
    } 
    ioctl(sfd, SNDCTL_DSP_SYNC, 0); /*此句可以不要 */ 
    if (fstat(fd, &stat) == -1 || stat.st_size == 0) 
    return 2; 
    fdm = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, fd, 0); 
    if (fdm == MAP_FAILED) 
    return 3; 
    decode(fdm, stat.st_size); 
    if (munmap(fdm, stat.st_size) == -1) 
    return 4; 
    ioctl(sfd, SNDCTL_DSP_RESET, 0); 
    close(sfd); 
    return 0; 
} 
static 
enum mad_flow input(void *data, struct mad_stream *stream) 
{ 
    struct buffer *buffer = data; 
    if (!buffer->length) 
    return MAD_FLOW_STOP; 
    mad_stream_buffer(stream, buffer->start, buffer->length); 
    buffer->length = 0; 
    return MAD_FLOW_CONTINUE; 
} 
/*這一段是處理采樣後的pcm音頻 */ 
static inline signed int scale(mad_fixed_t sample) 
{ 
    sample += (1L << (MAD_F_FRACBITS - 16)); 
    if (sample >= MAD_F_ONE) 
    sample = MAD_F_ONE - 1; 
    else if (sample < -MAD_F_ONE) 
    sample = -MAD_F_ONE; 
    return sample >> (MAD_F_FRACBITS + 1 - 16); 
} 
static 
enum mad_flow output(void *data, 
             struct mad_header const *header, struct mad_pcm *pcm) 
{ 
    unsigned int nchannels, nsamples, n; 
    mad_fixed_t const *left_ch, *right_ch; 
    unsigned char Output[6912], *OutputPtr; 
    int fmt, wrote, speed; 
 
    nchannels = pcm->channels; 
    n = nsamples = pcm->length; 
    left_ch = pcm->samples[0]; 
    right_ch = pcm->samples[1]; 
 
    fmt = AFMT_S16_LE; 
    speed = pcm->samplerate * 2; /*播放速度是采樣率的兩倍 */ 
    ioctl(sfd, SNDCTL_DSP_SPEED, &(speed)); 
    ioctl(sfd, SNDCTL_DSP_SETFMT, &fmt); 
    ioctl(sfd, SNDCTL_DSP_CHANNELS, &(pcm->channels)); 
    OutputPtr = Output; 
    while (nsamples--) { 
    signed int sample; 
    sample = scale(*left_ch++); 
    *(OutputPtr++) = sample >> 0; 
    *(OutputPtr++) = sample >> 8; 
    if (nchannels == 2) { 
        sample = scale(*right_ch++); 
        *(OutputPtr++) = sample >> 0; 
        *(OutputPtr++) = sample >> 8; 
    } 
    } 
    n *= 4;         /*數據長度為pcm音頻采樣的4倍 */ 
    OutputPtr = Output; 
    while (n) { 
    wrote = write(sfd, OutputPtr, n); 
    OutputPtr += wrote; 
    n -= wrote; 
    } 
    OutputPtr = Output; 
    return MAD_FLOW_CONTINUE; 
} 
 
static 
enum mad_flow error(void *data, 
            struct mad_stream *stream, struct mad_frame *frame) 
{ 
    return MAD_FLOW_CONTINUE; 
} 
 
static 
int decode(unsigned char const *start, unsigned long length) 
{ 
    struct buffer buffer; 
    struct mad_decoder decoder; 
    int result; 
    buffer.start = start; 
    buffer.length = length; 
    mad_decoder_init(&decoder, &buffer, input, 0, 0, output, error, 0); 
    mad_decoder_options(&decoder, 0); 
    result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC); 
    mad_decoder_finish(&decoder); 
    return result; 
}