Initial community commit

1 files changed, 417 insertions, 0 deletions

diff --git a/Src/Plugins/Input/in_mp4/PlayThread.cpp b/Src/Plugins/Input/in_mp4/PlayThread.cpp
new file mode 100644
index 00000000..661d3003
--- /dev/null
+++ b/Src/Plugins/Input/in_mp4/PlayThread.cpp
@@ -0,0 +1,417 @@
+#include "main.h"
+#include "../winamp/wa_ipc.h"
+#include "VideoThread.h"
+#include "AudioSample.h"
+#include "api__in_mp4.h"
+#include <assert.h>
+#include <api/service/waservicefactory.h>
+#include "../nu/AudioOutput.h"
+#include <strsafe.h>
+
+const DWORD PAUSE_TIMEOUT = 100; // number of milliseconds to sleep for when paused
+
+static bool audio_opened;
+static HANDLE events[3];
+static bool done;
+bool open_mp4(const wchar_t *fn);
+static AudioSample *sample = 0;
+static DWORD waitTime;
+static MP4SampleId nextSampleId;
+Nullsoft::Utility::LockGuard play_mp4_guard;
+
+static MP4Duration first_timestamp=0;
+
+class MP4Wait
+{
+public:
+	int WaitOrAbort(int time_in_ms)
+	{	
+		WaitForMultipleObjects(3, events, FALSE, INFINITE); // pauseEvent signal state is opposite of pause state
+		int ret = WaitForMultipleObjects(2, events, FALSE, time_in_ms);
+		if (ret == WAIT_TIMEOUT)
+			return 0;
+		if (ret == WAIT_OBJECT_0+1)
+			return 2;
+		return 1;
+	}
+};
+
+nu::AudioOutput<MP4Wait> audio_output(&mod);
+
+MP4Duration GetClock()
+{
+	if (audio)
+	{
+		return audio_output.GetFirstTimestamp() + mod.outMod->GetOutputTime();
+	}
+	else if (video)
+	{
+		return video_clock.GetOutputTime();
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+static void OutputSample(AudioSample *sample)
+{
+	if (first)
+	{
+		first_timestamp = MP4ConvertFromTrackTimestamp(MP4hFile, audio_track, sample->timestamp, MP4_MSECS_TIME_SCALE);
+		first = false;
+	}
+
+	if (sample->result == MP4_SUCCESS)
+	{
+		if (!audio_opened)
+		{
+			audio_opened=true;
+
+			if (audio_output.Open(first_timestamp, sample->numChannels, sample->sampleRate, sample->bitsPerSample) == false)
+			{
+				PostMessage(mod.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
+				return ;
+			}
+			unsigned __int32 pregap = 0;
+			unsigned __int32 postgap = 0;
+			GetGaps(MP4hFile, pregap, postgap);
+			audio_output.SetDelays(0, pregap, postgap);
+			mod.SetInfo(audio_bitrate + video_bitrate, sample->sampleRate / 1000, sample->numChannels, 1);
+		}
+
+		int skip = 0;
+		int sample_size = (sample->bitsPerSample / 8) * sample->numChannels;
+		int outSamples = MulDiv(sample->outputValid, m_timescale, sample->sampleRate * sample_size);
+		/* if (!audio_chunk && outSamples > sample->duration)
+			outSamples = (int)sample->duration; */
+
+		if (sample->offset > 0)
+		{
+			int cut = (int)min(outSamples, sample->offset);
+			outSamples -= cut;
+			skip = cut;
+		}
+
+		size_t outSize = MulDiv(sample_size * sample->sampleRate, outSamples, m_timescale);
+
+		if (audio_bitrate != sample->bitrate)
+		{
+			audio_bitrate = sample->bitrate;
+			mod.SetInfo(audio_bitrate + video_bitrate, -1, -1, 1);
+		}
+
+		if (audio_output.Write(sample->output + MulDiv(sample_size * sample->sampleRate, skip, m_timescale), outSize) == 1)
+		{
+			return ;
+		}
+
+		if (sample->sampleId == numSamples) // done!
+			done = true; // TODO: probably don't want to bail out yet if video is playing
+	}
+}
+
+static bool DecodeAudioSample(AudioSample *sample)
+{
+	if (m_needseek != -1)
+	{
+		sample->outputValid = 0;
+		sample->outputCursor = sample->output;
+		sample->result = MP4_SUCCESS;
+		sample->sampleRate = m_timescale;
+		audio->GetOutputProperties(&sample->sampleRate, &sample->numChannels, &sample->bitsPerSample);
+		if (audio->GetCurrentBitrate(&sample->bitrate) != MP4_SUCCESS || !sample->bitrate)
+			sample->bitrate = audio_bitrate;
+	}
+	else
+	{
+		sample->outputValid = sample->outputSize;
+		sample->outputCursor = 0;
+		sample->result = audio->DecodeSample(sample->input, sample->inputValid, sample->output, &sample->outputValid);
+		if (sample->inputValid == 0 && sample->outputValid == 0) {
+			return false;
+		}
+		sample->sampleRate = m_timescale;
+		audio->GetOutputProperties(&sample->sampleRate, &sample->numChannels, &sample->bitsPerSample);
+		if (audio->GetCurrentBitrate(&sample->bitrate) != MP4_SUCCESS || !sample->bitrate)
+			sample->bitrate = audio_bitrate;
+		OutputSample(sample);
+	}
+	return true;
+}
+
+static void ReadNextAudioSample()
+{
+	if (nextSampleId > numSamples)
+	{
+		return;
+	}
+
+	unsigned __int32 buffer_size = sample->inputSize;
+
+	bool sample_read = false;
+	play_mp4_guard.Lock();
+	if (audio_chunk)
+		sample_read = MP4ReadChunk(MP4hFile, audio_track, nextSampleId++, (unsigned __int8 **)&sample->input, &buffer_size, &sample->timestamp, &sample->duration);
+	else
+		sample_read = MP4ReadSample(MP4hFile, audio_track, nextSampleId++, (unsigned __int8 **)&sample->input, &buffer_size, &sample->timestamp, &sample->duration, &sample->offset);
+	play_mp4_guard.Unlock();
+	if (sample_read)
+	{
+		sample->inputValid = buffer_size;
+
+		if (audio_chunk)
+		{
+			sample->duration = 0;
+			sample->offset = 0;
+		}
+		sample->sampleId = nextSampleId-1;
+
+		DecodeAudioSample(sample);
+	}
+}
+
+static bool BuildAudioBuffers()
+{
+	size_t outputFrameSize;
+	//if (audio->OutputFrameSize(&outputFrameSize) != MP4_SUCCESS	    || !outputFrameSize)
+	//{
+	outputFrameSize = 8192 * 6; // fallback size
+	//}
+
+	u_int32_t maxSize = 0;
+	if (audio)
+	{
+		if (audio_chunk)
+			maxSize = 65536; // TODO!!!!
+		else
+			maxSize = MP4GetTrackMaxSampleSize(MP4hFile, audio_track);
+		if (!maxSize)
+			return 0;
+
+		sample = new AudioSample(maxSize, outputFrameSize);
+		if (!sample->OK())
+		{
+			delete sample;
+			return false;
+		}
+	}
+
+	if (video)
+	{
+		maxSize = MP4GetTrackMaxSampleSize(MP4hFile, video_track);
+
+		video_sample = new VideoSample(maxSize);
+		if (!video_sample->OK())
+		{
+			delete video_sample;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+DWORD WINAPI PlayProc(LPVOID lpParameter)
+{
+	// set an event when we start.  this keeps Windows from queueing an APC before the thread proc even starts (evil, evil windows)
+	HANDLE threadCreatedEvent = (HANDLE)lpParameter;
+	SetEvent(threadCreatedEvent);
+
+	video=0;
+	if (!open_mp4(lastfn))
+	{
+		if (WaitForSingleObject(killEvent, 200) != WAIT_OBJECT_0)
+			PostMessage(mod.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
+		return 0;
+	}
+
+	audio_output.Init(mod.outMod);
+
+	if (videoOutput && video)
+	{
+		// TODO: this is really just a placeholder, we should do smarter stuff
+		// like query the decoder object for a name rather than guess
+		char set_info[256] = {0};
+		char *audio_info = MP4PrintAudioInfo(MP4hFile, audio_track);
+		char *video_info = 0;
+		if (video_track != MP4_INVALID_TRACK_ID)
+			video_info = MP4PrintVideoInfo(MP4hFile, video_track);
+
+		if (video_info)
+		{
+			StringCchPrintfA(set_info, 256, "%s, %s %ux%u", audio_info, video_info,  MP4GetTrackVideoWidth(MP4hFile, video_track), MP4GetTrackVideoHeight(MP4hFile, video_track));
+			videoOutput->extended(VIDUSER_SET_INFOSTRING,(INT_PTR)set_info,0);
+			MP4Free(video_info);
+		}
+		MP4Free(audio_info);
+	}
+
+	if (!BuildAudioBuffers())
+	{
+		// TODO: benski> more cleanup work has to be done here!
+		if (WaitForSingleObject(killEvent, 200) != WAIT_OBJECT_0)
+			PostMessage(mod.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
+		return 0;
+	}
+
+	nextSampleId = 1;
+	nextVideoSampleId = 1;
+	if (video)
+		Video_Init();
+
+	first = true;
+	audio_opened = false;
+	first_timestamp= 0;
+
+	events[0]=killEvent;
+	events[1]=seekEvent;
+	events[2]=pauseEvent;
+	waitTime = audio?0:INFINITE;
+	done = false;
+
+	while (!done)
+	{
+		int ret = WaitForMultipleObjects(2, events, FALSE, waitTime);
+		switch (ret)
+		{
+			case WAIT_OBJECT_0: // kill event
+				done = true;
+				break;
+
+			case WAIT_OBJECT_0 + 1: // seek event
+				{
+					bool rewind = m_needseek < GetClock();
+					// TODO: reset pregap?
+					MP4SampleId new_video_sample = MP4_INVALID_SAMPLE_ID;
+					if (video)
+					{
+						SetEvent(video_start_flushing);
+						WaitForSingleObject(video_flush_done, INFINITE);
+
+						MP4Duration duration = MP4ConvertToTrackDuration(MP4hFile, video_track, m_needseek, MP4_MSECS_TIME_SCALE);
+						if (duration != MP4_INVALID_DURATION)
+						{
+							new_video_sample = MP4GetSampleIdFromTime(MP4hFile, video_track, duration, true, rewind);
+							if (new_video_sample == MP4_INVALID_SAMPLE_ID)
+								new_video_sample = MP4GetSampleIdFromTime(MP4hFile, video_track, duration, false); // try again without keyframe seeking
+
+							/* TODO: make sure the new seek direction is in the same as the request seek direction.  
+							e.g. make sure a seek FORWARD doesn't go BACKWARD
+							MP4Timestamp video_timestamp = MP4GetSampleTime(MP4hFile, video_track, seek_video_sample);
+							int new_time = MP4ConvertFromTrackTimestamp(MP4hFile, video_track, video_timestamp, MP4_MSECS_TIME_SCALE);
+							if (m_needseek < GetClock())
+							video_timestamp = MP4GetSampleIdFromTime(MP4hFile, video_track, duration, true); // first closest keyframe prior
+							*/
+							if (new_video_sample != MP4_INVALID_SAMPLE_ID)
+							{
+								int m_old_needseek = m_needseek;
+
+								MP4Timestamp video_timestamp = MP4GetSampleTime(MP4hFile, video_track, new_video_sample);
+								m_needseek = MP4ConvertFromTrackTimestamp(MP4hFile, video_track, video_timestamp, MP4_MSECS_TIME_SCALE);
+								if (!audio)
+								{
+									MP4Timestamp video_timestamp = MP4GetSampleTime(MP4hFile, video_track, new_video_sample);
+									m_needseek = MP4ConvertFromTrackTimestamp(MP4hFile, video_track, video_timestamp, MP4_MSECS_TIME_SCALE);
+									video_clock.Seek(m_needseek);
+									m_needseek = -1;
+								}
+								else
+								{
+									// TODO check this will just do what is needed
+									//		aim of this is when there is 1 artwork
+									//		frame then we don't lock audio<->video
+									//		as it otherwise prevents audio seeking
+									if (!m_needseek && m_old_needseek != m_needseek && new_video_sample == 1)
+									{
+										m_needseek = m_old_needseek;
+									}
+								}
+							}
+						}
+					}
+
+					if (audio)
+					{
+						MP4Duration duration = MP4ConvertToTrackDuration(MP4hFile, audio_track, m_needseek, MP4_MSECS_TIME_SCALE);
+						if (duration != MP4_INVALID_DURATION)
+						{
+							MP4SampleId newSampleId = audio_chunk?MP4GetChunkIdFromTime(MP4hFile, audio_track, duration):MP4GetSampleIdFromTime(MP4hFile, audio_track, duration);
+							if (newSampleId != MP4_INVALID_SAMPLE_ID)
+							{
+								audio->Flush();
+
+								if (video)
+								{
+									if (new_video_sample == MP4_INVALID_SAMPLE_ID)
+									{
+										SetEvent(video_resume);
+									}
+									else
+									{
+										nextVideoSampleId = new_video_sample;
+										SetEvent(video_flush);
+									}
+									WaitForSingleObject(video_flush_done, INFINITE);
+								}
+								m_needseek = MP4ConvertFromTrackTimestamp(MP4hFile, audio_track, duration, MP4_MILLISECONDS_TIME_SCALE);
+								ResetEvent(seekEvent);
+								audio_output.Flush(m_needseek);
+								m_needseek = -1;
+								nextSampleId = newSampleId;
+								continue;
+							}
+						}
+					}
+					else
+					{
+						if (new_video_sample == MP4_INVALID_SAMPLE_ID)
+						{
+							SetEvent(video_resume);
+						}
+						else
+						{
+							nextVideoSampleId = new_video_sample;
+							SetEvent(video_flush);
+						}
+						WaitForSingleObject(video_flush_done, INFINITE);
+
+						ResetEvent(seekEvent);
+						continue;
+					}
+				}
+				break;
+
+			case WAIT_TIMEOUT:
+				ReadNextAudioSample();
+				break;
+		}
+	}
+
+	if (WaitForSingleObject(killEvent, 0) == WAIT_TIMEOUT) // if (!killed)
+	{
+		// tell audio decoder about end-of-stream and get remaining audio
+		/* if (audio) {
+			audio->EndOfStream();
+			
+			sample->inputValid = 0;
+			while (DecodeAudioSample(sample)) {
+			}
+		}
+		*/
+		audio_output.Write(0,0);
+		audio_output.WaitWhilePlaying();
+
+		if (WaitForSingleObject(killEvent, 0) == WAIT_TIMEOUT)
+			PostMessage(mod.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
+	}
+	SetEvent(killEvent);
+
+	// eat the rest of the APC messages
+	while (SleepEx(0, TRUE) == WAIT_IO_COMPLETION) {}
+
+	if (video)
+		Video_Close();
+
+	return 0;
+}
\ No newline at end of file