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); } }