CSL  5.2
SoundFileMP3.cpp
Go to the documentation of this file.
1 //
2 // SoundFileMP3.cpp -- MP3File implementation
3 // See the copyright notice and acknowledgment of authors in the file COPYRIGHT
4 //
5 
6 #include "SoundFileMP3.h"
7 #include "math.h"
8 
9 #ifdef USE_libMAD
10 
11 using namespace csl;
12 
13 #define DEFAULT_MP3_RATE 44100
14 
15 // The following utility routine performs rounding to MP3_SAMP_TYPE
16 
17 #ifdef CSL_MP3_AS_FLOATS
18 
19 static double samp_scale = 0.01 / (double) (1L << MAD_F_FRACBITS);
20 
21 static inline float scale_MP3(mad_fixed_t sample) {
22  double fsample = sample;
23  return (float) (fsample / samp_scale);
24 }
25 
26 #define MP3_SAMP_TYPE float
27 #define MP3_WRITE sf_writef_float
28 #define MP3_DEPTH 32
29 
30 #else // CSL_MP3_AS_INTS
31 
32 #define MP3_SAMP_TYPE short
33 
34 // static double samp_scale = (1L << MAD_F_FRACBITS) + 0.5;
35 //
36 //static inline int scale_MP3(mad_fixed_t sample) {
37 // double fsample = SampleBuffer samp_scale;
38 // return (int) fsample;
39 //}
40 
41 static inline MP3_SAMP_TYPE scale_MP3(mad_fixed_t sample) {
42  sample += (1L << (MAD_F_FRACBITS - 16)); // round
43  if (sample >= MAD_F_ONE) // clip
44  sample = MAD_F_ONE - 1;
45  else if (sample < -MAD_F_ONE)
46  sample = -MAD_F_ONE;
47  return (MP3_SAMP_TYPE) (sample >> (MAD_F_FRACBITS + 1 - 16)); // quantize
48 }
49 
50 #define MP3_WRITE sf_writef_short
51 #define MP3_DEPTH 16
52 
53 #endif
54 
55 #define scale_MP3F(v) (((float) scale_MP3(v)) / 32768.0f)
56 
57 //
58 // DecodedFile
59 //
60 
61 // constructor
62 
63 DecodedFile::DecodedFile(string tpath, int start, int stop, float maxDurInSecs)
64  : LSoundFile(tpath, start, stop, false, maxDurInSecs) {
65  // no-op
66 }
67 
68 // Desctructor
69 
70 DecodedFile::~DecodedFile() {
71  if ( ! mBuffers.empty())
72  mBuffers.clear(); // erase old values
73 }
74 
75 // DecodedFile::checkBufferStack - make certain the buffer can hold num_samples frames
76 
77 bool DecodedFile::checkBufferStack(unsigned num_samples) {
78  if (mBuffers.empty()) {
79  return this->addBuffer(mNumChannels, CGestalt::sndFileFrames());
80  } else {
81  Buffer * bf = mBuffers.back(); // get buffer from vector in data struct
82  if ((bf->mNumFrames + num_samples) > bf->mNumAlloc) { // if it's full
83  return this->addBuffer(mNumChannels, CGestalt::sndFileFrames());
84  }
85  }
86  return true;
87 }
88 
89 // Add a new buffer to the buffer vector
90 
91 bool DecodedFile::addBuffer(unsigned nnumChannels, unsigned nnumFrames) {
92 //#ifdef FMAK_ANALYZER
93 // unsigned totS = this->totalSize();
94 // unsigned maxSongLength = gConfig->iValue(kMaxSongLength) * mFrameRate;
95 //
96 // if (totS > maxSongLength) {
97 // // numFrames = maxSongLength;
98 // return false;
99 // // LMS used to throw a runtime error, which is a rather useless response.
100 // // throw RunTimeError("Sound file too long");
101 // }
102 //#endif
103  Buffer * bf2 = new Buffer(nnumChannels, nnumFrames);
104  bf2->allocateBuffers();
105  bf2->mNumFrames = 0;
106  mBuffers.push_back(bf2); // push new buffer onto vector
107  return true;
108 }
109 
110 /// store samples into the receiver, adding another buffer if necessary
111 
112 bool DecodedFile::writeBuffer (float * L_buffer, float * R_buffer, unsigned num_samples) {
113  sample * outL, * outR;
114  bool retVal = true;
115 
116  if (!this->checkBufferStack(num_samples))
117  return false;
118  Buffer * bf = mBuffers.back(); // get buffer from vector
119 
120  outL = bf->buffer(0) + bf->mNumFrames; // get prts for copy loop
121  unsigned nsamples = num_samples;
122  if (mMaxDurInSecs > 0.0) { // check for overflow of mMaxDurInSecs
123  unsigned tot = this->totalSize();
124  unsigned maxFrames = (unsigned) (mMaxDurInSecs * mFrameRate);
125  if ((tot + nsamples) >= maxFrames) {
126  retVal = false;
127  nsamples = maxFrames - tot;
128  }
129  }
130  bf->mNumFrames += nsamples; // increment buf ctr
131  memcpy(L_buffer, outL, (nsamples * sizeof(sample))); // do memcpy
132  if (mNumChannels == 2) {
133  outR = bf->buffer(1) + bf->mNumFrames;
134  memcpy(R_buffer, outL, (nsamples * sizeof(sample))); // other memcpy
135  }
136  return retVal;
137 }
138 
139 bool DecodedFile::writeBuffer (int * L_buffer, int * R_buffer, unsigned num_samples) {
140  sample * outL, * outR;
141  int * left_ch, * right_ch;
142  bool retVal = true;
143 
144  if (!this->checkBufferStack(num_samples))
145  return false;
146  Buffer * bf = mBuffers.back(); // get buffer from vector
147  outL = bf->buffer(0) + bf->mNumFrames; // get prts for copy loop
148  left_ch = L_buffer;
149  if (mNumChannels == 2) {
150  outR = bf->buffer(1) + bf->mNumFrames;
151  right_ch = R_buffer;
152  }
153  unsigned nsamples = num_samples;
154  if (mMaxDurInSecs > 0.0) { // check for overflow of mMaxSize
155  unsigned tot = this->totalSize();
156  unsigned maxFrames = (unsigned) (mMaxDurInSecs * mFrameRate);
157  if ((tot + nsamples) >= maxFrames) {
158  retVal = false;
159  // We set a check for an absurd situation when badly encoded MP3 files change sample rates half way through the file, changing maxFrames.
160  nsamples = (tot > maxFrames) ? 0 : maxFrames - tot;
161  }
162  }
163  bf->mNumFrames += nsamples; // increment buf ctr
164  while (nsamples--) { // float copy loop
165  *outL++ = scale_MP3F(*left_ch++);
166  if (mNumChannels == 2)
167  *outR++ = scale_MP3F(*right_ch++);
168  }
169  return retVal;
170 }
171 
172 bool DecodedFile::writeBuffer (float * stereo_buffer, unsigned num_samples) {
173  sample * outL, * outR, * inP;
174  bool retVal = true;
175 
176  if (!this->checkBufferStack(num_samples))
177  return false;
178  Buffer * bf = mBuffers.back(); // get buffer from vector
179  outL = bf->buffer(0) + bf->mNumFrames; // get prts for copy loop
180  if (mNumChannels == 2)
181  outR = bf->buffer(1) + bf->mNumFrames;
182  unsigned nsamples = num_samples / mNumChannels;
183  if (mMaxDurInSecs > 0.0) { // check for overflow of mMaxSize
184  unsigned tot = this->totalSize();
185  unsigned maxFrames = (unsigned) (mMaxDurInSecs * mFrameRate);
186  if ((tot + nsamples) >= maxFrames) {
187  retVal = false;
188  nsamples = maxFrames - tot;
189  }
190  }
191  bf->mNumFrames += nsamples; // increment buf ctr
192  inP = stereo_buffer;
193  while (nsamples--) { // float copy loop
194  *outL++ = *inP++;
195  if (mNumChannels == 2)
196  *outR++ = *inP++;
197  }
198  return retVal;
199 }
200 
201 // calc total size
202 
203 unsigned DecodedFile::totalSize() {
204  unsigned totS = 0;
205  for (BufferVector::iterator it = mBuffers.begin(); it != mBuffers.end(); it++)
206  totS += (*it)->mNumFrames;
207  return totS;
208 }
209 
210 /// merge (concatenate) the buffers into 1 after loading
211 
212 void DecodedFile::mergeBuffers() {
213  if (mBuffers.empty()) {
214 // logMsg(kLogError, "DecodedFile::mergeBuffers - empty buffer vector");
215  mIsValid = false;
216  return;
217  }
218  Buffer * bf = mBuffers.front();
219  if (bf->mNumFrames <= 0) {
220 // logMsg(kLogError, "DecodedFile::mergeBuffers - empty buffer");
221  mIsValid = false;
222  return;
223  }
224  if (mBuffers.size() > 1) { // if > 1 buffer
225  unsigned totS = this->totalSize();
226  bf = new Buffer(2, totS); // create large buffer
227  bf->allocateBuffers();
228  unsigned offset = 0; // copy loop
229  for (BufferVector::iterator it = mBuffers.begin(); it != mBuffers.end(); it++) {
230  Buffer * b2 = *it;
231  bf->copySamplesFromTo(*b2, offset); // write sample to concat buffer
232  offset += b2->mNumFrames;
233  }
234  }
235  mNumChannels = bf->mNumChannels;
236  mNumFrames = bf->mNumFrames;
237  mWavetable.freeBuffers();
238  mWavetable.setSize(mNumChannels, mNumFrames);
239  mWavetable.allocateBuffers();
240  mWavetable.copySamplesFrom(*bf); // copy data over to mWavetable
241  mSFInfo = 0;
242  mSndfile = 0;
243  mStart = 0;
244  mStop = mNumFrames;
245  mBytesPerSample = 4;
246  mIsValid = true;
247  mBase = 0;
248  if (mBuffers.size() > 1)
249  delete bf;
250 // mBuffers.clear(); // erase old values
251  for (BufferVector::iterator it = mBuffers.begin(); it != mBuffers.end(); it++)
252  delete *it;
253 }
254 
255 void DecodedFile::openForWrite(SoundFileFormat tformat, unsigned nchannels, unsigned rate, unsigned bitDepth)
256  throw (CException) {
257  throw IOError("Decoded files cannot be written");
258 }
259 
260 void DecodedFile::openForReadWrite() throw (CException) {
261  throw IOError("Decoded files cannot be written");
262 }
263 
264 // copy next buffer from cache
265 
266 void DecodedFile::nextBuffer(Buffer &outB) throw (CException) {
267 
268 }
269 
270 //
271 //////////////////// MP3File implementation ///////////////////////////////////////////////////////
272 //
273 
274 // simple buffer vector struct with the MP3 file ptr
275 
276 struct vbuffer {
277  unsigned char const * start;
278  unsigned long length;
279  BufferVector * outBufs;
280  MP3File * mp3File;
281 };
282 
283 // temp buffer & file for writing output
284 
285 #ifdef WRITE_MP3_TO_FILE
286 static MP3_SAMP_TYPE * xlate_buffer = NULL;
287 static SNDFILE * sfOutput = NULL;
288 #endif
289 
290 void close_file(int fildes) {
291  close(fildes);
292 }
293 
294 // This is the input callback. The purpose of this callback is to (re)fill
295 // the stream buffer which is to be decoded.
296 
297 static enum mad_flow m3_input(void * data, struct mad_stream * stream) {
298  struct vbuffer * buffer = (vbuffer *) data;
299  if ( ! buffer->length)
300  return MAD_FLOW_STOP;
301  mad_stream_buffer(stream, buffer->start, buffer->length);
302  buffer->length = 0;
303  return MAD_FLOW_CONTINUE;
304 }
305 
306 // This is the output callback function; it scales and writes the decoder output to an AIFF file.
307 
308 static enum mad_flow m3_output(void * data, struct mad_header const * header, struct mad_pcm * pcm) {
309  unsigned int nchannels, nsamples;
310  mad_fixed_t const *left_ch, *right_ch;
311  bool continueDecoding = true;
312  // pcm->samplerate contains the sampling frequency
313  nchannels = pcm->channels;
314  nsamples = pcm->length; // normally 1152
315  left_ch = pcm->samples[0];
316  right_ch = pcm->samples[1];
317 
318 #ifdef WRITE_MP3_TO_FILE
319  MP3_SAMP_TYPE * out_ptr = xlate_buffer;
320  while (nsamples--) {
321  *out_ptr++ = scale_MP3(*left_ch++);
322  if (nchannels == 2)
323  *out_ptr++ = scale_MP3(*right_ch++);
324  }
325  MP3_WRITE(sfOutput, xlate_buffer, pcm->length); // libsndfile sf_writef_short function
326 
327 #else // else write to buffer
328 
329  struct vbuffer * vbf = (vbuffer *) data;
330  MP3File * mp3File = vbf->mp3File;
331  if (mp3File->numChannels() != nchannels)
332  mp3File->setNumChannels(nchannels);
333 
334  continueDecoding = mp3File->writeBuffer((int *) left_ch, (int *) right_ch, nsamples);
335 #endif
336 
337  return continueDecoding ? MAD_FLOW_CONTINUE : MAD_FLOW_STOP;
338 }
339 
340 // This is the error callback function. It is called whenever a decoding
341 // error occurs. The error is indicated by stream->error; the list of
342 // possible MAD_ERROR_* errors can be found in the mad.h (or stream.h)
343 // header file.
344 
345 static enum mad_flow m3_error(void *data, struct mad_stream *stream, struct mad_frame *frame) {
346 // struct vbuffer * buffer = (vbuffer *) data;
347 // fprintf(stderr, "\tMP3 decoding error 0x%04x (%s) at byte offset %u\n",
348 // stream->error, mad_stream_errorstr(stream),
349 // stream->this_frame - buffer->start);
350  return MAD_FLOW_CONTINUE;
351 }
352 
353 // Header handler
354 
355 static enum mad_flow m3_header(void *data, struct mad_header const *header) {
356 // fprintf(stderr, "SR: %d\n", header->samplerate);
357  struct vbuffer * vbf = (vbuffer *) data;
358  MP3File * mp3File = vbf->mp3File;
359  mp3File->mMP3Rate = header->samplerate;
360  mp3File->setFrameRate(header->samplerate);
361  return MAD_FLOW_CONTINUE;
362 }
363 
364 // This is the function that performs all the decoding.
365 // It instantiates a decoder object and configures it with the input,
366 // output, and error callback functions above. A single call to
367 // mad_decoder_run() continues until a callback function returns
368 // MAD_FLOW_STOP (to stop decoding) or MAD_FLOW_BREAK (to stop decoding and
369 // signal an error).
370 //
371 // Note that this assumes:
372 // a stereo input file
373 // a file name with a "/" and a ".mp3"
374 
375 int MP3File::decodeMP3() throw (CException) {
376  int inFile;
377  struct stat stat;
378 // fprintf(stderr, "\tMP3File::decodeMP3() \"%s\"n", mPath.c_str());
379  inFile = open(mPath.c_str(), O_RDONLY); // open & test in file
380  if (fstat(inFile, &stat) == -1 || stat.st_size == 0)
381 // throw IOError("Sound file MP3 open error");
382  return -1;
383  // memory-map input file -- ToDo: this is UNIX-specific
384  void * mapped_data = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, inFile, 0);
385 
386 #ifdef WRITE_MP3_TO_FILE
387  mTempPath = new char[CSL_LINE_LEN]; // create temp file name
388  if (mTempDir)
389  MP3_TEMP_NAME(mPath.c_str(), mTempPath, mTempDir)
390  else
391  AIFF_TEMP_NAME(mPath.c_str(), mTempPath)
392  // create output sound file
393  mTempFile = new LSoundFile(mTempPath, -1, -1, false);
394  mTempFile->openForWrite(kSoundFileFormatAIFF, 2, CGestalt::frameRate(), MP3_DEPTH);
395 #endif
396 
397  struct vbuffer vbf; // now set up libMAD decoder
398  struct mad_decoder decoder;
399  int result = 0;
400  vbf.start = (unsigned char const *) mapped_data;
401  vbf.length = stat.st_size;
402  vbf.mp3File = this;
403  // create first buffer
404  Buffer * bf = new Buffer(2, CGestalt::sndFileFrames());
405 
406  bf->allocateBuffers();
407  bf->mNumFrames = 0;
408  mBuffers.push_back(bf); // store buffer
409  vbf.outBufs = & mBuffers;
410 #ifdef WRITE_MP3_TO_FILE // set up the statics
411  sfOutput = mTempFile->sndFile();
412  xlate_buffer = new MP3_SAMP_TYPE[CGestalt::maxBufferFrames()];
413 #endif
414 
415  mad_decoder_init(&decoder, &vbf, // configure input, output, and error functions
416  m3_input,
417  m3_header, /* header */
418  0 /* filter */,
419  m3_output, /* output function does the work */
420  m3_error,
421  0 /* message */);
422 
423  // start decoding
424  result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
425 
426  mad_decoder_finish(&decoder); // release the decoder
427 #ifdef CSL_DEBUG
428  logMsg("MP3 decoder returned %d; temp file %s", result, tempPath);
429 #endif
430  munmap(mapped_data, stat.st_size);
431  close_file(inFile);
432 #ifdef WRITE_MP3_TO_FILE
433  mTempFile->close();
434  delete mTempFile;
435 #else // handle MP3 buffer vector
436  this->mergeBuffers();
437 #endif
438  return result;
439 }
440 
441 /// MP3File constructors
442 
443 MP3File::MP3File(string tpath, int start, int stop)
444  : DecodedFile(tpath, start, stop, 0) {
445  mMode = kSoundFileClosed;
446  mMP3Rate = DEFAULT_MP3_RATE; // default rate
447 // fprintf(stderr, "\tMP3File::c'tor \"%s\" \n", path.c_str());
448  openForRead(); // read and cache whole file
449 }
450 
451 MP3File::MP3File(float maxDurInSecs, string tpath)
452  : DecodedFile(tpath, -1, -1, maxDurInSecs) {
453  mMode = kSoundFileClosed;
454  mMP3Rate = DEFAULT_MP3_RATE; // default rate
455 // fprintf(stderr, "\tMP3File::c'tor \"%s\" \n", path.c_str());
456  openForRead(); // read and cache whole file
457 }
458 
459 MP3File::~MP3File() { }
460 
461 /// openForRead decodes MP3 file into a temp file and plugs that into the receiver
462 
463 void MP3File::openForRead() throw (CException) {
464 // fprintf(stderr, "\tMP3File::openForRead() \"%s\"n", mTempPath);
465 // mTempDir = NULL;
466  if (mMode == kSoundFileRead)
467  return;
468  mMode = kSoundFileRead;
469 
470  if(!this->readTags()) { // read the ID3 tags
471 // logMsg(kLogError, "No tags in MP3 sound file");
472 // return;
473  }
474  int ret = this->decodeMP3(); // decode the MP3 using libMAD
475  if (ret < 0) {
476  mIsValid = false;
477  return;
478  }
479  mFrameRate = mMP3Rate; // ToDo: this can be a problem if the sample rate changes during the file.
480 
481 // if (mFrameRate != DEFAULT_MP3_RATE) {
482 //// if ((mMP3Rate != 48000) && (mMP3Rate != 32000)) {
483 // if ((mMP3Rate < 20000) || (mMP3Rate > 50000)) {
484 // logMsg(kLogError, "Unsupported MP3 file sample rate: %d", mMP3Rate);
485 // throw IOError("Unsupported MP3 file sample rate");
486 // }
487 //#ifdef CSL_USE_SRConv
488 // this->convertRate(mTempPath, mMP3Rate, DEFAULT_MP3_RATE);
489 //#endif
490 // }
491 #ifdef WRITE_MP3_TO_FILE
492  mTempFile = new LSoundFile(mTempPath);
493  mTempFile->openForRead();
494  mSFInfo = mTempFile->sfInfo();
495  mSndfile = mTempFile->sndFile();
496  mMode = mTempFile->mode();
497  mStart = mTempFile->startFrame();
498  mStop = mTempFile->stopFrame();
499  mIsValid = mTempFile->isValid();
500  mNumChannels = mTempFile->numChannels();
501  mNumFrames = mTempFile->duration();
502  mWavetable.copyFrom(mTempFile->mWavetable);
503 #endif
504 }
505 
506 #endif // USE_libMAD
507 
508 #ifdef USE_libFAAD // Support AAC/MP4 file reading using libFAAD
509 
510 //
511 //////////////////// AACFile implementation /////////////////////////////////////////////////////////////////////
512 //
513 
514 static int fill_buffer(aac_buffer *b) {
515  int bread;
516  if (b->bytes_consumed > 0) {
517  if (b->bytes_into_buffer) {
518  memmove((void*)b->buffer, (void*)(b->buffer + b->bytes_consumed),
519  b->bytes_into_buffer*sizeof(unsigned char));
520  }
521  if (!b->at_eof) {
522  bread = fread((void*)(b->buffer + b->bytes_into_buffer), 1,
523  b->bytes_consumed, b->infile);
524 
525  if (bread != b->bytes_consumed)
526  b->at_eof = 1;
527 
528  b->bytes_into_buffer += bread;
529  }
530  b->bytes_consumed = 0;
531  if (b->bytes_into_buffer > 3) {
532  if (memcmp(b->buffer, "TAG", 3) == 0)
533  b->bytes_into_buffer = 0;
534  }
535  if (b->bytes_into_buffer > 11) {
536  if (memcmp(b->buffer, "LYRICSBEGIN", 11) == 0)
537  b->bytes_into_buffer = 0;
538  }
539  if (b->bytes_into_buffer > 8) {
540  if (memcmp(b->buffer, "APETAGEX", 8) == 0)
541  b->bytes_into_buffer = 0;
542  }
543  }
544  return 1;
545 }
546 
547 static void advance_buffer(aac_buffer *b, int bytes) {
548  b->file_offset += bytes;
549  b->bytes_consumed = bytes;
550  b->bytes_into_buffer -= bytes;
551  if (b->bytes_into_buffer < 0)
552  b->bytes_into_buffer = 0;
553 }
554 
555 static int adts_sample_rates[] =
556 {96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000,7350,0,0,0};
557 
558 static int adts_parse(aac_buffer *b, int *bitrate, float *length) {
559  int frames, frame_length;
560  int t_framelength = 0;
561  int samplerate;
562  float frames_per_sec, bytes_per_frame;
563 
564  /* Read all frames to ensure correct time and bitrate */
565  for (frames = 0; /* */; frames++) {
566  fill_buffer(b);
567  if (b->bytes_into_buffer > 7) {
568  /* check syncword */
569  if (!((b->buffer[0] == 0xFF)&&((b->buffer[1] & 0xF6) == 0xF0)))
570  break;
571  if (frames == 0)
572  samplerate = adts_sample_rates[(b->buffer[2]&0x3c)>>2];
573  frame_length = ((((unsigned int)b->buffer[3] & 0x3)) << 11)
574  | (((unsigned int)b->buffer[4]) << 3) | (b->buffer[5] >> 5);
575  t_framelength += frame_length;
576  if (frame_length > b->bytes_into_buffer)
577  break;
578 
579  advance_buffer(b, frame_length);
580  } else {
581  break;
582  }
583  }
584  frames_per_sec = (float)samplerate/1024.0f;
585  if (frames != 0)
586  bytes_per_frame = (float)t_framelength/(float)(frames*1000);
587  else
588  bytes_per_frame = 0;
589  *bitrate = (int)(8. * bytes_per_frame * frames_per_sec + 0.5);
590  if (frames_per_sec != 0)
591  *length = (float)frames/frames_per_sec;
592  else
593  *length = 1;
594  return 1;
595 }
596 
597 uint32_t read_callback(void *user_data, void *buffer, uint32_t length) {
598  return fread(buffer, 1, length, (FILE*)user_data);
599 }
600 
601 uint32_t seek_callback(void *user_data, uint64_t position) {
602  return fseek((FILE*)user_data, position, SEEK_SET);
603 }
604 
605 ///* MicroSoft channel definitions */
606 //#define SPEAKER_FRONT_LEFT 0x1
607 //#define SPEAKER_FRONT_RIGHT 0x2
608 //#define SPEAKER_FRONT_CENTER 0x4
609 //#define SPEAKER_LOW_FREQUENCY 0x8
610 //#define SPEAKER_BACK_LEFT 0x10
611 //#define SPEAKER_BACK_RIGHT 0x20
612 //#define SPEAKER_FRONT_LEFT_OF_CENTER 0x40
613 //#define SPEAKER_FRONT_RIGHT_OF_CENTER 0x80
614 //#define SPEAKER_BACK_CENTER 0x100
615 //#define SPEAKER_SIDE_LEFT 0x200
616 //#define SPEAKER_SIDE_RIGHT 0x400
617 //#define SPEAKER_TOP_CENTER 0x800
618 //#define SPEAKER_TOP_FRONT_LEFT 0x1000
619 //#define SPEAKER_TOP_FRONT_CENTER 0x2000
620 //#define SPEAKER_TOP_FRONT_RIGHT 0x4000
621 //#define SPEAKER_TOP_BACK_LEFT 0x8000
622 //#define SPEAKER_TOP_BACK_CENTER 0x10000
623 //#define SPEAKER_TOP_BACK_RIGHT 0x20000
624 //#define SPEAKER_RESERVED 0x80000000
625 //
626 //static long aacChannelConfig2wavexChannelMask(NeAACDecFrameInfo *hInfo) {
627 // if (hInfo->channels == 6 && hInfo->num_lfe_channels) {
628 // return SPEAKER_FRONT_LEFT + SPEAKER_FRONT_RIGHT +
629 // SPEAKER_FRONT_CENTER + SPEAKER_LOW_FREQUENCY +
630 // SPEAKER_BACK_LEFT + SPEAKER_BACK_RIGHT;
631 // } else {
632 // return 0;
633 // }
634 //}
635 //
636 //static const char * position2string(int position) {
637 // switch (position) {
638 // case FRONT_CHANNEL_CENTER: return "Center front";
639 // case FRONT_CHANNEL_LEFT: return "Left front";
640 // case FRONT_CHANNEL_RIGHT: return "Right front";
641 // case SIDE_CHANNEL_LEFT: return "Left side";
642 // case SIDE_CHANNEL_RIGHT: return "Right side";
643 // case BACK_CHANNEL_LEFT: return "Left back";
644 // case BACK_CHANNEL_RIGHT: return "Right back";
645 // case BACK_CHANNEL_CENTER: return "Center back";
646 // case LFE_CHANNEL: return "LFE";
647 // case UNKNOWN_CHANNEL: return "Unknown";
648 // default: return "";
649 // }
650 // return "";
651 //}
652 //
653 //static void print_channel_info(NeAACDecFrameInfo *frameInfo) {
654 // /* print some channel info */
655 // int i;
656 // long channelMask = aacChannelConfig2wavexChannelMask(frameInfo);
657 //
658 // logMsg(" ---------------------");
659 // if (frameInfo->num_lfe_channels > 0) {
660 // logMsg(" | Config: %2d.%d Ch |", frameInfo->channels-frameInfo->num_lfe_channels, frameInfo->num_lfe_channels);
661 // } else {
662 // logMsg(" | Config: %2d Ch |", frameInfo->channels);
663 // }
664 // if (channelMask)
665 // logMsg(" WARNING: channels are reordered according to");
666 // else
667 // logMsg("");
668 // logMsg(" ---------------------");
669 // if (channelMask)
670 // logMsg(" MS defaults defined in WAVE_FORMAT_EXTENSIBLE");
671 // else
672 // logMsg("");
673 // logMsg(" | Ch | Position |");
674 // logMsg(" ---------------------");
675 // for (i = 0; i < frameInfo->channels; i++) {
676 // logMsg(" | %.2d | %-14s |", i, position2string((int)frameInfo->channel_position[i]));
677 // }
678 // logMsg(" ---------------------");
679 // logMsg("");
680 //}
681 
682 //static int FindAdtsSRIndex(int sr) {
683 // int i;
684 // for (i = 0; i < 16; i++) {
685 // if (sr == adts_sample_rates[i])
686 // return i;
687 // }
688 // return 16 - 1;
689 //}
690 
691 /* find AAC track */
692 
693 static int GetAACTrack(mp4ff_t *infile) {
694  int i, rc;
695  int numTracks = mp4ff_total_tracks(infile);
696 
697  for (i = 0; i < numTracks; i++) {
698  unsigned char * buff = NULL;
699  unsigned int buff_size = 0;
700  mp4AudioSpecificConfig mp4ASC;
701  mp4ff_get_decoder_config(infile, i, &buff, &buff_size);
702  if (buff) {
703  rc = NeAACDecAudioSpecificConfig(buff, buff_size, &mp4ASC);
704  free(buff);
705  if (rc < 0)
706  continue;
707  return i;
708  }
709  }
710  return -1; /* can't decode this */
711 }
712 
713 static const unsigned long srates[] =
714 { 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000 };
715 
716 /* print some mp4 file info */
717 
718 void MP4File::printMP4(mp4ff_t * infile, int track, unsigned *song_length) {
719  logMsg("%s file info:", mPath.c_str());
720  char *tag = NULL, *item = NULL;
721  int k, j;
722  const char *ot[6] = { "NULL", "MAIN AAC", "LC AAC", "SSR AAC", "LTP AAC", "HE AAC" };
723  long samples = mp4ff_num_samples(infile, track);
724  float f = 1024.0;
725  float seconds;
726  if (mp4ASC.sbr_present_flag == 1)
727  f = f * 2.0;
728  seconds = (float)samples * (float)(f-1.0) / (float)mp4ASC.samplingFrequency;
729  *song_length = (unsigned) samples * (unsigned) (f - 1);
730  logMsg("%s\t%.3f secs, %d ch, %d Hz", ot[(mp4ASC.objectTypeIndex > 5) ? 0 : mp4ASC.objectTypeIndex],
731  seconds, mp4ASC.channelsConfiguration, mp4ASC.samplingFrequency);
732 #define PRINT_MP4_METADATA
733 #ifdef PRINT_MP4_METADATA
734  j = mp4ff_meta_get_num_items(infile);
735  for (k = 0; k < j; k++) {
736  if (mp4ff_meta_get_by_index(infile, k, &item, &tag)) {
737  if (item != NULL && tag != NULL) {
738  logMsg("\t\t%s: %s", item, tag);
739  free(item); item = NULL;
740  free(tag); tag = NULL;
741  }
742  }
743  }
744  if (j > 0) logMsg("");
745 #endif
746 }
747 
748 ///////////////////////////////////////////////////////////////////////////////////////
749 
750 MP4File::MP4File(string tpath, int start, int stop)
751  : DecodedFile(tpath, start, stop, 0) {
752  mMode = kSoundFileClosed;
753  openForRead(); // read and cache whole file
754 }
755 
756 MP4File::MP4File(float maxDurInSecs, string tpath)
757  : DecodedFile(tpath, -1, -1, maxDurInSecs) {
758  mMode = kSoundFileClosed;
759  openForRead(); // read and cache whole file
760 }
761 
762 MP4File::~MP4File() {
763  // structs are auto-free'd
764 }
765 
766 // open file and get stats
767 
768 void MP4File::openForRead() throw (CException) {
769  unsigned char header[8];
770  int mp4file = 0;
771  Status result;
772  if (mMode == kSoundFileRead)
773  return;
774  mMode = kSoundFileRead;
775 
776 // unsigned long cap = NeAACDecGetCapabilities();
777 // if (cap & FIXED_POINT_CAP)
778 // logMsg("Fixed point version");
779 // else
780 // logMsg("Floating point version");
781 
782  /* check for mp4 file */
783  FILE * hMP4File = fopen(mPath.c_str(), "rb");
784  if (!hMP4File) {
785  logMsg("Error opening file (fopen): %s", mPath.c_str());
786  return;
787  }
788  fread(header, 1, 8, hMP4File);
789  rewind(hMP4File);
790  // logMsg("Header: %.4s - %.4s", &header[0], &header[4]);
791  // if (header[4] == 'f' && header[5] == 't' && header[6] == 'y' && header[7] == 'p')
792  if (memcmp(&header[4], "ftyp", 4) == 0)
793  mp4file = 1;
794 
795  if (mp4file) // now call the right decoder method
796  result = this->decodeMP4file(hMP4File);
797  else
798  result = this->decodeAACfile(hMP4File);
799 
800  if (result != kOk) {
801 // logMsg("Error opening file (decode): %s", mPath.c_str());
802 // return;
803  }
804  fclose(hMP4File);
805  this->mergeBuffers();
806 
807  if (mIsValid) {
808  this->readTags(); // read the ID3 tags
809  }
810 }
811 
812 // decode
813 
814 Status MP4File::decodeAACfile(FILE * inFile) throw (CException){
815  float length;
816  int bread, fileread;
817  int header_type;
818  int bitrate;
819  int tagsize;
820  unsigned long samplerate;
821  unsigned char tchannels;
822  void *sample_buffer;
823 // unsigned char *adtsData;
824 // int adtsDataSize;
825 
826  memset(&aacBuff, 0, sizeof(aac_buffer));
827  aacBuff.infile = inFile;
828  fseek(aacBuff.infile, 0, SEEK_END);
829  fileread = ftell(aacBuff.infile);
830  fseek(aacBuff.infile, 0, SEEK_SET);
831 
832  if ( ! (aacBuff.buffer = (unsigned char *) malloc(FAAD_MIN_STREAMSIZE * MAX_CHANNELS))) {
833  logMsg("Memory allocation error");
834  return kErr;
835  }
836  memset(aacBuff.buffer, 0, FAAD_MIN_STREAMSIZE * MAX_CHANNELS);
837 
838  bread = fread(aacBuff.buffer, 1, FAAD_MIN_STREAMSIZE*MAX_CHANNELS, aacBuff.infile);
839  aacBuff.bytes_into_buffer = bread;
840  aacBuff.bytes_consumed = 0;
841  aacBuff.file_offset = 0;
842 
843  if (bread != FAAD_MIN_STREAMSIZE*MAX_CHANNELS)
844  aacBuff.at_eof = 1;
845 
846  tagsize = 0;
847  if (!memcmp(aacBuff.buffer, "ID3", 3)) {
848  /* high bit is not used */
849  tagsize = (aacBuff.buffer[6] << 21) | (aacBuff.buffer[7] << 14) |
850  (aacBuff.buffer[8] << 7) | (aacBuff.buffer[9] << 0);
851 
852  tagsize += 10;
853  advance_buffer(&aacBuff, tagsize);
854  fill_buffer(&aacBuff);
855  }
856  hDecoder = NeAACDecOpen();
857 
858  /* Set the default object type and samplerate */
859  /* This is useful for RAW AAC files */
860  config = NeAACDecGetCurrentConfiguration(hDecoder);
861  config->defObjectType = LC;
862  config->outputFormat = 4;
863  config->downMatrix = 1;
864  config->useOldADTSFormat = 0;
865 // config->dontUpSampleImplicitSBR = 1;
866  NeAACDecSetConfiguration(hDecoder, config);
867 
868  /* get AAC infos for printing */
869  header_type = 0;
870  if ((aacBuff.buffer[0] == 0xFF) && ((aacBuff.buffer[1] & 0xF6) == 0xF0)) {
871  adts_parse(&aacBuff, &bitrate, &length);
872  fseek(aacBuff.infile, tagsize, SEEK_SET);
873 
874  bread = fread(aacBuff.buffer, 1, FAAD_MIN_STREAMSIZE*MAX_CHANNELS, aacBuff.infile);
875  if (bread != FAAD_MIN_STREAMSIZE*MAX_CHANNELS)
876  aacBuff.at_eof = 1;
877  else
878  aacBuff.at_eof = 0;
879  aacBuff.bytes_into_buffer = bread;
880  aacBuff.bytes_consumed = 0;
881  aacBuff.file_offset = tagsize;
882  header_type = 1;
883  } else if (memcmp(aacBuff.buffer, "ADIF", 4) == 0) {
884  int skip_size = (aacBuff.buffer[4] & 0x80) ? 9 : 0;
885  bitrate = ((unsigned int)(aacBuff.buffer[4 + skip_size] & 0x0F)<<19) |
886  ((unsigned int)aacBuff.buffer[5 + skip_size]<<11) |
887  ((unsigned int)aacBuff.buffer[6 + skip_size]<<3) |
888  ((unsigned int)aacBuff.buffer[7 + skip_size] & 0xE0);
889 
890  length = (float) fileread;
891  if (length != 0) {
892  length = ((float)length*8.0f)/((float)bitrate) + 0.5f;
893  }
894  bitrate = (int)((float)bitrate/1000.0f + 0.5f);
895  header_type = 2;
896  }
897 
898  fill_buffer(&aacBuff);
899  if ((bread = NeAACDecInit(hDecoder, aacBuff.buffer,
900  aacBuff.bytes_into_buffer, &samplerate, &tchannels)) < 0) {
901  /* If some error initializing occured, skip the file */
902  logMsg("Error initializing decoder library.");
903  if (aacBuff.buffer)
904  free(aacBuff.buffer);
905  NeAACDecClose(hDecoder);
906  fclose(aacBuff.infile);
907  return kErr;
908  }
909  advance_buffer(&aacBuff, bread);
910  fill_buffer(&aacBuff);
911 
912  /* print AAC file info */
913  logMsg("%s file info:", mPath.c_str());
914  switch (header_type) {
915  case 0:
916  logMsg("RAW");
917  break;
918  case 1:
919  logMsg("ADTS, %.3f sec, %d kbps, %d Hz", length, bitrate, samplerate);
920  break;
921  case 2:
922  logMsg("ADIF, %.3f sec, %d kbps, %d Hz", length, bitrate, samplerate);
923  break;
924  }
925 
926  do { // main read loop
927  sample_buffer = NeAACDecDecode(hDecoder, &frameInfo, aacBuff.buffer, aacBuff.bytes_into_buffer);
928 
929  /* update buffer indices */
930  advance_buffer(&aacBuff, frameInfo.bytesconsumed);
931 
932  if (frameInfo.error > 0) {
933  logMsg("Error: %s",
934  NeAACDecGetErrorMessage(frameInfo.error));
935  }
936  if ( ! writeBuffer((float *) sample_buffer, frameInfo.samples) )
937  break;
938  /* fill buffer */
939  fill_buffer(&aacBuff);
940  if (aacBuff.bytes_into_buffer == 0)
941  sample_buffer = NULL; /* to make sure it stops now */
942 
943  } while (sample_buffer != NULL); // end of loop
944 
945  NeAACDecClose(hDecoder);
946  if (aacBuff.buffer)
947  free(aacBuff.buffer);
948  return (frameInfo.error ? kErr : kOk);
949 }
950 
951 // read and decode an MP4 file
952 
953 Status MP4File::decodeMP4file(FILE * inFile) throw (CException) {
954  int track;
955  void *sample_buffer;
956  long sampleId, numSamples;
957  mp4ff_t *mp4File;
958 // FILE *adtsFile;
959 // unsigned char *adtsData;
960 // int adtsDataSize;
961  unsigned char *tbuffer = NULL;
962  unsigned int buffer_size;
963  unsigned long samplerate;
964  unsigned char tchannels;
965  /* for gapless decoding */
966  unsigned int useAacLength = 1;
967  unsigned int initial = 1;
968  unsigned int framesize;
969  unsigned long timescale;
970 
971  /* initialise the callback structure */
972  mp4ff_callback_t * mp4cb = (mp4ff_callback_t *) malloc(sizeof(mp4ff_callback_t));
973  mp4cb->read = read_callback;
974  mp4cb->seek = seek_callback;
975  mp4cb->user_data = inFile;
976 
977  hDecoder = NeAACDecOpen();
978 
979  /* Set configuration */
980  config = NeAACDecGetCurrentConfiguration(hDecoder);
981  config->outputFormat = 4;
982  config->downMatrix = 1;
983  // config->dontUpSampleImplicitSBR = 1;
984  NeAACDecSetConfiguration(hDecoder, config);
985 
986  mp4File = mp4ff_open_read(mp4cb);
987 
988  if ((track = GetAACTrack(mp4File)) < 0) {
989  logMsg("Warning: Unable to find correct AAC sound track in the MP4 file.");
990  NeAACDecClose(hDecoder);
991  mp4ff_close(mp4File);
992  free(mp4cb);
993  fclose(inFile);
994  return kErr;
995  }
996  tbuffer = NULL;
997  buffer_size = 0;
998  mp4ff_get_decoder_config(mp4File, track, &tbuffer, &buffer_size);
999 
1000  if (NeAACDecInit2(hDecoder, tbuffer, buffer_size, &samplerate, &tchannels) < 0) {
1001  /* If some error initializing occured, skip the file */
1002  logMsg("Error initializing decoder library.");
1003  NeAACDecClose(hDecoder);
1004  mp4ff_close(mp4File);
1005  free(mp4cb);
1006  fclose(inFile);
1007  return kErr;
1008  }
1009  timescale = mp4ff_time_scale(mp4File, track);
1010  framesize = 1024;
1011  useAacLength = 0;
1012  mFrameRate = samplerate;
1013  mNumChannels = tchannels;
1014  if (tbuffer) {
1015  if (NeAACDecAudioSpecificConfig(tbuffer, buffer_size, &mp4ASC) >= 0) {
1016  if (mp4ASC.frameLengthFlag == 1)
1017  framesize = 960;
1018  if (mp4ASC.sbr_present_flag == 1)
1019  framesize *= 2;
1020  }
1021  free(tbuffer);
1022  }
1023  numSamples = mp4ff_num_samples(mp4File, track);
1024 
1025  unsigned songLength;
1026 // if (gConfig->Verbose())
1027 // this->printMP4(mp4File, track, &songLength);
1028 
1029  this->addBuffer(mNumChannels, (songLength + mFrameRate));
1030  // IO loop
1031  for (sampleId = 0; sampleId < numSamples; sampleId++) {
1032  int rc;
1033  long dur;
1034  unsigned int sample_count;
1035  unsigned int delay = 0;
1036  tbuffer = NULL;
1037  buffer_size = 0;
1038  /* get acces unit from MP4 file */
1039  dur = mp4ff_get_sample_duration(mp4File, track, sampleId);
1040  rc = mp4ff_read_sample(mp4File, track, sampleId, &tbuffer, &buffer_size);
1041  if (rc == 0) {
1042  logMsg("Reading from MP4 file failed.");
1043  NeAACDecClose(hDecoder);
1044  mp4ff_close(mp4File);
1045  free(mp4cb);
1046  fclose(inFile);
1047  return kErr;
1048  } // decode a block here, returns the sample buffer
1049  sample_buffer = NeAACDecDecode(hDecoder, &frameInfo, tbuffer, buffer_size);
1050  if (tbuffer) free(tbuffer);
1051 
1052  if (sampleId == 0) dur = 0;
1053 
1054  if (useAacLength || (timescale != samplerate)) {
1055  sample_count = frameInfo.samples;
1056  } else {
1057  sample_count = (unsigned int)(dur * frameInfo.channels);
1058  if (sample_count > frameInfo.samples)
1059  sample_count = frameInfo.samples;
1060 
1061  if (!useAacLength && !initial && (sampleId < numSamples/2) && (sample_count != frameInfo.samples)) {
1062  logMsg("MP4 seems to have incorrect frame duration, using values from AAC data.");
1063  useAacLength = 1;
1064  sample_count = frameInfo.samples;
1065  }
1066  }
1067  if (initial && (sample_count < framesize*frameInfo.channels) && (frameInfo.samples > sample_count))
1068  delay = frameInfo.samples - sample_count;
1069 // if ((sampleId == 0) && gConfig->Verbose() && !frameInfo.error) { // print some channel info
1070 // print_channel_info(&frameInfo);
1071 // }
1072  if ((frameInfo.error == 0) && (sample_count > 0))
1073  if ( ! writeBuffer((float *) sample_buffer, sample_count))
1074  break;
1075 
1076  if (frameInfo.error > 0) {
1077  logMsg("Warning: %s", NeAACDecGetErrorMessage(frameInfo.error));
1078  }
1079  }
1080  NeAACDecClose(hDecoder);
1081  mp4ff_close(mp4File);
1082  free(mp4cb);
1083  return (frameInfo.error ? kErr : kOk);
1084 }
1085 
1086 #endif