/* 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" #include "player.h" #include "playerData.h" #include "utils.h" #include "pcm_utils.h" #include "audio.h" #include "path.h" #include "log.h" #ifdef HAVE_MAD #include "mp3_decode.h" #endif #ifdef HAVE_OGG #include "ogg_decode.h" #endif #ifdef HAVE_FLAC #include "flac_decode.h" #endif #ifdef HAVE_AUDIOFILE #include "audiofile_decode.h" #endif #ifdef HAVE_FAAD #include "mp4_decode.h" #endif #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> int * decode_pid = NULL; void decodeSigHandler(int sig) { if(sig==SIGCHLD) { int status; if(decode_pid && *decode_pid==wait3(&status,WNOHANG,NULL)) { if(WIFSIGNALED(status) && WTERMSIG(status)!=SIGTERM) { ERROR("decode process died from a " "non-TERM signal: %i\n", WTERMSIG(status)); } *decode_pid = 0; } } else if(sig==SIGTERM) { if(decode_pid) { int pid = *decode_pid; if(pid>0) kill(pid,SIGTERM); } exit(0); } } void stopDecode(DecoderControl * dc) { if(decode_pid && *decode_pid>0 && (dc->start || dc->state==DECODE_STATE_DECODE)) { dc->stop = 1; while(decode_pid && *decode_pid>0 && dc->stop) usleep(1000); } } void quitDecode(PlayerControl * pc, DecoderControl * dc) { stopDecode(dc); pc->state = PLAYER_STATE_STOP; pc->play = 0; pc->stop = 0; pc->pause = 0; kill(getppid(),SIGUSR1); } int calculateCrossFadeChunks(PlayerControl * pc, AudioFormat * af) { long chunks; if(pc->crossFade<=0) return 0; chunks = (af->sampleRate*af->bits*af->channels/8.0/CHUNK_SIZE); chunks = (chunks*pc->crossFade+0.5); if(chunks>(buffered_chunks-buffered_before_play)) { chunks = buffered_chunks-buffered_before_play; } if(chunks<0) chunks = 0; return (int)chunks; } int waitOnDecode(PlayerControl * pc, AudioFormat * af, DecoderControl * dc, Buffer * cb) { while(decode_pid && *decode_pid>0 && dc->start) usleep(1000); if(dc->start || dc->error!=DECODE_ERROR_NOERROR) { strncpy(pc->erroredFile,pc->file,MAXPATHLEN); printf("error: %i, start: %i, decode_pid: %i\n",dc->error, dc->start,*decode_pid); pc->error = PLAYER_ERROR_FILE; quitDecode(pc,dc); return -1; } if(initAudio(af)<0) { strncpy(pc->erroredFile,pc->file,MAXPATHLEN); pc->error = PLAYER_ERROR_AUDIO; quitDecode(pc,dc); return -1; } pc->elapsedTime = 0; pc->bitRate = 0; pc->sampleRate = af->sampleRate; pc->bits = af->bits; pc->channels = af->channels; pc->totalTime = cb->totalTime; return 0; } void decodeSeek(PlayerControl * pc, AudioFormat * af, DecoderControl * dc, Buffer * cb) { if(decode_pid && *decode_pid>0) { cb->next = -1; if(dc->state!=DECODE_STATE_DECODE || dc->error || strcmp(dc->file,pc->file)!=0) { stopDecode(dc); cb->end = 0; dc->error = 0; dc->start = 1; dc->error = 0; waitOnDecode(pc,af,dc,cb); } if(*decode_pid>0 && dc->state==DECODE_STATE_DECODE) { dc->seekWhere = pc->seekWhere > pc->totalTime-0.1 ? pc->totalTime-0.1 : pc->seekWhere; dc->seekWhere = 0 > dc->seekWhere ? 0 : dc->seekWhere; cb->begin = 0; dc->seek = 1; pc->elapsedTime = dc->seekWhere; pc->bitRate = 0; while(*decode_pid>0 && dc->seek) usleep(1000); } } pc->seek = 0; } #define processDecodeInput() \ 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; \ if(pause) { \ finishAudio(); \ pc->state = PLAYER_STATE_PAUSE; \ } \ else { \ if(initAudio(NULL)<0) { \ strncpy(pc->erroredFile,pc->file,MAXPATHLEN); \ pc->error = PLAYER_ERROR_AUDIO; \ quitDecode(pc,dc); \ return; \ } \ pc->state = PLAYER_STATE_PLAY; \ } \ pc->pause = 0; \ kill(getppid(),SIGUSR1); \ } \ if(pc->seek) { \ pc->totalPlayTime+= pc->elapsedTime-pc->beginTime; \ decodeSeek(pc,af,dc,cb); \ pc->beginTime = pc->elapsedTime; \ doCrossFade = 0; \ nextChunk = -1; \ bbp = 0; \ } \ if(pc->stop) { \ pc->totalPlayTime+= pc->elapsedTime-pc->beginTime; \ quitDecode(pc,dc); \ return; \ } int decoderInit(PlayerControl * pc, Buffer * cb, AudioFormat *af, DecoderControl * dc) { int pid; decode_pid = &(pc->decode_pid); pid = fork(); if(pid==0) { /* CHILD */ while(1) { if(dc->start) { strncpy(dc->file,pc->file,MAXPATHLEN); switch(pc->decodeType) { #ifdef HAVE_MAD case DECODE_TYPE_MP3: dc->error = mp3_decode(cb,af,dc); break; #endif #ifdef HAVE_FAAD case DECODE_TYPE_MP4: dc->error = mp4_decode(cb,af,dc); break; #endif #ifdef HAVE_OGG case DECODE_TYPE_OGG: dc->error = ogg_decode(cb,af,dc); break; #endif #ifdef HAVE_FLAC case DECODE_TYPE_FLAC: dc->error = flac_decode(cb,af,dc); break; #endif #ifdef HAVE_AUDIOFILE case DECODE_TYPE_AUDIOFILE: dc->error = audiofile_decode(cb,af,dc); break; #endif default: dc->error = DECODE_ERROR_UNKTYPE; } if(dc->error!=DECODE_ERROR_NOERROR) { dc->start = 0; dc->stop = 0; dc->state = DECODE_STATE_STOP; } } else if(dc->stop) { dc->state = DECODE_STATE_STOP; dc->stop = 0; } else if(dc->seek) dc->start = 1; else usleep(10000); } exit(0); /* END OF CHILD */ } else if(pid<0) { strncpy(pc->erroredFile,pc->file,MAXPATHLEN); pc->error = PLAYER_ERROR_SYSTEM; return -1; } else *decode_pid = pid; return 0; } /* decode w/ buffering * this will fork another process * child process does decoding * parent process does playing audio */ void decode() { Buffer * cb; PlayerControl * pc; AudioFormat * af; DecoderControl * dc; cb = &(getPlayerData()->buffer); cb->begin = 0; cb->end = 0; cb->wrap = 0; pc = &(getPlayerData()->playerControl); dc = &(getPlayerData()->decoderControl); af = &(getPlayerData()->audioFormat); dc->error = 0; dc->start = 1; cb->next = -1; if(decode_pid==NULL || *decode_pid<=0) { if(decoderInit(pc,cb,af,dc)<0) return; } { /* PARENT */ int pause = 0; int quit = 0; int bbp = buffered_before_play; int doCrossFade = 0; int crossFadeChunks = 0; int fadePosition; int nextChunk = -1; int test; if(waitOnDecode(pc,af,dc,cb)<0) return; pc->state = PLAYER_STATE_PLAY; pc->play = 0; pc->beginTime = pc->elapsedTime; kill(getppid(),SIGUSR1); while(*decode_pid>0 && !cb->wrap && cb->end-cb->begin<bbp && dc->state==DECODE_STATE_DECODE) { processDecodeInput(); if(quit) return; usleep(1000); } while(!quit) { processDecodeInput(); if(dc->state==DECODE_STATE_STOP && pc->queueState==PLAYER_QUEUE_FULL && pc->queueLockState==PLAYER_QUEUE_UNLOCKED) { cb->next = cb->end; dc->start = 1; pc->queueState = PLAYER_QUEUE_DECODE; kill(getppid(),SIGUSR1); } if(cb->next>=0 && doCrossFade==0 && !dc->start) { nextChunk = -1; if(isCurrentAudioFormat(af)) { doCrossFade = 1; crossFadeChunks = calculateCrossFadeChunks(pc,af); if(!crossFadeChunks || pc->crossFade>=cb->totalTime) { doCrossFade = -1; } } else doCrossFade = -1; } if(pause) usleep(10000); else if((cb->begin!=cb->end || cb->wrap) && cb->begin!=cb->next) { if(doCrossFade==1 && cb->next>=0 && ((cb->next>cb->begin && (fadePosition=cb->next-cb->begin) <=crossFadeChunks) || (cb->begin>cb->next && (fadePosition=cb->next-cb->begin+ buffered_chunks)<=crossFadeChunks))) { if(nextChunk<0) { crossFadeChunks = fadePosition; } test = cb->end; if(cb->wrap) test+=buffered_chunks; nextChunk = cb->begin+crossFadeChunks; if(nextChunk<test) { if(nextChunk>=buffered_chunks) { nextChunk-= buffered_chunks; } pcm_mix(cb->chunks+cb->begin* CHUNK_SIZE, cb->chunks+nextChunk* CHUNK_SIZE, cb->chunkSize[ cb->begin], cb->chunkSize[ nextChunk], af, ((float)fadePosition)/ crossFadeChunks); if(cb->chunkSize[nextChunk]> cb->chunkSize[cb->begin] ) { cb->chunkSize[cb->begin] = cb->chunkSize [nextChunk]; } } else { if(dc->state==DECODE_STATE_STOP) { doCrossFade = -1; } else continue; } } pc->elapsedTime = cb->times[cb->begin]; pc->bitRate = cb->bitRate[cb->begin]; pcm_volumeChange(cb->chunks+cb->begin* CHUNK_SIZE, cb->chunkSize[cb->begin], af, pc->softwareVolume); if(playAudio(cb->chunks+cb->begin*CHUNK_SIZE, cb->chunkSize[cb->begin])<0) { quit = 1; } cb->begin++; if(cb->begin>=buffered_chunks) { cb->begin = 0; cb->wrap = 0; } } else if(cb->next==cb->begin) { pc->totalPlayTime+= pc->elapsedTime- pc->beginTime; if(doCrossFade==1 && nextChunk>=0) { nextChunk = cb->begin+crossFadeChunks; test = cb->end; if(cb->wrap) test+=buffered_chunks; if(nextChunk<test) { if(nextChunk>=buffered_chunks) { nextChunk-= buffered_chunks; } cb->begin = nextChunk; } } while(pc->queueState==PLAYER_QUEUE_DECODE || pc->queueLockState==PLAYER_QUEUE_LOCKED) { processDecodeInput(); if(quit) { quitDecode(pc,dc); return; } usleep(1000); } if(pc->queueState!=PLAYER_QUEUE_PLAY) { quit = 1; break; } else { cb->next = -1; if(waitOnDecode(pc,af,dc,cb)<0) return; nextChunk = -1; doCrossFade = 0; crossFadeChunks = 0; pc->queueState = PLAYER_QUEUE_EMPTY; kill(getppid(),SIGUSR1); } pc->beginTime = cb->times[cb->begin]; } else if(*decode_pid<=0 || (dc->state==DECODE_STATE_STOP && !dc->start)) { quit = 1; break; } else usleep(1000); } pc->totalPlayTime+= pc->elapsedTime-pc->beginTime; \ quitDecode(pc,dc); /* END OF PARENT */ } return; }