MyMusicTest::MyMusicTest(QWidget *parent): QMainWindow(parent)
{
setWindowTitle("My Music Player");
mStackedWidget = new QStackedWidget;
setCentralWidget(mStackedWidget);
mHttpWindow = new HttpWindow();
mStackedWidget->addWidget(mHttpWindow);
mMyPlayerView = new MyPlayerView;
mStackedWidget->addWidget(mMyPlayerView);
mStackedWidget->setCurrentIndex(0);
mAboutAction = new QAction(tr("About"), this);
mExitAction = new QAction(tr("Exit"), this);
mBackAction = new QAction(tr("Back"), this);
connect(mHttpWindow, SIGNAL(streamSelected(QString)), this, SLOT(playStream(QString)));
connect(mMyPlayerView, SIGNAL(backButtonPressed()), this, SLOT(showHttpView()));
connect(mExitAction, SIGNAL(triggered()), this, SLOT(close()));
connect(mAboutAction, SIGNAL(triggered()), this, SLOT(about()));
connect(mBackAction, SIGNAL(triggered()), this, SLOT(showHttpView()));
createMenus(true);
}
void playFile(char *filename) {
Stream file;
fillStreamWithFile(&file, filename);
broadwayInit();
file.length = 10000;
playStream(&file);
// u8 sps[] = {103,66,192,30,146,68,5,1,127,203,8,0,0,31,72,0,7,83,0,120,177,117};
}
void Player::play(const Alternative<String, const PlayList* > & item,
const XBMCAddon::xbmcgui::ListItem* listitem, bool windowed, int startpos)
{
TRACE;
if (Alternative<String, const PlayList*>::isNullReference(item))
playCurrent(windowed);
else if (item.which() == XBMCAddon::first)
playStream(item.former(), listitem, windowed);
else // item is a PlayListItem
playPlaylist(item.later(),windowed,startpos);
}
void CMusicChannelFMod::update()
{
// if this channel is playing an async music, may retry to start the music each frame
if (_MusicStream && _MusicBuffer == NULL && _MusicChannel == -1)
{
// keeeep trying
playStream();
}
// close anything that still needs to be closed
updateWaitingForClose();
}
void Player::play(const Alternative<String, const PlayList* > & item,
const XBMCAddon::xbmcgui::ListItem* listitem, bool windowed, int startpos)
{
XBMC_TRACE;
if (&item == &defaultPlayParameter)
playCurrent(windowed);
else if (item.which() == XBMCAddon::first)
playStream(item.former(), listitem, windowed);
else // item is a PlayListItem
playPlaylist(item.later(),windowed,startpos);
}
/// Play from memory.
bool CMusicChannelFMod::playSync(const std::string &filepath, bool loop)
{
CIFile ifile;
ifile.allowBNPCacheFileOnOpen(false);
ifile.setCacheFileOnOpen(false);
ifile.open(filepath);
// try to load the music in memory
uint32 fs = ifile.getFileSize();
if (!fs) {
nlwarning("NLSOUND FMod Driver: Empty music file");
return false;
}
// read Buffer
nlassert(!_MusicBuffer);
_MusicBuffer = new uint8[fs];
try {
ifile.serialBuffer(_MusicBuffer, fs);
}
catch (...)
{
nlwarning("NLSOUND FMod Driver: Error while reading music file");
delete[] _MusicBuffer;
_MusicBuffer = NULL;
return false;
}
// open FMOD stream
_MusicStream = FSOUND_Stream_Open((const char*)_MusicBuffer,
FSOUND_2D | FSOUND_LOADMEMORY | (loop ? FSOUND_LOOP_NORMAL : FSOUND_LOOP_OFF), 0, fs);
if (!_MusicStream)
{
nlwarning("NLSOUND FMod Driver: Error while creating the FMOD stream for music file");
delete[] _MusicBuffer;
_MusicBuffer = NULL;
return false;
}
if (!playStream())
{
nlwarning("NLSOUND FMod Driver: Error While trying to play sync music file");
FSOUND_Stream_Close(_MusicStream);
_MusicStream = NULL;
delete[] _MusicBuffer;
_MusicBuffer = NULL;
return false;
}
return true;
}
bool startSound (int f, bool loopy) {
if (soundOK) {
cacheLoopySound = loopy;
int a = cacheSound (f);
if (a == -1) {
debugOut( "Failed to cache sound!\n");
return false;
}
soundCache[a].looping = loopy;
soundCache[a].vol = defSoundVol;
playStream (a, false, loopy);
}
return true;
}
/// Play async, if bnp give path of bnp and position and size of file inside, else just path to file with fileSize 0.
bool CMusicChannelFMod::playAsync(const std::string &filepath, bool loop, uint fileOffset , uint fileSize)
{
nlassert(!_MusicBuffer);
// open fmod stream async
_MusicStream = FSOUND_Stream_Open((const char *)filepath.c_str(),
FSOUND_2D | ( loop ? FSOUND_LOOP_NORMAL : FSOUND_LOOP_OFF) | FSOUND_NONBLOCKING, fileOffset, fileSize);
nlassert(_MusicStream);
// with FSOUND_NONBLOCKING, the file is surely not ready, but still try now (will retry to replay at each updateMusic())
playStream();
nlassert(!_MusicBuffer);
return true;
}
bool DemoPlayer::play(const char *fileName) {
if (!fileName)
return false;
debugC(1, kDebugDemo, "Playing \"%s\"", fileName);
init();
Common::File bat;
if (!bat.open(fileName))
return false;
return playStream(bat);
}
bool playMOD (int f, int a, int fromTrack) {
if (! soundOK) return true;
stopMOD (a);
setResourceForFatal (f);
uint32_t length = openFileFromNum (f);
if (length == 0) {
finishAccess();
setResourceForFatal (-1);
return false;
}
unsigned char * memImage;
memImage = (unsigned char *) loadEntireFileToMemory (bigDataFile, length);
if (! memImage) return fatal (ERROR_MUSIC_MEMORY_LOW);
modCache[a].stream = alureCreateStreamFromMemory(memImage, length, 19200, 0, NULL);
delete memImage;
if (modCache[a].stream != NULL) {
setMusicVolume (a, defVol);
if (! alureSetStreamOrder (modCache[a].stream, fromTrack)) {
debugOut( "Failed to set stream order: %s\n",
alureGetErrorString());
}
playStream (a, true, true);
} else {
debugOut("Failed to create stream from MOD: %s\n",
alureGetErrorString());
warning (ERROR_MUSIC_ODDNESS);
soundCache[a].stream = NULL;
soundCache[a].playing = false;
soundCache[a].playingOnSource = 0;
}
setResourceForFatal (-1);
return true;
}
void handle_play(){
char res_play[1024];
char date[256];
getDate(date);
sprintf(res_play,
"RTSP/1.0 200 OK\r\n"
"CSeq: %s\r\n"
"Date: %s\r\n"
"Range: npt=%d.000-214.000\r\n"
"Session: %i\r\n"
"RTP-Info: url=rtsp://192.168.56.102:3005\r\n\r\n",
cseq,
date,
streamer->pauseTime,
rtspSessionID);
printf("-------------S -> C-------------\n"
"%s\n", res_play);
write(rtsp_sock,res_play,strlen(res_play));
int pid;
if(streamer->pauseSet){ streamer->pauseSet = 0; }
else{
pid = fork();
if(pid>0){
printf("\n\n\n\nmother process %d : %d\n\n\n\n", getpid(), pid);
streamer->playpid=pid;
}
else if(pid==0){
close(rtsp_sock);
printf("\n\n\nchild process : %d\n\n\n\n", getpid(),pid);
playStream(streamer);
}
else if(pid==-1){
perror("fork error : ");
exit(0);
}
}
}
bool DemoPlayer::play(uint32 index) {
if (index >= ARRAYSIZE(_scripts))
return false;
Script &script = _scripts[index];
debugC(1, kDebugDemo, "Playing demoIndex %d: %d", index, script.source);
switch (script.source) {
case kScriptSourceFile:
return play(script.script);
case kScriptSourceDirect:
{
Common::MemoryReadStream stream((const byte *)script.script, strlen(script.script));
init();
return playStream(stream);
}
default:
return false;
}
}
void eMoviePlayer::gotMessage(const Message &msg )
{
eString mrl;
eString restmp = "";
eString command = "";
eDebug("[MOVIEPLAYER] message %d coming in...", msg.type);
switch (msg.type)
{
case Message::start:
case Message::start2:
{
status.STAT = PLAY;
killThreads();
if (msg.filename)
{
mrl = eString(msg.filename);
eDebug("[MOVIEPLAYER] mrl = %s", mrl.c_str());
free((char*)msg.filename);
eDebug("[MOVIEPLAYER] Server IP: %s", server.serverIP.c_str());
eDebug("[MOVIEPLAYER] Server Port: %d", atoi(server.streamingPort.c_str()));
if (msg.type == Message::start2)
{
// stop vlc, just to check whether vlc is up and running
if (int res = sendRequest2VLC("?control=stop") < 0)
{
eDebug("[MOVIEPLAYER] couldn't communicate with vlc, streaming server ip address may be wrong in settings. Errno: %d",res);
setErrorStatus();
break;
}
usleep(200000);
// empty vlc's playlist
if (sendRequest2VLC("?control=empty") < 0)
{
setErrorStatus();
break;
}
usleep(200000);
// vlc: set sout...
if (sendRequest2VLC("?sout=" + httpEscape(sout(mrl))) < 0)
{
setErrorStatus();
break;
}
usleep(200000);
// vlc: add mrl to playlist
if (sendRequest2VLC("?control=add&mrl=" + httpEscape(mrl)) < 0)
{
setErrorStatus();
break;
}
if(mrl.left(3) != "dvd" && mrl.left(3) != "vcd" )
{
usleep(200000);
// vlc: play (circumvention for vlc deficiency)
if (sendRequest2VLC("?control=play") < 0)
{
setErrorStatus();
break;
}
usleep(200000);
// vlc: stop (circumvention for vlc deficiency)
if (sendRequest2VLC("?control=stop") < 0)
{
setErrorStatus();
break;
}
}
usleep(200000);
// vlc: start playback of first item in playlist
if (sendRequest2VLC("?control=play") < 0)
{
setErrorStatus();
break;
}
}
usleep(200000);
// receive and play ts stream
// initialBuffer = INITIALBUFFER; // for future for plugin
if (playStream(mrl) < 0)
{
setErrorStatus();
break;
}
}
break;
}
case Message::pause:
status.STAT = PAUSE;
break;
case Message::play:
status.STAT = PLAY;
break;
case Message::forward:
break;
case Message::rewind:
break;
case Message::async:
status.A_SYNC=false;
break;
case Message::subtitles:
status.SUBT=false;
break;
case Message::nsf:
status.NSF=true;
break;
case Message::dvbon:
status.DVB=false;
break;
case Message::dvboff:
status.DVB=true;
break;
case Message::runplg:
status.PLG=true;
break;
case Message::endplg:
status.PLG=false;
break;
case Message::bufsize:
{
percBuffer = atoi(msg.filename);
eDebug("### percBuffer %d", percBuffer);
initialBuffer = (int)( INITIALBUFFER/100. * percBuffer );
break;
}
case Message::jump:
{
int jump = atoi(eString(msg.filename).c_str());
eDebug("[MOVIEPLAYER] jump: %d seconds", jump);
break;
}
case Message::quit:
{
quit(0);
break;
}
default:
eDebug("unhandled thread message");
}
eDebug("[MOVIEPLAYER] message %d handled.", msg.type);
}
void broadwayPlayStream() {
playStream(&broadwayStream);
}
static void test_midiStream(UINT udev, HWND hwnd)
{
HMIDISTRM hm;
MMRESULT rc, rc2;
MIDIHDR mhdr;
union {
MIDIPROPTEMPO tempo;
MIDIPROPTIMEDIV tdiv;
} midiprop;
if (hwnd)
rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
else
rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
if (rc == MMSYSERR_NOTSUPPORTED)
{
skip( "MIDI stream not supported\n" );
return;
}
ok(!rc, "midiStreamOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc));
if (rc) return;
test_notification(hwnd, "midiStreamOpen", MOM_OPEN, 0);
midiprop.tempo.cbStruct = sizeof(midiprop.tempo);
rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_GET|MIDIPROP_TEMPO);
ok(!rc, "midiStreamProperty TEMPO rc=%s\n", mmsys_error(rc));
ok(midiprop.tempo.dwTempo==500000, "default stream tempo %u microsec per quarter note\n", midiprop.tempo.dwTempo);
midiprop.tdiv.cbStruct = sizeof(midiprop.tdiv);
rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_GET|MIDIPROP_TIMEDIV);
ok(!rc, "midiStreamProperty TIMEDIV rc=%s\n", mmsys_error(rc));
todo_wine ok(24==LOWORD(midiprop.tdiv.dwTimeDiv), "default stream time division %u\n", midiprop.tdiv.dwTimeDiv);
memset(&mhdr, 0, sizeof(mhdr));
mhdr.dwFlags = 0;
mhdr.dwUser = 0x56FA552C;
mhdr.dwOffset = 1234567890;
mhdr.dwBufferLength = sizeof(strmEvents);
mhdr.dwBytesRecorded = mhdr.dwBufferLength;
mhdr.lpData = (LPSTR)&strmEvents[0];
if (mhdr.lpData) {
rc = midiOutLongMsg((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
ok(rc==MIDIERR_UNPREPARED, "midiOutLongMsg unprepared rc=%s\n", mmsys_error(rc));
test_notification(hwnd, "midiOutLong unprepared", 0, WHATEVER);
rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, offsetof(MIDIHDR,dwOffset)-1);
ok(rc==MMSYSERR_INVALPARAM, "midiOutPrepare tiny rc=%s\n", mmsys_error(rc));
rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, offsetof(MIDIHDR,dwOffset));
ok(!rc, "midiOutPrepare old size rc=%s\n", mmsys_error(rc));
ok(mhdr.dwFlags & MHDR_PREPARED, "MHDR.dwFlags when prepared %x\n", mhdr.dwFlags);
/* The device is still in paused mode and should queue the message. */
rc = midiStreamOut(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
ok(!rc, "midiStreamOut old size rc=%s\n", mmsys_error(rc));
rc2 = rc;
trace("MIDIHDR flags=%x when submitted\n", mhdr.dwFlags);
/* w9X/me does not set MHDR_ISSTRM when StreamOut exits,
* but it will be set on all systems after the job is finished. */
Sleep(90);
/* Wine <1.1.39 started playing immediately */
test_notification(hwnd, "midiStream still paused", 0, WHATEVER);
/* MSDN asks to use midiStreamRestart prior to midiStreamOut()
* because the starting state is 'pause', but some apps seem to
* work with the inverse order: queue everything, then play.
*/
rc = midiStreamRestart(hm);
ok(!rc, "midiStreamRestart rc=%s\n", mmsys_error(rc));
if (!rc2) while(mhdr.dwFlags & MHDR_INQUEUE) {
trace("async MIDI still queued\n");
Sleep(100);
} /* Checking INQUEUE is not the recommended way to wait for the end of a job, but we're testing. */
/* MHDR_ISSTRM is not necessarily set when midiStreamOut returns
* rather than when the queue is eventually processed. */
ok(mhdr.dwFlags & MHDR_ISSTRM, "MHDR.dwFlags %x no ISSTRM when out of queue\n", mhdr.dwFlags);
if (!rc2) while(!(mhdr.dwFlags & MHDR_DONE)) {
/* Never to be seen except perhaps on multicore */
trace("async MIDI still not done\n");
Sleep(100);
}
ok(mhdr.dwFlags & MHDR_DONE, "MHDR.dwFlags %x not DONE when out of queue\n", mhdr.dwFlags);
test_notification(hwnd, "midiStream callback", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
test_notification(hwnd, "midiStreamOut", MOM_DONE, (DWORD_PTR)&mhdr);
/* Native fills dwOffset regardless of the cbMidiHdr size argument to midiStreamOut */
ok(1234567890!=mhdr.dwOffset, "play left MIDIHDR.dwOffset at %u\n", mhdr.dwOffset);
rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, offsetof(MIDIHDR,dwOffset));
ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, offsetof(MIDIHDR,dwOffset));
ok(!rc, "midiOutUnprepare #2 rc=%s\n", mmsys_error(rc));
trace("MIDIHDR stream flags=%x when finished\n", mhdr.dwFlags);
ok(mhdr.dwFlags & MHDR_DONE, "MHDR.dwFlags when done %x\n", mhdr.dwFlags);
test_position(hm, TIME_MS, TIME_MS);
test_position(hm, TIME_TICKS, TIME_TICKS);
todo_wine test_position(hm, TIME_MIDI, TIME_MIDI);
test_position(hm, TIME_SMPTE, TIME_MS);
test_position(hm, TIME_SAMPLES, TIME_MS);
test_position(hm, TIME_BYTES, TIME_MS);
Sleep(400); /* Hear note */
midiprop.tempo.cbStruct = sizeof(midiprop.tempo);
rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_GET|MIDIPROP_TEMPO);
ok(!rc, "midiStreamProperty TEMPO rc=%s\n", mmsys_error(rc));
ok(0x0493E0==midiprop.tempo.dwTempo, "stream set tempo %u\n", midiprop.tdiv.dwTimeDiv);
rc = midiStreamRestart(hm);
ok(!rc, "midiStreamRestart #2 rc=%s\n", mmsys_error(rc));
mhdr.dwFlags |= MHDR_ISSTRM;
/* Preset flags (e.g. MHDR_ISSTRM) do not disturb. */
rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, offsetof(MIDIHDR,dwOffset));
ok(!rc, "midiOutPrepare used flags %x rc=%s\n", mhdr.dwFlags, mmsys_error(rc));
rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, offsetof(MIDIHDR,dwOffset));
ok(!rc, "midiOutUnprepare used flags %x rc=%s\n", mhdr.dwFlags, mmsys_error(rc));
rc = midiStreamRestart(hm);
ok(!rc, "midiStreamRestart #3 rc=%s\n", mmsys_error(rc));
}
ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser);
ok(0==((MIDISHORTEVENT*)&strmEvents)[0].dwStreamID, "dwStreamID set to %x\n", ((LPMIDIEVENT)&strmEvents[0])->dwStreamID);
/* dwBytesRecorded controls how much is played, not dwBufferLength
* allowing to immediately forward packets from midiIn to midiOut */
mhdr.dwOffset = 1234123123;
mhdr.dwBufferLength = sizeof(strmNops);
trace("buffer: %u\n", mhdr.dwBufferLength);
mhdr.dwBytesRecorded = 0;
mhdr.lpData = (LPSTR)&strmNops[0];
strmNops[0].dwEvent |= MEVT_F_CALLBACK;
strmNops[1].dwEvent |= MEVT_F_CALLBACK;
rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
ok(!rc, "midiOutPrepare rc=%s\n", mmsys_error(rc));
rc = playStream(hm, &mhdr);
ok(!rc, "midiStreamOut 0 bytes recorded rc=%s\n", mmsys_error(rc));
test_notification(hwnd, "midiStreamOut", MOM_DONE, (DWORD_PTR)&mhdr);
test_notification(hwnd, "0 bytes recorded", 0, WHATEVER);
/* FIXME: check dwOffset within callback
* instead of the unspecified value afterwards */
ok(1234123123==mhdr.dwOffset || broken(0==mhdr.dwOffset), "play 0 set MIDIHDR.dwOffset to %u\n", mhdr.dwOffset);
/* w2k and later only set dwOffset when processing MEVT_T_CALLBACK,
* while w9X/me/nt always sets it. Have Wine behave like w2k because the
* dwOffset slot does not exist in the small size MIDIHDR. */
mhdr.dwOffset = 1234123123;
mhdr.dwBytesRecorded = 1*sizeof(MIDISHORTEVENT);
rc = playStream(hm, &mhdr);
ok(!rc, "midiStreamOut 1 event out of 2 rc=%s\n", mmsys_error(rc));
test_notification(hwnd, "1 of 2 events", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
test_notification(hwnd, "1 of 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
test_notification(hwnd, "1 of 2 events", 0, WHATEVER);
ok(0==mhdr.dwOffset, "MIDIHDR.dwOffset 1/2 changed to %u\n", mhdr.dwOffset);
mhdr.dwOffset = 1234123123;
mhdr.dwBytesRecorded = 2*sizeof(MIDISHORTEVENT);
rc = playStream(hm, &mhdr);
ok(!rc, "midiStreamOut 1 event out of 2 rc=%s\n", mmsys_error(rc));
test_notification(hwnd, "2 of 2 events", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
test_notification(hwnd, "2 of 2 events", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
test_notification(hwnd, "2 of 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
test_notification(hwnd, "2 of 2 events", 0, WHATEVER);
ok(sizeof(MIDISHORTEVENT)==mhdr.dwOffset, "MIDIHDR.dwOffset 2/2 changed to %u\n", mhdr.dwOffset);
ok(mhdr.dwBytesRecorded == 2*sizeof(MIDISHORTEVENT), "dwBytesRecorded changed to %u\n", mhdr.dwBytesRecorded);
strmNops[0].dwEvent &= ~MEVT_F_CALLBACK;
strmNops[1].dwEvent &= ~MEVT_F_CALLBACK;
mhdr.dwOffset = 1234123123;
rc = playStream(hm, &mhdr);
ok(!rc, "midiStreamOut 1 event out of 2 rc=%s\n", mmsys_error(rc));
test_notification(hwnd, "0 CB in 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
test_notification(hwnd, "0 CB in 2 events", 0, WHATEVER);
/* w9X/me/nt set dwOffset to the position played last */
ok(1234123123==mhdr.dwOffset || broken(sizeof(MIDISHORTEVENT)==mhdr.dwOffset), "MIDIHDR.dwOffset nocb changed to %u\n", mhdr.dwOffset);
mhdr.dwBytesRecorded = mhdr.dwBufferLength-1;
rc = playStream(hm, &mhdr);
ok(rc==MMSYSERR_INVALPARAM,"midiStreamOut dwBytesRecorded modulo MIDIEVENT rc=%s\n", mmsys_error(rc));
if (!rc) {
test_notification(hwnd, "2 of 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
}
mhdr.dwBytesRecorded = mhdr.dwBufferLength+1;
rc = playStream(hm, &mhdr);
ok(rc==MMSYSERR_INVALPARAM,"midiStreamOut dwBufferLength<dwBytesRecorded rc=%s\n", mmsys_error(rc));
test_notification(hwnd, "past MIDIHDR tests", 0, WHATEVER);
rc = midiStreamStop(hm);
ok(!rc, "midiStreamStop rc=%s\n", mmsys_error(rc));
ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser);
rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
ok(0==strmNops[0].dwStreamID, "dwStreamID[0] set to %x\n", strmNops[0].dwStreamID);
ok(0==strmNops[1].dwStreamID, "dwStreamID[1] set to %x\n", strmNops[1].dwStreamID);
mhdr.dwBufferLength = 70000; /* > 64KB! */
mhdr.lpData = HeapAlloc(GetProcessHeap(), 0 , mhdr.dwBufferLength);
ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength);
if (mhdr.lpData) {
mhdr.dwFlags = 0;
/* PrepareHeader detects the too large buffer is for a stream. */
rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
todo_wine ok(rc==MMSYSERR_INVALPARAM, "midiOutPrepare stream too large rc=%s\n", mmsys_error(rc));
rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
HeapFree(GetProcessHeap(), 0, mhdr.lpData);
}
rc = midiStreamClose(hm);
ok(!rc, "midiStreamClose rc=%s\n", mmsys_error(rc));
test_notification(hwnd, "midiStreamClose", MOM_CLOSE, 0);
test_notification(hwnd, "midiStream over", 0, WHATEVER);
rc = midiStreamOpen(&hm, &udev, 1, 0, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
ok(!rc /*w2k*/|| rc==MMSYSERR_INVALPARAM/*w98*/, "midiStreamOpen NULL function rc=%s\n", mmsys_error(rc));
if (!rc) {
trace("Device %d accepts NULL CALLBACK_FUNCTION\n", udev);
rc = midiStreamClose(hm);
ok(!rc, "midiStreamClose rc=%s\n", mmsys_error(rc));
}
rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)0xDEADBEEF, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
ok(rc==MMSYSERR_INVALPARAM, "midiStreamOpen bad window rc=%s\n", mmsys_error(rc));
if (!rc) {
rc = midiStreamClose(hm);
ok(!rc, "midiStreamClose rc=%s\n", mmsys_error(rc));
}
}
/* Perform RTSP Handshake with the streaming server machine as part of the connection process */
int performRtspHandshake(IP_ADDRESS addr, PSTREAM_CONFIGURATION streamConfigPtr) {
struct in_addr inaddr;
// Initialize global state
remoteAddr = addr;
memcpy(&inaddr, &addr, sizeof(addr));
sprintf(rtspTargetUrl, "rtsp://%s", inet_ntoa(inaddr));
currentSeqNumber = 1;
hasSessionId = 0;
if (serverMajorVersion == 3) {
rtspClientVersion = 10;
}
else {
rtspClientVersion = 11;
}
{
RTSP_MESSAGE response;
if (!requestOptions(&response)) {
Limelog("RTSP OPTIONS request failed\n");
return -1;
}
if (response.message.response.statusCode != 200) {
Limelog("RTSP OPTIONS request failed: %d\n",
response.message.response.statusCode);
return -1;
}
freeMessage(&response);
}
{
RTSP_MESSAGE response;
if (!requestDescribe(&response)) {
Limelog("RTSP DESCRIBE request failed\n");
return -1;
}
if (response.message.response.statusCode != 200) {
Limelog("RTSP DESCRIBE request failed: %d\n",
response.message.response.statusCode);
return -1;
}
freeMessage(&response);
}
{
RTSP_MESSAGE response;
char* sessionId;
if (!setupStream(&response, "streamid=audio")) {
Limelog("RTSP SETUP streamid=audio request failed\n");
return -1;
}
if (response.message.response.statusCode != 200) {
Limelog("RTSP SETUP streamid=audio request failed: %d\n",
response.message.response.statusCode);
return -1;
}
sessionId = getOptionContent(response.options, "Session");
if (sessionId == NULL) {
Limelog("RTSP SETUP streamid=audio is missing session attribute");
return -1;
}
strcpy(sessionIdString, sessionId);
hasSessionId = 1;
freeMessage(&response);
}
{
RTSP_MESSAGE response;
if (!setupStream(&response, "streamid=video")) {
Limelog("RTSP SETUP streamid=video request failed\n");
return -1;
}
if (response.message.response.statusCode != 200) {
Limelog("RTSP SETUP streamid=video request failed: %d\n",
response.message.response.statusCode);
return -1;
}
freeMessage(&response);
}
{
RTSP_MESSAGE response;
if (!sendVideoAnnounce(&response, streamConfigPtr)) {
Limelog("RTSP ANNOUNCE request failed\n");
return -1;
}
if (response.message.response.statusCode != 200) {
Limelog("RTSP ANNOUNCE request failed: %d\n",
response.message.response.statusCode);
return -1;
}
freeMessage(&response);
}
{
RTSP_MESSAGE response;
if (!playStream(&response, "streamid=video")) {
Limelog("RTSP PLAY streamid=video request failed\n");
return -1;
}
if (response.message.response.statusCode != 200) {
Limelog("RTSP PLAY streamid=video failed: %d\n",
response.message.response.statusCode);
return -1;
}
freeMessage(&response);
}
{
RTSP_MESSAGE response;
if (!playStream(&response, "streamid=audio")) {
Limelog("RTSP PLAY streamid=audio request failed\n");
return -1;
}
if (response.message.response.statusCode != 200) {
Limelog("RTSP PLAY streamid=audio failed: %d\n",
response.message.response.statusCode);
return -1;
}
freeMessage(&response);
}
return 0;
}
int pauseMusic(sp_session *session , char *uri , char *name )
{
TRACE_2( PLAYERMANAGER , "pauseMusic().");
int status = PC_SUCCESS;
char response[255] = { 0 };
LOCK_MUTEX( PLAYERMANAGER , &mutexSession );
sp_error error;
if( pausing == FALSE )
{
pauseStream( name );
error = sp_session_player_play( session , 0 );
if( error != SP_ERROR_OK )
{
TRACE_ERROR( PLAYERMANAGER , "Cannot pause track, reason: %s" , sp_error_message( error ) );
status = PC_ERROR;
snprintf( response , 255 , "NOK: Cannot pause track, reason: %s" , sp_error_message( error ) );
sendVoid( ( void * )response , strlen( response ) );
}
else
{
TRACE_1( PLAYERMANAGER , "Success to pause track.");
pausing = TRUE;
snprintf( response , 255 , "OK");
sendVoid( ( void * )response , strlen( response ) );
}
}
else if( pausing == TRUE )
{
playStream( name );
error = sp_session_player_play( session , 1 );
if( error != SP_ERROR_OK )
{
TRACE_ERROR( PLAYERMANAGER , "Cannot play track, reason: %s" , sp_error_message( error ) );
status = PC_ERROR;
}
else
{
TRACE_1( PLAYERMANAGER , "Success to play track.");
pausing = FALSE;
}
}
UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession );
return status;
}
int playMusic( sp_session *session , char *uri , char *name , playqueue_fifo_t *playqueue )
{
TRACE_2( PLAYERMANAGER , "playMusic().");
static int firstTime = 0;
int status = PC_SUCCESS;
char response[255] = { 0 };
sp_error error;
LOCK_MUTEX( PLAYERMANAGER , &mutexSession );
TRACE_3( PLAYERMANAGER , "Test if a music is playing or not");
if( currentTrack == NULL )
{
TRACE_WARNING( PLAYERMANAGER , "Cannot play track because no track has been loaded.");
status = PC_ERROR;
snprintf( response , 255 , "NOK: Cannot play track because no track has been loaded.");
sendVoid( ( void * )response , strlen( response ) );
}
else
{
TRACE_1( PLAYERMANAGER , "Getting the track.");
currentTrack = getNextTrackToPlayqueue( playqueue );
loadTrack( session , currentTrack );
error = sp_session_player_play( session , 1 );
if( error != SP_ERROR_OK )
{
TRACE_ERROR( PLAYERMANAGER , "Cannot play track, reason: %s" , sp_error_message( error ) );
status = PC_ERROR;
}
else
{
TRACE_1( PLAYERMANAGER , "Success to play track.");
if( firstTime++ != 0 )
playStream( name );
playing = TRUE;
snprintf( response , 255 , "OK");
sendVoid( ( void * )response , strlen( response ) );
}
if( currentStreamName[0] == 0 )
{
strncpy( currentStreamName , name , strlen( name ) );
}
else if( strcmp( currentStreamName , name ) != 0 )
{
memset( currentStreamName , 0 , 255 );
strncpy( currentStreamName , name , strlen( name ) );
}
else if( !strcmp( currentStreamName , name ) )
{
//Do nothing
}
}
UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession );
return status;
}
