int main(void)
{
#ifndef GD_LEGACY_API
return 77; /* skip */
#else
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "data RAW UINT8 11\n";
int fd, error, r = 0;
unsigned int spf;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
spf = GetSamplesPerFrame(filedir, "data", &error);
unlink(format);
rmdir(filedir);
CHECKU(spf, 11);
return r;
#endif
}
//-------------------------------------------------------------------------
// Description:
//
// Verifies that the APO is ready to process and locks its state if so.
//
// Parameters:
//
// u32NumInputConnections - [in] number of input connections attached to this APO
// ppInputConnections - [in] connection descriptor of each input connection attached to this APO
// u32NumOutputConnections - [in] number of output connections attached to this APO
// ppOutputConnections - [in] connection descriptor of each output connection attached to this APO
//
// Return values:
//
// S_OK Object is locked and ready to process.
// E_POINTER Invalid pointer passed to function.
// APOERR_INVALID_CONNECTION_FORMAT Invalid connection format.
// APOERR_NUM_CONNECTIONS_INVALID Number of input or output connections is not valid on
// this APO.
STDMETHODIMP CSwapAPOMFX::LockForProcess(UINT32 u32NumInputConnections,
APO_CONNECTION_DESCRIPTOR** ppInputConnections,
UINT32 u32NumOutputConnections, APO_CONNECTION_DESCRIPTOR** ppOutputConnections)
{
ASSERT_NONREALTIME();
HRESULT hr = S_OK;
hr = CBaseAudioProcessingObject::LockForProcess(u32NumInputConnections,
ppInputConnections, u32NumOutputConnections, ppOutputConnections);
IF_FAILED_JUMP(hr, Exit);
if (!IsEqualGUID(m_AudioProcessingMode, AUDIO_SIGNALPROCESSINGMODE_RAW) && m_fEnableDelayMFX)
{
m_nDelayFrames = FRAMES_FROM_HNS(HNS_DELAY);
m_iDelayIndex = 0;
m_pf32DelayBuffer.Free();
// Allocate one second's worth of audio
//
// This allocation is being done using CoTaskMemAlloc because the delay is very large
// This introduces a risk of glitches if the delay buffer gets paged out
//
// A more typical approach would be to allocate the memory using AERT_Allocate, which locks the memory
// But for the purposes of this APO, CoTaskMemAlloc suffices, and the risk of glitches is not important
m_pf32DelayBuffer.Allocate(GetSamplesPerFrame() * m_nDelayFrames);
WriteSilence(m_pf32DelayBuffer, m_nDelayFrames, GetSamplesPerFrame());
if (nullptr == m_pf32DelayBuffer)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
}
Exit:
return hr;
}
void CAudioEncoder::Initialize (void)
{
// called from derived classes init function from the start function
// in the media flow
m_audioSrcFrameNumber = 0;
m_audioDstFrameNumber = 0;
m_audioDstSampleNumber = 0;
m_audioSrcElapsedDuration = 0;
m_audioDstElapsedDuration = 0;
// destination parameters are from the audio profile
m_audioDstType = GetFrameType();
m_audioDstSampleRate = m_pConfig->GetIntegerValue(CFG_AUDIO_SAMPLE_RATE);
m_audioDstChannels = m_pConfig->GetIntegerValue(CFG_AUDIO_CHANNELS);
m_audioDstSamplesPerFrame = GetSamplesPerFrame();
// if we need to resample
if (m_audioDstSampleRate != m_audioSrcSampleRate) {
// create a resampler for each audio destination channel -
// we will combine the channels before resampling
m_audioResample = (resample_t *)malloc(sizeof(resample_t) *
m_audioDstChannels);
for (int ix = 0; ix < m_audioDstChannels; ix++) {
m_audioResample[ix] = st_resample_start(m_audioSrcSampleRate,
m_audioDstSampleRate);
}
}
// this calculation doesn't take into consideration the resampling
// size of the src. 4 times might not be enough - we need most likely
// 2 times the max of the src samples and the dest samples
m_audioPreEncodingBufferLength = 0;
m_audioPreEncodingBufferMaxLength =
4 * DstSamplesToBytes(m_audioDstSamplesPerFrame);
m_audioPreEncodingBuffer = (u_int8_t*)realloc(
m_audioPreEncodingBuffer,
m_audioPreEncodingBufferMaxLength);
}
int DirFileSource::samplesPerFrame(const QString &field) {
int err = 0;
return GetSamplesPerFrame(_filename.latin1(), field.left(FIELD_LENGTH).latin1(), &err);
}
bool DirFileSource::isValidField(const QString& field) const {
int err = 0;
GetSamplesPerFrame(_filename.latin1(), field.left(FIELD_LENGTH).latin1(), &err);
return err == 0;
}
//-------------------------------------------------------------------------
// Description:
//
// Do the actual processing of data.
//
// Parameters:
//
// u32NumInputConnections - [in] number of input connections
// ppInputConnections - [in] pointer to list of input APO_CONNECTION_PROPERTY pointers
// u32NumOutputConnections - [in] number of output connections
// ppOutputConnections - [in] pointer to list of output APO_CONNECTION_PROPERTY pointers
//
// Return values:
//
// void
//
// Remarks:
//
// This function processes data in a manner dependent on the implementing
// object. This routine can not fail and can not block, or call any other
// routine that blocks, or touch pagable memory.
//
STDMETHODIMP_(void) CSwapAPOGFX::APOProcess(
UINT32 u32NumInputConnections,
APO_CONNECTION_PROPERTY** ppInputConnections,
UINT32 u32NumOutputConnections,
APO_CONNECTION_PROPERTY** ppOutputConnections)
{
UNREFERENCED_PARAMETER(u32NumInputConnections);
UNREFERENCED_PARAMETER(u32NumOutputConnections);
FLOAT32 *pf32InputFrames, *pf32OutputFrames;
ATLASSERT(m_bIsLocked);
// assert that the number of input and output connectins fits our registration properties
ATLASSERT(m_pRegProperties->u32MinInputConnections <= u32NumInputConnections);
ATLASSERT(m_pRegProperties->u32MaxInputConnections >= u32NumInputConnections);
ATLASSERT(m_pRegProperties->u32MinOutputConnections <= u32NumOutputConnections);
ATLASSERT(m_pRegProperties->u32MaxOutputConnections >= u32NumOutputConnections);
// check APO_BUFFER_FLAGS.
switch( ppInputConnections[0]->u32BufferFlags )
{
case BUFFER_INVALID:
{
ATLASSERT(false); // invalid flag - should never occur. don't do anything.
break;
}
case BUFFER_VALID:
{
// get input pointer to connection buffer
pf32InputFrames = reinterpret_cast<FLOAT32*>(ppInputConnections[0]->pBuffer);
ATLASSERT( IS_VALID_TYPED_READ_POINTER(pf32InputFrames) );
// get output pointer to connection buffer
pf32OutputFrames = reinterpret_cast<FLOAT32*>(ppOutputConnections[0]->pBuffer);
ATLASSERT( IS_VALID_TYPED_READ_POINTER(pf32OutputFrames) );
// Swap only if we have more than one channel and it is enabled
if (!IsEqualGUID(m_AudioProcessingMode, AUDIO_SIGNALPROCESSINGMODE_RAW) && m_fEnableSwapGFX && (1 < m_u32SamplesPerFrame))
{
ProcessSwapScale(pf32OutputFrames, pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount,
m_u32SamplesPerFrame, m_pf32Coefficients );
}
else
{
// copy the memory only if there is an output connection, and input/output pointers are unequal
if ( (0 != u32NumOutputConnections) &&
(ppOutputConnections[0]->pBuffer != ppInputConnections[0]->pBuffer) )
{
CopyMemory(pf32OutputFrames, pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount *
GetBytesPerSampleContainer() * GetSamplesPerFrame());
}
}
// Set the valid frame count.
ppOutputConnections[0]->u32ValidFrameCount = ppInputConnections[0]->u32ValidFrameCount;
// pass along buffer flags
ppOutputConnections[0]->u32BufferFlags = ppInputConnections[0]->u32BufferFlags;
break;
}
case BUFFER_SILENT:
{
// Set valid frame count.
ppOutputConnections[0]->u32ValidFrameCount = ppInputConnections[0]->u32ValidFrameCount;
// pass along buffer flags
ppOutputConnections[0]->u32BufferFlags = ppInputConnections[0]->u32BufferFlags;
break;
}
default:
{
ATLASSERT(false); // invalid flag - should never occur
break;
}
} // switch
} // APOProcess
//-------------------------------------------------------------------------
// Description:
//
// Do the actual processing of data.
//
// Parameters:
//
// u32NumInputConnections - [in] number of input connections
// ppInputConnections - [in] pointer to list of input APO_CONNECTION_PROPERTY pointers
// u32NumOutputConnections - [in] number of output connections
// ppOutputConnections - [in] pointer to list of output APO_CONNECTION_PROPERTY pointers
//
// Return values:
//
// void
//
// Remarks:
//
// This function processes data in a manner dependent on the implementing
// object. This routine can not fail and can not block, or call any other
// routine that blocks, or touch pagable memory.
//
STDMETHODIMP_(void) CSwapAPOMFX::APOProcess(
UINT32 u32NumInputConnections,
APO_CONNECTION_PROPERTY** ppInputConnections,
UINT32 u32NumOutputConnections,
APO_CONNECTION_PROPERTY** ppOutputConnections)
{
UNREFERENCED_PARAMETER(u32NumInputConnections);
UNREFERENCED_PARAMETER(u32NumOutputConnections);
FLOAT32 *pf32InputFrames, *pf32OutputFrames;
ATLASSERT(m_bIsLocked);
// assert that the number of input and output connectins fits our registration properties
ATLASSERT(m_pRegProperties->u32MinInputConnections <= u32NumInputConnections);
ATLASSERT(m_pRegProperties->u32MaxInputConnections >= u32NumInputConnections);
ATLASSERT(m_pRegProperties->u32MinOutputConnections <= u32NumOutputConnections);
ATLASSERT(m_pRegProperties->u32MaxOutputConnections >= u32NumOutputConnections);
// check APO_BUFFER_FLAGS.
switch( ppInputConnections[0]->u32BufferFlags )
{
case BUFFER_INVALID:
{
ATLASSERT(false); // invalid flag - should never occur. don't do anything.
break;
}
case BUFFER_VALID:
case BUFFER_SILENT:
{
// get input pointer to connection buffer
pf32InputFrames = reinterpret_cast<FLOAT32*>(ppInputConnections[0]->pBuffer);
ATLASSERT( IS_VALID_TYPED_READ_POINTER(pf32InputFrames) );
// get output pointer to connection buffer
pf32OutputFrames = reinterpret_cast<FLOAT32*>(ppOutputConnections[0]->pBuffer);
ATLASSERT( IS_VALID_TYPED_READ_POINTER(pf32OutputFrames) );
if (BUFFER_SILENT == ppInputConnections[0]->u32BufferFlags)
{
WriteSilence( pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount,
GetSamplesPerFrame() );
}
// swap and apply coefficients to the input buffer in-place
if (
!IsEqualGUID(m_AudioProcessingMode, AUDIO_SIGNALPROCESSINGMODE_RAW) &&
m_fEnableSwapMFX &&
(1 < m_u32SamplesPerFrame)
)
{
ProcessSwapScale(pf32InputFrames, pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount,
m_u32SamplesPerFrame, m_pf32Coefficients );
}
// copy to the delay buffer
if (
!IsEqualGUID(m_AudioProcessingMode, AUDIO_SIGNALPROCESSINGMODE_RAW) &&
m_fEnableDelayMFX
)
{
ProcessDelay(pf32OutputFrames, pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount,
GetSamplesPerFrame(),
m_pf32DelayBuffer,
m_nDelayFrames,
&m_iDelayIndex);
// we don't try to remember silence
ppOutputConnections[0]->u32BufferFlags = BUFFER_VALID;
}
else
{
// copy the memory only if there is an output connection, and input/output pointers are unequal
if ( (0 != u32NumOutputConnections) &&
(ppOutputConnections[0]->pBuffer != ppInputConnections[0]->pBuffer) )
{
CopyFrames( pf32OutputFrames, pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount,
GetSamplesPerFrame() );
}
// pass along buffer flags
ppOutputConnections[0]->u32BufferFlags = ppInputConnections[0]->u32BufferFlags;
}
// Set the valid frame count.
ppOutputConnections[0]->u32ValidFrameCount = ppInputConnections[0]->u32ValidFrameCount;
break;
}
default:
{
ATLASSERT(false); // invalid flag - should never occur
break;
}
} // switch
} // APOProcess
//-------------------------------------------------------------------------
// Description:
//
// Do the actual processing of data.
//
// Parameters:
//
// u32NumInputConnections - [in] number of input connections
// ppInputConnections - [in] pointer to list of input APO_CONNECTION_PROPERTY pointers
// u32NumOutputConnections - [in] number of output connections
// ppOutputConnections - [in] pointer to list of output APO_CONNECTION_PROPERTY pointers
//
// Return values:
//
// void
//
// Remarks:
//
// This function processes data in a manner dependent on the implementing
// object. This routine can not fail and can not block, or call any other
// routine that blocks, or touch pagable memory.
//
STDMETHODIMP_(void) CSwapAPOLFX::APOProcess(
UINT32 u32NumInputConnections,
APO_CONNECTION_PROPERTY** ppInputConnections,
UINT32 u32NumOutputConnections,
APO_CONNECTION_PROPERTY** ppOutputConnections)
{
UNREFERENCED_PARAMETER(u32NumInputConnections);
UNREFERENCED_PARAMETER(u32NumOutputConnections);
FLOAT32 *pf32InputFrames, *pf32OutputFrames;
ATLASSERT(m_bIsLocked);
// assert that the number of input and output connectins fits our registration properties
ATLASSERT(m_pRegProperties->u32MinInputConnections <= u32NumInputConnections);
ATLASSERT(m_pRegProperties->u32MaxInputConnections >= u32NumInputConnections);
ATLASSERT(m_pRegProperties->u32MinOutputConnections <= u32NumOutputConnections);
ATLASSERT(m_pRegProperties->u32MaxOutputConnections >= u32NumOutputConnections);
// check APO_BUFFER_FLAGS.
switch( ppInputConnections[0]->u32BufferFlags )
{
case BUFFER_INVALID:
{
ATLASSERT(false); // invalid flag - should never occur. don't do anything.
break;
}
case BUFFER_VALID:
{
// get input pointer to connection buffer
pf32InputFrames = reinterpret_cast<FLOAT32*>(ppInputConnections[0]->pBuffer);
ATLASSERT( IS_VALID_TYPED_READ_POINTER(pf32InputFrames) );
// get output pointer to connection buffer
pf32OutputFrames = reinterpret_cast<FLOAT32*>(ppOutputConnections[0]->pBuffer);
ATLASSERT( IS_VALID_TYPED_WRITE_POINTER(pf32OutputFrames) );
// Do something useful here since the data in the input buffer is valid.
if (m_fEnableSwapLFX)
{
ProcessSwap(pf32OutputFrames, pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount,
m_u32SamplesPerFrame);
}
else
{
// copy the memory only if there is an output connection, and input/output pointers are unequal
if ( (0 != u32NumOutputConnections) &&
(ppOutputConnections[0]->pBuffer != ppInputConnections[0]->pBuffer) )
{
CopyMemory(pf32OutputFrames, pf32InputFrames,
ppInputConnections[0]->u32ValidFrameCount *
GetBytesPerSampleContainer() * GetSamplesPerFrame());
}
}
// Set the valid frame count.
ppOutputConnections[0]->u32ValidFrameCount = ppInputConnections[0]->u32ValidFrameCount;
// pass along buffer flags
ppOutputConnections[0]->u32BufferFlags = ppInputConnections[0]->u32BufferFlags;
break;
}
case BUFFER_SILENT:
{
// Set valid frame count.
ppOutputConnections[0]->u32ValidFrameCount = ppInputConnections[0]->u32ValidFrameCount;
// pass along buffer flags
ppOutputConnections[0]->u32BufferFlags = ppInputConnections[0]->u32BufferFlags;
break;
}
default:
{
ATLASSERT(false); // invalid flag - should never occur
break;
}
} // switch
} // APOProcess