extern "C" int apple_alac_decode_frame(unsigned char *sampleBuffer, uint32_t bufferLength,
unsigned char *dest, int *outsize) {
uint32_t numFrames = 0;
BitBuffer theInputBuffer;
BitBufferInit(&theInputBuffer, sampleBuffer, bufferLength);
theDecoder->Decode(&theInputBuffer, dest, Swap32BtoN(cookie.config.frameLength),
cookie.config.numChannels, &numFrames);
*outsize = numFrames;
return 0;
}
void HitagSSelectUid(u8 *uid, u8 *cSendData)//u8 * pcUid, u8 * pcPage1
{
u8 cTemp[1];
// temporary buffer command & CRC byte
BitBufferInit( cSendData );
cTemp[0] = HITAGS_SELECT_UID << 3;
BitBufferStoreBlock( cTemp, 5 ); // store the five command bits
BitBufferStoreBlock( uid, 32 ); // append UID
cTemp[0] = crc8( cSendData, 37, CRC_PRESET ); // calculate CRC byte
BitBufferStoreBlock( cTemp, 8 ); // append CRC byte
}
size_t ALACSource::readSamples(void *buffer, size_t nsamples)
{
uint32_t bpf = m_asbd.mBytesPerFrame;
if (!m_buffer.count()) {
uint32_t size;
MP4SampleId sid;
try {
sid = m_file.GetSampleIdFromTime(m_track_id, m_position);
size = m_file.GetSampleSize(m_track_id, sid);
} catch (mp4v2::impl::Exception *e) {
delete e;
return 0;
}
MP4Timestamp start;
MP4Duration duration;
std::vector<uint8_t> ivec(size);
uint8_t *vp = &ivec[0];
try {
m_file.ReadSample(m_track_id, sid, &vp, &size, &start,
&duration);
} catch (mp4v2::impl::Exception *e) {
handle_mp4error(e);
}
BitBuffer bits;
BitBufferInit(&bits, vp, size);
m_buffer.resize(duration);
uint32_t ncount;
CHECKCA(m_decoder->Decode(&bits, m_buffer.write_ptr(),
duration, m_asbd.mChannelsPerFrame,
&ncount));
m_buffer.commit(ncount);
m_buffer.advance(m_position - start);
}
uint32_t count = std::min(m_buffer.count(),
static_cast<uint32_t>(nsamples));
size_t nbytes = count * bpf;
util::unpack(m_buffer.read_ptr(), buffer, &nbytes,
m_asbd.mBytesPerFrame / m_asbd.mChannelsPerFrame,
m_oasbd.mBytesPerFrame / m_oasbd.mChannelsPerFrame);
m_buffer.advance(count);
m_position += count;
return count;
}
static prMALError
SDKImportAudio7(
imStdParms *stdParms,
imFileRef SDKfileRef,
imImportAudioRec7 *audioRec7)
{
prMALError result = malNoError;
// privateData
ImporterLocalRec8H ldataH = reinterpret_cast<ImporterLocalRec8H>(audioRec7->privateData);
stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(ldataH));
ImporterLocalRec8Ptr localRecP = reinterpret_cast<ImporterLocalRec8Ptr>( *ldataH );
if(localRecP && localRecP->audio_track && localRecP->alac)
{
assert(localRecP->reader != NULL);
assert(localRecP->file != NULL && localRecP->file->GetMovie() != NULL);
assert(audioRec7->position >= 0); // Do they really want contiguous samples?
assert(audioRec7->position < localRecP->duration);
if(audioRec7->size > localRecP->duration - audioRec7->position)
{
// this does happen, we get asked for audio data past the duration
// let's make sure there's no garbage there and re-set audioRec7->size
for(int c=0; c < localRecP->numChannels; c++)
{
memset(audioRec7->buffer[c], 0, sizeof(float) * audioRec7->size);
}
audioRec7->size = localRecP->duration - audioRec7->position;
}
const AP4_UI32 timestamp_ms = audioRec7->position * 1000 / localRecP->audioSampleRate;
const size_t bytes_per_sample = (localRecP->alac->mConfig.bitDepth <= 16 ? 2 : 4);
const size_t alac_buf_size = localRecP->alac->mConfig.frameLength * localRecP->alac->mConfig.numChannels *
bytes_per_sample + kALACMaxEscapeHeaderBytes;
uint8_t *alac_buffer = (uint8_t *)malloc(alac_buf_size);
AP4_Ordinal sample_index = 0;
AP4_Result ap4_result = localRecP->audio_track->GetSampleIndexForTimeStampMs(timestamp_ms, sample_index);
if(ap4_result == AP4_SUCCESS)
{
// for surround channels
// Premiere uses Left, Right, Left Rear, Right Rear, Center, LFE
// ALAC uses Center, Left, Right, Left Rear, Right Rear, LFE
// http://alac.macosforge.org/trac/browser/trunk/ReadMe.txt
static const int surround_swizzle[] = {4, 0, 1, 2, 3, 5};
static const int stereo_swizzle[] = {0, 1, 2, 3, 4, 5}; // no swizzle, actually
const int *swizzle = localRecP->numChannels > 2 ? surround_swizzle : stereo_swizzle;
csSDK_uint32 samples_needed = audioRec7->size;
PrAudioSample pos = 0;
AP4_DataBuffer dataBuffer;
while(samples_needed > 0 && ap4_result == AP4_SUCCESS && result == malNoError)
{
AP4_Sample sample;
ap4_result = localRecP->audio_track->ReadSample(sample_index, sample, dataBuffer);
if(ap4_result == AP4_SUCCESS)
{
const PrAudioSample sample_pos = sample.GetDts() *
localRecP->audioSampleRate /
localRecP->audio_track->GetMediaTimeScale();
const PrAudioSample sample_len = sample.GetDuration() *
localRecP->audioSampleRate /
localRecP->audio_track->GetMediaTimeScale();
const PrAudioSample skip_samples = (audioRec7->position > sample_pos) ? (audioRec7->position - sample_pos) : 0;
long samples_to_read = sample_len - skip_samples;
if(samples_to_read > samples_needed)
samples_to_read = samples_needed;
else if(samples_to_read < 0)
samples_to_read = 0;
if(samples_to_read > 0)
{
BitBuffer bits;
BitBufferInit(&bits, dataBuffer.UseData(), dataBuffer.GetDataSize());
uint32_t outSamples = 0;
int32_t alac_result = localRecP->alac->Decode(&bits,
alac_buffer, localRecP->alac->mConfig.frameLength, localRecP->numChannels,
&outSamples);
if(alac_result == 0)
{
bool eos = false;
if(samples_to_read > outSamples)
{
samples_to_read = outSamples;
eos = true;
}
if(localRecP->alac->mConfig.bitDepth == 16)
{
CopySamples<int16_t>((const int16_t *)alac_buffer, audioRec7->buffer,
localRecP->numChannels, swizzle, samples_to_read, pos, skip_samples);
}
else if(localRecP->alac->mConfig.bitDepth == 32)
{
CopySamples<int32_t>((const int32_t *)alac_buffer, audioRec7->buffer,
localRecP->numChannels, swizzle, samples_to_read, pos, skip_samples);
}
else
{
assert(localRecP->alac->mConfig.bitDepth == 20 || localRecP->alac->mConfig.bitDepth == 24);
CopySamples24(alac_buffer, audioRec7->buffer,
localRecP->numChannels, swizzle, samples_to_read, pos, skip_samples,
localRecP->alac->mConfig.bitDepth);
}
if(eos)
{
// end of the stream
break;
}
}
else
assert(false);
}
samples_needed -= samples_to_read;
pos += samples_to_read;
sample_index++;
}
else
assert(false);
}
assert(ap4_result == AP4_SUCCESS);
if(ap4_result != AP4_SUCCESS && ap4_result != AP4_ERROR_EOS && ap4_result != AP4_ERROR_OUT_OF_RANGE)
{
result = imFileReadFailed;
}
}
else
{
assert(ap4_result == AP4_ERROR_EOS);
}
free(alac_buffer);
}
stdParms->piSuites->memFuncs->unlockHandle(reinterpret_cast<char**>(ldataH));
assert(result == malNoError);
return result;
}
size_t ALACSource::readSamples(void *buffer, size_t nsamples)
{
nsamples = adjustSamplesToRead(nsamples);
if (!nsamples) return 0;
try {
uint32_t bpf = m_format.bytesPerFrame();
uint8_t *bufp = static_cast<uint8_t*>(buffer);
uint32_t nread = 0;
uint32_t size = std::min(m_buffer.rest(),
static_cast<uint32_t>(nsamples));
if (size) {
std::memcpy(bufp, &m_buffer.v[m_buffer.done * bpf], size * bpf);
m_buffer.advance(size);
nread += size;
bufp += size * bpf;
}
while (nread < nsamples) {
MP4SampleId sid =
m_file.GetSampleIdFromTime(m_track_id, m_position);
uint32_t size;
try {
size = m_file.GetSampleSize(m_track_id, sid);
} catch (mp4v2::impl::Exception *e) {
/*
* Come here when we try to read more samples beyond the end.
* This usually happens when stts entries are incorrect.
* We just treat this as EOF.
*/
delete e;
break;
}
MP4Timestamp start;
MP4Duration duration;
std::vector<uint8_t> ivec(size);
uint8_t *vp = &ivec[0];
m_file.ReadSample(m_track_id, sid, &vp, &size, &start, &duration);
m_buffer.done = m_position - start;
m_position = start + duration;
BitBuffer bits;
BitBufferInit(&bits, &ivec[0], size);
m_buffer.v.resize(bpf * duration);
uint32_t ncount;
CHECKCA(m_decoder->Decode(&bits, &m_buffer.v[0], duration,
m_format.m_nchannels, &ncount));
m_buffer.nsamples = ncount;
duration = std::min(ncount - m_buffer.done,
static_cast<uint32_t>(nsamples) - nread);
std::memcpy(bufp, &m_buffer.v[m_buffer.done * bpf], duration * bpf);
m_buffer.advance(duration);
nread += duration;
bufp += duration * bpf;
}
addSamplesRead(nread);
return nread;
} catch (mp4v2::impl::Exception *e) {
handle_mp4error(e);
}
}
