| /*---------------------------------------------------------------------------- |
| * |
| * File: |
| * eas_pcm.c |
| * |
| * Contents and purpose: |
| * Implements the PCM engine including ADPCM decode for SMAF and CMX audio playback. |
| * |
| * Copyright Sonic Network Inc. 2005 |
| |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *---------------------------------------------------------------------------- |
| * Revision Control: |
| * $Revision: 849 $ |
| * $Date: 2007-08-28 08:59:11 -0700 (Tue, 28 Aug 2007) $ |
| *---------------------------------------------------------------------------- |
| */ |
| |
| #include "eas_data.h" |
| #include "eas_report.h" |
| #include "eas_host.h" |
| #include "eas_config.h" |
| #include "eas_parser.h" |
| #include "eas_pcm.h" |
| #include "eas_math.h" |
| #include "eas_mixer.h" |
| |
| #define PCM_MIXER_GUARD_BITS (NUM_MIXER_GUARD_BITS + 1) |
| |
| /*---------------------------------------------------------------------------- |
| * Decoder interfaces |
| *---------------------------------------------------------------------------- |
| */ |
| |
| static EAS_RESULT LinearPCMDecode (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState); |
| static EAS_RESULT LinearPCMLocate (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState, EAS_I32 time); |
| |
| static const S_DECODER_INTERFACE PCMDecoder = |
| { |
| NULL, |
| LinearPCMDecode, |
| LinearPCMLocate, |
| }; |
| |
| /* SMAF ADPCM decoder */ |
| #ifdef _SMAF_PARSER |
| extern S_DECODER_INTERFACE SmafDecoder; |
| #define SMAF_DECODER &SmafDecoder |
| extern S_DECODER_INTERFACE Smaf7BitDecoder; |
| #define SMAF_7BIT_DECODER &Smaf7BitDecoder |
| #else |
| #define SMAF_DECODER NULL |
| #define SMAF_7BIT_DECODER NULL |
| #endif |
| |
| /* IMA ADPCM decoder */ |
| #ifdef _IMA_DECODER |
| extern S_DECODER_INTERFACE IMADecoder; |
| #define IMA_DECODER &IMADecoder |
| #else |
| #define IMA_DECODER NULL |
| #endif |
| |
| static const S_DECODER_INTERFACE * const decoders[] = |
| { |
| &PCMDecoder, |
| SMAF_DECODER, |
| IMA_DECODER, |
| SMAF_7BIT_DECODER |
| }; |
| |
| /*---------------------------------------------------------------------------- |
| * Sample rate conversion |
| *---------------------------------------------------------------------------- |
| */ |
| |
| #define SRC_RATE_MULTIPLER (0x40000000 / _OUTPUT_SAMPLE_RATE) |
| |
| #ifdef _LOOKUP_SAMPLE_RATE |
| static const EAS_U32 srcConvRate[][2] = |
| { |
| 4000L, (4000L << 15) / _OUTPUT_SAMPLE_RATE, |
| 8000L, (8000L << 15) / _OUTPUT_SAMPLE_RATE, |
| 11025L, (11025L << 15) / _OUTPUT_SAMPLE_RATE, |
| 12000L, (12000L << 15) / _OUTPUT_SAMPLE_RATE, |
| 16000L, (16000L << 15) / _OUTPUT_SAMPLE_RATE, |
| 22050L, (22050L << 15) / _OUTPUT_SAMPLE_RATE, |
| 24000L, (24000L << 15) / _OUTPUT_SAMPLE_RATE, |
| 32000L, (32000L << 15) / _OUTPUT_SAMPLE_RATE |
| }; |
| static EAS_U32 CalcBaseFreq (EAS_U32 sampleRate); |
| #define SRC_CONV_RATE_ENTRIES (sizeof(srcConvRate)/sizeof(EAS_U32)/2) |
| #endif |
| |
| |
| /* interface prototypes */ |
| static EAS_RESULT RenderPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState, EAS_I32 numSamples); |
| |
| |
| /* local prototypes */ |
| static S_PCM_STATE *FindSlot (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_PCM_CALLBACK pCallbackFunc, EAS_VOID_PTR cbInstData); |
| static EAS_RESULT InitPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState); |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEInit() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Initializes the PCM engine |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PEInit (S_EAS_DATA *pEASData) |
| { |
| S_PCM_STATE *pState; |
| EAS_INT i; |
| |
| /* check for static memory allocation */ |
| if (pEASData->staticMemoryModel) |
| pEASData->pPCMStreams = EAS_CMEnumData(EAS_CM_PCM_DATA); |
| /* allocate dynamic memory */ |
| else |
| pEASData->pPCMStreams = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_PCM_STATE) * MAX_PCM_STREAMS); |
| |
| if (!pEASData->pPCMStreams) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate memory for PCM streams\n"); */ } |
| return EAS_ERROR_MALLOC_FAILED; |
| } |
| |
| //zero the memory to insure complete initialization |
| EAS_HWMemSet((void *)(pEASData->pPCMStreams),0, sizeof(S_PCM_STATE) * MAX_PCM_STREAMS); |
| |
| /* initialize the state data */ |
| for (i = 0, pState = pEASData->pPCMStreams; i < MAX_PCM_STREAMS; i++, pState++) |
| pState->fileHandle = NULL; |
| |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEShutdown() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Shuts down the PCM engine |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PEShutdown (S_EAS_DATA *pEASData) |
| { |
| |
| /* free any dynamic memory */ |
| if (!pEASData->staticMemoryModel) |
| { |
| if (pEASData->pPCMStreams) |
| { |
| EAS_HWFree(pEASData->hwInstData, pEASData->pPCMStreams); |
| pEASData->pPCMStreams = NULL; |
| } |
| } |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PERender() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Render a buffer of PCM audio |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PERender (S_EAS_DATA* pEASData, EAS_I32 numSamples) |
| { |
| S_PCM_STATE *pState; |
| EAS_RESULT result; |
| EAS_INT i; |
| |
| /* render all the active streams */ |
| for (i = 0, pState = pEASData->pPCMStreams; i < MAX_PCM_STREAMS; i++, pState++) |
| { |
| if ((pState->fileHandle) && (pState->state != EAS_STATE_STOPPED) && (pState->state != EAS_STATE_PAUSED)) |
| if ((result = RenderPCMStream(pEASData, pState, numSamples)) != EAS_SUCCESS) |
| return result; |
| } |
| return EAS_SUCCESS; |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEState() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Returns the current state of the stream |
| * |
| * Inputs: |
| * pEASData - pointer to overall EAS data structure |
| * handle - pointer to file handle |
| * pState - pointer to variable to store state |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| * Notes: |
| * This interface is also exposed in the internal library for use by the other modules. |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| EAS_RESULT EAS_PEState (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pInstData, EAS_STATE *pState) |
| { |
| /* return current state */ |
| *pState = pInstData->state; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEClose() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Close the file and clean up |
| * |
| * Inputs: |
| * pEASData - pointer to overall EAS data structure |
| * handle - pointer to file handle |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PEClose (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState) |
| { |
| EAS_RESULT result; |
| |
| if ((result = EAS_HWCloseFile(pEASData->hwInstData, pState->fileHandle)) != EAS_SUCCESS) |
| return result; |
| |
| pState->fileHandle = NULL; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * PCM_Reset() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Reset the sequencer. Used for locating backwards in the file. |
| * |
| * Inputs: |
| * pEASData - pointer to overall EAS data structure |
| * handle - pointer to file handle |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PEReset (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState) |
| { |
| EAS_RESULT result; |
| |
| /* reset file position to first byte of data in the stream */ |
| if ((result = EAS_HWFileSeek(pEASData->hwInstData, pState->fileHandle, pState->startPos)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %d seeking to start of PCM file\n", result); */ } |
| return result; |
| } |
| |
| /* re-initialize stream */ |
| return InitPCMStream(pEASData, pState); |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEOpenStream() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Starts up a PCM playback |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PEOpenStream (S_EAS_DATA *pEASData, S_PCM_OPEN_PARAMS *pParams, EAS_PCM_HANDLE *pHandle) |
| { |
| EAS_RESULT result; |
| S_PCM_STATE *pState; |
| EAS_I32 filePos; |
| |
| /* make sure we support this decoder */ |
| if (pParams->decoder >= NUM_DECODER_MODULES) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Decoder selector out of range\n"); */ } |
| return EAS_ERROR_PARAMETER_RANGE; |
| } |
| if (decoders[pParams->decoder] == NULL) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Decoder module not available\n"); */ } |
| return EAS_ERROR_FEATURE_NOT_AVAILABLE; |
| } |
| |
| /* find a slot for the new stream */ |
| if ((pState = FindSlot(pEASData, pParams->fileHandle, pParams->pCallbackFunc, pParams->cbInstData)) == NULL) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Unable to open ADPCM stream, too many streams open\n"); */ } |
| return EAS_ERROR_MAX_PCM_STREAMS; |
| } |
| |
| /* get the current file position */ |
| if ((result = EAS_HWFilePos(pEASData->hwInstData, pState->fileHandle, &filePos)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_HWFilePos returned %ld\n",result); */ } |
| pState->fileHandle = NULL; |
| return result; |
| } |
| |
| pState->pDecoder = decoders[pParams->decoder]; |
| pState->startPos = filePos; |
| pState->bytesLeftLoop = pState->byteCount = pParams->size; |
| pState->loopStart = pParams->loopStart; |
| pState->samplesTilLoop = (EAS_I32) pState->loopStart; |
| pState->loopSamples = pParams->loopSamples; |
| pState->samplesInLoop = 0; |
| pState->blockSize = (EAS_U16) pParams->blockSize; |
| pState->flags = pParams->flags; |
| pState->envData = pParams->envData; |
| pState->volume = pParams->volume; |
| pState->sampleRate = (EAS_U16) pParams->sampleRate; |
| |
| /* set the base frequency */ |
| pState->basefreq = (SRC_RATE_MULTIPLER * (EAS_U32) pParams->sampleRate) >> 15; |
| |
| /* calculate shift for frequencies > 1.0 */ |
| pState->rateShift = 0; |
| while (pState->basefreq > 32767) |
| { |
| pState->basefreq = pState->basefreq >> 1; |
| pState->rateShift++; |
| } |
| |
| /* initialize */ |
| if ((result = InitPCMStream(pEASData, pState)) != EAS_SUCCESS) |
| return result; |
| |
| *pHandle = pState; |
| |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PEOpenStream: StartPos=%d, byteCount = %d, loopSamples=%d\n", |
| pState->startPos, pState->byteCount, pState->loopSamples); */ } |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEContinueStream() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Continues a PCM stream |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -e{715} reserved for future use */ |
| EAS_RESULT EAS_PEContinueStream (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState, EAS_I32 size) |
| { |
| |
| /* add new samples to count */ |
| pState->bytesLeft += size; |
| if (pState->bytesLeft > 0) |
| pState->flags &= ~PCM_FLAGS_EMPTY; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEGetFileHandle() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Returns the file handle of a stream |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| EAS_RESULT EAS_PEGetFileHandle (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState, EAS_FILE_HANDLE *pFileHandle) |
| { |
| *pFileHandle = pState->fileHandle; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEUpdateParams() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Update the pitch and volume parameters for a PCM stream |
| * |
| * Inputs: |
| * pEASData - pointer to EAS library instance data |
| * handle - pointer to S_PCM_STATE for this stream |
| * gainLeft - linear gain multipler in 1.15 fraction format |
| * gainRight - linear gain multipler in 1.15 fraction format |
| * pitch - pitch shift in cents |
| * initial - initial settings, set current gain |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| * Notes |
| * In mono mode, leftGain controls the output gain and rightGain is ignored |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| /*lint -esym(715, gainRight) used only in 2-channel version */ |
| EAS_RESULT EAS_PEUpdateParams (S_EAS_DATA* pEASData, EAS_PCM_HANDLE pState, EAS_I16 pitch, EAS_I16 gainLeft, EAS_I16 gainRight) |
| { |
| |
| pState->gainLeft = gainLeft; |
| |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| pState->gainRight = gainRight; |
| #endif |
| |
| pState->pitch = pitch; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PELocate() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * This function seeks to the requested place in the file. Accuracy |
| * is dependent on the sample rate and block size. |
| * |
| * Inputs: |
| * pEASData - pointer to overall EAS data structure |
| * pState - stream handle |
| * time - media time in milliseconds |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PELocate (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState, EAS_I32 time) |
| { |
| if (pState->pDecoder->pfLocate == NULL) |
| return EAS_ERROR_FEATURE_NOT_AVAILABLE; |
| |
| return pState->pDecoder->pfLocate(pEASData, pState, time); |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEUpdateVolume() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Update the volume parameters for a PCM stream |
| * |
| * Inputs: |
| * pEASData - pointer to EAS library instance data |
| * handle - pointer to S_PCM_STATE for this stream |
| * gainLeft - linear gain multipler in 1.15 fraction format |
| * gainRight - linear gain multipler in 1.15 fraction format |
| * initial - initial settings, set current gain |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| * Notes |
| * In mono mode, leftGain controls the output gain and rightGain is ignored |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| EAS_RESULT EAS_PEUpdateVolume (S_EAS_DATA* pEASData, EAS_PCM_HANDLE pState, EAS_I16 volume) |
| { |
| pState->volume = volume; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEUpdatePitch() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Update the pitch parameter for a PCM stream |
| * |
| * Inputs: |
| * pEASData - pointer to EAS library instance data |
| * pState - pointer to S_PCM_STATE for this stream |
| * pitch - new pitch value in pitch cents |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| EAS_RESULT EAS_PEUpdatePitch (S_EAS_DATA* pEASData, EAS_PCM_HANDLE pState, EAS_I16 pitch) |
| { |
| pState->pitch = pitch; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEPause() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Mute and stop rendering a PCM stream. Sets the gain target to zero and stops the playback |
| * at the end of the next audio frame. |
| * |
| * Inputs: |
| * pEASData - pointer to EAS library instance data |
| * handle - pointer to S_PCM_STATE for this stream |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| EAS_RESULT EAS_PEPause (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState) |
| { |
| /* set state to stopping */ |
| pState->state = EAS_STATE_PAUSING; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PEResume() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Resume rendering a PCM stream. Sets the gain target back to its |
| * previous setting and restarts playback at the end of the next audio |
| * frame. |
| * |
| * Inputs: |
| * pEASData - pointer to EAS library instance data |
| * handle - pointer to S_PCM_STATE for this stream |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| EAS_RESULT EAS_PEResume (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState) |
| { |
| /* set state to stopping */ |
| pState->state = EAS_STATE_PLAY; |
| return EAS_SUCCESS; |
| } |
| |
| EAS_U32 getDecayScale(EAS_U32 index) |
| { |
| EAS_U32 utemp; |
| |
| //envelope decay segment |
| switch (index) |
| { |
| case 0: //no decay |
| utemp = 512;//32768; |
| break; |
| case 1: //.0156 dB per update |
| utemp = 511;//32709; |
| break; |
| case 2: //.03125 |
| utemp = 510;//32649; |
| break; |
| case 3: //.0625 |
| utemp = 508;//32532; |
| break; |
| case 4: //.125 |
| utemp = 505;//32298; |
| break; |
| case 5: //.25 |
| utemp = 497;//31835; |
| break; |
| case 6: //.5 |
| utemp = 483;//30929; |
| break; |
| case 7: //1.0 |
| utemp = 456;//29193; |
| break; |
| case 8: //2.0 |
| utemp = 406;//26008; |
| break; |
| case 9: //4.0 |
| utemp = 323;//20642; |
| break; |
| case 10: //8.0 |
| utemp = 203;//13004; |
| break; |
| case 11: //16.0 |
| utemp = 81;//5160; |
| break; |
| case 12: //32.0 |
| utemp = 13;//813; |
| break; |
| case 13: //64.0 |
| utemp = 0;//20; |
| break; |
| case 14: //128.0 |
| utemp = 0; |
| break; |
| case 15: //256.0 |
| default: |
| utemp = 0; |
| break; |
| } |
| //printf("getdecayscale returned %d\n",utemp); |
| return utemp; |
| } |
| |
| EAS_U32 getAttackIncrement(EAS_U32 index) |
| { |
| EAS_U32 utemp; |
| |
| //envelope decay segment |
| switch (index) |
| { |
| case 0: |
| utemp = 32; |
| break; |
| case 1: |
| utemp = 64; |
| break; |
| case 2: |
| utemp = 128; |
| break; |
| case 3: |
| utemp = 256; |
| break; |
| case 4: |
| utemp = 512; |
| break; |
| case 5: |
| utemp = 1024; |
| break; |
| case 6: |
| utemp = 2048; |
| break; |
| case 7: |
| utemp = 4096; |
| break; |
| case 8: |
| utemp = 8192; |
| break; |
| case 9: |
| utemp = 16384; |
| break; |
| case 10: |
| utemp = 32768; |
| break; |
| case 11: |
| utemp = 65536; |
| break; |
| case 12: |
| utemp = 65536; |
| break; |
| case 13: |
| utemp = 65536; |
| break; |
| case 14: |
| utemp = 65535; |
| break; |
| case 15: |
| default: |
| utemp = 0; |
| break; |
| } |
| //printf("getattackincrement returned %d\n",utemp); |
| return utemp; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PERelease() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Put the PCM stream envelope into release. |
| * |
| * Inputs: |
| * pEASData - pointer to EAS library instance data |
| * handle - pointer to S_PCM_STATE for this stream |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| /*lint -esym(715, pEASData) reserved for future use */ |
| EAS_RESULT EAS_PERelease (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState) |
| { |
| EAS_U32 utemp; |
| |
| //printf("handling note-off part of envelope\n"); |
| /*if the note is not ignore release or sustained*/ |
| if (((pState->envData >> 24) & 0x0F)==0) |
| { |
| /* set envelope state to release */ |
| pState->envState = PCM_ENV_RELEASE; |
| utemp = ((pState->envData >> 20) & 0x0F); |
| pState->envScale = getDecayScale(utemp); //getReleaseScale(utemp); |
| } |
| else |
| { |
| /*else change envelope state to sustain */ |
| pState->envState = PCM_ENV_SUSTAIN; |
| utemp = ((pState->envData >> 28) & 0x0F); |
| pState->envScale = getDecayScale(utemp); //getSustainScale(utemp); |
| } |
| //since we are in release, don't let anything hang around too long |
| //printf("checking env scale, val = %d\n",((S_PCM_STATE*) handle)->envScale); |
| if (pState->envScale > 505) |
| pState->envScale = 505; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * FindSlot() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Locates an empty stream slot and assigns the file handle |
| * |
| * Inputs: |
| * pEASData - pointer to EAS library instance data |
| * fileHandle - file handle |
| * pCallbackFunc - function to be called back upon EAS_STATE_STOPPED |
| * |
| * Outputs: |
| * returns handle to slot or NULL if all slots are used |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static S_PCM_STATE *FindSlot (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_PCM_CALLBACK pCallbackFunc, EAS_VOID_PTR cbInstData) |
| { |
| EAS_INT i; |
| S_PCM_STATE *pState; |
| |
| #ifndef NO_PCM_STEAL |
| S_PCM_STATE *foundState = NULL; |
| EAS_INT count = 0; |
| EAS_U32 startOrder = 0xFFFFFFFF; |
| S_PCM_STATE *stealState = NULL; |
| EAS_U32 youngest = 0; |
| |
| /* find an empty slot, count total in use, and find oldest in use (lowest start order) */ |
| for (i = 0, pState = pEASData->pPCMStreams; i < MAX_PCM_STREAMS; i++, pState++) |
| { |
| /* if this one is available */ |
| if (pState->fileHandle == NULL) |
| { |
| foundState = pState; |
| } |
| /* else this one is in use, so see if it is the oldest, and count total in use */ |
| /* also find youngest */ |
| else |
| { |
| /*one more voice in use*/ |
| count++; |
| /* is this the oldest? (lowest start order) */ |
| if ((pState->state != EAS_STATE_STOPPING) && (pState->startOrder < startOrder)) |
| { |
| /* remember this one */ |
| stealState = pState; |
| /* remember the oldest so far */ |
| startOrder = pState->startOrder; |
| } |
| /* is this the youngest? (highest start order) */ |
| if (pState->startOrder >= youngest) |
| { |
| youngest = pState->startOrder; |
| } |
| } |
| } |
| |
| /* if there are too many voices active, stop the oldest one */ |
| if (count > PCM_STREAM_THRESHOLD) |
| { |
| //printf("stealing!!!\n"); |
| /* make sure we got one, although we should always have one at this point */ |
| if (stealState != NULL) |
| { |
| //flag this as stopping, so it will get shut off |
| stealState->state = EAS_STATE_STOPPING; |
| } |
| } |
| |
| /* if there are no available open streams (we won't likely see this, due to stealing) */ |
| if (foundState == NULL) |
| return NULL; |
| |
| /* save info */ |
| foundState->startOrder = youngest + 1; |
| foundState->fileHandle = fileHandle; |
| foundState->pCallback = pCallbackFunc; |
| foundState->cbInstData = cbInstData; |
| return foundState; |
| #else |
| /* find an empty slot*/ |
| for (i = 0; i < MAX_PCM_STREAMS; i++) |
| { |
| pState = &pEASData->pPCMStreams[i]; |
| if (pState->fileHandle != NULL) |
| continue; |
| |
| pState->fileHandle = fileHandle; |
| pState->pCallback = pCallbackFunc; |
| pState->cbInstData = cbInstData; |
| return pState; |
| } |
| return NULL; |
| #endif |
| } |
| |
| #ifdef _LOOKUP_SAMPLE_RATE |
| /*---------------------------------------------------------------------------- |
| * CalcBaseFreq() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Calculates the fractional phase increment for the sample rate converter |
| * |
| * Inputs: |
| * sampleRate - sample rate in samples/sec |
| * |
| * Outputs: |
| * Returns fractional sample rate with a 15-bit fraction |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_U32 CalcBaseFreq (EAS_U32 sampleRate) |
| { |
| EAS_INT i; |
| |
| /* look up the conversion rate */ |
| for (i = 0; i < (EAS_INT)(SRC_CONV_RATE_ENTRIES); i ++) |
| { |
| if (srcConvRate[i][0] == sampleRate) |
| return srcConvRate[i][1]; |
| } |
| |
| /* if not found in table, do it the long way */ |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Sample rate %u not in table, calculating by division\n", sampleRate); */ } |
| |
| return (SRC_RATE_MULTIPLER * (EAS_U32) sampleRate) >> 15; |
| } |
| #endif |
| |
| /*---------------------------------------------------------------------------- |
| * InitPCMStream() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Start an ADPCM stream playback. Decodes the header, preps the engine. |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_RESULT InitPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState) |
| { |
| |
| /* initialize the data structure */ |
| pState->bytesLeft = pState->byteCount; |
| pState->phase = 0; |
| pState->srcByte = 0; |
| pState->decoderL.acc = 0; |
| pState->decoderL.output = 0; |
| pState->decoderL.x0 = pState->decoderL.x1 = 0; |
| pState->decoderL.step = 0; |
| pState->decoderR.acc = 0; |
| pState->decoderR.output = 0; |
| pState->decoderR.x0 = pState->decoderR.x1 = 0; |
| pState->decoderR.step = 0; |
| pState->hiNibble = EAS_FALSE; |
| pState->pitch = 0; |
| pState->blockCount = 0; |
| pState->gainLeft = PCM_DEFAULT_GAIN_SETTING; |
| // pState->currentGainLeft = PCM_DEFAULT_GAIN_SETTING; |
| pState->envValue = 0; |
| pState->envState = PCM_ENV_START; |
| |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| pState->gainRight = PCM_DEFAULT_GAIN_SETTING; |
| // pState->currentGainRight = PCM_DEFAULT_GAIN_SETTING; |
| #endif |
| pState->state = EAS_STATE_READY; |
| |
| /* initialize the decoder */ |
| if (pState->pDecoder->pfInit) |
| return (*pState->pDecoder->pfInit)(pEASData, pState); |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * RenderPCMStream() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Decodes a buffer of ADPCM data. |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_RESULT RenderPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState, EAS_I32 numSamples) |
| { |
| EAS_RESULT result; |
| EAS_U32 phaseInc; |
| EAS_I32 gainLeft, gainIncLeft; |
| EAS_I32 *pOut; |
| EAS_I32 temp; |
| EAS_U32 utemp; |
| |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| EAS_I32 gainRight, gainIncRight; |
| #endif |
| |
| #if 0 |
| printf("env data: AR = %d, DR = %d, SL = %d, SR = %d, RR = %d\n", |
| ((pState->envData >> 12) & 0x0F), |
| ((pState->envData >> 16) & 0x0F), |
| ((pState->envData >> 8) & 0x0F), |
| ((pState->envData >> 28) & 0x0F), |
| ((pState->envData >> 20) & 0x0F)); |
| #endif |
| |
| if (pState->envState == PCM_ENV_START) |
| { |
| //printf("env start\n"); |
| utemp = ((pState->envData >> 12) & 0x0F); |
| //if fastest rate, attack is already completed |
| //do the same for slowest rate, since that allows zero to be passed for default envelope |
| if (utemp == 0x0F || utemp == 0x00) |
| { |
| //start envelope at full |
| pState->envValue = (32768<<7); |
| //jump right into decay |
| utemp = ((pState->envData >> 16) & 0x0F); |
| pState->envScale = getDecayScale(utemp); |
| pState->envState = PCM_ENV_DECAY; |
| pState->currentGainLeft = (EAS_I16) FMUL_15x15(pState->gainLeft, pState->volume); |
| pState->currentGainRight = (EAS_I16) FMUL_15x15(pState->gainRight, pState->volume); |
| } |
| //else attack has a ramp |
| else |
| { |
| //start the envelope very low |
| pState->envValue = (2<<7); |
| pState->currentGainLeft = 0; |
| pState->currentGainRight = 0; |
| //get envelope attack scaling value |
| pState->envScale = getAttackIncrement(utemp); |
| //go to attack state |
| pState->envState = PCM_ENV_ATTACK; |
| } |
| } |
| if (pState->envState == PCM_ENV_ATTACK) |
| { |
| //printf("env attack, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale); |
| //update envelope value |
| pState->envValue = pState->envValue + (pState->envScale << 7); |
| //check envelope level and update state if needed |
| if (pState->envValue >= (32768<<7)) |
| { |
| pState->envValue = (32768<<7); |
| utemp = ((pState->envData >> 16) & 0x0F); |
| pState->envScale = getDecayScale(utemp); |
| pState->envState = PCM_ENV_DECAY; |
| } |
| } |
| else if (pState->envState == PCM_ENV_DECAY) |
| { |
| //printf("env decay, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale); |
| //update envelope value |
| pState->envValue = (pState->envValue * pState->envScale)>>9; |
| //check envelope level against sustain level and update state if needed |
| utemp = ((pState->envData >> 8) & 0x0F); |
| if (utemp == (EAS_U32)0x0F) |
| utemp = (2<<7); |
| else |
| { |
| utemp = ((32769<<7) >> (utemp>>1)); |
| } |
| if (pState->envValue <= utemp) |
| { |
| utemp = ((pState->envData >> 28) & 0x0F); |
| pState->envScale = getDecayScale(utemp); //getSustainScale(utemp); |
| pState->envState = PCM_ENV_SUSTAIN; |
| } |
| } |
| else if (pState->envState == PCM_ENV_SUSTAIN) |
| { |
| //printf("env sustain, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale); |
| //update envelope value |
| pState->envValue = (pState->envValue * pState->envScale)>>9; |
| //check envelope level against bottom level and update state if needed |
| if (pState->envValue <= (2<<7)) |
| { |
| //no more decay |
| pState->envScale = 512; |
| pState->envState = PCM_ENV_END; |
| } |
| } |
| else if (pState->envState == PCM_ENV_RELEASE) |
| { |
| //printf("env release, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale); |
| //update envelope value |
| pState->envValue = (pState->envValue * pState->envScale)>>9; |
| //check envelope level against bottom level and update state if needed |
| if (pState->envValue <= (2<<7)) |
| { |
| //no more decay |
| pState->envScale = 512; |
| pState->envState = PCM_ENV_END; |
| } |
| } |
| else if (pState->envState == PCM_ENV_END) |
| { |
| //printf("env end\n"); |
| /* set state to stopping, already ramped down */ |
| pState->state = EAS_STATE_STOPPING; |
| } |
| |
| //pState->gainLeft = (EAS_U16)((pState->gainLeft * (pState->envValue>>7))>>15); |
| //pState->gainRight = (EAS_U16)((pState->gainRight * (pState->envValue>>7))>>15); |
| |
| /* gain to 32-bits to increase resolution on anti-zipper filter */ |
| /*lint -e{703} use shift for performance */ |
| gainLeft = (EAS_I32) pState->currentGainLeft << SYNTH_UPDATE_PERIOD_IN_BITS; |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| /*lint -e{703} use shift for performance */ |
| gainRight = (EAS_I32) pState->currentGainRight << SYNTH_UPDATE_PERIOD_IN_BITS; |
| #endif |
| |
| /* calculate a new gain increment, gain target is zero if pausing */ |
| if ((pState->state == EAS_STATE_PAUSING) || (pState->state == EAS_STATE_PAUSED)) |
| { |
| gainIncLeft = -pState->currentGainLeft; |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| gainIncRight= -pState->currentGainRight; |
| #endif |
| } |
| else |
| { |
| EAS_I32 gain = FMUL_15x15(pState->envValue >> 7, pState->volume); |
| gainIncLeft = FMUL_15x15(pState->gainLeft, gain) - pState->currentGainLeft; |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| gainIncRight = FMUL_15x15(pState->gainRight, gain) - pState->currentGainRight; |
| #endif |
| } |
| |
| /* calculate phase increment */ |
| phaseInc = pState->basefreq; |
| |
| /* convert pitch cents to linear multiplier */ |
| if (pState->pitch) |
| { |
| temp = EAS_Calculate2toX(pState->pitch); |
| phaseInc = FMUL_15x15(phaseInc, temp); |
| } |
| phaseInc = phaseInc << pState->rateShift; |
| |
| /* pointer to mix buffer */ |
| pOut = pEASData->pMixBuffer; |
| |
| /* render a buffer of samples */ |
| while (numSamples--) |
| { |
| |
| /* interpolate an output sample */ |
| pState->decoderL.output = pState->decoderL.x0 + FMUL_15x15((pState->decoderL.x1 - pState->decoderL.x0), pState->phase & PHASE_FRAC_MASK); |
| |
| /* stereo output */ |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| |
| /* stereo stream? */ |
| if (pState->flags & PCM_FLAGS_STEREO) |
| pState->decoderR.output = pState->decoderR.x0 + FMUL_15x15((pState->decoderR.x1 - pState->decoderR.x0), pState->phase & PHASE_FRAC_MASK); |
| |
| /* gain scale and mix */ |
| /*lint -e{704} use shift instead of division */ |
| *pOut++ += (pState->decoderL.output * (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS; |
| gainLeft += gainIncLeft; |
| |
| /*lint -e{704} use shift instead of division */ |
| if (pState->flags & PCM_FLAGS_STEREO) |
| *pOut++ += (pState->decoderR.output * (gainRight >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS; |
| else |
| *pOut++ += (pState->decoderL.output * (gainRight >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS; |
| |
| gainRight += gainIncRight; |
| |
| /* mono output */ |
| #else |
| /* if stereo stream, decode right channel and mix to mono */ |
| if (pState->flags & PCM_FLAGS_STEREO) |
| { |
| pState->decoderR.output= pState->decoderR.x0 + FMUL_15x15((pState->decoderR.x1 - pState->decoderR.x0), pState->phase & PHASE_FRAC_MASK); |
| |
| /* for mono, sum stereo ADPCM to mono */ |
| /*lint -e{704} use shift instead of division */ |
| *pOut++ += ((pState->decoderL.output + pState->decoderR.output) * (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS; |
| } |
| else |
| /*lint -e{704} use shift instead of division */ |
| *pOut++ += (pState->decoderL.output * (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS; |
| |
| gainLeft += gainIncLeft; |
| #endif |
| |
| /* advance phase accumulator */ |
| pState->phase += phaseInc; |
| |
| /* if integer part of phase accumulator is non-zero, advance to next sample */ |
| while (pState->phase & ~PHASE_FRAC_MASK) |
| { |
| pState->decoderL.x0 = pState->decoderL.x1; |
| pState->decoderR.x0 = pState->decoderR.x1; |
| |
| /* give the source a chance to continue the stream */ |
| if (!pState->bytesLeft && pState->pCallback && ((pState->flags & PCM_FLAGS_EMPTY) == 0)) |
| { |
| pState->flags |= PCM_FLAGS_EMPTY; |
| (*pState->pCallback)(pEASData, pState->cbInstData, pState, EAS_STATE_EMPTY); |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "RenderPCMStream: After empty callback, bytesLeft = %d\n", pState->bytesLeft); */ } |
| } |
| |
| /* decode the next sample */ |
| if ((result = (*pState->pDecoder->pfDecodeSample)(pEASData, pState)) != EAS_SUCCESS) |
| return result; |
| |
| /* adjust phase by one sample */ |
| pState->phase -= (1L << NUM_PHASE_FRAC_BITS); |
| } |
| |
| } |
| |
| /* save new gain */ |
| /*lint -e{704} use shift instead of division */ |
| pState->currentGainLeft = (EAS_I16) (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS); |
| |
| #if (NUM_OUTPUT_CHANNELS == 2) |
| /*lint -e{704} use shift instead of division */ |
| pState->currentGainRight = (EAS_I16) (gainRight >> SYNTH_UPDATE_PERIOD_IN_BITS); |
| #endif |
| |
| /* if pausing, set new state and notify */ |
| if (pState->state == EAS_STATE_PAUSING) |
| { |
| pState->state = EAS_STATE_PAUSED; |
| if (pState->pCallback) |
| (*pState->pCallback)(pEASData, pState->cbInstData, pState, pState->state); |
| } |
| |
| /* if out of data, set stopped state and notify */ |
| if (pState->bytesLeft == 0 || pState->state == EAS_STATE_STOPPING) |
| { |
| pState->state = EAS_STATE_STOPPED; |
| |
| /* do callback unless the file has already been closed */ |
| if (pState->pCallback && pState->fileHandle) |
| (*pState->pCallback)(pEASData, pState->cbInstData, pState, pState->state); |
| } |
| |
| if (pState->state == EAS_STATE_READY) |
| pState->state = EAS_STATE_PLAY; |
| |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * LinearPCMDecode() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Decodes a PCM sample |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_RESULT LinearPCMDecode (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState) |
| { |
| EAS_RESULT result; |
| EAS_HW_DATA_HANDLE hwInstData; |
| |
| hwInstData = ((S_EAS_DATA*) pEASData)->hwInstData; |
| |
| /* if out of data, check for loop */ |
| if ((pState->bytesLeft == 0) && (pState->loopSamples != 0)) |
| { |
| if ((result = EAS_HWFileSeek(pEASData->hwInstData, pState->fileHandle, (EAS_I32) (pState->startPos + pState->loopLocation))) != EAS_SUCCESS) |
| return result; |
| pState->bytesLeft = pState->byteCount = (EAS_I32) pState->bytesLeftLoop; |
| pState->flags &= ~PCM_FLAGS_EMPTY; |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "LinearPCMDecode: Rewind file to %d, bytesLeft = %d\n", pState->startPos, pState->bytesLeft); */ } |
| } |
| |
| if (pState->bytesLeft) |
| { |
| |
| /* check format byte for 8-bit samples */ |
| if (pState->flags & PCM_FLAGS_8_BIT) |
| { |
| /* fetch left or mono sample */ |
| if ((result = EAS_HWGetByte(hwInstData, pState->fileHandle, &pState->srcByte)) != EAS_SUCCESS) |
| return result; |
| |
| /* if unsigned */ |
| if (pState->flags & PCM_FLAGS_UNSIGNED) |
| { |
| /*lint -e{734} converting unsigned 8-bit to signed 16-bit */ |
| pState->decoderL.x1 = (EAS_PCM)(((EAS_PCM) pState->srcByte << 8) ^ 0x8000); |
| } |
| else |
| { |
| /*lint -e{734} converting signed 8-bit to signed 16-bit */ |
| pState->decoderL.x1 = (EAS_PCM)((EAS_PCM) pState->srcByte << 8); |
| } |
| pState->bytesLeft--; |
| |
| /* fetch right sample */ |
| if(pState->flags & PCM_FLAGS_STEREO) |
| { |
| if ((result = EAS_HWGetByte(hwInstData, pState->fileHandle, &pState->srcByte)) != EAS_SUCCESS) |
| return result; |
| |
| /* if unsigned */ |
| if (pState->flags & PCM_FLAGS_UNSIGNED) |
| { |
| /*lint -e{734} converting unsigned 8-bit to signed 16-bit */ |
| pState->decoderR.x1 = (EAS_PCM)(((EAS_PCM) pState->srcByte << 8) ^ 0x8000); |
| } |
| else |
| { |
| /*lint -e{734} converting signed 8-bit to signed 16-bit */ |
| pState->decoderR.x1 = (EAS_PCM)((EAS_PCM) pState->srcByte << 8); |
| } |
| pState->bytesLeft--; |
| } |
| } |
| |
| /* must be 16-bit samples */ |
| else |
| { |
| //unsigned 16 bit currently not supported |
| if (pState->flags & PCM_FLAGS_UNSIGNED) |
| { |
| return EAS_ERROR_INVALID_PCM_TYPE; |
| } |
| |
| /* fetch left or mono sample */ |
| if ((result = EAS_HWGetWord(hwInstData, pState->fileHandle, &pState->decoderL.x1, EAS_FALSE)) != EAS_SUCCESS) |
| return result; |
| pState->bytesLeft -= 2; |
| |
| /* fetch right sample */ |
| if(pState->flags & PCM_FLAGS_STEREO) |
| { |
| if ((result = EAS_HWGetWord(hwInstData, pState->fileHandle, &pState->decoderR.x1, EAS_FALSE)) != EAS_SUCCESS) |
| return result; |
| pState->bytesLeft -= 2; |
| } |
| } |
| } |
| |
| /* no more data, force zero samples */ |
| else |
| pState->decoderL.x1 = pState->decoderR.x1 = 0; |
| |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * LinearPCMLocate() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Locate in a linear PCM stream |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_RESULT LinearPCMLocate (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState, EAS_I32 time) |
| { |
| EAS_RESULT result; |
| EAS_I32 temp; |
| EAS_I32 secs, msecs; |
| EAS_INT shift; |
| |
| /* calculate size of sample frame */ |
| if (pState->flags & PCM_FLAGS_8_BIT) |
| shift = 0; |
| else |
| shift = 1; |
| if (pState->flags & PCM_FLAGS_STEREO) |
| shift++; |
| |
| /* break down into secs and msecs */ |
| secs = time / 1000; |
| msecs = time - (secs * 1000); |
| |
| /* calculate sample number fraction from msecs */ |
| temp = (msecs * pState->sampleRate); |
| temp = (temp >> 10) + ((temp * 49) >> 21); |
| |
| /* add integer sample count */ |
| temp += secs * pState->sampleRate; |
| |
| /* calculate the position based on sample frame size */ |
| /*lint -e{703} use shift for performance */ |
| temp <<= shift; |
| |
| /* past end of sample? */ |
| if (temp > (EAS_I32) pState->loopStart) |
| { |
| /* if not looped, flag error */ |
| if (pState->loopSamples == 0) |
| { |
| pState->bytesLeft = 0; |
| pState->flags |= PCM_FLAGS_EMPTY; |
| return EAS_ERROR_LOCATE_BEYOND_END; |
| } |
| |
| /* looped sample - calculate position in loop */ |
| while (temp > (EAS_I32) pState->loopStart) |
| temp -= (EAS_I32) pState->loopStart; |
| } |
| |
| /* seek to new position */ |
| if ((result = EAS_PESeek(pEASData, pState, &temp)) != EAS_SUCCESS) |
| return result; |
| |
| /* reset state */ |
| if ((pState->state != EAS_STATE_PAUSING) && (pState->state != EAS_STATE_PAUSED)) |
| pState->state = EAS_STATE_READY; |
| |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_PESeek |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Locate to a particular byte in a PCM stream |
| *---------------------------------------------------------------------------- |
| * This bit is tricky because the chunks may not be contiguous, |
| * so we have to rely on the parser to position in the file. We |
| * do this by seeking to the end of each chunk and simulating an |
| * empty buffer condition until we get to where we want to go. |
| * |
| * A better solution would be a parser API for re-positioning, |
| * but there isn't time at the moment to re-factor all the |
| * parsers to support a new API. |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_PESeek (S_EAS_DATA *pEASData, S_PCM_STATE *pState, EAS_I32 *pLocation) |
| { |
| EAS_RESULT result; |
| |
| /* seek to start of audio */ |
| if ((result = EAS_HWFileSeek(pEASData->hwInstData, pState->fileHandle, pState->startPos)) != EAS_SUCCESS) |
| { |
| pState->state = EAS_STATE_ERROR; |
| return result; |
| } |
| pState->bytesLeft = pState->bytesLeftLoop; |
| |
| /* skip through chunks until we find the right chunk */ |
| while (*pLocation > (EAS_I32) pState->bytesLeft) |
| { |
| /* seek to end of audio chunk */ |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PESeek: Seek to offset = %d\n", pState->bytesLeft); */ } |
| if ((result = EAS_HWFileSeekOfs(pEASData->hwInstData, pState->fileHandle, pState->bytesLeft)) != EAS_SUCCESS) |
| { |
| pState->state = EAS_STATE_ERROR; |
| return result; |
| } |
| *pLocation -= pState->bytesLeft; |
| pState->bytesLeft = 0; |
| pState->flags |= PCM_FLAGS_EMPTY; |
| |
| /* retrieve more data */ |
| if (pState->pCallback) |
| (*pState->pCallback)(pEASData, pState->cbInstData, pState, EAS_STATE_EMPTY); |
| |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PESeek: bytesLeft=%d, byte location = %d\n", pState->bytesLeft, *pLocation); */ } |
| |
| /* no more samples */ |
| if (pState->bytesLeft == 0) |
| return EAS_ERROR_LOCATE_BEYOND_END; |
| } |
| |
| /* seek to new offset in current chunk */ |
| if (*pLocation > 0) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PESeek: Seek to offset = %d\n", *pLocation); */ } |
| if ((result = EAS_HWFileSeekOfs(pEASData->hwInstData, pState->fileHandle, *pLocation)) != EAS_SUCCESS) |
| { |
| pState->state = EAS_STATE_ERROR; |
| return result; |
| } |
| |
| /* if not streamed, calculate number of bytes left */ |
| if (pState->flags & PCM_FLAGS_STREAMING) |
| pState->bytesLeft = 0x7fffffff; |
| else |
| pState->bytesLeft -= *pLocation; |
| } |
| return EAS_SUCCESS; |
| } |
| |
