2004-02-24 00:41:20 +01:00
|
|
|
/* the Music Player Daemon (MPD)
|
|
|
|
* (c)2003-2004 by Warren Dukes (shank@mercury.chem.pitt.edu)
|
|
|
|
* This project's homepage is: http://www.musicpd.org
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "decode.h"
|
2004-02-27 02:35:23 +01:00
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
#include "player.h"
|
|
|
|
#include "playerData.h"
|
|
|
|
#include "utils.h"
|
|
|
|
#include "pcm_utils.h"
|
|
|
|
#include "audio.h"
|
|
|
|
#include "path.h"
|
|
|
|
#include "log.h"
|
2004-04-11 20:27:12 +02:00
|
|
|
#include "sig_handlers.h"
|
2004-05-18 15:13:55 +02:00
|
|
|
#include "ls.h"
|
2004-06-03 01:22:37 +02:00
|
|
|
#include "utf8.h"
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
#include <signal.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/resource.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2004-04-12 20:51:16 +02:00
|
|
|
volatile int * volatile decode_pid = NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2005-03-08 01:17:33 +01:00
|
|
|
void decodeSigHandler(int sig, siginfo_t * si, void * v) {
|
2004-02-24 00:41:20 +01:00
|
|
|
if(sig==SIGCHLD) {
|
|
|
|
int status;
|
2004-02-27 23:25:06 +01:00
|
|
|
if(decode_pid && *decode_pid==wait3(&status,WNOHANG,NULL)) {
|
2004-04-12 01:07:43 +02:00
|
|
|
if(WIFSIGNALED(status) && WTERMSIG(status)!=SIGTERM &&
|
|
|
|
WTERMSIG(status)!=SIGINT)
|
|
|
|
{
|
|
|
|
ERROR("decode process died from signal: %i\n",
|
2004-02-24 00:41:20 +01:00
|
|
|
WTERMSIG(status));
|
|
|
|
}
|
2004-02-27 23:25:06 +01:00
|
|
|
*decode_pid = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
2005-03-08 03:51:15 +01:00
|
|
|
/* this is causing problems for alsa and other things that generate
|
|
|
|
* extra processes. it causes them to not die */
|
|
|
|
/*else if(sig==SIGTERM && si->si_pid==getppid()) {
|
|
|
|
DEBUG("player/decoder got SIGTERM from parent process\n");*/
|
|
|
|
else if(sig==SIGTERM) {
|
2004-02-27 23:25:06 +01:00
|
|
|
if(decode_pid) {
|
|
|
|
int pid = *decode_pid;
|
|
|
|
if(pid>0) kill(pid,SIGTERM);
|
|
|
|
}
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_SUCCESS);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void stopDecode(DecoderControl * dc) {
|
2004-02-27 23:25:06 +01:00
|
|
|
if(decode_pid && *decode_pid>0 &&
|
2004-05-19 04:14:20 +02:00
|
|
|
(dc->start || dc->state!=DECODE_STATE_STOP))
|
2004-02-27 23:25:06 +01:00
|
|
|
{
|
2004-02-24 00:41:20 +01:00
|
|
|
dc->stop = 1;
|
2004-05-20 02:21:58 +02:00
|
|
|
while(decode_pid && *decode_pid>0 && dc->stop) my_usleep(10000);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void quitDecode(PlayerControl * pc, DecoderControl * dc) {
|
|
|
|
stopDecode(dc);
|
2004-06-01 01:29:35 +02:00
|
|
|
pc->metadataState = PLAYER_METADATA_STATE_READ;
|
2004-02-24 00:41:20 +01:00
|
|
|
pc->state = PLAYER_STATE_STOP;
|
2004-05-20 05:44:33 +02:00
|
|
|
dc->seek = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
pc->play = 0;
|
|
|
|
pc->stop = 0;
|
|
|
|
pc->pause = 0;
|
|
|
|
kill(getppid(),SIGUSR1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int calculateCrossFadeChunks(PlayerControl * pc, AudioFormat * af) {
|
2004-03-05 02:29:08 +01:00
|
|
|
long chunks;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
if(pc->crossFade<=0) return 0;
|
|
|
|
|
|
|
|
chunks = (af->sampleRate*af->bits*af->channels/8.0/CHUNK_SIZE);
|
|
|
|
chunks = (chunks*pc->crossFade+0.5);
|
|
|
|
|
2004-02-25 22:10:56 +01:00
|
|
|
if(chunks>(buffered_chunks-buffered_before_play)) {
|
|
|
|
chunks = buffered_chunks-buffered_before_play;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-02-25 18:53:48 +01:00
|
|
|
if(chunks<0) chunks = 0;
|
|
|
|
|
2004-03-05 02:29:08 +01:00
|
|
|
return (int)chunks;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-06-20 00:27:29 +02:00
|
|
|
#define playSilenceOrSleep() \
|
|
|
|
if(isAudioDeviceOpen()) { \
|
|
|
|
playAudio(silence, CHUNK_SIZE); \
|
|
|
|
} \
|
|
|
|
else my_usleep(10000);
|
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
#define handleDecodeStart() \
|
2004-05-20 05:44:33 +02:00
|
|
|
if(decodeWaitedOn) { \
|
|
|
|
if(dc->state!=DECODE_STATE_START && *decode_pid > 0 && \
|
|
|
|
dc->error==DECODE_ERROR_NOERROR) \
|
|
|
|
{ \
|
|
|
|
decodeWaitedOn = 0; \
|
|
|
|
if(openAudioDevice(&(cb->audioFormat))<0) { \
|
2004-05-31 13:42:46 +02:00
|
|
|
strncpy(pc->erroredUrl, pc->utf8url, \
|
|
|
|
MAXPATHLEN); \
|
|
|
|
pc->erroredUrl[MAXPATHLEN] = '\0'; \
|
2004-05-20 05:44:33 +02:00
|
|
|
pc->error = PLAYER_ERROR_AUDIO; \
|
2004-11-03 03:11:08 +01:00
|
|
|
ERROR("problems opening audio device while playing \"%s\"\n", pc->utf8url); \
|
2004-05-20 05:44:33 +02:00
|
|
|
quitDecode(pc,dc); \
|
|
|
|
return; \
|
|
|
|
} \
|
|
|
|
pc->totalTime = dc->totalTime; \
|
|
|
|
pc->sampleRate = dc->audioFormat.sampleRate; \
|
|
|
|
pc->bits = dc->audioFormat.bits; \
|
|
|
|
pc->channels = dc->audioFormat.channels; \
|
2004-06-03 14:34:25 +02:00
|
|
|
sizeToTime = 8.0/cb->audioFormat.bits/ \
|
|
|
|
cb->audioFormat.channels/ \
|
|
|
|
cb->audioFormat.sampleRate; \
|
2004-05-20 05:44:33 +02:00
|
|
|
} \
|
|
|
|
else if(dc->state!=DECODE_STATE_START || *decode_pid <= 0) { \
|
2004-05-31 13:42:46 +02:00
|
|
|
strncpy(pc->erroredUrl, pc->utf8url, MAXPATHLEN); \
|
|
|
|
pc->erroredUrl[MAXPATHLEN] = '\0'; \
|
2004-05-20 05:44:33 +02:00
|
|
|
pc->error = PLAYER_ERROR_FILE; \
|
2004-05-19 04:14:20 +02:00
|
|
|
quitDecode(pc,dc); \
|
|
|
|
return; \
|
2004-05-20 05:44:33 +02:00
|
|
|
} \
|
|
|
|
else { \
|
2004-06-20 00:27:29 +02:00
|
|
|
my_usleep(10000); \
|
2004-05-20 05:44:33 +02:00
|
|
|
continue; \
|
|
|
|
} \
|
2004-05-19 04:14:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int waitOnDecode(PlayerControl * pc, DecoderControl * dc, OutputBuffer * cb,
|
2004-10-26 04:13:13 +02:00
|
|
|
int * decodeWaitedOn)
|
2004-05-19 04:14:20 +02:00
|
|
|
{
|
2004-06-01 01:29:35 +02:00
|
|
|
strncpy(pc->currentUrl, pc->utf8url, MAXPATHLEN);
|
|
|
|
pc->currentUrl[MAXPATHLEN] = '\0';
|
2004-10-26 04:13:13 +02:00
|
|
|
MpdTag * tag = NULL;
|
2004-06-01 01:29:35 +02:00
|
|
|
|
2004-05-20 02:21:58 +02:00
|
|
|
while(decode_pid && *decode_pid>0 && dc->start) my_usleep(10000);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
if(dc->start || dc->error!=DECODE_ERROR_NOERROR) {
|
2004-05-31 13:42:46 +02:00
|
|
|
strncpy(pc->erroredUrl, pc->utf8url, MAXPATHLEN);
|
|
|
|
pc->erroredUrl[MAXPATHLEN] = '\0';
|
2004-02-24 00:41:20 +01:00
|
|
|
pc->error = PLAYER_ERROR_FILE;
|
|
|
|
quitDecode(pc,dc);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-10-26 04:13:13 +02:00
|
|
|
if((tag = metadataChunkToMpdTagDup(&(pc->fileMetadataChunk)))) {
|
|
|
|
sendMetadataToAudioDevice(tag);
|
|
|
|
freeMpdTag(tag);
|
|
|
|
}
|
2004-10-25 22:09:03 +02:00
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
pc->totalTime = pc->fileTime;
|
|
|
|
pc->bitRate = 0;
|
|
|
|
pc->sampleRate = 0;
|
|
|
|
pc->bits = 0;
|
|
|
|
pc->channels = 0;
|
|
|
|
*decodeWaitedOn = 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
int decodeSeek(PlayerControl * pc, DecoderControl * dc, OutputBuffer * cb,
|
2004-10-26 04:13:13 +02:00
|
|
|
int * decodeWaitedOn, int * next)
|
2004-05-19 04:14:20 +02:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
2004-05-30 15:33:13 +02:00
|
|
|
if(decode_pid && *decode_pid>0) {
|
2004-05-19 04:14:20 +02:00
|
|
|
if(dc->state==DECODE_STATE_STOP || dc->error ||
|
2004-05-31 13:42:46 +02:00
|
|
|
strcmp(dc->utf8url, pc->utf8url)!=0)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
|
|
|
stopDecode(dc);
|
2004-06-10 21:48:53 +02:00
|
|
|
*next = -1;
|
2004-03-23 02:12:30 +01:00
|
|
|
cb->begin = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
cb->end = 0;
|
|
|
|
dc->error = 0;
|
|
|
|
dc->start = 1;
|
2004-10-26 04:13:13 +02:00
|
|
|
waitOnDecode(pc,dc,cb,decodeWaitedOn);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-05-30 15:33:13 +02:00
|
|
|
if(*decode_pid>0 && dc->state!=DECODE_STATE_STOP &&
|
|
|
|
dc->seekable)
|
|
|
|
{
|
2004-06-10 21:48:53 +02:00
|
|
|
*next = -1;
|
2004-03-18 23:20:26 +01:00
|
|
|
dc->seekWhere = pc->seekWhere > pc->totalTime-0.1 ?
|
|
|
|
pc->totalTime-0.1 :
|
|
|
|
pc->seekWhere;
|
|
|
|
dc->seekWhere = 0 > dc->seekWhere ? 0 : dc->seekWhere;
|
2004-05-30 15:33:13 +02:00
|
|
|
dc->seekError = 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
dc->seek = 1;
|
2004-05-30 15:33:13 +02:00
|
|
|
while(*decode_pid>0 && dc->seek) my_usleep(10000);
|
|
|
|
if(!dc->seekError) {
|
|
|
|
pc->elapsedTime = dc->seekWhere;
|
|
|
|
ret = 0;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
pc->seek = 0;
|
2004-05-19 04:14:20 +02:00
|
|
|
|
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#define processDecodeInput() \
|
2004-04-15 07:07:04 +02:00
|
|
|
if(pc->cycleLogFiles) { \
|
|
|
|
myfprintfCloseAndOpenLogFile(); \
|
|
|
|
pc->cycleLogFiles = 0; \
|
|
|
|
} \
|
2004-02-24 00:41:20 +01:00
|
|
|
if(pc->lockQueue) { \
|
|
|
|
pc->queueLockState = PLAYER_QUEUE_LOCKED; \
|
|
|
|
pc->lockQueue = 0; \
|
|
|
|
} \
|
|
|
|
if(pc->unlockQueue) { \
|
|
|
|
pc->queueLockState = PLAYER_QUEUE_UNLOCKED; \
|
|
|
|
pc->unlockQueue = 0; \
|
|
|
|
} \
|
|
|
|
if(pc->pause) { \
|
|
|
|
pause = !pause; \
|
2004-03-26 23:25:01 +01:00
|
|
|
if(pause) pc->state = PLAYER_STATE_PAUSE; \
|
2004-03-20 20:47:05 +01:00
|
|
|
else { \
|
2004-05-10 04:20:15 +02:00
|
|
|
if(openAudioDevice(NULL)<0) { \
|
2004-05-31 13:42:46 +02:00
|
|
|
strncpy(pc->erroredUrl, pc->utf8url, \
|
|
|
|
MAXPATHLEN); \
|
|
|
|
pc->erroredUrl[MAXPATHLEN] = '\0'; \
|
2004-03-20 20:47:05 +01:00
|
|
|
pc->error = PLAYER_ERROR_AUDIO; \
|
2004-11-03 03:11:08 +01:00
|
|
|
ERROR("problems opening audio device while playing \"%s\"\n", pc->utf8url); \
|
2004-03-20 20:47:05 +01:00
|
|
|
quitDecode(pc,dc); \
|
|
|
|
return; \
|
|
|
|
} \
|
|
|
|
pc->state = PLAYER_STATE_PLAY; \
|
|
|
|
} \
|
2004-02-24 00:41:20 +01:00
|
|
|
pc->pause = 0; \
|
|
|
|
kill(getppid(),SIGUSR1); \
|
2004-05-10 04:20:15 +02:00
|
|
|
if(pause) closeAudioDevice(); \
|
2004-02-24 00:41:20 +01:00
|
|
|
} \
|
|
|
|
if(pc->seek) { \
|
2004-10-26 04:13:13 +02:00
|
|
|
if(decodeSeek(pc,dc,cb,&decodeWaitedOn,&next) == 0) { \
|
2004-05-19 04:14:20 +02:00
|
|
|
doCrossFade = 0; \
|
|
|
|
nextChunk = -1; \
|
2004-05-20 05:44:33 +02:00
|
|
|
bbp = 0; \
|
2004-05-19 04:14:20 +02:00
|
|
|
} \
|
2004-02-24 00:41:20 +01:00
|
|
|
} \
|
|
|
|
if(pc->stop) { \
|
2005-03-05 15:01:13 +01:00
|
|
|
dropBufferedAudio(); \
|
2004-02-24 00:41:20 +01:00
|
|
|
quitDecode(pc,dc); \
|
|
|
|
return; \
|
|
|
|
}
|
|
|
|
|
2004-05-18 15:13:55 +02:00
|
|
|
void decodeStart(PlayerControl * pc, OutputBuffer * cb, DecoderControl * dc) {
|
|
|
|
int ret;
|
|
|
|
InputStream inStream;
|
2004-06-03 04:56:26 +02:00
|
|
|
InputPlugin * plugin = NULL;
|
2004-06-02 03:26:15 +02:00
|
|
|
char * path;
|
2004-04-11 20:27:12 +02:00
|
|
|
|
2004-05-31 13:42:46 +02:00
|
|
|
if(isRemoteUrl(pc->utf8url)) {
|
2004-06-02 03:26:15 +02:00
|
|
|
path = utf8StrToLatin1Dup(pc->utf8url);
|
2004-05-31 13:42:46 +02:00
|
|
|
}
|
2004-06-02 03:26:15 +02:00
|
|
|
else path = strdup(rmp2amp(utf8ToFsCharset(pc->utf8url)));
|
|
|
|
|
|
|
|
if(!path) {
|
|
|
|
dc->error = DECODE_ERROR_FILE;
|
|
|
|
dc->state = DECODE_STATE_STOP;
|
|
|
|
dc->start = 0;
|
|
|
|
return;
|
|
|
|
}
|
2004-05-31 13:42:46 +02:00
|
|
|
|
2004-06-06 21:41:03 +02:00
|
|
|
copyMpdTagToOutputBuffer(cb, NULL);
|
2004-05-31 13:42:46 +02:00
|
|
|
|
|
|
|
strncpy(dc->utf8url, pc->utf8url, MAXPATHLEN);
|
|
|
|
dc->utf8url[MAXPATHLEN] = '\0';
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-05-31 13:42:46 +02:00
|
|
|
if(openInputStream(&inStream, path) < 0) {
|
2004-05-18 15:13:55 +02:00
|
|
|
dc->error = DECODE_ERROR_FILE;
|
|
|
|
dc->state = DECODE_STATE_STOP;
|
2004-06-02 03:26:15 +02:00
|
|
|
dc->start = 0;
|
|
|
|
free(path);
|
2004-05-18 15:13:55 +02:00
|
|
|
return;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-05-30 15:33:13 +02:00
|
|
|
dc->seekable = inStream.seekable;
|
2004-05-19 04:14:20 +02:00
|
|
|
dc->state = DECODE_STATE_START;
|
|
|
|
dc->start = 0;
|
|
|
|
|
|
|
|
while(!inputStreamAtEOF(&inStream) && bufferInputStream(&inStream) < 0
|
2004-10-16 14:22:19 +02:00
|
|
|
&& !dc->stop)
|
|
|
|
{
|
|
|
|
/* sleep so we don't consume 100% of the cpu */
|
|
|
|
my_usleep(1000);
|
|
|
|
}
|
2004-05-19 04:14:20 +02:00
|
|
|
|
|
|
|
if(dc->stop) {
|
|
|
|
dc->state = DECODE_STATE_STOP;
|
|
|
|
dc->stop = 0;
|
2004-06-02 03:26:15 +02:00
|
|
|
free(path);
|
2004-05-19 04:14:20 +02:00
|
|
|
return;
|
|
|
|
}
|
2004-05-18 15:13:55 +02:00
|
|
|
|
2004-06-07 07:00:56 +02:00
|
|
|
/*if(inStream.metaName) {
|
2004-06-06 21:41:03 +02:00
|
|
|
MpdTag * tag = newMpdTag();
|
2004-06-07 07:00:56 +02:00
|
|
|
tag->name = strdup(inStream.metaName);
|
2004-06-06 21:41:03 +02:00
|
|
|
copyMpdTagToOutputBuffer(cb, tag);
|
|
|
|
freeMpdTag(tag);
|
2004-06-07 07:00:56 +02:00
|
|
|
}*/
|
2004-06-06 21:41:03 +02:00
|
|
|
|
|
|
|
/* reset Metadata in OutputBuffer */
|
2004-05-31 13:42:46 +02:00
|
|
|
|
2004-05-31 03:21:17 +02:00
|
|
|
ret = DECODE_ERROR_UNKTYPE;
|
2004-06-04 01:45:40 +02:00
|
|
|
if(isRemoteUrl(dc->utf8url)) {
|
2004-06-06 18:42:14 +02:00
|
|
|
cb->acceptMetadata = 1;
|
2004-06-03 04:58:41 +02:00
|
|
|
plugin = getInputPluginFromMimeType(inStream.mime);
|
2004-05-31 03:21:17 +02:00
|
|
|
if(plugin == NULL) {
|
2004-05-31 13:42:46 +02:00
|
|
|
plugin = getInputPluginFromSuffix(
|
|
|
|
getSuffix(dc->utf8url));
|
2004-05-20 05:44:33 +02:00
|
|
|
}
|
2004-06-01 03:07:02 +02:00
|
|
|
/* this is needed for bastard streams that don't have a suffix
|
|
|
|
or set the mimeType */
|
|
|
|
if(plugin == NULL) {
|
|
|
|
plugin = getInputPluginFromName("mp3");
|
|
|
|
}
|
2004-05-31 03:21:17 +02:00
|
|
|
if(plugin && (plugin->streamTypes & INPUT_PLUGIN_STREAM_URL) &&
|
|
|
|
plugin->streamDecodeFunc)
|
2004-05-18 15:13:55 +02:00
|
|
|
{
|
2004-05-31 03:21:17 +02:00
|
|
|
ret = plugin->streamDecodeFunc(cb, dc, &inStream);
|
2004-05-18 15:13:55 +02:00
|
|
|
}
|
|
|
|
}
|
2004-05-31 03:21:17 +02:00
|
|
|
else {
|
2004-06-06 18:42:14 +02:00
|
|
|
cb->acceptMetadata = 0;
|
2004-05-31 13:42:46 +02:00
|
|
|
plugin = getInputPluginFromSuffix(getSuffix(dc->utf8url));
|
2004-05-31 03:21:17 +02:00
|
|
|
if(plugin && (plugin->streamTypes && INPUT_PLUGIN_STREAM_FILE))
|
|
|
|
{
|
|
|
|
if(plugin->streamDecodeFunc) {
|
|
|
|
ret = plugin->streamDecodeFunc(cb, dc,
|
|
|
|
&inStream);
|
|
|
|
}
|
|
|
|
else if(plugin->fileDecodeFunc) {
|
|
|
|
closeInputStream(&inStream);
|
2004-05-31 13:42:46 +02:00
|
|
|
ret = plugin->fileDecodeFunc(cb, dc, path);
|
2004-05-31 03:21:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-18 15:19:30 +02:00
|
|
|
if(ret<0 || ret == DECODE_ERROR_UNKTYPE) {
|
2004-05-31 13:42:46 +02:00
|
|
|
strncpy(pc->erroredUrl, dc->utf8url, MAXPATHLEN);
|
|
|
|
pc->erroredUrl[MAXPATHLEN] = '\0';
|
2004-05-18 15:13:55 +02:00
|
|
|
if(ret != DECODE_ERROR_UNKTYPE) dc->error = DECODE_ERROR_FILE;
|
2004-05-20 05:44:33 +02:00
|
|
|
else {
|
|
|
|
dc->error = DECODE_ERROR_UNKTYPE;
|
|
|
|
closeInputStream(&inStream);
|
|
|
|
}
|
2004-05-18 15:13:55 +02:00
|
|
|
dc->stop = 0;
|
|
|
|
dc->state = DECODE_STATE_STOP;
|
|
|
|
}
|
2004-06-02 03:26:15 +02:00
|
|
|
|
|
|
|
free(path);
|
2004-05-18 15:13:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int decoderInit(PlayerControl * pc, OutputBuffer * cb, DecoderControl * dc) {
|
|
|
|
|
|
|
|
int pid;
|
|
|
|
decode_pid = &(pc->decode_pid);
|
|
|
|
|
|
|
|
blockSignals();
|
|
|
|
pid = fork();
|
|
|
|
|
|
|
|
if(pid==0) {
|
|
|
|
/* CHILD */
|
|
|
|
unblockSignals();
|
|
|
|
|
|
|
|
while(1) {
|
2004-04-15 07:07:04 +02:00
|
|
|
if(dc->cycleLogFiles) {
|
|
|
|
myfprintfCloseAndOpenLogFile();
|
|
|
|
dc->cycleLogFiles = 0;
|
|
|
|
}
|
2004-05-30 15:33:13 +02:00
|
|
|
else if(dc->start || dc->seek) decodeStart(pc, cb, dc);
|
2004-05-20 05:44:33 +02:00
|
|
|
else if(dc->stop) {
|
|
|
|
dc->state = DECODE_STATE_STOP;
|
|
|
|
dc->stop = 0;
|
|
|
|
}
|
2004-04-01 05:48:51 +02:00
|
|
|
else my_usleep(10000);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-04-03 01:34:16 +02:00
|
|
|
exit(EXIT_SUCCESS);
|
2004-02-24 00:41:20 +01:00
|
|
|
/* END OF CHILD */
|
|
|
|
}
|
2004-02-29 09:10:52 +01:00
|
|
|
else if(pid<0) {
|
2004-04-11 20:27:12 +02:00
|
|
|
unblockSignals();
|
2004-05-31 13:42:46 +02:00
|
|
|
strncpy(pc->erroredUrl, pc->utf8url, MAXPATHLEN);
|
|
|
|
pc->erroredUrl[MAXPATHLEN] = '\0';
|
2004-02-24 00:41:20 +01:00
|
|
|
pc->error = PLAYER_ERROR_SYSTEM;
|
|
|
|
return -1;
|
|
|
|
}
|
2004-04-11 20:27:12 +02:00
|
|
|
|
|
|
|
*decode_pid = pid;
|
|
|
|
unblockSignals();
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-06-07 14:11:57 +02:00
|
|
|
void handleMetadata(OutputBuffer * cb, PlayerControl * pc, int * previous,
|
|
|
|
int * currentChunkSent, MetadataChunk * currentChunk)
|
|
|
|
{
|
2004-06-08 20:55:16 +02:00
|
|
|
if(cb->begin!=cb->end) {
|
2004-06-06 21:41:03 +02:00
|
|
|
int meta = cb->metaChunk[cb->begin];
|
2004-06-07 14:11:57 +02:00
|
|
|
if( meta != *previous ) {
|
2004-06-09 18:58:33 +02:00
|
|
|
DEBUG("player: metadata change\n");
|
2004-06-07 14:11:57 +02:00
|
|
|
if( meta >= 0 && cb->metaChunkSet[meta]) {
|
2004-06-09 18:58:33 +02:00
|
|
|
DEBUG("player: new metadata from decoder!\n");
|
2004-06-07 14:11:57 +02:00
|
|
|
memcpy(currentChunk,
|
2004-06-06 21:41:03 +02:00
|
|
|
cb->metadataChunks+meta,
|
|
|
|
sizeof(MetadataChunk));
|
2004-06-07 14:11:57 +02:00
|
|
|
*currentChunkSent = 0;
|
2004-06-07 00:13:23 +02:00
|
|
|
cb->metaChunkSet[meta] = 0;
|
2004-06-06 21:41:03 +02:00
|
|
|
}
|
|
|
|
}
|
2004-06-07 14:11:57 +02:00
|
|
|
*previous = meta;
|
|
|
|
}
|
|
|
|
if(!(*currentChunkSent) && pc->metadataState ==
|
|
|
|
PLAYER_METADATA_STATE_WRITE)
|
|
|
|
{
|
2004-10-25 22:11:35 +02:00
|
|
|
MpdTag * tag = NULL;
|
|
|
|
|
2004-06-07 14:11:57 +02:00
|
|
|
*currentChunkSent = 1;
|
2004-10-25 22:11:35 +02:00
|
|
|
|
|
|
|
if((tag = metadataChunkToMpdTagDup(currentChunk))) {
|
2004-10-26 04:00:17 +02:00
|
|
|
sendMetadataToAudioDevice(tag);
|
2004-10-25 22:11:35 +02:00
|
|
|
freeMpdTag(tag);
|
|
|
|
}
|
|
|
|
|
2004-06-07 14:11:57 +02:00
|
|
|
memcpy(&(pc->metadataChunk), currentChunk,
|
|
|
|
sizeof(MetadataChunk));
|
|
|
|
pc->metadataState = PLAYER_METADATA_STATE_READ;
|
|
|
|
kill(getppid(), SIGUSR1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void advanceOutputBufferTo(OutputBuffer * cb, PlayerControl * pc,
|
|
|
|
int * previous, int * currentChunkSent, MetadataChunk * currentChunk,
|
|
|
|
int to)
|
|
|
|
{
|
|
|
|
while(cb->begin!=to) {
|
|
|
|
handleMetadata(cb, pc, previous, currentChunkSent,
|
|
|
|
currentChunk);
|
|
|
|
cb->begin++;
|
|
|
|
if(cb->begin>=buffered_chunks) {
|
|
|
|
cb->begin = 0;
|
|
|
|
}
|
2004-06-06 21:41:03 +02:00
|
|
|
}
|
2004-06-06 18:42:14 +02:00
|
|
|
}
|
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
void decodeParent(PlayerControl * pc, DecoderControl * dc, OutputBuffer * cb) {
|
|
|
|
int pause = 0;
|
|
|
|
int quit = 0;
|
|
|
|
int bbp = buffered_before_play;
|
|
|
|
int doCrossFade = 0;
|
|
|
|
int crossFadeChunks = 0;
|
|
|
|
int fadePosition;
|
|
|
|
int nextChunk = -1;
|
|
|
|
int test;
|
|
|
|
int decodeWaitedOn = 0;
|
|
|
|
char silence[CHUNK_SIZE];
|
2004-06-03 14:34:25 +02:00
|
|
|
double sizeToTime = 0.0;
|
2004-06-07 14:11:57 +02:00
|
|
|
int previousMetadataChunk = -1;
|
|
|
|
MetadataChunk currentMetadataChunk;
|
|
|
|
int currentChunkSent = 1;
|
2004-06-10 21:48:53 +02:00
|
|
|
int end;
|
|
|
|
int next = -1;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
memset(silence,0,CHUNK_SIZE);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-10-26 04:13:13 +02:00
|
|
|
if(waitOnDecode(pc,dc,cb,&decodeWaitedOn)<0) return;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-10-25 22:09:03 +02:00
|
|
|
pc->elapsedTime = 0;
|
2004-05-19 04:14:20 +02:00
|
|
|
pc->state = PLAYER_STATE_PLAY;
|
|
|
|
pc->play = 0;
|
|
|
|
kill(getppid(),SIGUSR1);
|
2004-05-20 05:44:33 +02:00
|
|
|
|
2004-06-08 20:55:16 +02:00
|
|
|
while(*decode_pid>0 && cb->end-cb->begin<bbp &&
|
|
|
|
cb->end!=buffered_chunks-1 &&
|
2004-05-19 04:14:20 +02:00
|
|
|
dc->state!=DECODE_STATE_STOP)
|
|
|
|
{
|
|
|
|
processDecodeInput();
|
|
|
|
if(quit) return;
|
2004-06-20 00:27:29 +02:00
|
|
|
playSilenceOrSleep();
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
while(!quit) {
|
|
|
|
processDecodeInput();
|
|
|
|
handleDecodeStart();
|
2004-06-07 14:11:57 +02:00
|
|
|
handleMetadata(cb, pc, &previousMetadataChunk,
|
|
|
|
¤tChunkSent, ¤tMetadataChunk);
|
2004-05-19 04:14:20 +02:00
|
|
|
if(dc->state==DECODE_STATE_STOP &&
|
|
|
|
pc->queueState==PLAYER_QUEUE_FULL &&
|
|
|
|
pc->queueLockState==PLAYER_QUEUE_UNLOCKED)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2004-06-10 21:48:53 +02:00
|
|
|
next = cb->end;
|
2004-05-19 04:14:20 +02:00
|
|
|
dc->start = 1;
|
|
|
|
pc->queueState = PLAYER_QUEUE_DECODE;
|
|
|
|
kill(getppid(),SIGUSR1);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-06-20 19:07:13 +02:00
|
|
|
if(next>=0 && doCrossFade==0 && !dc->start &&
|
|
|
|
dc->state!=DECODE_STATE_START)
|
|
|
|
{
|
2004-05-19 04:14:20 +02:00
|
|
|
nextChunk = -1;
|
|
|
|
if(isCurrentAudioFormat(&(cb->audioFormat))) {
|
|
|
|
doCrossFade = 1;
|
|
|
|
crossFadeChunks =
|
|
|
|
calculateCrossFadeChunks(pc,
|
|
|
|
&(cb->audioFormat));
|
|
|
|
if(!crossFadeChunks ||
|
2004-05-10 14:35:18 +02:00
|
|
|
pc->crossFade>=dc->totalTime)
|
2004-05-19 04:14:20 +02:00
|
|
|
{
|
|
|
|
doCrossFade = -1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
2004-05-19 04:14:20 +02:00
|
|
|
else doCrossFade = -1;
|
|
|
|
}
|
2004-06-10 21:48:53 +02:00
|
|
|
|
|
|
|
/* copy thse to locale variables to prevent any potential
|
|
|
|
race conditions and weirdness */
|
|
|
|
end = cb->end;
|
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
if(pause) my_usleep(10000);
|
2004-06-10 21:48:53 +02:00
|
|
|
else if(cb->begin!=end && cb->begin!=next) {
|
|
|
|
if(doCrossFade==1 && next>=0 &&
|
|
|
|
((next>cb->begin &&
|
|
|
|
(fadePosition=next-cb->begin)
|
2004-02-24 00:41:20 +01:00
|
|
|
<=crossFadeChunks) ||
|
2004-06-10 21:48:53 +02:00
|
|
|
(cb->begin>next &&
|
|
|
|
(fadePosition=next-cb->begin+
|
2004-02-25 22:10:56 +01:00
|
|
|
buffered_chunks)<=crossFadeChunks)))
|
2004-05-19 04:14:20 +02:00
|
|
|
{
|
|
|
|
if(nextChunk<0) {
|
|
|
|
crossFadeChunks = fadePosition;
|
|
|
|
}
|
2004-06-10 21:48:53 +02:00
|
|
|
test = end;
|
|
|
|
if(end < cb->begin) test+=buffered_chunks;
|
2004-05-19 04:14:20 +02:00
|
|
|
nextChunk = cb->begin+crossFadeChunks;
|
|
|
|
if(nextChunk<test) {
|
|
|
|
if(nextChunk>=buffered_chunks)
|
|
|
|
{
|
|
|
|
nextChunk -= buffered_chunks;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-05-19 04:14:20 +02:00
|
|
|
pcm_mix(cb->chunks+cb->begin*CHUNK_SIZE,
|
2004-02-24 00:41:20 +01:00
|
|
|
cb->chunks+nextChunk*
|
|
|
|
CHUNK_SIZE,
|
|
|
|
cb->chunkSize[
|
|
|
|
cb->begin],
|
|
|
|
cb->chunkSize[
|
|
|
|
nextChunk],
|
2004-05-10 14:35:18 +02:00
|
|
|
&(cb->audioFormat),
|
2004-02-24 00:41:20 +01:00
|
|
|
((float)fadePosition)/
|
|
|
|
crossFadeChunks);
|
2004-05-19 04:14:20 +02:00
|
|
|
if(cb->chunkSize[nextChunk]>
|
2004-02-24 00:41:20 +01:00
|
|
|
cb->chunkSize[cb->begin]
|
|
|
|
)
|
2004-05-19 04:14:20 +02:00
|
|
|
{
|
|
|
|
cb->chunkSize[cb->begin]
|
2004-02-24 00:41:20 +01:00
|
|
|
= cb->chunkSize
|
|
|
|
[nextChunk];
|
|
|
|
}
|
2004-02-28 00:13:26 +01:00
|
|
|
}
|
2004-05-19 04:14:20 +02:00
|
|
|
else {
|
|
|
|
if(dc->state==DECODE_STATE_STOP)
|
|
|
|
{
|
|
|
|
doCrossFade = -1;
|
|
|
|
}
|
|
|
|
else continue;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
}
|
2004-05-30 15:33:13 +02:00
|
|
|
pc->elapsedTime = cb->times[cb->begin];
|
2004-05-19 04:14:20 +02:00
|
|
|
pc->bitRate = cb->bitRate[cb->begin];
|
|
|
|
pcm_volumeChange(cb->chunks+cb->begin*
|
|
|
|
CHUNK_SIZE,
|
|
|
|
cb->chunkSize[cb->begin],
|
|
|
|
&(cb->audioFormat),
|
|
|
|
pc->softwareVolume);
|
|
|
|
if(playAudio(cb->chunks+cb->begin*CHUNK_SIZE,
|
|
|
|
cb->chunkSize[cb->begin])<0)
|
|
|
|
{
|
|
|
|
quit = 1;
|
|
|
|
}
|
2004-06-03 14:34:25 +02:00
|
|
|
pc->totalPlayTime+= sizeToTime*cb->chunkSize[cb->begin];
|
2004-06-19 18:27:48 +02:00
|
|
|
if( cb->begin+1 >= buffered_chunks ) {
|
2004-05-19 04:14:20 +02:00
|
|
|
cb->begin = 0;
|
|
|
|
}
|
2004-06-19 18:27:48 +02:00
|
|
|
else cb->begin++;
|
2004-05-19 04:14:20 +02:00
|
|
|
}
|
2004-06-10 21:48:53 +02:00
|
|
|
else if(next==cb->begin) {
|
2004-05-19 04:14:20 +02:00
|
|
|
if(doCrossFade==1 && nextChunk>=0) {
|
|
|
|
nextChunk = cb->begin+crossFadeChunks;
|
|
|
|
test = cb->end;
|
2004-06-10 21:48:53 +02:00
|
|
|
if(end < cb->begin) test+=buffered_chunks;
|
2004-05-19 04:14:20 +02:00
|
|
|
if(nextChunk<test) {
|
|
|
|
if(nextChunk>=buffered_chunks)
|
|
|
|
{
|
|
|
|
nextChunk -= buffered_chunks;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-06-07 14:11:57 +02:00
|
|
|
advanceOutputBufferTo(cb, pc,
|
|
|
|
&previousMetadataChunk,
|
|
|
|
¤tChunkSent,
|
|
|
|
¤tMetadataChunk,
|
|
|
|
nextChunk);
|
2004-05-19 04:14:20 +02:00
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-05-19 04:14:20 +02:00
|
|
|
while(pc->queueState==PLAYER_QUEUE_DECODE ||
|
|
|
|
pc->queueLockState==PLAYER_QUEUE_LOCKED)
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2004-05-19 04:14:20 +02:00
|
|
|
processDecodeInput();
|
|
|
|
if(quit) {
|
|
|
|
quitDecode(pc,dc);
|
|
|
|
return;
|
|
|
|
}
|
2004-05-20 02:21:58 +02:00
|
|
|
my_usleep(10000);
|
2004-05-19 04:14:20 +02:00
|
|
|
}
|
|
|
|
if(pc->queueState!=PLAYER_QUEUE_PLAY) {
|
2004-02-24 00:41:20 +01:00
|
|
|
quit = 1;
|
|
|
|
break;
|
|
|
|
}
|
2004-05-18 21:32:05 +02:00
|
|
|
else {
|
2004-06-10 21:48:53 +02:00
|
|
|
next = -1;
|
2004-10-26 04:13:13 +02:00
|
|
|
if(waitOnDecode(pc,dc,cb,&decodeWaitedOn)<0) {
|
2004-05-19 04:14:20 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
nextChunk = -1;
|
|
|
|
doCrossFade = 0;
|
|
|
|
crossFadeChunks = 0;
|
|
|
|
pc->queueState = PLAYER_QUEUE_EMPTY;
|
|
|
|
kill(getppid(),SIGUSR1);
|
2004-05-18 21:32:05 +02:00
|
|
|
}
|
2004-05-19 04:14:20 +02:00
|
|
|
}
|
|
|
|
else if(*decode_pid<=0 ||
|
|
|
|
(dc->state==DECODE_STATE_STOP && !dc->start))
|
|
|
|
{
|
|
|
|
quit = 1;
|
|
|
|
break;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-05-19 04:14:20 +02:00
|
|
|
else {
|
|
|
|
if(playAudio(silence, CHUNK_SIZE) < 0) quit = 1;
|
|
|
|
}
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
quitDecode(pc,dc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* decode w/ buffering
|
|
|
|
* this will fork another process
|
|
|
|
* child process does decoding
|
|
|
|
* parent process does playing audio
|
|
|
|
*/
|
|
|
|
void decode() {
|
|
|
|
OutputBuffer * cb;
|
|
|
|
PlayerControl * pc;
|
|
|
|
DecoderControl * dc;
|
|
|
|
|
|
|
|
cb = &(getPlayerData()->buffer);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-06-09 18:58:33 +02:00
|
|
|
clearAllMetaChunkSets(cb);
|
2004-05-19 04:14:20 +02:00
|
|
|
cb->begin = 0;
|
|
|
|
cb->end = 0;
|
|
|
|
pc = &(getPlayerData()->playerControl);
|
|
|
|
dc = &(getPlayerData()->decoderControl);
|
|
|
|
dc->error = 0;
|
2004-05-20 05:44:33 +02:00
|
|
|
dc->seek = 0;
|
|
|
|
dc->stop = 0;
|
|
|
|
dc->start = 1;
|
2004-06-01 01:29:35 +02:00
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
if(decode_pid==NULL || *decode_pid<=0) {
|
|
|
|
if(decoderInit(pc,cb,dc)<0) return;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-05-19 04:14:20 +02:00
|
|
|
decodeParent(pc, dc, cb);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|