426 lines
11 KiB
C++
426 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include "mp3reader.h"
|
|
|
|
static uint32_t U32_AT(const uint8_t *ptr) {
|
|
return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
|
|
}
|
|
|
|
static bool parseHeader(
|
|
uint32_t header, size_t *frame_size,
|
|
uint32_t *out_sampling_rate = NULL, uint32_t *out_channels = NULL ,
|
|
uint32_t *out_bitrate = NULL, uint32_t *out_num_samples = NULL) {
|
|
*frame_size = 0;
|
|
|
|
if (out_sampling_rate) {
|
|
*out_sampling_rate = 0;
|
|
}
|
|
|
|
if (out_channels) {
|
|
*out_channels = 0;
|
|
}
|
|
|
|
if (out_bitrate) {
|
|
*out_bitrate = 0;
|
|
}
|
|
|
|
if (out_num_samples) {
|
|
*out_num_samples = 1152;
|
|
}
|
|
|
|
if ((header & 0xffe00000) != 0xffe00000) {
|
|
return false;
|
|
}
|
|
|
|
unsigned version = (header >> 19) & 3;
|
|
|
|
if (version == 0x01) {
|
|
return false;
|
|
}
|
|
|
|
unsigned layer = (header >> 17) & 3;
|
|
|
|
if (layer == 0x00) {
|
|
return false;
|
|
}
|
|
|
|
unsigned bitrate_index = (header >> 12) & 0x0f;
|
|
|
|
if (bitrate_index == 0 || bitrate_index == 0x0f) {
|
|
// Disallow "free" bitrate.
|
|
return false;
|
|
}
|
|
|
|
unsigned sampling_rate_index = (header >> 10) & 3;
|
|
|
|
if (sampling_rate_index == 3) {
|
|
return false;
|
|
}
|
|
|
|
static const int kSamplingRateV1[] = { 44100, 48000, 32000 };
|
|
int sampling_rate = kSamplingRateV1[sampling_rate_index];
|
|
if (version == 2 /* V2 */) {
|
|
sampling_rate /= 2;
|
|
} else if (version == 0 /* V2.5 */) {
|
|
sampling_rate /= 4;
|
|
}
|
|
|
|
unsigned padding = (header >> 9) & 1;
|
|
|
|
if (layer == 3) {
|
|
// layer I
|
|
|
|
static const int kBitrateV1[] = {
|
|
32, 64, 96, 128, 160, 192, 224, 256,
|
|
288, 320, 352, 384, 416, 448
|
|
};
|
|
|
|
static const int kBitrateV2[] = {
|
|
32, 48, 56, 64, 80, 96, 112, 128,
|
|
144, 160, 176, 192, 224, 256
|
|
};
|
|
|
|
int bitrate =
|
|
(version == 3 /* V1 */)
|
|
? kBitrateV1[bitrate_index - 1]
|
|
: kBitrateV2[bitrate_index - 1];
|
|
|
|
if (out_bitrate) {
|
|
*out_bitrate = bitrate;
|
|
}
|
|
|
|
*frame_size = (12000 * bitrate / sampling_rate + padding) * 4;
|
|
|
|
if (out_num_samples) {
|
|
*out_num_samples = 384;
|
|
}
|
|
} else {
|
|
// layer II or III
|
|
|
|
static const int kBitrateV1L2[] = {
|
|
32, 48, 56, 64, 80, 96, 112, 128,
|
|
160, 192, 224, 256, 320, 384
|
|
};
|
|
|
|
static const int kBitrateV1L3[] = {
|
|
32, 40, 48, 56, 64, 80, 96, 112,
|
|
128, 160, 192, 224, 256, 320
|
|
};
|
|
|
|
static const int kBitrateV2[] = {
|
|
8, 16, 24, 32, 40, 48, 56, 64,
|
|
80, 96, 112, 128, 144, 160
|
|
};
|
|
|
|
int bitrate;
|
|
if (version == 3 /* V1 */) {
|
|
bitrate = (layer == 2 /* L2 */)
|
|
? kBitrateV1L2[bitrate_index - 1]
|
|
: kBitrateV1L3[bitrate_index - 1];
|
|
|
|
if (out_num_samples) {
|
|
*out_num_samples = 1152;
|
|
}
|
|
} else {
|
|
// V2 (or 2.5)
|
|
|
|
bitrate = kBitrateV2[bitrate_index - 1];
|
|
if (out_num_samples) {
|
|
*out_num_samples = (layer == 1 /* L3 */) ? 576 : 1152;
|
|
}
|
|
}
|
|
|
|
if (out_bitrate) {
|
|
*out_bitrate = bitrate;
|
|
}
|
|
|
|
if (version == 3 /* V1 */) {
|
|
*frame_size = 144000 * bitrate / sampling_rate + padding;
|
|
} else {
|
|
// V2 or V2.5
|
|
size_t tmp = (layer == 1 /* L3 */) ? 72000 : 144000;
|
|
*frame_size = tmp * bitrate / sampling_rate + padding;
|
|
}
|
|
}
|
|
|
|
if (out_sampling_rate) {
|
|
*out_sampling_rate = sampling_rate;
|
|
}
|
|
|
|
if (out_channels) {
|
|
int channel_mode = (header >> 6) & 3;
|
|
|
|
*out_channels = (channel_mode == 3) ? 1 : 2;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Mask to extract the version, layer, sampling rate parts of the MP3 header,
|
|
// which should be same for all MP3 frames.
|
|
static const uint32_t kMask = 0xfffe0c00;
|
|
|
|
static ssize_t sourceReadAt(FILE *fp, off64_t offset, void *data, size_t size) {
|
|
int retVal = fseek(fp, offset, SEEK_SET);
|
|
if (retVal != EXIT_SUCCESS) {
|
|
return 0;
|
|
} else {
|
|
return fread(data, 1, size, fp);
|
|
}
|
|
}
|
|
|
|
// Resync to next valid MP3 frame in the file.
|
|
static bool resync(
|
|
FILE *fp, uint32_t match_header,
|
|
off64_t *inout_pos, uint32_t *out_header) {
|
|
|
|
if (*inout_pos == 0) {
|
|
// Skip an optional ID3 header if syncing at the very beginning
|
|
// of the datasource.
|
|
|
|
for (;;) {
|
|
uint8_t id3header[10];
|
|
int retVal = sourceReadAt(fp, *inout_pos, id3header,
|
|
sizeof(id3header));
|
|
if (retVal < (ssize_t)sizeof(id3header)) {
|
|
// If we can't even read these 10 bytes, we might as well bail
|
|
// out, even if there _were_ 10 bytes of valid mp3 audio data...
|
|
return false;
|
|
}
|
|
|
|
if (memcmp("ID3", id3header, 3)) {
|
|
break;
|
|
}
|
|
|
|
// Skip the ID3v2 header.
|
|
|
|
size_t len =
|
|
((id3header[6] & 0x7f) << 21)
|
|
| ((id3header[7] & 0x7f) << 14)
|
|
| ((id3header[8] & 0x7f) << 7)
|
|
| (id3header[9] & 0x7f);
|
|
|
|
len += 10;
|
|
|
|
*inout_pos += len;
|
|
}
|
|
|
|
}
|
|
|
|
off64_t pos = *inout_pos;
|
|
bool valid = false;
|
|
|
|
const int32_t kMaxReadBytes = 1024;
|
|
const int32_t kMaxBytesChecked = 128 * 1024;
|
|
uint8_t buf[kMaxReadBytes];
|
|
ssize_t bytesToRead = kMaxReadBytes;
|
|
ssize_t totalBytesRead = 0;
|
|
ssize_t remainingBytes = 0;
|
|
bool reachEOS = false;
|
|
uint8_t *tmp = buf;
|
|
|
|
do {
|
|
if (pos >= *inout_pos + kMaxBytesChecked) {
|
|
// Don't scan forever.
|
|
break;
|
|
}
|
|
|
|
if (remainingBytes < 4) {
|
|
if (reachEOS) {
|
|
break;
|
|
} else {
|
|
memcpy(buf, tmp, remainingBytes);
|
|
bytesToRead = kMaxReadBytes - remainingBytes;
|
|
|
|
/*
|
|
* The next read position should start from the end of
|
|
* the last buffer, and thus should include the remaining
|
|
* bytes in the buffer.
|
|
*/
|
|
totalBytesRead = sourceReadAt(fp, pos + remainingBytes,
|
|
buf + remainingBytes, bytesToRead);
|
|
|
|
if (totalBytesRead <= 0) {
|
|
break;
|
|
}
|
|
reachEOS = (totalBytesRead != bytesToRead);
|
|
remainingBytes += totalBytesRead;
|
|
tmp = buf;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
uint32_t header = U32_AT(tmp);
|
|
|
|
if (match_header != 0 && (header & kMask) != (match_header & kMask)) {
|
|
++pos;
|
|
++tmp;
|
|
--remainingBytes;
|
|
continue;
|
|
}
|
|
|
|
size_t frame_size;
|
|
uint32_t sample_rate, num_channels, bitrate;
|
|
if (!parseHeader(
|
|
header, &frame_size,
|
|
&sample_rate, &num_channels, &bitrate)) {
|
|
++pos;
|
|
++tmp;
|
|
--remainingBytes;
|
|
continue;
|
|
}
|
|
|
|
// We found what looks like a valid frame,
|
|
// now find its successors.
|
|
|
|
off64_t test_pos = pos + frame_size;
|
|
|
|
valid = true;
|
|
const int FRAME_MATCH_REQUIRED = 3;
|
|
for (int j = 0; j < FRAME_MATCH_REQUIRED; ++j) {
|
|
uint8_t tmp[4];
|
|
ssize_t retval = sourceReadAt(fp, test_pos, tmp, sizeof(tmp));
|
|
if (retval < (ssize_t)sizeof(tmp)) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
|
|
uint32_t test_header = U32_AT(tmp);
|
|
|
|
if ((test_header & kMask) != (header & kMask)) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
|
|
size_t test_frame_size;
|
|
if (!parseHeader(test_header, &test_frame_size)) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
|
|
test_pos += test_frame_size;
|
|
}
|
|
|
|
if (valid) {
|
|
*inout_pos = pos;
|
|
|
|
if (out_header != NULL) {
|
|
*out_header = header;
|
|
}
|
|
}
|
|
|
|
++pos;
|
|
++tmp;
|
|
--remainingBytes;
|
|
} while (!valid);
|
|
|
|
return valid;
|
|
}
|
|
|
|
Mp3Reader::Mp3Reader() : mFp(NULL) {
|
|
}
|
|
|
|
// Initialize the MP3 reader.
|
|
bool Mp3Reader::init(const char *file) {
|
|
|
|
// Open the file.
|
|
mFp = fopen(file, "rb");
|
|
if (mFp == NULL) return false;
|
|
|
|
// Sync to the first valid frame.
|
|
off64_t pos = 0;
|
|
uint32_t header;
|
|
bool success = resync(mFp, 0 /*match_header*/, &pos, &header);
|
|
if (success == false) return false;
|
|
|
|
mCurrentPos = pos;
|
|
mFixedHeader = header;
|
|
|
|
size_t frame_size;
|
|
return parseHeader(header, &frame_size, &mSampleRate,
|
|
&mNumChannels, &mBitrate);
|
|
}
|
|
|
|
// Get the next valid MP3 frame.
|
|
bool Mp3Reader::getFrame(void *buffer, uint32_t *size) {
|
|
|
|
size_t frame_size;
|
|
uint32_t bitrate;
|
|
uint32_t num_samples;
|
|
uint32_t sample_rate;
|
|
for (;;) {
|
|
ssize_t n = sourceReadAt(mFp, mCurrentPos, buffer, 4);
|
|
if (n < 4) {
|
|
return false;
|
|
}
|
|
|
|
uint32_t header = U32_AT((const uint8_t *)buffer);
|
|
|
|
if ((header & kMask) == (mFixedHeader & kMask)
|
|
&& parseHeader(
|
|
header, &frame_size, &sample_rate, NULL /*out_channels*/,
|
|
&bitrate, &num_samples)) {
|
|
break;
|
|
}
|
|
|
|
// Lost sync.
|
|
off64_t pos = mCurrentPos;
|
|
if (!resync(mFp, mFixedHeader, &pos, NULL /*out_header*/)) {
|
|
// Unable to resync. Signalling end of stream.
|
|
return false;
|
|
}
|
|
|
|
mCurrentPos = pos;
|
|
|
|
// Try again with the new position.
|
|
}
|
|
ssize_t n = sourceReadAt(mFp, mCurrentPos, buffer, frame_size);
|
|
if (n < (ssize_t)frame_size) {
|
|
return false;
|
|
}
|
|
|
|
*size = frame_size;
|
|
mCurrentPos += frame_size;
|
|
return true;
|
|
}
|
|
|
|
// Close the MP3 reader.
|
|
void Mp3Reader::close() {
|
|
assert(mFp != NULL);
|
|
fclose(mFp);
|
|
}
|
|
|
|
Mp3Reader::~Mp3Reader() {
|
|
}
|