void CPerfLog::LogSamples()
{
if (m_eMode == None)
return;
DWORD dwNow = GetTickCount();
if (dwNow - m_dwLastSampled < m_dwInterval)
return;
// 'data counters' amount of transferred file data
UINT nCurDn = (UINT)(theStats.sessionReceivedBytes - m_nLastSessionRecvBytes);
UINT nCurUp = (UINT)(theStats.sessionSentBytes - m_nLastSessionSentBytes);
// 'overhead counters' amount of total overhead
uint64 nDnOHTotal = theStats.GetDownDataOverheadFileRequest() +
theStats.GetDownDataOverheadSourceExchange() +
theStats.GetDownDataOverheadServer() +
theStats.GetDownDataOverheadKad() +
theStats.GetDownDataOverheadOther();
uint64 nUpOHTotal = theStats.GetUpDataOverheadFileRequest() +
theStats.GetUpDataOverheadSourceExchange() +
theStats.GetUpDataOverheadServer() +
theStats.GetUpDataOverheadKad() +
theStats.GetUpDataOverheadOther();
UINT nCurDnOH = (UINT)(nDnOHTotal - m_nLastDnOH);
UINT nCurUpOH = (UINT)(nUpOHTotal - m_nLastUpOH);
WriteSamples(nCurDn, nCurUp, nCurDnOH, nCurUpOH);
m_nLastSessionRecvBytes = theStats.sessionReceivedBytes;
m_nLastSessionSentBytes = theStats.sessionSentBytes;
m_nLastDnOH = nDnOHTotal;
m_nLastUpOH = nUpOHTotal;
m_dwLastSampled = dwNow;
}
ALuint FillBuffer(T *Buffer, ALuint BufferSamples)
{
ALuint SamplesInBuffer = 0;
while(SamplesInBuffer < BufferSamples)
{
// Check if any tracks are still playing and how many samples are waiting to render
size_t TracksPlaying = 0;
ALuint SamplesToDo = BufferSamples - SamplesInBuffer;
for(std::vector<MidiTrack>::iterator i = Tracks.begin(),
end = Tracks.end();i != end;i++)
{
if(i->Offset < i->data.size())
{
SamplesToDo = std::min<ALuint>(SamplesToDo, i->SamplesLeft);
TracksPlaying++;
}
}
if(TracksPlaying == 0)
break;
if(SamplesToDo == 0)
{
ProcessMidi();
continue;
}
// Render samples
WriteSamples(SamplesToDo, Buffer);
Buffer += SamplesToDo*2;
SamplesInBuffer += SamplesToDo;
for(std::vector<MidiTrack>::iterator i = Tracks.begin(),
end = Tracks.end();i != end;i++)
{
if(i->Offset < i->data.size())
i->SamplesLeft -= SamplesToDo;
}
}
return SamplesInBuffer;
}
//Execute()
EXPORT_API ODK_RESULT Execute (ODK_UINT32 cmd
,const char* const in
,const char* inout
,const char* out)
{
switch (cmd)
{
case FCT_HASH_WaveSetup:
{
return WaveSetup ((ODK_S7STRING*) &(in[0]), (ODK_S7STRING*) &(in[256]));
}
case FCT_HASH_WaveSetupNoName:
{
return WaveSetupNoName ();
}
case FCT_HASH_GetSamplesStereo:
{
return GetSamplesStereo ((ODK_INT16*) &(out[0]), (ODK_INT16*) &(out[2048]), *((ODK_BOOL*) &(out[4096])));
}
case FCT_HASH_WriteSamples:
{
return WriteSamples ((ODK_INT16*) &(in[0]), (ODK_INT16*) &(in[2048]));
}
default:
{
typedef ODK_RESULT (*t_CallbackFunction)(void);
#pragma warning ( disable: 4189 )
// check the existence of the callback functions
// (but suppress warning of not used variables)
{
t_CallbackFunction tmp1 = &OnLoad;
t_CallbackFunction tmp2 = &OnUnload;
t_CallbackFunction tmp3 = &OnRun;
t_CallbackFunction tmp4 = &OnStop;
}
return ODK_COMMAND_NOT_IMPLEMENTED;
}
}
}
/*----------------------------------------------------------------------
| main
+---------------------------------------------------------------------*/
int
main(int argc, char** argv)
{
if (argc < 3) {
PrintUsageAndExit();
}
// parse command line
AP4_Result result;
char** args = argv+1;
unsigned char key[16];
bool key_option = false;
if (!strcmp(*args, "--key")) {
if (argc != 5) {
fprintf(stderr, "ERROR: invalid command line\n");
return 1;
}
++args;
if (AP4_ParseHex(*args++, key, 16)) {
fprintf(stderr, "ERROR: invalid hex format for key\n");
return 1;
}
key_option = true;
}
// create the input stream
AP4_ByteStream* input = NULL;
result = AP4_FileByteStream::Create(*args++, AP4_FileByteStream::STREAM_MODE_READ, input);
if (AP4_FAILED(result)) {
fprintf(stderr, "ERROR: cannot open input (%d)\n", result);
}
// create the output stream
AP4_ByteStream* output = NULL;
result = AP4_FileByteStream::Create(*args++, AP4_FileByteStream::STREAM_MODE_WRITE, output);
if (AP4_FAILED(result)) {
fprintf(stderr, "ERROR: cannot open output (%d)\n", result);
}
// open the file
AP4_File* input_file = new AP4_File(*input);
// get the movie
AP4_SampleDescription* sample_description;
AP4_Track* video_track;
AP4_Movie* movie = input_file->GetMovie();
if (movie == NULL) {
fprintf(stderr, "ERROR: no movie in file\n");
goto end;
}
// get the video track
video_track = movie->GetTrack(AP4_Track::TYPE_VIDEO);
if (video_track == NULL) {
fprintf(stderr, "ERROR: no video track found\n");
goto end;
}
// check that the track is of the right type
sample_description = video_track->GetSampleDescription(0);
if (sample_description == NULL) {
fprintf(stderr, "ERROR: unable to parse sample description\n");
goto end;
}
// show info
AP4_Debug("Video Track:\n");
AP4_Debug(" duration: %ld ms\n", video_track->GetDurationMs());
AP4_Debug(" sample count: %ld\n", video_track->GetSampleCount());
switch (sample_description->GetType()) {
case AP4_SampleDescription::TYPE_HEVC:
WriteSamples(video_track, sample_description, output);
break;
case AP4_SampleDescription::TYPE_PROTECTED:
if (!key_option) {
fprintf(stderr, "ERROR: encrypted tracks require a key\n");
goto end;
}
DecryptAndWriteSamples(video_track, sample_description, key, output);
break;
default:
fprintf(stderr, "ERROR: unsupported sample type\n");
break;
}
end:
delete input_file;
input->Release();
output->Release();
return 0;
}
void CPerfLog::Shutdown()
{
if (m_eMode == OneSample)
WriteSamples(0, 0, 0, 0);
}
// The audio thread.
void SoundStream::SoundLoop()
{
Common::SetCurrentThreadName("Audio thread");
InitializeSoundLoop();
bool surroundSupported = SupportSurroundOutput() && SConfig::GetInstance().bDPL2Decoder;
memset(realtimeBuffer, 0, SOUND_MAX_FRAME_SIZE * sizeof(u16));
memset(dpl2buffer, 0, SOUND_MAX_FRAME_SIZE * sizeof(soundtouch::SAMPLETYPE));
memset(samplebuffer, 0, SOUND_MAX_FRAME_SIZE * sizeof(soundtouch::SAMPLETYPE));
u32 channelmultiplier = surroundSupported ? SOUND_SAMPLES_SURROUND : SOUND_SAMPLES_STEREO;
CMixer* mixer = GetMixer();
if (SConfig::GetInstance().bTimeStretching)
{
float ratemultiplier = 1.0f;
soundtouch::SoundTouch sTouch;
sTouch.setChannels(2);
sTouch.setSampleRate(mixer->GetSampleRate());
sTouch.setTempo(1.0);
sTouch.setSetting(SETTING_USE_QUICKSEEK, 0);
sTouch.setSetting(SETTING_USE_AA_FILTER, 1);
while (threadData.load())
{
u32 availablesamples = mixer->AvailableSamples();
u32 numsamples = std::min(availablesamples, 400u);
if (numsamples == 400u)
{
float rate = mixer->GetCurrentSpeed();
if (rate <= 0)
{
rate = 1.0f;
}
numsamples = mixer->Mix(samplebuffer, numsamples);
rate *= ratemultiplier;
rate = rate < 0.5f ? 0.5f : rate;
rate = roundf(rate * 16.0f) / 16.0f;
sTouch.setTempo(rate);
sTouch.putSamples(samplebuffer, numsamples);
}
u32 samplesneeded = SamplesNeeded();
availablesamples = sTouch.numSamples();
if (samplesneeded >= SOUND_FRAME_SIZE && availablesamples > 0)
{
ratemultiplier = std::fmaxf(std::fminf((float)availablesamples / (float)samplesneeded, 1.1f), 0.9f);
numsamples = std::min(availablesamples, SOUND_FRAME_SIZE);
if (surroundSupported)
{
numsamples = sTouch.receiveSamples(dpl2buffer, numsamples);
DPL2Decode(dpl2buffer, numsamples, samplebuffer);
}
else
{
numsamples = sTouch.receiveSamples(samplebuffer, numsamples);
}
floatTos16(realtimeBuffer, samplebuffer, numsamples, channelmultiplier);
WriteSamples(realtimeBuffer, numsamples);
}
else
{
Common::SleepCurrentThread(1);
}
}
}
else
{
while (threadData.load())
{
u32 neededsamples = std::min(SamplesNeeded(), SOUND_FRAME_SIZE);
u32 availablesamples = mixer->AvailableSamples() & (~(0xF));
if (neededsamples == SOUND_FRAME_SIZE && availablesamples > 0)
{
u32 numsamples = std::min(availablesamples, neededsamples);
if (surroundSupported)
{
numsamples = mixer->Mix(dpl2buffer, numsamples);
DPL2Decode(dpl2buffer, numsamples, samplebuffer);
floatTos16(realtimeBuffer, samplebuffer, numsamples, channelmultiplier);
}
else
{
numsamples = mixer->Mix(realtimeBuffer, numsamples);
}
WriteSamples(realtimeBuffer, numsamples);
}
else
{
Common::SleepCurrentThread(1);
}
}
}
}
/*----------------------------------------------------------------------
| main
+---------------------------------------------------------------------*/
int
main(int argc, char** argv)
{
if (argc < 3) {
PrintUsageAndExit();
}
// default options
Options.segment_duration = 0;
Options.pmt_pid = 0x100;
Options.audio_pid = 0x101;
Options.video_pid = 0x102;
Options.verbose = false;
Options.playlist = NULL;
Options.playlist_hls_version = 3;
Options.input = NULL;
Options.output = NULL;
Options.segment_duration_threshold = DefaultSegmentDurationThreshold;
// parse command line
AP4_Result result;
char** args = argv+1;
while (const char* arg = *args++) {
if (!strcmp(arg, "--segment")) {
if (*args == NULL) {
fprintf(stderr, "ERROR: --segment requires a number\n");
return 1;
}
Options.segment_duration = strtoul(*args++, NULL, 10);
} else if (!strcmp(arg, "--segment-duration-threshold")) {
if (*args == NULL) {
fprintf(stderr, "ERROR: --segment-duration-threshold requires a number\n");
return 1;
}
Options.segment_duration_threshold = strtoul(*args++, NULL, 10);
} else if (!strcmp(arg, "--verbose")) {
Options.verbose = true;
} else if (!strcmp(arg, "--pmt-pid")) {
if (*args == NULL) {
fprintf(stderr, "ERROR: --pmt-pid requires a number\n");
return 1;
}
Options.pmt_pid = strtoul(*args++, NULL, 10);
} else if (!strcmp(arg, "--audio-pid")) {
if (*args == NULL) {
fprintf(stderr, "ERROR: --audio-pid requires a number\n");
return 1;
}
Options.audio_pid = strtoul(*args++, NULL, 10);
} else if (!strcmp(arg, "--video-pid")) {
if (*args == NULL) {
fprintf(stderr, "ERROR: --video-pid requires a number\n");
return 1;
}
Options.video_pid = strtoul(*args++, NULL, 10);
} else if (!strcmp(arg, "--playlist")) {
if (*args == NULL) {
fprintf(stderr, "ERROR: --playlist requires a filename\n");
return 1;
}
Options.playlist = *args++;
} else if (!strcmp(arg, "--playlist-hls-version")) {
if (*args == NULL) {
fprintf(stderr, "ERROR: --playlist-hls-version requires a number\n");
return 1;
}
Options.playlist_hls_version = strtoul(*args++, NULL, 10);
if (Options.playlist_hls_version ==0) {
fprintf(stderr, "ERROR: --playlist-hls-version requires number > 0\n");
return 1;
}
} else if (Options.input == NULL) {
Options.input = arg;
} else if (Options.output == NULL) {
Options.output = arg;
} else {
fprintf(stderr, "ERROR: unexpected argument\n");
return 1;
}
}
// check args
if (Options.input == NULL) {
fprintf(stderr, "ERROR: missing input file name\n");
return 1;
}
if (Options.output == NULL) {
fprintf(stderr, "ERROR: missing output file name\n");
return 1;
}
// create the input stream
AP4_ByteStream* input = NULL;
result = AP4_FileByteStream::Create(Options.input, AP4_FileByteStream::STREAM_MODE_READ, input);
if (AP4_FAILED(result)) {
fprintf(stderr, "ERROR: cannot open input (%d)\n", result);
return 1;
}
// open the file
AP4_File* input_file = new AP4_File(*input, AP4_DefaultAtomFactory::Instance, true);
// get the movie
AP4_SampleDescription* sample_description;
AP4_Movie* movie = input_file->GetMovie();
if (movie == NULL) {
fprintf(stderr, "ERROR: no movie in file\n");
return 1;
}
// get the audio and video tracks
AP4_Track* audio_track = movie->GetTrack(AP4_Track::TYPE_AUDIO);
AP4_Track* video_track = movie->GetTrack(AP4_Track::TYPE_VIDEO);
if (audio_track == NULL && video_track == NULL) {
fprintf(stderr, "ERROR: no suitable tracks found\n");
delete input_file;
input->Release();
return 1;
}
// create the appropriate readers
AP4_LinearReader* linear_reader = NULL;
SampleReader* audio_reader = NULL;
SampleReader* video_reader = NULL;
if (movie->HasFragments()) {
// create a linear reader to get the samples
linear_reader = new AP4_LinearReader(*movie, input);
if (audio_track) {
linear_reader->EnableTrack(audio_track->GetId());
audio_reader = new FragmentedSampleReader(*linear_reader, audio_track->GetId());
}
if (video_track) {
linear_reader->EnableTrack(video_track->GetId());
video_reader = new FragmentedSampleReader(*linear_reader, video_track->GetId());
}
} else {
if (audio_track) {
audio_reader = new TrackSampleReader(*audio_track);
}
if (video_track) {
video_reader = new TrackSampleReader(*video_track);
}
}
// create an MPEG2 TS Writer
AP4_Mpeg2TsWriter writer(Options.pmt_pid);
AP4_Mpeg2TsWriter::SampleStream* audio_stream = NULL;
AP4_Mpeg2TsWriter::SampleStream* video_stream = NULL;
// add the audio stream
if (audio_track) {
sample_description = audio_track->GetSampleDescription(0);
if (sample_description == NULL) {
fprintf(stderr, "ERROR: unable to parse audio sample description\n");
goto end;
}
unsigned int stream_type = 0;
unsigned int stream_id = 0;
if (sample_description->GetFormat() == AP4_SAMPLE_FORMAT_MP4A) {
stream_type = AP4_MPEG2_STREAM_TYPE_ISO_IEC_13818_7;
stream_id = AP4_MPEG2_TS_DEFAULT_STREAM_ID_AUDIO;
} else if (sample_description->GetFormat() == AP4_SAMPLE_FORMAT_AC_3 ||
sample_description->GetFormat() == AP4_SAMPLE_FORMAT_EC_3) {
stream_type = AP4_MPEG2_STREAM_TYPE_ATSC_AC3;
stream_id = AP4_MPEG2_TS_STREAM_ID_PRIVATE_STREAM_1;
} else {
fprintf(stderr, "ERROR: audio codec not supported\n");
return 1;
}
result = writer.SetAudioStream(audio_track->GetMediaTimeScale(),
stream_type,
stream_id,
audio_stream,
Options.audio_pid);
if (AP4_FAILED(result)) {
fprintf(stderr, "could not create audio stream (%d)\n", result);
goto end;
}
}
// add the video stream
if (video_track) {
sample_description = video_track->GetSampleDescription(0);
if (sample_description == NULL) {
fprintf(stderr, "ERROR: unable to parse video sample description\n");
goto end;
}
// decide on the stream type
unsigned int stream_type = 0;
unsigned int stream_id = AP4_MPEG2_TS_DEFAULT_STREAM_ID_VIDEO;
if (sample_description->GetFormat() == AP4_SAMPLE_FORMAT_AVC1 ||
sample_description->GetFormat() == AP4_SAMPLE_FORMAT_AVC2 ||
sample_description->GetFormat() == AP4_SAMPLE_FORMAT_AVC3 ||
sample_description->GetFormat() == AP4_SAMPLE_FORMAT_AVC4) {
stream_type = AP4_MPEG2_STREAM_TYPE_AVC;
} else if (sample_description->GetFormat() == AP4_SAMPLE_FORMAT_HEV1 ||
sample_description->GetFormat() == AP4_SAMPLE_FORMAT_HVC1) {
stream_type = AP4_MPEG2_STREAM_TYPE_HEVC;
} else {
fprintf(stderr, "ERROR: video codec not supported\n");
return 1;
}
result = writer.SetVideoStream(video_track->GetMediaTimeScale(),
stream_type,
stream_id,
video_stream,
Options.video_pid);
if (AP4_FAILED(result)) {
fprintf(stderr, "could not create video stream (%d)\n", result);
goto end;
}
}
result = WriteSamples(writer,
audio_track, audio_reader, audio_stream,
video_track, video_reader, video_stream,
Options.segment_duration_threshold);
if (AP4_FAILED(result)) {
fprintf(stderr, "ERROR: failed to write samples (%d)\n", result);
}
end:
delete input_file;
input->Release();
delete linear_reader;
delete audio_reader;
delete video_reader;
return result == AP4_SUCCESS?0:1;
}
