ATX_END_INTERFACE_MAP
/*----------------------------------------------------------------------
| AacDecoderOutput_Flush
+---------------------------------------------------------------------*/
static BLT_Result
AacDecoderOutput_Flush(AacDecoder* self)
{
ATX_ListItem* item;
while ((item = ATX_List_GetFirstItem(self->output.packets))) {
BLT_MediaPacket* packet = ATX_ListItem_GetData(item);
if (packet) BLT_MediaPacket_Release(packet);
ATX_List_RemoveItem(self->output.packets, item);
}
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| CrossFaderOutputPort_GetPacket
+---------------------------------------------------------------------*/
BLT_METHOD
CrossFaderOutputPort_GetPacket(BLT_PacketProducerInstance* instance,
BLT_MediaPacket** packet)
{
CrossFader* fader = (CrossFader*)instance;
ATX_ListItem* item;
item = ATX_List_GetFirstItem(fader->output.packets);
if (item) {
*packet = ATX_ListItem_GetData(item);
ATX_List_RemoveItem(fader->output.packets, item);
ATX_LOG_FINER("CrossFaderInputPort_GetPacket - got one");
return BLT_SUCCESS;
} else {
*packet = NULL;
ATX_LOG_FINER("CrossFaderInputPort_GetPacket - no more data");
return BLT_ERROR_PORT_HAS_NO_DATA;
}
}
/*----------------------------------------------------------------------
| AacDecoderOutput_GetPacket
+---------------------------------------------------------------------*/
BLT_METHOD
AacDecoderOutput_GetPacket(BLT_PacketProducer* _self,
BLT_MediaPacket** packet)
{
AacDecoder* self = ATX_SELF_M(output, AacDecoder, BLT_PacketProducer);
ATX_ListItem* packet_item;
/* default return */
*packet = NULL;
/* check if we have a packet available */
packet_item = ATX_List_GetFirstItem(self->output.packets);
if (packet_item) {
*packet = (BLT_MediaPacket*)ATX_ListItem_GetData(packet_item);
ATX_List_RemoveItem(self->output.packets, packet_item);
return BLT_SUCCESS;
}
return BLT_ERROR_PORT_HAS_NO_DATA;
}
ATX_END_INTERFACE_MAP
/*----------------------------------------------------------------------
| SilenceRemoverOutput_GetPacket
+---------------------------------------------------------------------*/
BLT_METHOD
SilenceRemoverOutput_GetPacket(BLT_PacketProducer* _self,
BLT_MediaPacket** packet)
{
SilenceRemover* self = ATX_SELF_M(output, SilenceRemover, BLT_PacketProducer);
ATX_ListItem* item;
item = ATX_List_GetFirstItem(self->output.packets);
if (item) {
*packet = ATX_ListItem_GetData(item);
ATX_List_RemoveItem(self->output.packets, item);
return BLT_SUCCESS;
} else {
*packet = NULL;
return BLT_ERROR_PORT_HAS_NO_DATA;
}
}
/*----------------------------------------------------------------------
| OsxAudioUnitsOutput_RenderCallback
+---------------------------------------------------------------------*/
static OSStatus
OsxAudioUnitsOutput_RenderCallback(void* inRefCon,
AudioUnitRenderActionFlags* ioActionFlags,
const AudioTimeStamp* inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList* ioData)
{
OsxAudioUnitsOutput* self = (OsxAudioUnitsOutput*)inRefCon;
ATX_ListItem* item;
unsigned int requested;
unsigned char* out;
ATX_Boolean timestamp_measured = ATX_FALSE;
BLT_COMPILER_UNUSED(ioActionFlags);
BLT_COMPILER_UNUSED(inTimeStamp);
BLT_COMPILER_UNUSED(inBusNumber);
BLT_COMPILER_UNUSED(inNumberFrames);
/* sanity check on the parameters */
if (ioData == NULL || ioData->mNumberBuffers == 0) return 0;
/* in case we have a strange request with more than one buffer, just return silence */
if (ioData->mNumberBuffers != 1) {
unsigned int i;
ATX_LOG_FINEST_1("strange request with %d buffers",
(int)ioData->mNumberBuffers);
for (i=0; i<ioData->mNumberBuffers; i++) {
ATX_SetMemory(ioData->mBuffers[i].mData, 0, ioData->mBuffers[i].mDataByteSize);
}
return 0;
}
/* init local variables */
requested = ioData->mBuffers[0].mDataByteSize;
out = (unsigned char*)ioData->mBuffers[0].mData;
ATX_LOG_FINEST_2("request for %d bytes, %d frames", (int)requested, (int)inNumberFrames);
/* lock the packet queue */
pthread_mutex_lock(&self->lock);
/* return now if we're paused */
//if (self->paused) goto end;
/* abort early if we have no packets */
if (ATX_List_GetItemCount(self->packet_queue) == 0) goto end;
/* fill as much as we can */
while (requested && (item = ATX_List_GetFirstItem(self->packet_queue))) {
BLT_MediaPacket* packet = ATX_ListItem_GetData(item);
const BLT_PcmMediaType* media_type;
BLT_Size payload_size;
BLT_Size chunk_size;
BLT_TimeStamp chunk_duration;
BLT_TimeStamp packet_ts;
unsigned int bytes_per_frame;
unsigned int sample_rate;
/* get the packet info */
BLT_MediaPacket_GetMediaType(packet, (const BLT_MediaType**)&media_type);
packet_ts = BLT_MediaPacket_GetTimeStamp(packet);
bytes_per_frame = media_type->channel_count*media_type->bits_per_sample/8;
sample_rate = media_type->sample_rate;
/* record the timestamp if we have not already done so */
if (!timestamp_measured) {
self->media_time_snapshot.rendered_packet_ts = packet_ts;
self->media_time_snapshot.rendered_host_time =
AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
BLT_TimeStamp_Set(self->media_time_snapshot.rendered_duration, 0, 0);
timestamp_measured = ATX_TRUE;
ATX_LOG_FINEST_2("rendered TS: packet ts=%lld, host ts=%lld",
BLT_TimeStamp_ToNanos(packet_ts),
self->media_time_snapshot.rendered_host_time);
}
/* compute how much to copy from this packet */
payload_size = BLT_MediaPacket_GetPayloadSize(packet);
if (payload_size <= requested) {
/* copy the entire payload and remove the packet from the queue */
chunk_size = payload_size;
ATX_CopyMemory(out, BLT_MediaPacket_GetPayloadBuffer(packet), chunk_size);
ATX_List_RemoveItem(self->packet_queue, item);
packet = NULL;
media_type = NULL;
ATX_LOG_FINER_1("media packet fully consumed, %d left in queue",
ATX_List_GetItemCount(self->packet_queue));
} else {
/* only copy a portion of the payload */
chunk_size = requested;
ATX_CopyMemory(out, BLT_MediaPacket_GetPayloadBuffer(packet), chunk_size);
}
/* update the counters */
requested -= chunk_size;
out += chunk_size;
/* update the media time snapshot */
if (bytes_per_frame) {
unsigned int frames_in_chunk = chunk_size/bytes_per_frame;
chunk_duration = BLT_TimeStamp_FromSamples(frames_in_chunk, sample_rate);
} else {
BLT_TimeStamp_Set(chunk_duration, 0, 0);
}
self->media_time_snapshot.rendered_duration =
BLT_TimeStamp_Add(self->media_time_snapshot.rendered_duration, chunk_duration);
/* update the packet unless we're done with it */
if (packet) {
/* update the packet offset and timestamp */
BLT_MediaPacket_SetPayloadOffset(packet, BLT_MediaPacket_GetPayloadOffset(packet)+chunk_size);
BLT_MediaPacket_SetTimeStamp(packet, BLT_TimeStamp_Add(packet_ts, chunk_duration));
}
}
end:
/* fill whatever is left with silence */
if (requested) {
ATX_LOG_FINEST_1("filling with %d bytes of silence", requested);
ATX_SetMemory(out, 0, requested);
}
pthread_mutex_unlock(&self->lock);
return 0;
}