/** 002 * libmad - MPEG audio decoder library 003 * Copyright (C) 2000-2004 Underbit Technologies, Inc. 004 * 005 * This program is free software; you can redistribute it and/or modify 006 * it under the terms of the GNU General Public License as published by 007 * the Free Software Foundation; either version 2 of the License, or 008 * (at your option) any later version. 009 * 010 * This program is distributed in the hope that it will be useful, 011 * but WITHOUT ANY WARRANTY; without even the implied warranty of 012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 013 * GNU General Public License for more details. 014 * 015 * You should have received a copy of the GNU General Public License 016 * along with this program; if not, write to the Free Software 017 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018 * 019 * $Id: minimad.c,v 1.4 2004/01/23 09:41:32 rob Exp $ 020 */ 021 022 # include <stdio.h> 023 # include <unistd.h> 024 # include <sys/stat.h> 025 # include <sys/mman.h> 026 027 # include "mad.h" 028 029 /** 030 * This is perhaps the simplest example use of the MAD high-level API. 031 * Standard input is mapped into memory via mmap(), then the high-level API 032 * is invoked with three callbacks: input, output, and error. The output 033 * callback converts MAD's high-resolution PCM samples to 16 bits, then 034 * writes them to standard output in little-endian, stereo-interleaved 035 * format. 036 */ 037 038 static int decode(unsigned char const *, unsigned long); 039 040 int main(int argc, char *argv[]) 041 { 042 struct stat stat; 043 void *fdm; 044 045 if (argc != 1) 046 return 1; 047 048 if (fstat(STDIN_FILENO, &stat) == -1 || 049 stat.st_size == 0) 050 return 2; 051 052 fdm = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, STDIN_FILENO, 0); 053 if (fdm == MAP_FAILED) 054 return 3; 055 056 decode(fdm, stat.st_size); 057 058 if (munmap(fdm, stat.st_size) == -1) 059 return 4; 060 061 return 0; 062 } 063 064 /** 065 * This is a private message structure. A generic pointer to this structure 066 * is passed to each of the callback functions. Put here any data you need 067 * to access from within the callbacks. 068 */ 069 070 struct buffer { 071 unsigned char const *start; 072 unsigned long length; 073 }; 074 075 /** 076 * This is the input callback. The purpose of this callback is to (re)fill 077 * the stream buffer which is to be decoded. In this example, an entire file 078 * has been mapped into memory, so we just call mad_stream_buffer() with the 079 * address and length of the mapping. When this callback is called a second 080 * time, we are finished decoding. 081 */ 082 083 static 084 enum mad_flow input(void *data, 085 struct mad_stream *stream) 086 { 087 struct buffer *buffer = data; 088 089 if (!buffer->length) 090 return MAD_FLOW_STOP; 091 092 mad_stream_buffer(stream, buffer->start, buffer->length); 093 094 buffer->length = 0; 095 096 return MAD_FLOW_CONTINUE; 097 } 098 099 /** 100 * The following utility routine performs simple rounding, clipping, and 101 * scaling of MAD's high-resolution samples down to 16 bits. It does not 102 * perform any dithering or noise shaping, which would be recommended to 103 * obtain any exceptional audio quality. It is therefore not recommended to 104 * use this routine if high-quality output is desired. 105 */ 106 107 static inline 108 signed int scale(mad_fixed_t sample) 109 { 110 /** round */ 111 sample += (1L << (MAD_F_FRACBITS - 16)); 112 113 /** clip */ 114 if (sample >= MAD_F_ONE) 115 sample = MAD_F_ONE - 1; 116 else if (sample < -MAD_F_ONE) 117 sample = -MAD_F_ONE; 118 119 /** quantize */ 120 return sample >> (MAD_F_FRACBITS + 1 - 16); 121 } 122 123 /** 124 * This is the output callback function. It is called after each frame of 125 * MPEG audio data has been completely decoded. The purpose of this callback 126 * is to output (or play) the decoded PCM audio. 127 */ 128 129 static 130 enum mad_flow output(void *data, 131 struct mad_header const *header, 132 struct mad_pcm *pcm) 133 { 134 unsigned int nchannels, nsamples; 135 mad_fixed_t const *left_ch, *right_ch; 136 137 /** pcm->samplerate contains the sampling frequency */ 138 139 nchannels = pcm->channels; 140 nsamples = pcm->length; 141 left_ch = pcm->samples[0]; 142 right_ch = pcm->samples[1]; 143 144 while (nsamples--) { 145 signed int sample; 146 147 /** output sample(s) in 16-bit signed little-endian PCM */ 148 149 sample = scale(*left_ch++); 150 putchar((sample >> 0) & 0xff); 151 putchar((sample >> 8) & 0xff); 152 153 if (nchannels == 2) { 154 sample = scale(*right_ch++); 155 putchar((sample >> 0) & 0xff); 156 putchar((sample >> 8) & 0xff); 157 } 158 } 159 160 return MAD_FLOW_CONTINUE; 161 } 162 163 /** 164 * This is the error callback function. It is called whenever a decoding 165 * error occurs. The error is indicated by stream->error; the list of 166 * possible MAD_ERROR_* errors can be found in the mad.h (or stream.h) 167 * header file. 168 */ 169 170 static 171 enum mad_flow error(void *data, 172 struct mad_stream *stream, 173 struct mad_frame *frame) 174 { 175 struct buffer *buffer = data; 176 177 fprintf(stderr, "decoding error 0x%04x (%s) at byte offset %u\n", 178 stream->error, mad_stream_errorstr(stream), 179 stream->this_frame - buffer->start); 180 181 /** return MAD_FLOW_BREAK here to stop decoding (and propagate an error) */ 182 183 return MAD_FLOW_CONTINUE; 184 } 185 186 /** 187 * This is the function called by main() above to perform all the decoding. 188 * It instantiates a decoder object and configures it with the input, 189 * output, and error callback functions above. A single call to 190 * mad_decoder_run() continues until a callback function returns 191 * MAD_FLOW_STOP (to stop decoding) or MAD_FLOW_BREAK (to stop decoding and 192 * signal an error). 193 */ 194 195 static 196 int decode(unsigned char const *start, unsigned long length) 197 { 198 struct buffer buffer; 199 struct mad_decoder decoder; 200 int result; 201 202 /** initialize our private message structure */ 203 204 buffer.start = start; 205 buffer.length = length; 206 207 /** configure input, output, and error functions */ 208 209 mad_decoder_init(&decoder, &buffer, 210 input, 0 /** header */, 0 /** filter */, output, 211 error, 0 /** message */); 212 213 /** start decoding */ 214 215 result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC); 216 217 /** release the decoder */ 218 219 mad_decoder_finish(&decoder); 220 221 return result; 222 }
