*/
#include "audioplayer.h"
-#include "vaudioplayer.h"
#include "demuxeraudio.h"
#include "timers.h"
#include "video.h"
#include "command.h"
#include "i18n.h"
#include "boxx.h"
+#include "log.h"
+#include "media.h"
+#include "mediaplayer.h"
+
+//how often do we retry if there is no data in stream
+#define MAXTRY 50
AudioPlayer * AudioPlayer::instance=NULL;
sequence=0;
playSequence=0;
currentPlaySequence=-1;
- filename=NULL;
+ uri=NULL;
demuxer=new DemuxerAudio();
logger->log("AudioPlayer", Log::DEBUG, "Audio player ctorII");
if (!demuxer->init(this, audio, NULL, 0, DemuxerAudio::PACKET_SIZE+200))
audio->reset();
lenInBytes=0;
logger->log("AudioPlayer", Log::DEBUG, "Audio player created");
+ canPosition=false;
}
AudioPlayer::~AudioPlayer()
audio->setStreamType(Audio::MPEG2_PES);
delete demuxer;
demuxer=NULL;
- delete filename;
+ delete uri;
}
void AudioPlayer::controlFeeder(int feederAction) {
}
//------------------- externally called functions --------------------------
-int AudioPlayer::play(const char * fn)
+int AudioPlayer::play(const MediaURI * u)
{
- logger->log("AudioPlayer", Log::DEBUG, "play request for %s", fn);
+ logger->log("AudioPlayer", Log::DEBUG, "play request for %s", u->getName());
int rt=0;
threadLock();
- if (filename) delete filename;
- filename=new char[strlen(fn)+1];
- strcpy(filename,fn);
+ if (uri) delete uri;
+ uri=new MediaURI(u);
requestState=S_PLAY;
requestedSequence++;
rt=requestedSequence;
}
int AudioPlayer::fastForward(){
+ if (! canPosition) return 1;
int rt=setRequestedState(S_FF);
threadSignalNoLock();
return rt;
}
int AudioPlayer::fastBackward(){
+ if (! canPosition) return 1;
int rt=setRequestedState(S_BACK);
threadSignalNoLock();
return rt;
}
int AudioPlayer::jumpToPercent(double percent){
+ if (! canPosition) return 1;
threadLock();
ULONG fsec=demuxer->getSecondsFromLen(lenInBytes);
ULONG npos=streampos;
}
int AudioPlayer::skipForward(int seconds) {
+ if (! canPosition) return 1;
threadLock();
ULONG curr=demuxer->getSecondsFromLen(streampos);
ULONG dest=demuxer->positionFromSeconds(curr+(UINT)seconds);
return 0;
}
int AudioPlayer::skipBackward(int seconds) {
+ if (! canPosition) return 1;
threadLock();
ULONG curr=demuxer->getSecondsFromLen(streampos);
if (curr > (UINT)seconds) {
Command::getInstance()->postMessageFromOuterSpace(m);
}
-void AudioPlayer::handleVDRerror(){
- if (!vdr->isConnected())
- {
- logger->log("AudioPlayer", Log::ERR, "disconnect");
- sendFrontendMessage(CONNECTION_LOST);
- setState(S_ERROR);
- }
-}
//open a new file
//called within the thread!
int AudioPlayer::openFile() {
- char * fn=NULL;
threadLock();
- if (filename) {
- fn=new char[strlen(filename)+1];
- strcpy(fn,filename);
- }
+ MediaURI fn(uri);
threadUnlock();
demuxer->reset();
streampos=0;
bytesWritten=0;
- lenInBytes=vdr->loadImage(fn,0,0);
- Log::getInstance()->log("Audioplayer", Log::DEBUG, "request file rt=%d file=%s",lenInBytes,fn);
- handleVDRerror();
- if (lenInBytes <= 0) {
+ MediaPlayer::getInstance()->closeMediaChannel(2);
+ int rt=MediaPlayer::getInstance()->openMedium(2,&fn,&lenInBytes,0,0);
+ Log::getInstance()->log("Audioplayer", Log::DEBUG, "request file rt=%d file=%s",rt,fn.getDisplayName());
+ if (rt != 0) {
return 1;
}
- UINT rsize=0;
- UCHAR *idbuf=vdr->getImageBlock(0,demuxer->headerBytes(),&rsize);
- handleVDRerror();
- if (rsize < demuxer->headerBytes() || idbuf == NULL) {
+ MediaInfo mi;
+ rt=MediaPlayer::getInstance()->getMediaInfo(2,&mi);
+ canPosition=mi.canPosition;
+ ULONG rsize=0;
+ UCHAR *idbuf=NULL;
+ if (canPosition) {
+ rt=MediaPlayer::getInstance()->getMediaBlock(2,0,demuxer->headerBytes(),&rsize,&idbuf);
+ }
+ else {
+ rt=-1;
+ }
+ if (rsize < demuxer->headerBytes() || rt != 0 ) {
if (idbuf) free(idbuf);
- Log::getInstance()->log("VAudioplayer", Log::DEBUG, "unable to get header for file %s",fn);
+ Log::getInstance()->log("Audioplayer", Log::DEBUG, "unable to get header for file %s",fn.getName());
return 0;
}
threadLock();
}
if (idbuf) free(idbuf);
idbuf=NULL;
- if (demuxer->getId3Tag() == NULL) {
+ if (demuxer->getId3Tag() == NULL && canPosition) {
//OK - look at the end
- idbuf=vdr->getImageBlock(lenInBytes-demuxer->footerBytes(),demuxer->footerBytes(),&rsize);
- handleVDRerror();
- if (rsize < demuxer->footerBytes() || idbuf == NULL) {
+ rt=MediaPlayer::getInstance()->getMediaBlock(2,lenInBytes-demuxer->footerBytes(),demuxer->footerBytes(),&rsize,&idbuf);
+ if (rsize < demuxer->footerBytes() || rt != 0) {
if (idbuf) free(idbuf);
- Log::getInstance()->log("VAudioplayer", Log::DEBUG, "unable to get footer for file %s",fn);
+ Log::getInstance()->log("Audioplayer", Log::DEBUG, "unable to get footer for file %s",fn.getName());
return 0;
}
threadLock();
hdrpos=demuxer->checkID3(idbuf,rsize);
threadUnlock();
if (hdrpos < 0) {
- Log::getInstance()->log("VAudioplayer", Log::DEBUG, "no ID3 in footer for file %s",fn);
+ Log::getInstance()->log("Audioplayer", Log::DEBUG, "no ID3 in footer for file %s",fn.getName());
}
free(idbuf);
}
switch(rstate)
{
case S_PAUSE:
- if (cstate != S_PLAY && cstate != S_FF) rstate=cstate; //ignore request
+ if (cstate != S_PLAY && cstate != S_FF && cstate != S_PAUSE) {
+ rstate=cstate; //ignore request
+ break;
+ }
else {
- skipfactor=0;
- demuxer->setSkipFactor(0);
- audio->mute();
- audio->pause();
+ if (cstate != S_PAUSE) {
+ skipfactor=0;
+ demuxer->setSkipFactor(0);
+ audio->mute();
+ audio->pause();
+ break;
+ }
}
- break;
+ //if cstate==S_PAUSE fallthrough to S_PLAY
+ rstate=S_PLAY;
case S_PLAY: // to S_PLAY
skipfactor=0;
demuxer->setSkipFactor(0);
//any change after done cancels the "done" timer
Timers::getInstance()->cancelTimer(this,1);
}
- logger->log("AudioPlayer", Log::DEBUG, "Switch state from %u to %u completed nf=%s", cstate, rstate,newFile?"true":"false");
+ logger->log("AudioPlayer", Log::DEBUG, "Switch state from %u to %u completed seq=%d, nf=%s", cstate, rstate,rseq,newFile?"true":"false");
//we return the newly set state
return rstate;
}
logger->log("AudioPlayer", Log::DEBUG, "player thread started");
thisWrite=0;
thisRead=0;
+ int retrycount=0;
while(1)
{
UCHAR cstate=checkState();
//TODO: use normal blocks...
thisRead=0;
thisWrite=0;
- threadBuffer = vdr->getImageBlock(streampos, BUFLEN , &thisRead);
- handleVDRerror();
- if (!threadBuffer || thisRead == 0) {
+ threadBuffer=NULL;
+ int rt=MediaPlayer::getInstance()->getMediaBlock(2,streampos,BUFLEN,&thisRead,&threadBuffer);
+ if (thisRead == 0 && threadBuffer) {
+ free(threadBuffer);
+ threadBuffer=NULL;
+ }
+ if ((!threadBuffer || thisRead == 0 ) && rt == 0) {
+ retrycount++;
+ if (retrycount > MAXTRY) rt=-1;
+ else {
+ logger->log("AudioPlayer", Log::DEBUG, "no data read, retrying");
+ continue;
+ }
+ }
+
+ if (!threadBuffer || thisRead == 0 || rt != 0) {
//OK we count this as end of stream
//hmm --- we should be able to detect if the audio has gone...
logger->log("AudioPlayer", Log::DEBUG, "stream end");
setRequestedState(S_DONE);
+ MediaPlayer::getInstance()->closeMediaChannel(2);
+ retrycount=0;
continue;
}
+ retrycount=0;
//logger->log("AudioPlayer", Log::DEBUG, "read %ld bytes at pos %ld",thisRead,streampos);
streampos+=thisRead;
}
}
logger->log("AudioPlayer", Log::DEBUG, "finished");
+ MediaPlayer::getInstance()->closeMediaChannel(2);
playerRunnig=false;
return;
}
time_t starttime=time(NULL)+timeout;
time_t curtime=0;
logger->log("AudioPlayer", Log::DEBUG, "waiting for sequence %d",seq);
+ int rt=-1;
while ((curtime=time(NULL)) < starttime) {
int cseq=getSequence();
- if (cseq >= seq) return cseq;
- MILLISLEEP(10);
+ if (cseq >= seq) {
+ rt=cseq;
+ break;
+ }
+ //logger->log("AudioPlayer", Log::DEBUG, "waiting for sequence loop");
+ MILLISLEEP(100);
}
- return -1;
+ logger->log("AudioPlayer", Log::DEBUG, "waiting for sequence %d returns %d",seq,rt);
+ return rt;
}
int AudioPlayer::getSequence() {
if (info && info->avrBitrate != info->bitRate) bitrateType='V';
rt=new char[len];
if (!tag && info) {
- SNPRINTF(rt,len-1,"%s: %s/L%d %cBR,SR=%dk,%s\n",tr("MpegInfo"),
- info->mpegVersion,info->mpegLayer,bitrateType,info->sampleRate/1000,
+ int sr=info->sampleRate/1000;
+ SNPRINTF(rt,len-1,"%s: %s/L%d %cBR,SR=%d.%02dkBit/s,%s\n",tr("MpegInfo"),
+ info->mpegVersion,info->mpegLayer,bitrateType,sr,(info->sampleRate/10-sr*100),
info->info);
}
else if (tag && info){
+ int sr=info->sampleRate/1000;
char *tmp=new char[taglen+1];
SNPRINTF(rt,len-1,"%s\n"
- "%s: %s/L%d %cBR,SR=%dk,%s\n",
+ "%s: %s/L%d %cBR,SR=%d.%02dkBit/s,%s\n",
tag->toString(tmp,taglen,false),
tr("MpegInfo"),
- info->mpegVersion,info->mpegLayer,bitrateType,info->sampleRate/1000,
+ info->mpegVersion,info->mpegLayer,bitrateType,sr,(info->sampleRate/10-sr*100),
info->info);
delete [] tmp;
}
class Boxx;
class DemuxerAudio;
+class MediaURI;
class AudioPlayer : public Thread_TYPE, public Callback, public TimerReceiver
//each of the commands works as a request
//only after getSequence returned the same sequence as those commands this is
//handled by the player and getError is valid
- int play(const char * filename);
+ int play(const MediaURI *uri);
//stop the player without shutting it down
int stop();
int pause();
const static ULONG STATUS_CHANGE=4; //some info has been changed
const static ULONG NEW_SONG=5; //some info has been changed
const static ULONG SHORT_UPDATE=6; //timer info update
+ const static ULONG EXTERN1=7; //for other users as parameter to player event
virtual void timercall(int reference);
UCHAR checkState();
//variables used by the thread
- UINT thisWrite;
- UINT thisRead;
+ ULONG thisWrite;
+ ULONG thisRead;
bool running;
UCHAR *threadBuffer;
UCHAR state;
UCHAR requestState;
- ULONG streampos;
- ULONG lenInBytes;
- ULONG bytesWritten;
- ULONG requestedStreampos;
+ ULLONG streampos;
+ ULLONG lenInBytes;
+ ULLONG bytesWritten;
+ ULLONG requestedStreampos;
int skipfactor;
//the buffer len in bytes
int currentPlaySequence;
//sequence that is changed for each new filename
int playSequence;
+ //can we position?
+ bool canPosition;
- char * filename;
+
+ MediaURI *uri;
int openFile();
- void handleVDRerror();
void sendFrontendMessage(ULONG para);
if (parent) return parent->charWidth(c);
else return surface->getCharWidth(c);
}
+
+Surface * Boxx::getSurface() {
+ if (parent) return parent->getSurface();
+ return surface;
+}
+
friend class BoxStack;
protected:
+ //get the surface this box is drawing to
+ Surface *getSurface();
Boxx* parent;
Region area;
vector<Boxx*> children;
--- /dev/null
+/*
+ Copyright 2005-2007 Mark Calderbank
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "demuxermedia.h"
+#include "callback.h"
+
+#include "video.h"
+#include "log.h"
+
+#ifndef WIN32
+#include <endian.h>
+#else
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN 4321
+#define __BYTE_ORDER __LITTLE_ENDIAN
+#endif
+
+#define PTS_JUMP_MARGIN 10000
+#define PTS_ALLOWANCE 90000
+
+// TODO: PTS class to handle wrapping arithmetic & comparisons?
+static ULLONG PTSDistance(ULLONG pts1, ULLONG pts2)
+{
+ // Assume pts1, pts2 < 2^33; calculate shortest distance between
+ ULLONG ret = (pts1 > pts2) ? pts1 - pts2 : pts2 - pts1;
+ if (ret > (1LL<<32)) ret = (1LL<<33) - ret;
+ return ret;
+}
+
+DemuxerMedia::DemuxerMedia()
+{
+ frameCounting = false;
+ packetCounting = false;
+}
+
+void DemuxerMedia::reset()
+{
+ frameCounting = false;
+ packetCounting = false;
+ pts_map.clear();
+ Demuxer::reset();
+ firstPTS=0;
+ lastPTS=0;
+ currentPTS=0;
+ last_horizontal_size=-1;
+ last_vertical_size=-1;
+}
+
+void DemuxerMedia::flush()
+{
+ state = 0;
+ submitting = false;
+ Demuxer::flush();
+}
+
+int DemuxerMedia::scan(UCHAR *buf, int len)
+{
+ int ret = 0;
+ int astate=0; //hdrbyte
+
+ while ((len + astate)> 3)
+ {
+ switch (astate) {
+ case 0: //1st hdr byte
+ if (*buf != 0) break;
+ astate++;
+ break;
+ case 1: //2nd hdrbyte
+ if (*buf != 0) {
+ astate=0;
+ break;
+ }
+ astate++;
+ break;
+ case 2: //3rd header byte
+ if (*buf != 1) {
+ astate=0;
+ break;
+ }
+ astate++;
+ break;
+ case 3: //4th header byte
+ if ((*buf <PESTYPE_AUD0 || *buf > PESTYPE_AUDMAX) && *buf != PESTYPE_PRIVATE_1) {
+ astate=0;
+ break;
+ }
+ if (*buf != PESTYPE_PRIVATE_1) {
+ //found audio
+ ret=*buf;
+ return ret;
+ }
+ //AC3 - TODO
+ astate=0;
+ default:
+ astate=0;
+ break;
+ }
+ buf++;
+ len--;
+ }
+ return ret;
+}
+
+int DemuxerMedia::findPTS(UCHAR* buf, int len, ULLONG* dest)
+{
+ // nobody uses this
+ // No PTS found.
+ return 0;
+}
+
+void DemuxerMedia::setFrameNum(ULONG frame)
+{
+ frameCounting = true;
+ frameNumber = frame;
+ Log::getInstance()->log("Demuxer", Log::DEBUG, "setFrameNum %d", frame);
+}
+
+void DemuxerMedia::setPacketNum(ULONG npacket)
+{
+ packetCounting = true;
+ packetNumber = npacket;
+ Log::getInstance()->log("Demuxer", Log::DEBUG, "setPacketNum %d", npacket);
+}
+
+int DemuxerMedia::put(UCHAR* buf, int len)
+{
+ int ret = 0; // return number of bytes consumed
+ if (submitting)
+ {
+ if (submitPacket(packet) == 0) // Still full!
+ return ret;
+ else
+ submitting = false;
+ }
+
+ if (state > 0) // We are half way through a PES packet.
+ {
+ if (len >= state) // The remainder of the packet is available.
+ {
+ packet.write(buf, state);
+ buf += state; len -= state; ret += state;
+ state = 0;
+ parseVDRPacketDetails();
+ if (submitPacket(packet) == 0) // Stream is full
+ {
+ submitting = true;
+ return ret;
+ }
+ }
+ else // Write what we have, then exit.
+ {
+ packet.write(buf, len);
+ state -= len;
+ return len;
+ }
+ }
+
+ while (len > 0)
+ {
+ switch (state)
+ {
+ case 0:
+ case -1:
+ if (*buf == 0x00) state--; else state = 0;
+ buf++; len--; ret++;
+ break;
+ case -2:
+ if (*buf == 0x01) state--; else if (*buf != 0x00) state = 0;
+ buf++; len--; ret++;
+ break;
+ case -3:
+ if ((*buf >= PESTYPE_VID0 && *buf <= PESTYPE_VIDMAX) ||
+ (*buf >= PESTYPE_AUD0 && *buf <= PESTYPE_AUDMAX) ||
+ (*buf == PESTYPE_PRIVATE_1))
+ {
+ packet.init(*buf);
+ state--;
+ }
+ else if (*buf == 0x00)
+ state = -1;
+ else
+ state = 0;
+ buf++; len--; ret++;
+ break;
+ case -4:
+ packetLength = ((UINT)*buf) << 8;
+ state--;
+ buf++; len--; ret++;
+ break;
+ case -5:
+ packetLength += *buf;
+ state--;
+ buf++; len--; ret++;
+ break;
+ }
+
+ if (state == -6) // Packet header complete
+ {
+ if (len >= packetLength) // The entire packet is available.
+ {
+ packet.write(buf, packetLength);
+ buf += packetLength; len -= packetLength; ret += packetLength;
+ state = 0;
+ parseVDRPacketDetails();
+ if (submitPacket(packet) == 0) // Stream is full
+ {
+ submitting = true;
+ return ret;
+ }
+ }
+ else // Write what we have.
+ {
+ packet.write(buf, len);
+ state = packetLength - len;
+ ret += len;
+ len = 0;
+ }
+ }
+ }
+ return ret;
+}
+
+ULONG DemuxerMedia::getPacketNum()
+{
+ return packetNumber;
+}
+
+void DemuxerMedia::parseVDRPacketDetails()
+{
+ parsePacketDetails(packet);
+
+ if (packetCounting && packet.getPacketType() >= PESTYPE_AUD0 &&
+ packet.getPacketType() <= PESTYPE_AUDMAX)
+ {
+ packetNumber++;
+ }
+
+ if (frameCounting && packet.findPictureHeader() &&
+ packet.getPacketType() >= PESTYPE_VID0 &&
+ packet.getPacketType() <= PESTYPE_VIDMAX)
+ {
+ ULLONG pts=packet.getPTS();
+ if (packet.findSeqHeader() > 1 && pts != PESPacket::PTS_INVALID)
+ {
+ if (firstPTS == 0) firstPTS=pts;
+ currentPTS=pts;
+
+ }
+ }
+ if (packet.getPacketType() >= PESTYPE_VID0 &&
+ packet.getPacketType() <= PESTYPE_VIDMAX &&
+ packet.findSeqHeader()) {
+ //check video size
+ if (horizontal_size != last_horizontal_size ||
+ vertical_size != last_vertical_size) {
+ last_horizontal_size=horizontal_size;
+ last_vertical_size=vertical_size;
+ Log::getInstance()->log("Demux", Log::DEBUG,"signal size change, new x %d, y %d",
+ horizontal_size,vertical_size);
+ if (callback) callback->call(this);
+ }
+ }
+
+}
+
+//find a sequence header backward
+//search for 00 00 01 <video> backwards
+ULLONG DemuxerMedia::findLastPTS(UCHAR *buffer, ULONG len) {
+ PESPacket pack;
+ int pstate=4;
+ ULONG minlen=12;
+ if (len < minlen) return 0;
+ UCHAR *curpos=buffer+len-minlen;
+ UCHAR *packend=buffer+len;
+ while ((curpos - pstate) > buffer) {
+ switch (pstate){
+ case 4:
+ if (*curpos < PESTYPE_VID0 || *curpos > PESTYPE_VIDMAX) break;
+ pstate--;
+ break;
+ case 3:
+ if (*curpos != 0x1) {
+ pstate=4;
+ continue;
+ }
+ pstate--;
+ break;
+ case 2:
+ case 1:
+ if (*curpos != 0) {
+ pstate=4;
+ continue;
+ }
+ pstate--;
+ break;
+ default:
+ pstate=4;
+ }
+ curpos--;
+ if (pstate != 0) {
+ continue;
+ }
+ //we found a header
+ //curpos points before the first 0
+ pack.init(*(curpos+4));
+ pack.write(curpos+7,packend-curpos-7);
+ packend=curpos+1;
+ ULLONG pts=pack.getPTS();
+ if (pts != PESPacket::PTS_INVALID) {
+ //ok we have it
+ lastPTS=pts;
+ Log::getInstance()->log("DemuxerMedia",Log::DEBUG,"findLastPTS found pts %llu at packet offset %lu from end",pts,len-(curpos+1-buffer));
+ return pts;
+ }
+ //hmm - still no PTS, continue search
+ state=4;
+ }
+ return 0;
+}
+
+ULLONG DemuxerMedia::getCurrentPTS() {
+ return PTSDistance(currentPTS,firstPTS);
+}
+ULLONG DemuxerMedia::getLenPTS() {
+ if (lastPTS == 0) return 0;
+ if (lastPTS < firstPTS) return 0;
+ return PTSDistance(lastPTS,firstPTS);
+}
+
+
+
--- /dev/null
+/*
+ Copyright 2005-2007 Mark Calderbank
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef DEMUXERMEDIA_H
+#define DEMUXERMEDIA_H
+
+#include "mutex.h"
+#include <deque>
+#include "demuxer.h"
+#include "defines.h"
+
+class DemuxerMedia : public Demuxer
+{
+ public:
+ DemuxerMedia();
+ void reset();
+ void flush();
+ int scan(UCHAR* buf, int len);
+ int findPTS(UCHAR* buf, int len, ULLONG* dest);
+ int put(UCHAR* buf, int len);
+ void setFrameNum(ULONG frame);
+ void setPacketNum(ULONG npacket);
+ ULONG getFrameNumFromPTS(ULLONG pts) {return 0;}
+ ULONG getPacketNum();
+ ULLONG getLenPTS();
+ ULLONG getCurrentPTS();
+ ULLONG findLastPTS(UCHAR *buf, ULONG len);
+
+ private:
+ int state;
+ bool submitting;
+ int packetLength;
+ PESPacket packet;
+
+ ULONG frameNumber, packetNumber;
+ bool frameCounting, packetCounting;
+ typedef struct { ULLONG pts; ULONG frame; } PTSMapEntry;
+ typedef std::deque<PTSMapEntry> PTSMap;
+ PTSMap pts_map;
+ Mutex pts_map_mutex;
+ ULLONG firstPTS;
+ ULLONG currentPTS;
+ ULLONG lastPTS;
+ int last_horizontal_size;
+ int last_vertical_size;
+
+ void parseVDRPacketDetails();
+};
+
+#endif
--- /dev/null
+/*
+ Copyright 2004-2006 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "imagereader.h"
+#include "mediaprovider.h"
+#include "media.h"
+#include "i18n.h"
+#include "log.h"
+
+
+ImageReader::ImageReader(int c, MediaProvider *p)
+{
+ logger = Log::getInstance();
+ logger->log("ImageReader", Log::DEBUG, "ctorI");
+ provider=p;
+ channel=c;
+ running=false;
+ readerRunning=false;
+ this->run();
+}
+
+ImageReader::~ImageReader()
+{
+ if (readerRunning) shutdown();
+ for (int i=0;i<MAXCHUNKS;i++) {
+ if (data[i].buffer != NULL) free(data[i].buffer);
+ data[i].buffer=NULL;
+ }
+}
+
+
+void ImageReader::run() {
+ if (running) return;
+ running=true;
+ readerRunning=true;
+ threadStart();
+}
+
+
+void ImageReader::shutdown()
+{
+ running=false;
+ if (readerRunning) {
+ logger->log("ImageReader",Log::DEBUG,"shutdown - warting for reader thread to stop");
+ threadSignalNoLock();
+ logger->log("ImageReader",Log::DEBUG,"shutdown notified");
+ //wait for the reader thread to stop
+ //at most wait 10s
+ for (int loopcount=200;readerRunning && loopcount > 0;loopcount--) {
+ MILLISLEEP(50);
+ }
+ if (readerRunning) {
+ logger->log("ImageReader",Log::ERR,"shutdown - unable to stop reader within 10s");
+ }
+ }
+}
+
+void ImageReader::stop() {
+ if (readerRunning) {
+ threadLock();
+ int numopen=0;
+ for (int i=0; i< MAXCHUNKS;i++) {
+ if (data[i].state == S_FETCHING) {
+ data[i].state = S_BREAK;
+ numopen++;
+ }
+ }
+ threadUnlock();
+ int loopcount=200;
+ while (numopen > 0 && loopcount > 0) {
+ numopen=0;
+ logger->log("ImageReader",Log::DEBUG,"stop - warting for reader thread to stop");
+ threadSignalNoLock();
+ logger->log("ImageReader",Log::DEBUG,"stop notified");
+ MILLISLEEP(50);
+ threadLock();
+ for (int i=0; i< MAXCHUNKS;i++) {
+ if (data[i].state == S_FETCHING) {
+ data[i].state = S_BREAK;
+ numopen++;
+ }
+ }
+ threadUnlock();
+ loopcount--;
+ }
+ if (numopen > 0)
+ logger->log("ImageReader",Log::ERR,"stop - unable to stop reader thread");
+ }
+}
+
+
+
+bool ImageReader::isReaderRunning() {
+ return readerRunning;
+}
+
+
+
+// ----------------------------------- Feed thread
+
+void ImageReader::waitTimed(int ms) {
+ threadLock();
+ struct timespec nt;
+ int sec=ms/1000;
+ int us=1000*(ms - 1000*sec);
+#ifndef WIN32
+ struct timeval ct;
+ gettimeofday(&ct,NULL);
+ nt.tv_sec=ct.tv_sec+sec;
+ nt.tv_nsec=1000*us+1000*ct.tv_usec;
+#else
+ DWORD ct=timeGetTime();
+ nt.tv_sec=ct/1000+sec;
+ nt.tv_nsec=1000*us+1000*ct*1000;
+#endif
+ threadWaitForSignalTimed(&nt);
+ threadUnlock();
+}
+
+void ImageReader::threadMethod()
+{
+ logger->log("ImageReader", Log::DEBUG, "player thread started");
+ int currentChunk=-1;
+ while(1)
+ {
+ if (! running) {
+ break;
+ }
+ if (currentChunk < 0) {
+ threadLock();
+ //check if new request is there (used=true && ongoing=true)
+ for (int i=0; i< MAXCHUNKS; i++) {
+ if (data[i].state == S_REQUEST) {
+ //found new chunk request
+ logger->log("ImageReaderThread", Log::DEBUG, "new chunk request found %i, offset=%llu, len=%u",i,data[i].offset,data[i].reqlen);
+ currentChunk=i;
+ data[i].state=S_FETCHING;
+ break;
+ }
+ }
+ threadUnlock();
+ }
+ threadCheckExit();
+ if (currentChunk < 0) {
+ waitTimed(500);
+ continue;
+ }
+ data[currentChunk].len=0;
+ logger->log("ImageReaderThread", Log::DEBUG, "start receive, offset %llu, len %u",data[currentChunk].offset,data[currentChunk].reqlen);
+ data[currentChunk].buffer=NULL;
+ int rt= provider->getMediaBlock(channel,data[currentChunk].offset, data[currentChunk].reqlen , &(data[currentChunk].len),&(data[currentChunk].buffer));
+ //set the chunk to ready
+ logger->log("ImageReaderThread", Log::DEBUG, "chunk received, offset %llu, len %u",data[currentChunk].offset,data[currentChunk].len);
+ if (rt != 0 || !(data[currentChunk].buffer) || data[currentChunk].len == 0 ) {
+ //OK we count this as end of stream
+ logger->log("ImageReaderThread", Log::DEBUG, "stream end");
+ if (data[currentChunk].buffer != NULL) {
+ free(data[currentChunk].buffer);
+ data[currentChunk].buffer=NULL;
+ }
+ }
+ threadLock();
+ //OK - now the chunk is received, try to see if we can read the next
+ //if somebody told us that this chunk is not needed any more we clean up
+ if ( data[currentChunk].state == S_BREAK) {
+ logger->log("ImageReaderThread", Log::DEBUG, "throw away chunk offset %llu, len %u", data[currentChunk].offset,data[currentChunk].reqlen);
+ data[currentChunk].len=0;
+ if (data[currentChunk].buffer) free(data[currentChunk].buffer);
+ data[currentChunk].buffer=NULL;
+ data[currentChunk].state=S_FREE;
+ }
+ data[currentChunk].state=S_READY;
+ if (data[currentChunk].len > 0) {
+ int i=0;
+ for (; i< MAXCHUNKS;i++) {
+ if (data[i].state == S_FREE ) {
+ data[i].state=S_REQUEST;
+ data[i].buffer=NULL;
+ data[i].offset=data[currentChunk].offset+data[currentChunk].len;
+ data[i].reqlen=data[currentChunk].reqlen;
+ logger->log("ImageReaderThread", Log::DEBUG, "follow on for offset %llu, len %u", data[i].offset,data[i].reqlen);
+ break;
+ }
+ }
+ //if we have a free chunk - read the data
+ if (i < MAXCHUNKS) currentChunk=i;
+ else currentChunk=-1;
+ }
+ else {
+ //OEF or error - don't read next chunk
+ currentChunk=-1;
+ }
+ threadUnlock();
+ threadSignalNoLock();
+ }
+ logger->log("ImageReaderThread", Log::DEBUG, "finished");
+ readerRunning=false;
+ return;
+}
+
+void ImageReader::threadPostStopCleanup()
+{
+}
+
+void ImageReader::call(void *) {
+ threadSignalNoLock();
+}
+
+// the real entry for receiving data
+int ImageReader::getImageChunk(ULLONG offset,UINT len, UINT * rsize, UCHAR **buffer){
+ logger->log("ImageReader", Log::DEBUG, "request chunk offset=%llu, len=%u",offset,len);
+ threadLock();
+ *buffer=NULL;
+ *rsize=0;
+ for (int found=2;found> 0; found--) {
+ //currently simple - we only check if we really have a chunk with exactly matching start
+ for (int i=0; i< MAXCHUNKS; i++ ) {
+ if (data[i].state != S_FREE && data[i].offset == offset) {
+ found=0;
+ while ( data[i].state != S_READY && data[i].state != S_FREE && readerRunning) {
+ threadUnlock();
+ waitTimed(500);
+ threadLock();
+ }
+ if (data[i].state == S_READY) {
+ //data is available
+ *buffer=data[i].buffer;
+ *rsize=data[i].len;
+ //now free the entry
+ data[i].buffer=NULL;
+ data[i].state=S_FREE;
+ logger->log("ImageReader", Log::DEBUG, "ready chunk found at index %u,offset=%llu, len=%u",i,data[i].offset,data[i].len);
+ if ( data[i].len >0) {
+ //check if the next chunk is already on the way
+ ULLONG nexto=data[i].offset+data[i].len;
+ bool nfound=false;
+ for (int x=0;x<MAXCHUNKS;x++) {
+ if (data[x].state != S_FREE && data[x].state != S_BREAK && data[x].offset==nexto) {
+ nfound=true;
+ break;
+ }
+ }
+ if (! nfound) {
+ //set up request for next chunk
+ data[i].offset=nexto;
+ data[i].state=S_REQUEST;
+ logger->log("ImageReader", Log::DEBUG, "next chunk requested at index %u,offset=%llu, len=%u",i,data[i].offset,data[i].reqlen);
+ }
+ }
+ break;
+ }
+ else {
+ //thread seems to be stopped
+ logger->log("ImageReader", Log::DEBUG, "no ready chunk found although in list");
+ ;
+ }
+ break;
+ }
+ }
+ if (found == 0) {
+ threadUnlock();
+ logger->log("ImageReader", Log::DEBUG, "returning buffer 0x%p, len %u",*buffer,*rsize);
+ threadSignalNoLock();
+ return 0;
+ }
+ //we found no chunk for us - so set up a new one
+ //remove all chunks
+ for (int i=0;i<MAXCHUNKS;i++) {
+ if (data[i].state == S_FETCHING) {
+ //the reader is just fetching - let him finish
+ data[i].state = S_BREAK;
+ }
+ else {
+ data[i].state=S_FREE;
+ if (data[i].buffer) free(data[i].buffer);
+ data[i].buffer=NULL;
+ }
+ }
+ //now we should find one free anyway
+ bool ffree=false;
+ for (int i=0;i<MAXCHUNKS;i++) {
+ if (data[i].state==S_FREE) {
+ ffree=true;
+ data[i].offset=offset;
+ data[i].reqlen=len;
+ data[i].state=S_REQUEST;
+ threadSignalNoLock();
+ break;
+ }
+ }
+ if (! ffree) {
+ logger->log("ImageReader", Log::ERR, "no free chunk to load data");
+ threadUnlock();
+ return -1;
+ }
+ }
+ threadUnlock();
+ logger->log("ImageReader", Log::ERR, "unable to get data");
+ return -1;
+ }
+
+
+
+
+
--- /dev/null
+/*
+ Copyright 2004-2006 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef IMAGEREADER_H
+#define IMAGEREADER_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifndef WIN32
+#include <sys/time.h>
+#endif
+#include <time.h>
+
+#include "callback.h"
+#include "thread.h"
+
+#ifdef WIN32
+#include "threadwin.h"
+#else
+#include "threadp.h"
+#endif
+
+
+
+class MediaProvider;
+class Log;
+
+
+class ImageReader : public Thread_TYPE, public Callback
+{
+ public:
+
+ //create an image reader for a media channel
+ //the channel must already been opened
+ ImageReader(int channel,MediaProvider *p);
+ //call shutdown before destroying the reader!
+ virtual ~ImageReader();
+ //request the next image block
+ //will return the current block (if already read) and request the next from the server
+ //rsize will return the received len: 0 on EOF, -1 on error
+ //the returned buffer has to be freed outside (really use free!)
+ //if the buffer is not filled it will wait until the chunk is received!
+ int getImageChunk(ULLONG offset,UINT len, UINT * rsize,UCHAR **buffer);
+
+ //is the reader still running?
+ bool isReaderRunning();
+
+ void shutdown();
+
+ //stop the reader (waits until the reader thread does not access anything)
+ void stop();
+
+
+ virtual void call(void * caller);
+
+
+ protected:
+ void threadMethod();
+ void threadPostStopCleanup();
+
+ private:
+ MediaProvider * provider;
+ int channel;
+ static const int MAXCHUNKS=2;
+ //start the player thread
+ void run();
+ Log* logger;
+
+ bool running;
+ bool readerRunning;
+ void waitTimed(int ms);
+
+ typedef enum {
+ S_REQUEST=1,
+ S_FETCHING=2,
+ S_READY=3,
+ S_BREAK=4,
+ S_FREE=0
+ } rstate;
+
+ class Chunk{
+ public:
+ UCHAR * buffer; //receive buffer (to be deallocated with free)
+ ULLONG offset; //offset within stream/file
+ UINT reqlen; //requested len
+ ULONG len; //received len
+ rstate state; //current state
+ Chunk() {
+ buffer=NULL;
+ offset=0;
+ reqlen=0;
+ len=0;
+ state=S_FREE;
+ }
+ };
+ //received data
+ //setting state in this array requires the thread lock
+ Chunk data[MAXCHUNKS];
+
+};
+
+#endif
+
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "localmediafile.h"
+#include "media.h"
+#include "mediaproviderids.h"
+#include <iostream>
+#include "log.h"
+
+
+LocalMediaFile *LocalMediaFile::instance =NULL;
+
+void LocalMediaFile::init() {
+ if (! instance) {
+ instance=new LocalMediaFile();
+ }
+}
+
+LocalMediaFile::LocalMediaFile():MediaFile(MPROVIDERID_LOCALMEDIAFILE){
+ MediaPlayerRegister::getInstance()->registerMediaProvider(this,MPROVIDERID_LOCALMEDIAFILE);
+}
+
+LocalMediaFile::~LocalMediaFile(){
+ }
+
+MediaList* LocalMediaFile::getRootList() {
+ Log::getInstance()->log("LocalMediaFile::getRootList",Log::DEBUG,"");
+ MediaURI *u=new MediaURI(providerid,"/" BASEDIR,"Local:");
+ MediaList *rt=new MediaList(u);
+ Media *m = createMedia("",BASEDIR);
+ if (m) {
+ m->setURI(u);
+ m->setDisplayName("LocalMedia");
+ rt->push_back(m);
+ }
+ delete u;
+ return rt;
+}
+
+
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef LOCALMEDIAFILE_H
+#define LOCALMEDIAFILE_H
+
+#include "mediafile.h"
+#include "media.h"
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <iostream>
+#include "log.h"
+
+#define BASEDIR "media"
+
+/**
+ * a simple implementation for a local media provider
+ * it will read all media below the /media directory
+ * if this exists
+ */
+
+class LocalMediaFile : public MediaFile {
+ public:
+ LocalMediaFile();
+ virtual ~LocalMediaFile();
+ virtual MediaList * getRootList();
+ static void init();
+ private:
+ static LocalMediaFile *instance;
+};
+
+
+
+#endif
*/
#include "media.h"
-#include "vdr.h"
#include <time.h>
+#include <arpa/inet.h>
+#ifndef SNPRINTF
+#define SNPRINTF snprintf
+#endif
+
+
+MediaURI::MediaURI(const MediaURI *cp) {
+ if ( ! cp) {
+ _providerId=0;
+ _name=NULL;
+ _display=NULL;
+ _allowedTypes=MEDIA_TYPE_ALL;
+ }
+ else {
+ _providerId=cp->_providerId;
+ _allowedTypes=cp->_allowedTypes;
+ _name=NULL;
+ if (cp->_name) {
+ _name=new char[strlen(cp->_name)+1];
+ strcpy(_name,cp->_name);
+ }
+ _display=NULL;
+ if (cp->_display) {
+ _display=new char[strlen(cp->_display)+1];
+ strcpy(_display,cp->_display);
+ }
+ }
+}
+MediaURI::MediaURI(ULONG p, const char * n, const char * dp) {
+ _allowedTypes=MEDIA_TYPE_ALL;
+ _providerId=p;
+ if (n) {
+ _name=new char[strlen(n)+1];
+ strcpy(_name,n);
+ } else {
+ _name=NULL;
+ }
+ _display=NULL;
+ if (dp) {
+ _display=new char[strlen(dp)+1];
+ strcpy(_display,dp);
+ }
+}
+
+
+int MediaURI::getSerializedLenImpl() {
+ int rt=4+4; //provider+allowedType
+ rt+=getSerializedStringLen(_name);
+ rt+=getSerializedStringLen(_display);
+ return rt;
+}
+/**
+ * 4 provider
+ * 4 allowedType
+ * 4 namelen (incl. 0)
+ * name+0
+ * 4 displaylen (incl. 0)
+ * display+0
+ */
+int MediaURI::serializeImpl(SerializeBuffer *b) {
+ version=1;
+ if (b->encodeLong(_providerId) != 0) return -1;
+ if (b->encodeLong(_allowedTypes) != 0) return -1;
+ if (b->encodeString(_name) != 0) return -1;
+ if (b->encodeString(_display) != 0) return -1;
+ return 0;
+}
+
+int MediaURI::deserializeImpl(SerializeBuffer *b) {
+ if (_name) delete _name;
+ _name=NULL;
+ if (_display) delete _display;
+ _display=NULL;
+ if (b->decodeLong(_providerId) != 0) return -1;
+ if (b->decodeLong(_allowedTypes) != 0) return -1;
+ ULONG nlen=0;
+ if (b->decodeString(nlen,_name) != 0) return -1;
+ if (b->decodeString(nlen,_display) != 0) return -1;
+ //if (version > 1) ...
+ return 0;
+}
+
+
+
+
+int MediaInfo::getSerializedLenImpl() {
+ int rt=8+1+4+4; //8len+1canPos+4type+4subtype
+ return rt;
+}
+
+
+/**
+ * serialize to buffer
+ * 8 len
+ * 1 canPos
+ * 4 type
+ * 4 subtype
+ */
+int MediaInfo::serializeImpl(SerializeBuffer *b) {
+ if (b->encodeLongLong(size) != 0) return -1;
+ if (b->encodeByte(canPosition?1:0) != 0) return -1;
+ if (b->encodeLong(type) != 0) return -1;
+ if (b->encodeLong(subtype) != 0) return -1;
+ return 0;
+}
+/**
+ * deserialize
+ * should be compatible to older serialize functions
+ */
+int MediaInfo::deserializeImpl(SerializeBuffer *b) {
+ if (b->decodeLongLong(size) != 0) return -1;
+ UCHAR cp=0;
+ if (b->decodeByte(cp) != 0) return -1;
+ canPosition=cp!=0;
+ if (b->decodeLong(type) != 0) return -1;
+ if (b->decodeLong(subtype) != 0) return -1;
+ return 0;
+}
-Media* Media::recInfoFor = NULL;
Media::Media()
{
- start = 0;
+ mtime = 0;
displayName = NULL;
fileName = NULL;
- index = -1;
- markList = NULL;
mediaType=MEDIA_TYPE_UNKNOWN;
+ uri=NULL;
+ index=0;
+}
+
+Media::Media(const Media *m) {
+ Media();
+ if (! m) return;
+ mtime=m->mtime;
+ mediaType=m->mediaType;
+ uri=NULL;
+ fileName=NULL;
+ displayName=NULL;
+ if (m->uri) uri=new MediaURI(m->uri);
+ setFileName(m->fileName);
+ setDisplayName(m->displayName);
+ index=m->index;
}
Media::~Media()
{
if (displayName) { delete[] displayName; displayName = NULL; }
if (fileName) { delete[] fileName; fileName = NULL; }
+ if (uri) delete uri;
index = -1; // just in case
-
- if (markList && markList->size())
- {
- for(UINT i = 0; i < markList->size(); i++)
- {
- delete (*markList)[i];
- }
- markList->clear();
- Log::getInstance()->log("Media", Log::DEBUG, "Media destructor, marks list deleted");
- }
-
- if (markList) delete markList;
}
ULONG Media::getTime() const
{
- return start;
+ return mtime;
}
const char* Media::getDisplayName() const
void Media::setTime(ULONG tstartTime)
{
- start = tstartTime;
+ mtime = tstartTime;
}
-void Media::setMediaType(int mtype)
+void Media::setMediaType(ULONG mtype)
{
mediaType=mtype;
}
-int Media::getMediaType() const
+ULONG Media::getMediaType() const
{
return mediaType;
}
-void Media::setDisplayName(char* tDisplayName)
+void Media::setDisplayName(const char* tDisplayName)
{
if (displayName) delete[] displayName;
-
+ displayName=NULL;
+ if (! tDisplayName) return;
displayName = new char[strlen(tDisplayName) + 1];
if (displayName) strcpy(displayName, tDisplayName);
}
-void Media::setFileName(char* tFileName)
+void Media::setFileName(const char* tFileName)
{
if (fileName) delete[] fileName;
-
+ fileName=NULL;
+ if (! tFileName) return;
fileName = new char[strlen(tFileName) + 1];
if (fileName) strcpy(fileName, tFileName);
}
+bool Media::hasDisplayName() const {
+ return (displayName != NULL);
+}
+
char * Media::getTimeString(char * buffer) const {
if (! buffer) buffer=new char[TIMEBUFLEN];
struct tm ltime;
- time_t recStartTime = (time_t)getTime();
- struct tm *btime = localtime(&recStartTime);
+ time_t tTime = (time_t)getTime();
+ struct tm *btime = localtime(&tTime);
memcpy(<ime,btime, sizeof(struct tm));
btime=<ime;
- if (btime && recStartTime != 0) {
+ if (btime && tTime != 0) {
#ifndef _MSC_VER
strftime(buffer,TIMEBUFLEN, "%0g/%0m/%0d %0H:%0M ", btime);
#else
- strftime(buffer, TIMEBUFLEN, "%y/%m/%d %H:%M ", btime);
+ strftime(buffer,TIMEBUFLEN, "%0G/%0m/%0d %0H:%0M ", btime);
#endif
}
else {
return buffer;
}
-void Media::loadMarks()
-{
- markList = VDR::getInstance()->getMarks(fileName);
+const MediaURI * Media::getURI() const {
+ return uri;
}
+void Media::setURI(const MediaURI *u) {
+ if (uri) delete uri;
+ uri=new MediaURI(u);
+}
+
+int Media::getSerializedLenImpl() {
+ int rt=4+4+1; //type,time,hasURI
+ rt+=getSerializedStringLen(fileName);
+ rt+=getSerializedStringLen(displayName);
+ if (uri) rt+=uri->getSerializedLen();
+ return rt;
+}
+/**
+ * 4 type
+ * 4 time
+ * 4 namelen (incl. 0)
+ * name+0
+ * 4 displaylen (incl. 0)
+ * display+0
+ * 1 hasURI
+ * URI
+ */
+int Media::serializeImpl(SerializeBuffer *b) {
+ if (b->encodeLong(mediaType) != 0) return -1;
+ if (b->encodeLong(mtime) != 0) return -1;
+ if (b->encodeString(fileName) != 0) return -1;
+ if (b->encodeString(displayName) != 0) return -1;
+
+ if (b->encodeByte(uri?1:0) != 0) return -1;
+ if (uri) {
+ if (uri->serialize(b) != 0) return -1;
+ }
+ return 0;
+}
+int Media::deserializeImpl(SerializeBuffer *b) {
+ if (fileName) delete fileName;
+ fileName=NULL;
+ if (displayName) delete displayName;
+ displayName=NULL;
+ if (uri) delete uri;
+ uri=NULL;
+ if (b->decodeLong(mediaType) != 0) return -1;
+ if (b->decodeLong(mtime) != 0) return -1;
+ ULONG nlen=0;
+ if (b->decodeString(nlen,fileName) != 0) return -1;
+ if (b->decodeString(nlen,displayName) != 0) return -1;
+ UCHAR hasURI=0;
+ if (b->decodeByte(hasURI) != 0) return -1;
+ if (hasURI!=0) {
+ uri=new MediaURI();
+ if (uri->deserialize(b) != 0) return -1;
+ }
+ return 0;
+}
-int Media::getPrevMark(int currentFrame)
-{
- MarkList::reverse_iterator i;
- Mark* loopMark = NULL;
- if (!markList || !markList->size()) return 0;
- for(i = markList->rbegin(); i != markList->rend(); i++)
- {
- loopMark = *i;
- Log::getInstance()->log("Media", Log::NOTICE, "findprev:comparing Frame %i with current Frame %i",loopMark->pos,currentFrame);
+MediaURI * MediaList::getURI(Media * m) {
+ if (! m) return NULL;
+ const MediaURI *rtc=m->getURI();
+ if (rtc) return new MediaURI(rtc);
+ if (!_root) return NULL;
+ if (! m->getFileName()) return NULL;
+ int len=strlen(m->getFileName());
+ if (_root->getName()) len+=strlen(_root->getName())+1;
+ MediaURI *rt=new MediaURI();
+ rt->_name=new char[len+1];
+ const char *fn=m->getFileName();
+ if (_root->getName()) {
+ while (*fn=='/') fn++;
+ sprintf(rt->_name,"%s/%s",_root->getName(),fn);
+ }
+ else {
+ sprintf(rt->_name,"%s",fn);
+ }
+ if (m->hasDisplayName() || _root->hasDisplayName()) {
+ len=strlen(m->getDisplayName())+1;
+ if (_root->hasDisplayName()) {
+ len+=strlen(_root->getDisplayName())+2;
+ }
+ rt->_display=new char[len];
+ if (_root->hasDisplayName()) {
+ const char *sp=m->getDisplayName();
+ if (*sp=='/')sp++;
+ sprintf(rt->_display,"%s/%s",_root->getDisplayName(),sp);
+ }
+ else {
+ sprintf(rt->_display,"%s",m->getDisplayName());
+ }
+ }
+ rt->_providerId=_root->_providerId;
+ rt->_allowedTypes=_root->_allowedTypes;
+ return rt;
+}
- if (loopMark->pos < currentFrame)
- {
- Log::getInstance()->log("Media", Log::NOTICE, "findprev:setting pos %i to jumpframe_target",loopMark->pos);
- return loopMark->pos;
+MediaURI * MediaList::getParent(MediaURI *c) {
+ MediaURI * rt=new MediaURI();
+ rt->_providerId=c->_providerId;
+ rt->_allowedTypes=c->_allowedTypes;
+ ULONG nlen=0;
+ if (c->_name) {
+ char * ls=strrchr(c->_name,'/');
+ if (ls) {
+ nlen=ls-c->_name;
+ rt->_name=new char[nlen+1];
+ strncpy(rt->_name,c->_name,nlen);
+ rt->_name[nlen]=0;
+ }
+ }
+ if (c->_display) {
+ char * ls=strrchr(c->_display,'/');
+ if (ls) {
+ nlen=ls-c->_display;
+ rt->_display=new char[nlen+1];
+ strncpy(rt->_display,c->_display,nlen);
+ rt->_display[nlen]=0;
}
}
+ return rt;
+}
- // No previous mark
- return 0;
+
+MediaList::MediaList(const MediaURI *root) {
+ _root=new MediaURI(root);
+ _owning=true;
}
-int Media::getNextMark(int currentFrame)
-{
- MarkList::iterator i;
- Mark* loopMark = NULL;
- if (!markList || !markList->size()) return 0;
+MediaList::~MediaList() {
+ emptyList();
+}
+void MediaList::emptyList(){
+ if (_owning) {
+ for (UINT i = 0; i < size(); i++)
+ {
+ delete (*this)[i];
+ }
+ }
+ clear();
+ if (_root) delete _root;
+ _root=NULL;
+ _owning=true;
+}
+
- for(i = markList->begin(); i != markList->end(); i++)
- {
- loopMark = *i;
- Log::getInstance()->log("Media", Log::NOTICE, "findnext:comparing Frame %i with current Frame %i",loopMark->pos,currentFrame);
+MediaURI * MediaList::getRootURI() {
+ if ( ! _root) return NULL;
+ return new MediaURI(_root);
+}
- if (loopMark->pos > currentFrame)
- {
- Log::getInstance()->log("Media", Log::NOTICE, "findnext:setting pos %i to jumpframe_target",loopMark->pos);
- return loopMark->pos;
- }
+ULONG MediaList::getProvider() {
+ if (! _root) return 0;
+ return _root->getProvider();
+}
+
+void MediaList::setOwning(bool owning) {
+ _owning=owning;
+}
+
+
+
+int MediaList::getSerializedLenImpl() {
+ int rt=4+1; //numelem+hasRoot
+ if (_root) rt+=_root->getSerializedLen();
+ for (MediaList::iterator it=begin();it<end();it++) {
+ rt+=(*it)->getSerializedLen();
}
+ return rt;
+}
- // No next mark
+/**
+ * 4 numelem
+ * 1 hasRoot
+ * URI root
+ * nx Media elements
+ *
+ */
+int MediaList::serializeImpl(SerializeBuffer *b) {
+ if (b->encodeLong(size()) != 0) return -1;
+ if (b->encodeByte(_root?1:0) != 0) return -1;
+ if (_root) {
+ if (_root->serialize(b) != 0) return -1;
+ }
+ for (MediaList::iterator it=begin();it<end();it++) {
+ if ((*it)->serialize(b) !=0) return -1;
+ }
return 0;
}
-bool Media::hasMarks()
-{
- return (markList && markList->size());
+int MediaList::deserializeImpl(SerializeBuffer *b) {
+ emptyList();
+ ULONG numelem;
+ if (b->decodeLong(numelem) != 0) return -1;
+ UCHAR hasRoot=0;
+ if (b->decodeByte(hasRoot) != 0) return -1;
+ if (hasRoot!=0) {
+ _root=new MediaURI();
+ if (_root->deserialize(b) != 0) return -1;
+ }
+ for (ULONG i=0;i<numelem;i++) {
+ Media *m=new Media();
+ if (m->deserialize(b) != 0) {
+ delete m;
+ return -1;
+ }
+ push_back(m);
+ }
+ return 0;
}
-MarkList* Media::getMarkList()
-{
- return markList;
-}
+
+
#ifndef MEDIA_H
#define MEDIA_H
+using namespace std;
+#include <vector>
#include <stdio.h>
#include <string.h>
#include "defines.h"
-#include "recinfo.h"
-#include "mark.h"
-#include "log.h"
-#include "demuxer.h"
+#include "serialize.h"
/* media types form a bitmask
so you can add them to have > 1*/
#define MEDIA_TYPE_ALL (1+2+4+8)
+/**
+ * MediaURI - a data holder for the complete path to a media
+ * depending on the provider there is an internal name and a display name
+ * by providing own MediaList implementations the provider can control
+ * how URIs are concatenated
+ */
+class MediaURI : public Serializable{
+ //to be able to access private members
+ friend class MediaList;
+ private:
+ char * _name;
+ char * _display;
+ ULONG _providerId;
+ ULONG _allowedTypes;
+ public:
+ MediaURI() {
+ _name=NULL;
+ _display=NULL;
+ _providerId=0;
+ _allowedTypes=MEDIA_TYPE_ALL;
+ }
+ //constructor copying params
+ MediaURI(ULONG provider, const char * name, const char * display);
+ virtual ~MediaURI() {
+ if (_name) delete _name;
+ if (_display) delete _display;
+ }
+ MediaURI(const MediaURI *cp) ;
+ const char * getName() const { return _name;}
+ const char * getDisplayName() const {
+ if (_display) return _display;
+ return _name;
+ }
+ ULONG getProvider() const {
+ return _providerId;
+ }
+ void setProvider(ULONG pid) {
+ _providerId=pid;
+ }
+ ULONG getAllowedTypes() const {
+ return _allowedTypes;
+ }
+ void setAllowedTypes(ULONG allowedTypes) {
+ _allowedTypes=allowedTypes;
+ }
+ bool hasDisplayName() const {
+ return _display!=NULL;
+ }
+
+ //serialize functions
+ //get the #of bytes needed to serialize
+ virtual int getSerializedLenImpl();
+ //serialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int serializeImpl(SerializeBuffer *b);
+ //deserialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int deserializeImpl(SerializeBuffer *b);
+
+};
+
+/**
+ * a class providing additional info for a medium
+ */
+class MediaInfo : public Serializable{
+ public:
+ ULLONG size;
+ bool canPosition;
+ ULONG type; //a media type
+ ULONG subtype; //TODO
+ /**
+ * return any info item contained within this info
+ */
+ virtual const char * getInfo(ULONG infoId) { return NULL;}
+ virtual ULLONG getIntegerInfo(ULONG infoId) { return 0;}
+ virtual const char * getInfoName(ULONG infoId) { return NULL;}
+ virtual bool hasInfo(ULONG infoId) { return false;}
+ MediaInfo() {
+ size=0;
+ canPosition=true;
+ type=MEDIA_TYPE_UNKNOWN;
+ subtype=0;
+ }
+ virtual ~MediaInfo(){};
+ //serialize functions
+ //get the #of bytes needed to serialize
+ virtual int getSerializedLenImpl();
+ //serialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int serializeImpl(SerializeBuffer *b);
+ //deserialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int deserializeImpl(SerializeBuffer *b);
+};
+
+/**
+ * the Media class - a data holder describing a single media
+ * WITHOUT the complete path
+ * to retrieve an URI you need the list where this media is contained
+ * this has the root URI and can construct the URI for this media
+ * optional the media can contain an UIR by itself - then this is used
+ */
-class Media
+class Media : public Serializable
{
+ friend class MediaList;
public:
Media();
- ~Media();
+ Media(const Media *m);
+ virtual ~Media();
- void setTime(ULONG startTime);
- void setDisplayName(char* displayName);
- void setFileName(char* fileName);
- void setMediaType(int mtype);
+ void setTime(ULONG mtimeTime);
+ void setDisplayName(const char* displayName);
+ void setFileName(const char* fileName);
+ void setMediaType(ULONG mtype);
ULONG getTime() const;
const char* getDisplayName() const;
//length for the time display buffer
const static int TIMEBUFLEN=100;
int index;
- int getMediaType() const;
-
- void loadMarks();
- int getPrevMark(int currentFrame);
- int getNextMark(int currentFrame);
- bool hasMarks();
- MarkList* getMarkList();
-
+ ULONG getMediaType() const;
+ bool hasDisplayName() const;
+ //optionally the media can contain an URI
+ //in this case the filename is not considered
+ //but the data from the URI is taken
+ //this enables having another providerId set in the media...
+ //returns URI without copy
+ const MediaURI * getURI() const;
+ void setURI(const MediaURI *uri);
+
+ //serialize functions
+ //get the #of bytes needed to serialize
+ virtual int getSerializedLenImpl();
+ //serialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int serializeImpl(SerializeBuffer *b);
+ //deserialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int deserializeImpl(SerializeBuffer *b);
private:
- ULONG start;
+ ULONG mtime;
char* displayName;
char* fileName;
- int mediaType;
+ ULONG mediaType;
+ MediaURI *uri;
- // I only want 1 RecInfo loaded at a time
- // if (recInfoFor == this) then recInfo is valid
- // else delete recInfo and reload for this recording
- static Media* recInfoFor;
- MarkList* markList;
};
-typedef vector<Media*> MediaList;
+
+
+typedef vector<Media*> MediaListI;
+
+/**
+ * the MediaList - containing a root URI and
+ * all the Media entries
+ * providers can provide derived classes to overwrite the URI-Methods
+ */
+class MediaList : public MediaListI , public Serializable{
+ private:
+ MediaURI *_root;
+ bool _owning;
+ void emptyList();
+ public:
+ MediaList(const MediaURI *root); //root is copied
+ virtual ~MediaList();
+ //no copy root UIR
+ virtual MediaURI * getRoot() {return _root;}
+ //all methods return a copy of the URI
+ //so the caller has to destroy this
+ virtual MediaURI * getRootURI();
+ virtual MediaURI * getParent(MediaURI *c) ;
+ virtual MediaURI * getURI(Media *m);
+ virtual ULONG getProvider();
+ virtual void setOwning(bool owning);
+ //serialize functions
+ //get the #of bytes needed to serialize
+ virtual int getSerializedLenImpl();
+ //serialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int serializeImpl(SerializeBuffer *b);
+ //deserialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ virtual int deserializeImpl(SerializeBuffer *b);
+ };
#endif
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "mediafile.h"
+#include "media.h"
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <iostream>
+#include "log.h"
+
+
+
+
+MediaFile::MediaFile(ULONG pid){
+ providerid=pid;
+}
+
+MediaFile::~MediaFile(){
+ };
+
+
+
+static struct mtype{
+ const char* extension;
+ ULONG type;
+ } mediatypes[]= {
+ {".mp3",MEDIA_TYPE_AUDIO},
+ {".MP3",MEDIA_TYPE_AUDIO},
+ {".jpg",MEDIA_TYPE_PICTURE},
+ {".JPG",MEDIA_TYPE_PICTURE},
+ {".jpeg",MEDIA_TYPE_PICTURE},
+ {".JPEG",MEDIA_TYPE_PICTURE},
+ {".mpg",MEDIA_TYPE_VIDEO},
+ {".MPG",MEDIA_TYPE_VIDEO}
+ };
+//#define NUMTYPES (sizeof(mediatypes)/sizeof(mtype))
+#define NUMTYPES 8
+
+//helper from vdr tools.c
+bool endswith(const char *s, const char *p)
+{
+ const char *se = s + strlen(s) - 1;
+ const char *pe = p + strlen(p) - 1;
+ while (pe >= p) {
+ if (*pe-- != *se-- || (se < s && pe >= p))
+ return false;
+ }
+ return true;
+}
+
+MediaList* MediaFile::getRootList() {
+ //has to be implemented in the derived class
+ return NULL;
+}
+
+ULONG MediaFile::getMediaType(const char * filename) {
+ for (ULONG i=0;i<NUMTYPES;i++) {
+ if (endswith(filename,mediatypes[i].extension)) {
+ return mediatypes[i].type;
+ }
+ }
+ return MEDIA_TYPE_UNKNOWN;
+}
+
+
+Media * MediaFile::createMedia(const char * dirname, const char * filename, bool withURI) {
+ Media * rt=NULL;
+ char *buffer;
+ asprintf(&buffer, "%s/%s", dirname, filename);
+ struct stat st;
+ ULONG mtype=MEDIA_TYPE_UNKNOWN;
+ if (stat(buffer, &st) == 0) {
+ if (S_ISDIR(st.st_mode)) {
+ mtype=MEDIA_TYPE_DIR;
+ }
+ else {
+ mtype=getMediaType(filename);
+ }
+ }
+ //only consider entries we accept by type here
+ if (mtype != MEDIA_TYPE_UNKNOWN) {
+ rt =new Media();
+ rt->setMediaType(mtype);
+ rt->setFileName(filename);
+ rt->setTime(st.st_mtime);
+ Log::getInstance()->log("Media",Log::DEBUG,"created Media %s, type=%d",filename,mtype);
+ if (withURI) {
+ MediaURI u(providerid,buffer,NULL);
+ rt->setURI(&u);
+ }
+ }
+ free(buffer);
+ return rt;
+}
+
+MediaList* MediaFile::getMediaList(const MediaURI * parent){
+ ULONG mediaType=parent->getAllowedTypes();
+ Log::getInstance()->log("MediaFile::getMediaList",Log::DEBUG,"parent %s,types=0x%0lx",parent->getName(),mediaType);
+ MediaList *rt=NULL;
+ rt=new MediaList(parent);
+ const char *dirname=parent->getName();
+ //open the directory and read out the entries
+ DIR *d=opendir(dirname);
+ struct dirent *e;
+ union { // according to "The GNU C Library Reference Manual"
+ struct dirent d;
+ char b[offsetof(struct dirent, d_name) + NAME_MAX + 1];
+ } u;
+
+ while (d != NULL && (readdir_r(d,&u.d,&e) == 0) && e != NULL) {
+ const char * fname=e->d_name;
+ if ( fname == NULL) continue;
+ if (strcmp(fname,".") == 0) continue;
+ if (strcmp(fname,"..") == 0) continue;
+ Media *m=createMedia(dirname,fname);
+ if (m && ( m->getMediaType() & mediaType)) {
+ Log::getInstance()->log("Media",Log::DEBUG,"added entry %s, type=%d",fname,m->getMediaType());
+ rt->push_back(m);
+ }
+ else {
+ if (m) delete m;
+ }
+ }
+ if (d != NULL) closedir(d);
+ return rt;
+ }
+
+
+int MediaFile::openMedium(ULONG channel, const MediaURI * uri, ULLONG * size, ULONG xsize, ULONG ysize) {
+ Log::getInstance()->log("Media::openMedium",Log::DEBUG,"fn=%s,chan=%u",uri->getName(),channel);
+ *size=0;
+ if (channel <0 || channel >= NUMCHANNELS) return -1;
+ struct ChannelInfo *info=&channels[channel];
+ if (info->file) info->reset();
+ FILE *fp=fopen(uri->getName(),"r");
+ if (! fp) {
+ Log::getInstance()->log("Media::openMedium",Log::ERR,"unable to open file fn=%s,chan=%u",uri->getName(),channel);
+ return -1;
+ }
+ struct stat st;
+ ULLONG mysize=0;
+ if ( fstat(fileno(fp),&st) == 0) mysize=st.st_size;
+ if (mysize == 0) {
+ Log::getInstance()->log("Media::openMedium",Log::ERR,"unable to open file fn=%s,chan=%u",uri->getName(),channel);
+ fclose(fp);
+ return -1;
+ }
+ info->setFilename(uri->getName());
+ info->file=fp;
+ info->size=mysize;
+ *size=mysize;
+ info->provider=providerid;
+ return 0;
+}
+
+
+int MediaFile::getMediaBlock(ULONG channel, ULLONG offset, ULONG len, ULONG * outlen,
+ unsigned char ** buffer) {
+ Log::getInstance()->log("Media::getMediaBlock",Log::DEBUG,"chan=%u,offset=%llu,len=%lu",channel,offset,len);
+ *outlen=0;
+ if (channel <0 || channel >= NUMCHANNELS) return -1;
+ struct ChannelInfo *info=&channels[channel];
+ if (! info->file) {
+ Log::getInstance()->log("Media::getMediaBlock",Log::ERR,"not open chan=%u",channel);
+ return -1;
+ }
+ ULLONG cpos=ftell(info->file);
+ if (offset != cpos) {
+ fseek(info->file,offset-cpos,SEEK_CUR);
+ }
+ if (offset != (ULLONG)ftell(info->file)) {
+ Log::getInstance()->log("Client", Log::DEBUG, "getMediaBlock pos = %llu not available", offset);
+ return -1;
+ }
+ if (*buffer == NULL) *buffer=(UCHAR *)malloc(len);
+ if (*buffer == NULL) {
+ Log::getInstance()->log("Media::getMediaBlock",Log::ERR,"uanble to allocate buffer");
+ return -1;
+ }
+ ULONG amount=fread(*buffer,1,len,info->file);
+ Log::getInstance()->log("Media::getMediaBlock",Log::DEBUG,"readlen=%lu",amount);
+ *outlen=amount;
+ return 0;
+}
+
+
+int MediaFile::closeMediaChannel(ULONG channel){
+ Log::getInstance()->log("Media::closeMediaChannel",Log::DEBUG,"chan=%u",channel);
+ if (channel <0 || channel >= NUMCHANNELS) return -1;
+ struct ChannelInfo *info=&channels[channel];
+ info->reset();
+ return 0;
+}
+
+//TODO: fill in more info
+int MediaFile::getMediaInfo(ULONG channel, MediaInfo * result){
+ Log::getInstance()->log("Media::getMediaInfo",Log::DEBUG,"chan=%u",channel);
+ if (channel <0 || channel >= NUMCHANNELS) return -1;
+ struct ChannelInfo *info=&channels[channel];
+ if (! info->file) return -1;
+ result->size=info->size;
+ result->canPosition=true;
+ return 0;
+}
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef MEDIAFILE_H
+#define MEDIAFILE_H
+
+#include "defines.h"
+#include "mediaprovider.h"
+
+
+class MediaFile : public MediaProvider
+{
+ public:
+ MediaFile(ULONG providerId);
+ virtual ~MediaFile();
+ /**
+ * get the root media list
+ * the returned list has to be destroyed by the caller
+ * if NULL is returned currently no media is available
+ */
+ virtual MediaList* getRootList();
+
+ /**
+ * get a medialist for a given parent
+ * the returned list has to be destroyed by the caller
+ * NULL if no entries found
+ */
+ virtual MediaList* getMediaList(const MediaURI * parent);
+
+ /**
+ * open a media uri
+ * afterwards getBlock or other functions must be possible
+ * currently only one medium is open at the same time
+ * for a given channel
+ * @param channel: channel id, NUMCHANNELS must be supported
+ * @param xsize,ysize: size of the screen
+ * @param size out: the size of the medium
+ * @return != 0 in case of error
+ *
+ */
+ virtual int openMedium(ULONG channel, const MediaURI * uri, ULLONG * size, ULONG xsize, ULONG ysize);
+
+ /**
+ * get a block for a channel
+ * @param offset - the offset
+ * @param len - the required len
+ * @param outlen out - the read len if 0 this is EOF
+ * @param buffer out the allocated buffer (must be freed with free!)
+ * @return != 0 in case of error
+ */
+ virtual int getMediaBlock(ULONG channel, ULLONG offset, ULONG len, ULONG * outlen,
+ unsigned char ** buffer);
+
+ /**
+ * close a media channel
+ */
+ virtual int closeMediaChannel(ULONG channel);
+
+ /**
+ * return the media info for a given channel
+ * return != 0 on error
+ * the caller has to provide a pointer to an existing media info
+ */
+ virtual int getMediaInfo(ULONG channel, MediaInfo * result);
+
+
+ protected:
+ /**
+ * create a Media out of a given file
+ * the Media object ha sto be deleted by the caller
+ * return NULL if not there or no matching type
+ */
+ Media * createMedia(const char * dirname, const char * filename, bool withURI=false);
+ struct ChannelInfo {
+ public:
+ FILE *file;
+ ULONG provider;
+ char *filename;
+ ULLONG size;
+ ChannelInfo(){
+ file=NULL;
+ provider=0;
+ filename=NULL;
+ size=0;
+ }
+ ~ChannelInfo(){
+ if (filename) delete[]filename;
+ if (file) fclose(file);
+ }
+ void setFilename(const char *f) {
+ if (filename) delete[] filename;
+ filename=NULL;
+ if (f) {
+ filename=new char[strlen(f)+1];
+ strcpy(filename,f);
+ }
+ }
+ void reset() {
+ if (file) fclose(file);
+ file=NULL;
+ if (filename) delete [] filename;
+ filename=NULL;
+ }
+ };
+ struct ChannelInfo channels[NUMCHANNELS];
+ ULONG providerid;
+
+ virtual ULONG getMediaType(const char *filename);
+
+};
+
+#endif
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+
+#include "mediaoptions.h"
+#include "woptionpane.h"
+#include "wtabbar.h"
+#include "option.h"
+#include "vdr.h"
+#include "i18n.h"
+#include <time.h>
+
+
+MediaOptions * MediaOptions::instance=NULL;
+
+static const char * option1[]={"clip","letter","clipfactor"};
+static const char * option2[]={"count","audio","picture","none"};
+
+static const char * msection="Media";
+
+MediaOptions::MediaOptions()
+{
+ myOptions.push_back( new Option(1,"Slide Show Interval",msection,"SlideShowInterval",Option::TYPE_INT,20,5,1,NULL));
+ myOptions.push_back( new Option(2,"Picture Mode",msection,"PictureMode",Option::TYPE_TEXT,3,0,0,option1));
+ myOptions.push_back( new Option(3,"max. Scale Factor",msection,"ScaleFactor",Option::TYPE_INT,5,0,1,NULL));
+ myOptions.push_back( new Option(4,"Picture Size %(10...150)",msection,"PictureSize",Option::TYPE_INT,150,90,10,NULL));
+ myOptions.push_back( new Option(5,"Factor Red",msection,"FactorRed",Option::TYPE_INT,180,100,20,NULL));
+ myOptions.push_back( new Option(6,"Factor Green",msection,"FactorGreen",Option::TYPE_INT,180,100,20,NULL));
+ myOptions.push_back( new Option(7,"Factor Blue",msection,"FactorBlue",Option::TYPE_INT,180,100,20,NULL));
+ myOptions.push_back( new Option(8,"DirectoryPlayMode",msection,"DirectoryPlayMode",Option::TYPE_TEXT,4,0,0,option2));
+ //strange: Option ctor only sets configChoice - maybe this should set both...
+ for(vector<Option*>::iterator j = myOptions.begin(); j != myOptions.end(); j++) {
+ (*j)->userSetChoice=(*j)->configChoice;
+ }
+ Log::getInstance()->log("MediaOptions",Log::DEBUG,"ctor %d options",myOptions.size());
+ pane=NULL;
+}
+
+MediaOptions::~MediaOptions()
+{
+ for(vector<Option*>::iterator j = myOptions.begin(); j != myOptions.end(); j++) delete *j;
+
+}
+
+bool MediaOptions::loadOptionsfromServer(VDR* vdr)
+{
+ return true;
+}
+
+bool MediaOptions::saveOptionstoServer()
+{
+ pane->saveOpts();
+ return externSaveOptionstoServer();
+}
+bool MediaOptions::externSaveOptionstoServer()
+{
+ bool rt=true;
+ Log::getInstance()->log("MediaOptions", Log::DEBUG, "save for %i options", myOptions.size());
+ for (UINT i = 0; i < myOptions.size(); i++)
+ {
+ if (! saveOption(myOptions[i])) rt=false;
+
+ }
+
+ return rt;
+}
+bool MediaOptions::saveOption(Option *o)
+{
+ if (o->configChoice == o->userSetChoice) return true; // no change
+
+ Log::getInstance()->log("MediaOptions", Log::DEBUG, "Option %s has changed", o->configKey);
+ //now we have saved
+ o->configChoice=o->userSetChoice;
+
+ // Save to vdr
+
+ if (o->optionType == Option::TYPE_TEXT)
+ {
+ VDR::getInstance()->configSave(o->configSection, o->configKey, o->options[o->userSetChoice]);
+ }
+ else
+ {
+ char buffer[20];
+ sprintf(buffer, "%i", o->userSetChoice);
+ VDR::getInstance()->configSave(o->configSection, o->configKey, buffer);
+ }
+ return true;
+}
+
+
+bool MediaOptions::addOptionPagesToWTB(WTabBar *wtb)
+{
+ pane=new WOptionPane();
+ for(vector<Option*>::iterator j = myOptions.begin(); j != myOptions.end(); j++) {
+ pane->addOptionLine(*j);
+ }
+ //we have to be carefull here
+ //the pane will get deleted when the tabbar is deleted
+ //but the options will not be deleted
+ wtb->addTab(tr("Media"),pane);
+ return true;
+}
+
+MediaOptions * MediaOptions::getInstance() {
+ if (! instance) {
+ instance=new MediaOptions();
+ }
+ return instance;
+}
+
+Option * MediaOptions::findOption(const char * name){
+ for(vector<Option*>::iterator j = myOptions.begin(); j != myOptions.end(); j++) {
+ if (strcmp((*j)->configKey,name) == 0) {
+ return *j;
+ }
+ }
+ return NULL;
+}
+
+const char * MediaOptions::getStringOption(const char * name) {
+ const char * rt=NULL;
+ Option *o=findOption(name);
+ if (!o) return NULL;
+ if (! o->optionType == Option::TYPE_TEXT) return NULL;
+ rt=o->options[o->userSetChoice];
+ Log::getInstance()->log("MediaOptions",Log::DEBUG,"option value for %s is %s",name,rt);
+ return rt;
+}
+int MediaOptions::getIntOption(const char * name) {
+ Option *o=findOption(name);
+ if (!o) return -1;
+ if (! o->optionType == Option::TYPE_INT) return -1;
+ int rt=o->userSetChoice;
+ Log::getInstance()->log("MediaOptions",Log::DEBUG,"option value for %s is %d",name,rt);
+ return rt;
+}
+bool MediaOptions::setIntOption(const char * name, UINT value) {
+ Option *o=findOption(name);
+ if (!o) return false;
+ if (! o->optionType == Option::TYPE_INT) return false;
+ o->userSetChoice=value;
+ Log::getInstance()->log("MediaOptions",Log::DEBUG,"option value for %s set to %d",name,value);
+ return saveOption(o);
+}
+bool MediaOptions::setStringOption(const char * name, const char * value) {
+ Option *o=findOption(name);
+ if (!o) return false;
+ if (! o->optionType == Option::TYPE_TEXT) return false;
+ bool rt=false;
+ for (UINT i = 0; i < o->numChoices; i++) {
+ if (!STRCASECMP(value, o->options[i]))
+ {
+ o->configChoice = i;
+ rt=true;
+ break;
+ }
+ }
+ if (rt) Log::getInstance()->log("MediaOptions",Log::DEBUG,"option value for %s set to %d",name,value);
+ return saveOption(o);
+}
+
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef MEDIAOPTIONS_H
+#define MEDIAOPTIONS_H
+
+#include <vector>
+#include <stdio.h>
+#include <string.h>
+#include "defines.h"
+#include "log.h"
+#include "abstractoption.h"
+
+using namespace std;
+class WTabBar;
+class VDR;
+class Option;
+class WOptionPane;
+
+class MediaOptions: AbstractOption
+{
+ public:
+ MediaOptions();
+ virtual ~MediaOptions();
+ virtual bool loadOptionsfromServer(VDR* vdr);
+ virtual bool saveOptionstoServer();
+ //this can be called without the pane being active
+ bool externSaveOptionstoServer();
+ virtual bool addOptionPagesToWTB(WTabBar *wtb);
+ static MediaOptions * getInstance();
+ const char * getStringOption(const char * name);
+ int getIntOption(const char * name);
+ bool setStringOption(const char * name, const char * value) ;
+ bool setIntOption(const char * name, UINT value) ;
+ private:
+ bool saveOption(Option *option);
+ vector<Option*> myOptions;
+ Option * findOption(const char* name);
+ static MediaOptions * instance;
+ WOptionPane *pane;
+};
+
+#endif
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "mediaplayer.h"
+#include "media.h"
+#include "log.h"
+
+class MediaProviderHolder {
+ public:
+ MediaProvider *provider;
+ ULONG id;
+ ULONG range;
+ MediaProviderHolder(MediaProvider *p,ULONG i, ULONG r=1) {
+ provider=p;
+ range=r;
+ id=i;
+ }
+};
+
+
+
+MediaPlayer::MediaPlayer(){}
+MediaPlayer::~MediaPlayer(){
+ for (Tplist::iterator it=plist.begin();it<plist.end();it++) {
+ delete *it;
+ }
+}
+
+/**
+ * get the root media list
+ * the returned list has to be destroyed by the caller
+ * if NULL is returned currently no media is available
+ */
+MediaList* MediaPlayer::getRootList(){
+ Log::getInstance()->log("MediaPlayer::getRootList",Log::DEBUG,"numproviders %d",plist.size());
+ MediaList * rt=new MediaList(new MediaURI(0,NULL,NULL));
+ for (Tplist::iterator it=plist.begin();it<plist.end();it++) {
+ MediaList *cur=(*it)->provider->getRootList();
+ if (cur) {
+ //we take the entries away from the list - so don't delete them with the list
+ cur->setOwning(false);
+ Log::getInstance()->log("MediaPlayer::getRootList",Log::DEBUG,"got list for provider %p with %d items",(*it),cur->size());
+ for (MediaList::iterator mi=cur->begin();mi<cur->end();mi++) {
+ Media *m=*mi;
+ //always set the URI in the root list because we combine entries
+ //from different lists
+ if (! m->getURI()) {
+ MediaURI *u=cur->getURI(m);
+ m->setURI(u);
+ Log::getInstance()->log("MediaPlayer::getRootList",Log::DEBUG,"set uri n=%s,d=%s",u->getName(),u->getDisplayName());
+ delete u;
+ }
+ rt->push_back(m);
+ Log::getInstance()->log("MediaPlayer::getRootList",Log::DEBUG,"added item to list name=%s",m->getFileName());
+ }
+ }
+ delete cur;
+ }
+ return rt;
+}
+
+/**
+ * get a medialist for a given parent
+ * the returned list has to be destroyed by the caller
+ * NULL if no entries found
+ */
+MediaList* MediaPlayer::getMediaList(const MediaURI * parent){
+ Log::getInstance()->log("MediaPlayer::getMediaList",Log::DEBUG,"numproviders %d,parent=%p",plist.size(),parent);
+ MediaProvider *p=providerById(parent->getProvider());
+ if (! p) {
+ return NULL;
+ }
+ return p->getMediaList(parent);
+}
+
+/**
+ * open a media uri
+ * afterwards getBlock or other functions must be possible
+ * currently only one medium is open at the same time
+ * for a given channel
+ * @param channel: channel id, NUMCHANNELS must be supported
+ * @param xsize,ysize: size of the screen
+ * @param size out: the size of the medium
+ * @return != 0 in case of error
+ *
+ */
+int MediaPlayer::openMedium(ULONG channel, const MediaURI * uri, ULLONG * size, ULONG xsize, ULONG ysize){
+ if ( channel >= NUMCHANNELS) return -1;
+ info[channel].provider=NULL;
+ *size= 0;
+ MediaProvider *p=providerById(uri->getProvider());
+ if (!p) {
+ return -1;
+ }
+ int rt=p->openMedium(channel,uri,size,xsize,ysize);
+ if (rt == 0) {
+ info[channel].providerId=uri->getProvider();
+ info[channel].provider=p;
+ }
+ return rt;
+
+}
+
+/**
+ * get a block for a channel
+ * @param offset - the offset
+ * @param len - the required len
+ * @param outlen out - the read len if 0 this is EOF
+ * @param buffer out the allocated buffer (must be freed with free!)
+ * @return != 0 in case of error
+ */
+int MediaPlayer::getMediaBlock(ULONG channel, ULLONG offset, ULONG len, ULONG * outlen,
+ unsigned char ** buffer) {
+ if ( channel >= NUMCHANNELS) return -1;
+ if ( info[channel].provider == NULL) return -1;
+ return info[channel].provider->getMediaBlock(channel,offset,len,outlen,buffer);
+}
+
+
+/**
+ * close a media channel
+ */
+int MediaPlayer::closeMediaChannel(ULONG channel){
+ if ( channel >= NUMCHANNELS) return -1;
+ if ( info[channel].provider == NULL) return -1;
+ int rt=info[channel].provider->closeMediaChannel(channel);
+ info[channel].provider=NULL;
+ info[channel].providerId=0;
+ return rt;
+}
+
+/**
+ * return the media info for a given channel
+ * return != 0 on error
+ * the caller has to provide a pointer to an existing media info
+ */
+int MediaPlayer::getMediaInfo(ULONG channel, struct MediaInfo * result){
+ if ( channel >= NUMCHANNELS) return -1;
+ if ( info[channel].provider == NULL) return -1;
+ return info[channel].provider->getMediaInfo(channel,result);
+}
+
+
+
+void MediaPlayer::registerMediaProvider(MediaProvider *p,ULONG providerId,ULONG range) {
+ if (! p) return;
+ MediaProviderHolder *h=new MediaProviderHolder(p,providerId,range);
+ Log::getInstance()->log("MediaPlayer::registerMediaProvider",Log::DEBUG,"p=%p",p);
+ plist.push_back(h);
+}
+
+MediaProvider * MediaPlayer::providerById(ULONG id) {
+ MediaProvider *rt=NULL;
+ for (Tplist::iterator it=plist.begin();it<plist.end();it++) {
+ MediaProviderHolder *h=*it;
+ if (id >= h->id && id < (h->id+h->range)) {
+ rt=h->provider;
+ break;
+ }
+ }
+ Log::getInstance()->log("MediaPlayer::providerById",Log::DEBUG,"id=%d,p=%p",id,rt);
+ return rt;
+}
+
+MediaPlayer* MediaPlayer::getInstance() {
+ return (MediaPlayer *) MediaPlayerRegister::getInstance();
+}
+
+MediaPlayerRegister* MediaPlayerRegister::getInstance() {
+ if ( ! instance) {
+ instance=new MediaPlayer();
+ }
+ return instance;
+}
+MediaPlayerRegister *MediaPlayerRegister::instance=NULL;
+
+
+
+
+
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef MEDIAPLAYER
+#define MEDIAPLAYER
+
+using namespace std;
+#include <vector>
+#include <stdio.h>
+#include <string.h>
+#include "mediaprovider.h"
+
+class MediaProviderHolder;
+
+
+class MediaPlayer : public MediaPlayerRegister, public MediaProvider
+{
+ public:
+ MediaPlayer();
+ virtual ~MediaPlayer();
+
+ /**
+ * get the root media list
+ * the returned list has to be destroyed by the caller
+ * if NULL is returned currently no media is available
+ */
+ virtual MediaList* getRootList();
+
+ /**
+ * get a medialist for a given parent
+ * the returned list has to be destroyed by the caller
+ * NULL if no entries found
+ */
+ virtual MediaList* getMediaList(const MediaURI * parent);
+
+ /**
+ * open a media uri
+ * afterwards getBlock or other functions must be possible
+ * currently only one medium is open at the same time
+ * for a given channel
+ * @param channel: channel id, NUMCHANNELS must be supported
+ * @param xsize,ysize: size of the screen
+ * @param size out: the size of the medium
+ * @return != 0 in case of error
+ *
+ */
+ virtual int openMedium(ULONG channel, const MediaURI * uri, ULLONG * size, ULONG xsize, ULONG ysize);
+
+ /**
+ * get a block for a channel
+ * @param offset - the offset
+ * @param len - the required len
+ * @param outlen out - the read len if 0 this is EOF
+ * @param buffer out the allocated buffer (must be freed with free!)
+ * @return != 0 in case of error
+ */
+ virtual int getMediaBlock(ULONG channel, ULLONG offset, ULONG len, ULONG * outlen,
+ unsigned char ** buffer);
+
+ /**
+ * close a media channel
+ */
+ virtual int closeMediaChannel(ULONG channel);
+
+ /**
+ * return the media info for a given channel
+ * return != 0 on error
+ * the caller has to provide a pointer to an existing media info
+ */
+ virtual int getMediaInfo(ULONG channel, struct MediaInfo * result);
+
+ /**
+ * from MediaPlayerRegister
+ */
+ virtual void registerMediaProvider(MediaProvider *p,ULONG providerID,ULONG range);
+
+ /**
+ * the instance
+ */
+ static MediaPlayer * getInstance();
+
+ private:
+ MediaProvider * providerById(ULONG id);
+ typedef vector<MediaProviderHolder *> Tplist;
+ Tplist plist;
+ struct channelInfo {
+ ULONG providerId;
+ MediaProvider *provider;
+ channelInfo() {
+ provider=NULL;
+ providerId=0;
+ }
+ };
+ struct channelInfo info[NUMCHANNELS];
+
+};
+
+
+#endif
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef MEDIAPROVIDER_H
+#define MEDIAPROVIDER_H
+
+#include <stdio.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include "defines.h"
+
+class Media;
+class MediaURI;
+class MediaInfo;
+class MediaList;
+
+
+/**
+ this interface has to be implemented by
+ any provider of media data.
+ In all URIs the provider has to insert providerIds out of its range.
+ threading issues:
+ all operations to one channel are not thread save - so users have to ensure
+ that at most one thread at a time is accesing operations to one channel.
+ Implementers have to ensure that other operations are thread safe.
+ Exception: registering providers is not thread safe (at least at the moment).
+ **/
+
+//the max number of media channels used in parallel
+#define NUMCHANNELS 3
+//name of a media file
+#define NAMESIZE 255
+
+class MediaProvider
+{
+ public:
+ MediaProvider(){}
+ virtual ~MediaProvider(){}
+
+ /**
+ * get the root media list
+ * the returned list has to be destroyed by the caller
+ * if NULL is returned currently no media is available
+ */
+ virtual MediaList* getRootList()=0;
+
+ /**
+ * get a medialist for a given parent
+ * the returned list has to be destroyed by the caller
+ * NULL if no entries found
+ */
+ virtual MediaList* getMediaList(const MediaURI * parent)=0;
+
+ /**
+ * open a media uri
+ * afterwards getBlock or other functions must be possible
+ * currently only one medium is open at the same time
+ * for a given channel
+ * @param channel: channel id, NUMCHANNELS must be supported
+ * @param xsize,ysize: size of the screen
+ * @param size out: the size of the medium
+ * @return != 0 in case of error
+ *
+ */
+ virtual int openMedium(ULONG channel, const MediaURI * uri, ULLONG * size, ULONG xsize, ULONG ysize)=0;
+
+ /**
+ * get a block for a channel
+ * @param offset - the offset
+ * @param len - the required len
+ * @param outlen out - the read len if 0 this is EOF
+ * @param buffer out the allocated buffer (must be freed with free!)
+ * if buffer is set at input the implementation CAN use
+ * this buffer - it is up to the caller to test if the buffer
+ * is at the same value when the method returns.
+ * it is assumed that there is enough room in the buffer if it set
+ * when calling
+ * @return != 0 in case of error
+ */
+ virtual int getMediaBlock(ULONG channel, ULLONG offset, ULONG len, ULONG * outlen,
+ unsigned char ** buffer)=0;
+
+ /**
+ * close a media channel
+ */
+ virtual int closeMediaChannel(ULONG channel)=0;
+
+ /**
+ * return the media info for a given channel
+ * return != 0 on error
+ * the caller has to provide a pointer to an existing media info
+ */
+ virtual int getMediaInfo(ULONG channel, MediaInfo * result)=0;
+
+};
+
+
+/**
+ * the mediaplayer to register providers at
+ * can be static ctor's
+ */
+class MediaPlayerRegister {
+ public:
+ virtual void registerMediaProvider(MediaProvider *pi,ULONG id,ULONG range=1)=0;
+ virtual ~MediaPlayerRegister(){}
+ static MediaPlayerRegister* getInstance();
+ protected:
+ static MediaPlayerRegister *instance;
+};
+
+
+#endif
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/*
+ This file contaisn the IDs for mediaproviders
+ Each provider should have it's ID defined here.
+ They should follow the name pattern:
+ MPROVIDERID_<name>
+ This is the ID a provider has ro use to register at it's local MediaProviderRegister
+ As the mediaprovider architecture is hierarchical there are distributors on each level, that
+ forward requests to their children.
+ Currently it looks like follows:
+
+ MediaPlayer client
+ - LocalMediaFile client
+ - VDR (distributor) client
+ |- <comm> - MediaPlayer server
+ - ServerFileMediaProvider server
+
+ As a distributor must forward multiple requests, it must register with a range of Ids.
+ This range includes it's own Id + a range for all its children.
+ This Range should be defined here as
+ MPROVIDERRANGE_<name>
+ If no range is defined here, the range is 1 - so no distribution.
+
+*/
+
+//we reserve the range 1...999 for client side providers
+static const ULONG MPROVIDERID_LOCALMEDIAFILE=1;
+static const ULONG MPROVIDERID_VDR=1000;
+static const ULONG MPROVIDERRANGE_VDR=10000; //so it has the IDs 1000..10999
+ //all providers on the server side
+ //must fit into this range
+
+static const ULONG MPROVIDERID_SERVERMEDIAFILE=1001;
+
+#ifndef MEDIAPROVIDERIDS_H
+#define MEDIAPROVIDERIDS_H
+
+#include "defines.h"
+
+#endif
-OBJECTS1 = command.o log.o tcp.o dsock.o thread.o timers.o i18n.o mutex.o \
- message.o messagequeue.o udp.o wol.o \
- vdr.o recman.o recording.o recinfo.o channel.o rectimer.o event.o \
- directory.o mark.o option.o \
- player.o playerradio.o vfeed.o afeed.o \
- demuxer.o demuxervdr.o demuxerts.o stream.o draintarget.o \
- region.o colour.o boxstack.o boxx.o tbboxx.o \
- vinfo.o vquestion.o vrecordinglist.o \
- vmute.o vvolume.o vtimerlist.o vtimeredit.o vrecordingmenu.o \
- vchannellist.o vwelcome.o vvideorec.o vepgsettimer.o \
- vchannelselect.o vserverselect.o vconnect.o vepg.o vrecmove.o \
- vradiorec.o vaudioselector.o vscreensaver.o vopts.o \
- wselectlist.o wjpeg.o wsymbol.o wbutton.o wtextbox.o wwss.o \
- woptionpane.o woptionbox.o wremoteconfig.o wtabbar.o \
- fonts/helvB24.o fonts/helvB18.o \
- remote.o led.o mtd.o video.o audio.o osd.o surface.o \
- vmedialist.o media.o vpicture.o vpicturebanner.o \
- vaudioplayer.o audioplayer.o demuxeraudio.o abstractoption.o \
- eventdispatcher.o vdrrequestpacket.o vdrresponsepacket.o \
- vvideolivetv.o vsleeptimer.o \
- playerlivetv.o playerliveradio.o \
- wprogressbar.o \
- bitmap.o dvbsubtitles.o
+OBJECTS1 = command.o log.o tcp.o dsock.o thread.o timers.o i18n.o mutex.o \
+ message.o messagequeue.o udp.o wol.o \
+ vdr.o recman.o recording.o recinfo.o channel.o rectimer.o event.o \
+ directory.o mark.o option.o \
+ player.o playerradio.o vfeed.o afeed.o \
+ demuxer.o demuxervdr.o demuxerts.o stream.o draintarget.o \
+ region.o colour.o boxstack.o boxx.o tbboxx.o \
+ vinfo.o vquestion.o vrecordinglist.o \
+ vmute.o vvolume.o vtimerlist.o vtimeredit.o vrecordingmenu.o \
+ vchannellist.o vwelcome.o vvideorec.o vepgsettimer.o \
+ vchannelselect.o vserverselect.o vconnect.o vepg.o vrecmove.o \
+ vradiorec.o vaudioselector.o vscreensaver.o vopts.o \
+ wselectlist.o wjpeg.o wsymbol.o wbutton.o wtextbox.o wwss.o \
+ woptionpane.o woptionbox.o wremoteconfig.o wtabbar.o \
+ fonts/helvB24.o fonts/helvB18.o \
+ remote.o led.o mtd.o video.o audio.o osd.o surface.o \
+ vmedialist.o media.o vpicturebanner.o \
+ audioplayer.o demuxeraudio.o abstractoption.o \
+ eventdispatcher.o vdrrequestpacket.o vdrresponsepacket.o \
+ vvideolivetv.o vsleeptimer.o \
+ playerlivetv.o playerliveradio.o \
+ wprogressbar.o \
+ bitmap.o dvbsubtitles.o \
+ imagereader.o vcolourtuner.o mediaoptions.o mediaplayer.o mediafile.o \
+ serialize.o localmediafile.o vmediaview.o vvideomedia.o playermedia.o \
+ demuxermedia.o
+
--- /dev/null
+/*
+ Copyright 2004-2006 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "playermedia.h"
+//we most probably need a new demux...
+#include "demuxermedia.h"
+#include "timers.h"
+#include "video.h"
+#include "command.h"
+#include "i18n.h"
+#include "boxx.h"
+#include "log.h"
+#include "media.h"
+#include "mediaplayer.h"
+
+//how long to wait for new data (100ms units)
+#define MAXTRY 300
+
+
+PlayerMedia::PlayerMedia(Boxx *parent) : afeed(this), vfeed(this)
+{
+ frontend=parent;
+ audio = Audio::getInstance();
+ video = Video::getInstance();
+ logger = Log::getInstance();
+ vdr = VDR::getInstance();
+ logger->log("PlayerMedia", Log::DEBUG, "ctorI");
+ running=true;
+ playerRunnig=false;
+ streampos = 0;
+ bytesWritten=0;
+ state = S_STOP;
+ requestState=S_STOP;
+ feederState=FEEDER_STOP;
+
+ threadBuffer = NULL;
+
+ Video::getInstance()->turnVideoOn();
+ requestedSequence=0;
+ sequence=0;
+ demuxer=new DemuxerMedia();
+ logger->log("PlayerMedia", Log::DEBUG, "ctorII");
+ if (!demuxer->init(this, audio, video, 2097152, 524288))
+ {
+ logger->log("PlayerMedia", Log::ERR, "Demuxer failed to init");
+ shutdown();
+ return ;
+ }
+ demuxer->setFrameNum(0);
+ logger->log("PlayerMedia", Log::DEBUG, " ctorIII");
+ afeed.init();
+ vfeed.init();
+ audio->reset();
+ video->reset();
+ video->stop();
+ video->blank();
+ logger->log("PlayerMedia", Log::DEBUG, "player created");
+ lengthFrames=0;
+ lengthBytes=0;
+ mediaChannel=0;
+ onStartup=0;
+ playingStarted=false;
+ appDestinationPTS=0;
+ canPosition=false;
+}
+
+PlayerMedia::~PlayerMedia()
+{
+ if (threadBuffer) free(threadBuffer);
+ Timers::getInstance()->cancelTimer(this,1);
+ controlFeeder(FEEDER_STOP);
+ audio->reset();
+ video->reset();
+ audio->setStreamType(Audio::MPEG2_PES);
+ delete demuxer;
+ demuxer=NULL;
+ MediaPlayer::getInstance()->closeMediaChannel(mediaChannel);
+}
+
+void PlayerMedia::controlFeeder(int feederAction) {
+ logger->log("PlayerMedia",Log::DEBUG,"control feeder old=%d, new=%d",feederState,feederAction);
+ switch (feederAction) {
+ case FEEDER_START:
+ case FEEDER_UNPAUSE:
+ if (feederState == FEEDER_STOP) {
+ afeed.start();
+ vfeed.start();
+ }
+ afeed.enable();
+ break;
+ case FEEDER_STOP:
+ if (feederState != FEEDER_STOP) {
+ afeed.stop();
+ vfeed.stop();
+ }
+ break;
+ case FEEDER_PAUSE:
+ afeed.disable();
+ break;
+ }
+ feederState=feederAction;
+}
+
+
+void PlayerMedia::run() {
+ if (playerRunnig) return;
+ playerRunnig=true;
+ threadStart();
+}
+
+
+void PlayerMedia::shutdown()
+{
+ running=false;
+ if (playerRunnig) {
+ threadSignalNoLock();
+ //wait for the player thread to stop
+ logger->log("PlayerMedia",Log::DEBUG,"shutdown - warting for player thread to stop");
+ //at most wait 10s
+ for (int loopcount=200;playerRunnig && loopcount > 0;loopcount--) {
+ MILLISLEEP(50);
+ }
+ if (playerRunnig) {
+ logger->log("PlayerMedia",Log::ERR,"shutdown - unable to stop player within 10s");
+ }
+ }
+}
+
+bool PlayerMedia::isPlayerRunning() {
+ return playerRunnig;
+}
+
+int PlayerMedia::setRequestedState(UCHAR rstate) {
+ int rt=0;
+ threadLock();
+ requestState=rstate;
+ requestedSequence++;
+ rt=requestedSequence;
+ threadUnlock();
+ return rt;
+}
+
+
+UCHAR PlayerMedia::getState() {
+ UCHAR rt=0;
+ threadLock();
+ rt=state;
+ threadUnlock();
+ return rt;
+}
+
+void PlayerMedia::setState(UCHAR s) {
+ threadLock();
+ state=s;
+ threadUnlock();
+}
+
+//------------------- externally called functions --------------------------
+
+//we leave all the open and close handling to the frontend
+//so we only need the channel
+int PlayerMedia::playNew(ULONG mChannel,ULLONG lBytes,ULLONG lFrames)
+{
+ logger->log("PlayerMedia", Log::DEBUG, "play request for channel %lu", mChannel);
+ if (getState() != S_STOP) {
+ return -1;
+ }
+ MediaInfo mi;
+ int rt=MediaPlayer::getInstance()->getMediaInfo(mChannel,&mi);
+ canPosition=mi.canPosition;
+ if (rt == 0 && mi.canPosition) {
+ //try to get the len
+ UCHAR buf[STARTBUFLEN];
+ UCHAR *bpointer=buf;
+ ULONG rtlen=0;
+ logger->log("PlayerMedia", Log::DEBUG, "try to find last PTS with %lu bytes", STARTBUFLEN);
+ int rb=MediaPlayer::getInstance()->getMediaBlock(mChannel,lBytes-STARTBUFLEN,STARTBUFLEN,&rtlen,&bpointer);
+ if (rb == 0) {
+ demuxer->findLastPTS(bpointer,rtlen);
+ }
+ if (bpointer != buf) free(bpointer);
+ }
+ mediaChannel=mChannel;
+ lengthBytes=lBytes;
+ lengthFrames=lFrames;
+ rt=0;
+ threadLock();
+ logger->log("PlayerMedia", Log::DEBUG, "play request setState");
+ requestState=S_SEEK;
+ requestedSequence++;
+ rt=requestedSequence;
+ playingStarted=true;
+ threadUnlock();
+ threadSignalNoLock();
+ logger->log("PlayerMedia", Log::DEBUG, "play request rt=%d",rt);
+ return rt;
+}
+
+int PlayerMedia::stop()
+{
+ int rt= setRequestedState(S_STOP);
+ threadSignalNoLock();
+ return rt;
+}
+
+int PlayerMedia::play(){
+ if (! playingStarted) return -1;
+ int rt=setRequestedState(S_PLAY);
+ threadSignalNoLock();
+ return rt;
+}
+
+int PlayerMedia::pause()
+{
+ int rt= setRequestedState(S_PAUSE);
+ threadSignalNoLock();
+ return rt;
+}
+int PlayerMedia::unpause()
+{
+ int rt= setRequestedState(S_PLAY);
+ threadSignalNoLock();
+ return rt;
+}
+
+int PlayerMedia::fastForward(){
+ if (! canPosition) return -1;
+ int rt=setRequestedState(S_FF);
+ threadSignalNoLock();
+ return rt;
+}
+
+int PlayerMedia::fastBackward(){
+ if (! canPosition) return -1;
+ int rt=setRequestedState(S_BACK);
+ threadSignalNoLock();
+ return rt;
+}
+int PlayerMedia::jumpToPercent(double percent){
+ if (! canPosition) return -1;
+ logger->log("PlayerMedia",Log::DEBUG,"jump to %i%% ",percent);
+ threadLock();
+ ULLONG npos=streampos;
+ //TODO: where to go - currently we simply take bytes...
+ npos=(ULLONG)(percent*lengthBytes/100);
+ if (npos > lengthBytes) npos=lengthBytes-1;
+ requestedStreampos=npos;
+ requestState=S_POSITION;
+ requestedSequence++;
+ threadUnlock();
+ //no need to wait here...
+ return 0;
+}
+
+int PlayerMedia::skipForward(int seconds) {
+ if (! canPosition) return -1;
+ logger->log("PlayerMedia",Log::DEBUG,"skip fw %ds",seconds);
+ threadLock();
+ ULLONG bps=getBytesPerSecond();
+ requestedStreampos=streampos+ (ULLONG)seconds*bps;
+ requestState=S_POSITION;
+ requestedSequence++;
+ threadUnlock();
+ logger->log("PlayerMedia",Log::DEBUG,"skip fw to %llu, %llu bps",requestedStreampos,bps);
+ return 0;
+}
+int PlayerMedia::skipBackward(int seconds) {
+ if (! canPosition) return -1;
+ logger->log("PlayerMedia",Log::DEBUG,"skip back %ds",seconds);
+ threadLock();
+ ULLONG bps=getBytesPerSecond();
+ if (streampos > (ULLONG)seconds*bps)
+ requestedStreampos=streampos- (ULLONG)seconds*bps;
+ else
+ requestedStreampos=0;
+ requestState=S_POSITION;
+ requestedSequence++;
+ threadUnlock();
+ logger->log("PlayerMedia",Log::DEBUG,"skip bw to %llu, %llu bps",requestedStreampos,bps);
+ return 0;
+}
+
+
+
+// ----------------------------------- Internal functions
+
+void PlayerMedia::gotoSeek() {
+ controlFeeder(FEEDER_STOP);
+ video->stop();
+ video->reset();
+ audio->reset();
+ audio->setStreamType(Audio::MPEG2_PES);
+ demuxer->flush();
+ demuxer->seek();
+ controlFeeder(FEEDER_START);
+ audio->play();
+ video->sync();
+ audio->sync();
+ audio->systemMuteOff();
+ audio->doMuting();
+ video->play();
+ video->pause();
+ onStartup=true; //search for Audio again
+ //TODO: should be done only at startup
+}
+
+
+
+void PlayerMedia::sendFrontendMessage(ULONG para)
+{
+ logger->log("PlayerMedia", Log::DEBUG, "sending frontend message %ld",para);
+ Message* m = new Message();
+ threadLock();
+ m->to = frontend;
+ threadUnlock();
+ m->from = this;
+ m->message = Message::PLAYER_EVENT;
+ m->parameter = para;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+}
+
+//method called by the playing thread to handle
+//"commands" by the frontend
+UCHAR PlayerMedia::checkState()
+{
+ threadLock();
+ UCHAR rstate=requestState;
+ UCHAR cstate=state;
+ int rseq=requestedSequence;
+ int cseq=sequence;
+ threadUnlock();
+
+ if ( rseq > cseq) {
+ logger->log("PlayerMedia", Log::DEBUG, "Switch state from %u to %u", cstate, rstate);
+ switch(rstate)
+ {
+ case S_PLAY: // to S_PLAY
+ {
+ if (cstate != S_SEEK && cstate != S_PAUSE) break;
+ appDestinationPTS=0;
+ if (cstate == S_PAUSE) {
+ audio->unPause();
+ video->unPause();
+ audio->unMute();
+ break;
+ }
+ controlFeeder(FEEDER_START);
+ video->reset();
+ video->play();
+ video->sync();
+ vfeed.release();
+ audio->unMute();
+ break;
+ }
+ case S_SEEK: //INITIAL_PLAY
+ {
+ //we are starting
+ gotoSeek();
+ break;
+ }
+ case S_PAUSE: // to S_PAUSE
+ {
+ if (cstate == S_PAUSE) {
+ rstate=S_PLAY;
+ video->unPause();
+ audio->unPause();
+ audio->unMute();
+ break;
+ }
+ if (cstate != S_PLAY) {
+ rstate=cstate;
+ break;
+ }
+ video->pause();
+ audio->pause();
+ break;
+ }
+ case S_FF: // to S_FF
+ {
+ gotoSeek();
+ rstate=S_SEEK;
+ break;
+ }
+ case S_BACK: // to S_BACK
+ {
+ gotoSeek();
+ rstate=S_SEEK;
+ break;
+ }
+ case S_STOP: // to S_STOP
+ {
+ if (cstate == S_STOP) {
+ break;
+ }
+ controlFeeder(FEEDER_STOP);
+ video->stop();
+ video->blank();
+ audio->stop();
+ audio->unPause();
+ audio->reset();
+ video->reset();
+ demuxer->reset();
+ demuxer->setFrameNum(0);//trigger framecounting
+ break;
+ }
+ case S_POSITION: // to S_JUMP
+ {
+ audio->mute();
+ audio->unPause();
+ video->unPause();
+ controlFeeder(FEEDER_STOP);
+ thisRead=0;
+ thisWrite=0;
+ if (threadBuffer) free(threadBuffer);
+ threadBuffer=NULL;
+ ULLONG bpts=0;
+ ULLONG curPts=getCurrentPTS();
+ if (curPts != 0) bpts=streampos/curPts;
+ if (bpts != 0) appDestinationPTS=requestedStreampos/bpts;
+ else appDestinationPTS=0;
+ streampos=requestedStreampos;
+ bytesWritten=streampos;
+ Log::getInstance()->log("PlayerMedia",Log::DEBUG,"position to %llu",streampos);
+ gotoSeek();
+ rstate=S_SEEK;
+ break;
+ }
+ case S_DONE:
+ Timers::getInstance()->setTimerD(this,1,15);
+ break;
+ }
+ threadLock();
+ state=rstate;
+ sequence=rseq;
+ threadUnlock();
+ if (cstate != rstate && rstate != S_DONE ) {
+ sendFrontendMessage(STATUS_CHANGE);
+ //any change after done cancels the "done" timer
+ Timers::getInstance()->cancelTimer(this,1);
+ }
+ logger->log("PlayerMedia", Log::DEBUG, "Switch state from %u to %u completed", cstate, rstate);
+ //we return the newly set state
+ return rstate;
+ }
+ //rstate could be different but no new request - so return cstate
+ return cstate;
+}
+
+
+
+
+// ----------------------------------- Feed thread
+
+void PlayerMedia::waitTimed(int ms) {
+ threadLock();
+ struct timespec nt;
+ int sec=ms/1000;
+ int us=1000*(ms - 1000*sec);
+#ifndef WIN32
+ struct timeval ct;
+ gettimeofday(&ct,NULL);
+ nt.tv_sec=ct.tv_sec+sec;
+ nt.tv_nsec=1000*us+1000*ct.tv_usec;
+#else
+ DWORD ct=timeGetTime();
+ nt.tv_sec=ct/1000+sec;
+ nt.tv_nsec=1000*us+1000*ct*1000;
+#endif
+ threadWaitForSignalTimed(&nt);
+ threadUnlock();
+}
+
+void PlayerMedia::threadMethod()
+{
+ logger->log("PlayerMedia", Log::DEBUG, "player thread started");
+ thisWrite=0;
+ thisRead=0;
+ int retrycount=0;
+ while(1)
+ {
+ UCHAR cstate=checkState();
+ if (! running) {
+ break;
+ }
+ if (cstate != S_PLAY && cstate != S_FF && cstate != S_BACK && cstate != S_SEEK) {
+ waitTimed(500);
+ continue;
+ }
+ threadCheckExit();
+
+ if (thisWrite == thisRead) {
+ thisRead=0;
+ thisWrite=0;
+ threadBuffer=NULL;
+ ULONG rd=BUFLEN;
+ if (onStartup) rd=STARTBUFLEN;
+ int rt=MediaPlayer::getInstance()->getMediaBlock(mediaChannel,streampos,rd,&thisRead,&threadBuffer);
+ if ( thisRead == 0 && threadBuffer) {
+ free(threadBuffer);
+ threadBuffer=NULL;
+ }
+ if ((!threadBuffer || thisRead == 0) && rt == 0) {
+ retrycount++;
+ if (retrycount > MAXTRY) rt=-1;
+ else {
+ logger->log("PlayerMedia", Log::DEBUG, "no data - retrying");
+ retrycount++;
+ continue;
+ }
+ }
+
+ if (!threadBuffer || thisRead == 0 || rt != 0) {
+ //OK we count this as end of stream
+ logger->log("PlayerMedia", Log::DEBUG, "stream end");
+ setRequestedState(S_DONE);
+ MediaPlayer::getInstance()->closeMediaChannel(mediaChannel);
+ continue;
+ }
+ //logger->log("PlayerMedia", Log::DEBUG, "read %ld bytes at pos %ld",thisRead,streampos);
+ streampos+=thisRead;
+ retrycount=0;
+ }
+
+ threadCheckExit();
+ if (onStartup)
+ {
+ if (demuxer->getselAudioChannel() < Demuxer::PESTYPE_AUD0) {
+ int a_stream = demuxer->scan(threadBuffer, thisRead);
+ if (a_stream != 0){
+ demuxer->setAudioStream(a_stream);
+ logger->log("PlayerMedia", Log::DEBUG, "Startup Audio stream chosen %x", a_stream);
+ }
+ else {
+ logger->log("PlayerMedia", Log::DEBUG, "Startup Audio stream not choosen - leave to demux");
+ }
+ }
+ onStartup = false;
+ setRequestedState(S_PLAY); //OK - start playing even if we have no audio
+ }
+
+ /*
+ MediaPacket p;
+ memset(&p,sizeof(p),0);
+ p.pos_buffer=0;
+ p.length=thisRead;
+ MediaPacketList pl;
+ pl.push_back(p);
+ audio->PrepareMediaSample(pl,0);
+ UINT bytesWritten=0;
+ UINT rt=audio->DeliverMediaSample(threadBuffer,&bytesWritten);
+ ULONG written=thisRead;
+ if (rt == 0)
+ written=bytesWritten;
+ */
+ ULONG written= demuxer->put(threadBuffer + thisWrite, thisRead - thisWrite);
+ thisWrite+=written;
+ bytesWritten+=written;
+ if (thisWrite < thisRead) {
+ if (written == 0) {
+ //logger->log("PlayerMedia", Log::DEBUG, "demuxer full, waiting ");
+ // demuxer is full and can't take anymore
+ waitTimed(200);
+ }
+ }
+ else {
+ //logger->log("PlayerMedia", Log::DEBUG, "block written %d", thisWrite);
+ thisWrite=0;
+ thisRead=0;
+ free(threadBuffer);
+ threadBuffer = NULL;
+ }
+
+ }
+
+ logger->log("PlayerMedia", Log::DEBUG, "finished");
+ MediaPlayer::getInstance()->closeMediaChannel(mediaChannel);
+ playerRunnig=false;
+ setRequestedState(S_STOP);
+ return;
+}
+
+int PlayerMedia::waitForSequence(int timeout, int seq) {
+ time_t starttime=time(NULL)+timeout;
+ time_t curtime=0;
+ logger->log("PlayerMedia", Log::DEBUG, "waiting for sequence %d",seq);
+ while ((curtime=time(NULL)) < starttime) {
+ int cseq=getSequence();
+ if (cseq >= seq) return cseq;
+ MILLISLEEP(10);
+ }
+ return -1;
+}
+
+int PlayerMedia::getSequence() {
+ int rt=0;
+ threadLock();
+ rt=sequence;
+ threadUnlock();
+ return rt;
+}
+
+
+
+void PlayerMedia::threadPostStopCleanup()
+{
+ if (threadBuffer)
+ {
+ delete(threadBuffer);
+ threadBuffer = NULL;
+ }
+ playerRunnig=false;
+}
+
+
+void PlayerMedia::timercall(int ref) {
+ if (ref == 1) {
+ logger->log("PlayerMedia", Log::DEBUG, "stream end - informing frontend");
+ sendFrontendMessage(STREAM_END);
+ }
+}
+
+
+void PlayerMedia::call(void* caller)
+{
+ if (caller == demuxer)
+ {
+ logger->log("PlayerMedia", Log::DEBUG, "Callback from demuxer");
+ //set position
+ if (demuxer->getHorizontalSize() > 0 && demuxer->getVerticalSize() > 0) {
+ int xpos=(video->getScreenWidth()-demuxer->getHorizontalSize())/2;
+ if (xpos <0 ) xpos=0;
+ int ypos=(video->getScreenHeight()-demuxer->getVerticalSize())/2;
+ if (ypos < 0) ypos=0;
+ logger->log("PlayerMedia", Log::DEBUG, "setting pos x=%d,y=%d",xpos,ypos);
+ video->setPosition(xpos,ypos);
+ }
+
+ if (video->getTVsize() == Video::ASPECT4X3)
+ {
+ logger->log("PlayerMedia", Log::DEBUG, "TV is 4:3, ignoring aspect switching");
+ return;
+ }
+
+ int dxCurrentAspect = demuxer->getAspectRatio();
+ if (dxCurrentAspect == Demuxer::ASPECT_4_3)
+ {
+ logger->log("PlayerMedia", Log::DEBUG, "Demuxer said video is 4:3 aspect, switching TV");
+ video->setAspectRatio(Video::ASPECT4X3);
+
+ Message* m = new Message();
+ m->from = this;
+ m->to = frontend;
+ m->message = Message::PLAYER_EVENT;
+ m->parameter = PlayerMedia::ASPECT43;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+ }
+ else if (dxCurrentAspect == Demuxer::ASPECT_16_9)
+ {
+ logger->log("PlayerMedia", Log::DEBUG, "Demuxer said video is 16:9 aspect, switching TV");
+ video->setAspectRatio(Video::ASPECT16X9);
+
+ Message* m = new Message();
+ m->from = this;
+ m->to = frontend;
+ m->message = Message::PLAYER_EVENT;
+ m->parameter = PlayerMedia::ASPECT169;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+ }
+ else
+ {
+ logger->log("PlayerMedia", Log::DEBUG, "Demuxer said video is something else... ignoring");
+ }
+
+ }
+ else
+ {
+ if (getState() == S_SEEK)
+ {
+ logger->log("PlayerMedia", Log::DEBUG, "feeder started writing");
+ setRequestedState(S_PLAY);
+ }
+
+ threadSignalNoLock();
+ }
+}
+
+void PlayerMedia::setAudioChannel(int newChannel)
+{
+ demuxer->setAudioChannel(newChannel);
+}
+
+bool* PlayerMedia::getDemuxerMpegAudioChannels()
+{
+ return demuxer->getmpAudioChannels();
+}
+
+bool* PlayerMedia::getDemuxerAc3AudioChannels()
+{
+ return demuxer->getac3AudioChannels();
+}
+
+int PlayerMedia::getCurrentAudioChannel()
+{
+ return demuxer->getselAudioChannel();
+}
+
+ULLONG PlayerMedia::getLengthBytes() {
+ return lengthBytes;
+}
+ULLONG PlayerMedia::getLengthFrames() {
+ return lengthFrames;
+}
+
+//PTS is always relative to first
+ULLONG PlayerMedia::getCurrentPTS()
+{
+ if (appDestinationPTS != 0) {
+ ULLONG lenPts=demuxer->getLenPTS();
+ if (appDestinationPTS < lenPts) return appDestinationPTS;
+ return lenPts;
+ }
+ return demuxer->getCurrentPTS();
+}
+ULLONG PlayerMedia::getLenPTS()
+{
+ return demuxer->getLenPTS();
+}
+
+ULLONG PlayerMedia::getBytesPerSecond() {
+ ULLONG currsec=getCurrentPTS()/90000;
+ if (currsec == 0) return 0;
+ return streampos/currsec;
+}
+
+char * PlayerMedia::getInfo() {
+ char * ibuf=new char[500];
+ int br=demuxer->getBitRate();
+ char brbuf[100];
+ if (br == 0x3ffff ) {
+ //VBR - use estimated
+ sprintf(brbuf,"VBR, cur %llu kBit/s",getBytesPerSecond()*8/1000);
+ }
+ else {
+ sprintf(brbuf,"CBR, %d kBit/s",br*4/10);
+ }
+ snprintf(ibuf,500,"%s: %dx%d\n"
+ "%s: %s\n"
+ "%s: %s\n",
+ tr("Format"),
+ demuxer->getHorizontalSize(),
+ demuxer->getVerticalSize(),
+ tr("Aspect"),
+ demuxer->getAspectRatio()==2?"4:3":"16:9",
+ tr("BitRate"),brbuf
+ );
+
+ return ibuf;
+}
+
+
+
+
+
--- /dev/null
+/*
+ Copyright 2004-2006 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef PLAYERMEDIA_H
+#define PLAYERMEDIA_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifndef WIN32
+#include <sys/time.h>
+#endif
+#include <time.h>
+
+#include "audio.h"
+#include "remote.h"
+#include "vdr.h"
+#include "callback.h"
+#include "message.h"
+#include "messagequeue.h"
+#include "thread.h"
+#include "afeed.h"
+#include "vfeed.h"
+#include "timerreceiver.h"
+#include "video.h"
+
+#ifdef WIN32
+#include "threadwin.h"
+#else
+#include "threadp.h"
+#endif
+
+
+
+class Boxx;
+class MediaURI;
+class Video;
+class DemuxerMedia;
+
+
+class PlayerMedia : public Thread_TYPE, public Callback, public TimerReceiver
+{
+ public:
+ PlayerMedia(Boxx *frontend);
+ virtual ~PlayerMedia();
+ //start the player thread
+ void run();
+
+ //is the player still running?
+ bool isPlayerRunning();
+
+ void shutdown();
+
+ //each of the commands works as a request
+ //only after getSequence returned the same sequence as those commands this is
+ //handled by the player and getError is valid
+ int playNew(ULONG mediaChannel,ULLONG lengthBytes, ULLONG lengthFrames=0);
+ //stop the player without shutting it down
+ int stop();
+ int play();
+ int pause();
+ int unpause();
+ int fastForward();
+ int fastBackward();
+ int jumpToPercent(double percent);
+ int skipForward(int sec);
+ int skipBackward(int sec);
+
+ //wait for a particular sequence to be handled
+ //timeout in s, returnes current sequence, -1 on timeout
+ int waitForSequence(int timeout, int sequence);
+ int getSequence();
+
+ //info functions
+
+ //get current position in s
+ ULONG getCurrentTimes();
+ //get song len in s
+ ULONG getSonglen();
+
+ ULLONG getLengthFrames();
+ ULLONG getLengthBytes();
+
+ virtual void call(void * caller);
+
+ UCHAR getState() ;
+
+ const static UCHAR S_PLAY = 1;
+ const static UCHAR S_PAUSE = 2;
+ const static UCHAR S_POSITION = 3;
+ const static UCHAR S_DONE=5;
+ const static UCHAR S_STOP = 6;
+ const static UCHAR S_ERROR = 8;
+ const static UCHAR S_FF = 9;
+ const static UCHAR S_BACK = 10;
+ const static UCHAR S_SEEK = 11;
+
+
+ //message parameters for frontend messages
+ const static ULONG CONNECTION_LOST=1;
+ const static ULONG STREAM_END=2;
+ const static ULONG STREAM_ERR=3;
+ const static ULONG STATUS_CHANGE=4; //some info has been changed
+ const static ULONG SHORT_UPDATE=6; //timer info update
+ const static ULONG ASPECT43 = 7;
+ const static ULONG ASPECT169 = 8;
+
+ virtual void timercall(int reference);
+ void setAudioChannel(int channel);
+ bool * getDemuxerMpegAudioChannels();
+ bool * getDemuxerAc3AudioChannels();
+ int getCurrentAudioChannel();
+ ULLONG getCurrentPTS();
+ ULLONG getLenPTS();
+ char * getInfo(); //return some info about the played file,caller has to destroy buffer
+
+ protected:
+ void threadMethod();
+ void threadPostStopCleanup();
+
+ private:
+ bool playerRunnig;
+ Audio* audio;
+ Video* video;
+ VDR* vdr;
+ Log* logger;
+
+ DemuxerMedia *demuxer;
+ AFeed afeed;
+ VFeed vfeed;
+
+ //feeder control
+ const static int FEEDER_START=1;
+ const static int FEEDER_STOP=2;
+ const static int FEEDER_PAUSE=3;
+ const static int FEEDER_UNPAUSE=4;
+ void controlFeeder(int action) ;
+ int feederState;
+
+ //synchronized get/set methods for states
+ int setRequestedState(UCHAR st);
+ void setState(UCHAR st);
+
+ //to be called from within the thread
+ UCHAR checkState();
+
+ //variables used by the thread
+ ULONG thisWrite;
+ ULONG thisRead;
+ bool running;
+ bool onStartup; //set for the firts chunk to find the audio channel
+
+ UCHAR *threadBuffer;
+ UCHAR state;
+ UCHAR requestState;
+ ULLONG streampos;
+ ULLONG bytesWritten;
+ ULLONG requestedStreampos;
+
+ //the buffer len in bytes
+ const static int BUFLEN=100000;
+ const static int STARTBUFLEN=250000;
+ Boxx *frontend;
+ //requested sequence
+ int requestedSequence;
+ //handled sequence
+ int sequence;
+
+ void sendFrontendMessage(ULONG para);
+ void gotoSeek();
+
+ void waitTimed(int ms);
+
+ //get the current average bitrate by using PTS compared to streampos
+ ULLONG getBytesPerSecond();
+
+ ULONG mediaChannel;
+ ULLONG lengthBytes;
+ ULLONG lengthFrames;
+ ULLONG appDestinationPTS; //if we are moving set the PTS to the destination
+ //for display at the bar, take this if !=0
+ bool playingStarted; //did we ever start to play?
+ bool canPosition;
+
+
+};
+
+#endif
+
Media PLayer Functions
Author: Andreas Vogel (andvogel@online.de)
-Version: 2007/03/14
+Version: 2008/03/20
+New 2008/03/20:
+ support for video (still not included in playAll)
+ server side scripting interface (include converter scripts)
+New 2008/01/02:
+Audio and pictures in parallel (YELLOW key)
+Jpeg EXIF Orientation
+ more flexible scaling
+ faster loading
+ Colour Tuner
+Media Options
+details below
Basics:
Adding some media player functions to VOMP.
This should enable VOMP to:
- work as a picture viewer (for digicam pictures)
- - play audio (at least mp3)
- - play (mpeg) video
-For me the priorities are like above, i.e. Prio 1 for the (jpeg) pictures, afterwards
-audio, later video.
+ - play audio (at least mp3)
+ - play (mpeg) video
It requires some extensions on the server side (of course).
+Version 2008/03/20
+play video
+ plays "well formatted" mpeg2 videos (extension .mpg, .MPG)
+ moving (skip fw,bw, to %) works basing on estimated values
+ no ffw, fbw
+ currently video is not included in the "playAll"
+server side conversions
+ on the server side there is an option to include commands that
+ convert media on the fly
+ You will loose navigation on the client in this case (i.e. no fw,bw, jump)
+CVS Version (delivered 2008/01/02):
+parallel audio and picture
+ use YELLOW key for audio player in background / toggle audioplayer
+ hierarchical mediaprovider structure
+ version handling at client-server interface
+ enable local mediaprovider (simply reading below /media)
+ have separate names for base directories (beside filenames) in config file
+ include standalone target into the makefile
+
+CVS Version (delivered 2007/07/15):
+Media Selection
+ browse through media directories
+ select single Media (OK)
+ select all Media from directory (PLAY)
+ change sort order (BLUE) - name, time, random
+Basic picture viewer functions:
+ show jpeg picture
+ auto scale them by 1/1, 1/2, 1/4, 1/8
+ rotate pictures
+ slide show
+Audio player functions
+ play mp3 audio
+ position by 10%...90%
+ show Id3 info
+ handle vbr
-First Version (delivered 2007/03/14):
- Basic picture viewer functions
- You can add a list of directories to vomp.conf that will be used as base dirs to
+Configuration
+ You can add a list of directories to vomp.conf that will be used as base dirs to
find media files.
+ For each directory you can define a separate name that is displayed.
Example:
[Media]
- Dir.1=/home/Andreas/pictest
+ Dir.1=/home/Andreas/pictestA
+ Dir.Name.1=Picture-test
Dir.2=/home/video
Dir.3=/home/bilder
Dir.4=/media
- You can have up to 10 directories there.
- The recognition of media types is based on extensions today. In the moment it recognizes:
+ You can have up to 50 directories there.
+ The recognition of media types is based on extensions today. In the moment it recognizes:
JPEG,jpeg,JPG,jpg as Jpeg
- mp3,MP3 as mp3 (not played yet)
+ mp3,MP3 as mp3
+ mpg,MPG as Mpeg2 video
+ Additionally you can define commands that handle other types of media.
+ Example:
+ Command.Name.1=/home/Andreas/src/vompserver-devenv/test1.sh
+ Command.Extension.1=avi
+ Command.Type.1=VIDEO
+ The allowed values for Type are
+ VIDEO - mpeg2
+ AUDIO - mp3
+ PICTURE - jpeg
+ The commands will be called with the following options:
+ check
+ at startup to check the command being available, has to return 0
+ play "filename" xsize ysize
+ must send the media stream to stdout
+ The command will be stopped with SIGINT. If this is not successfull, a SIGKILL will follow.
+ An example command file is included (test1.sh).
+ You can define up to 50 commands (1...50).
+
+ In the vomp main menu a new item is added (5 MediaPlayer).
+ This will open a menu with the configured base dirs (/ if none configured).
+ Additionally this menu will show the media under the client!!! /media directory.
- In the vom main menu a new item is added (5 MediaPlayer).
- This will open a menu with the configured base dirs (/ if none configured).
- SELECTOR WINDOW
+Usage and Keys
+
+SELECTOR WINDOW
You can traverse through the dirs with the normal keys.
- When pointing to a media file (currently only jpeg) you can activate the viewer with
- [OK] (normal view) or [PLAY] (slide show).
- PICTURE VIEWER
+ When pointing to a media file you can activate the viewer/player with
+ [OK] (normal view) or [PLAY] (slide show/play all files from this directory).
+ [BLUE] will toggle the serach order (name->time->random), the status line will display
+ the NEXT sort order that you get with [BLUE].
+ If the audio player is running you can bring it to front (and back) with the YELLOW key.
+
+PICTURE VIEWER
When viewing a picture, this gets loaded from the server (currently still a little bit slow),
- scaled (jpeg libs allows for 1/2, 1/4 and 1/8 only - but seems to be OK for many photos), and
- displayed. With [OK] you can toggle the status line, With [RED] you can rotate the picture clockwise,
+ Currently the scaling depends on the jpeg lib. You can have a scaling within the lib by 1/2,
+ 1/4 and 1/8. Additionally you can have an "after scaling" form 1/1...1/5. This anyway slows down.
+ You can select the after scaling in the options (default 1 - no after scaling).
+ There is an alternative Jpeg Lib available (see links) - with this lib you can better scale.
+ Still to be discussed...
+ You can select 3 different modes for the picture - "letter" - always completely on screen,
+ "crop" always cropped by next possible scale and "croppercent" - you can select the Picture Size
+ within the option page from 10%...150% - the picture gets scaled to best fit to the screen within
+ this range.
+ To adapt the colours to you screen there is a colourTuner. You can set factors for R/G/B either
+ in the media options or by pressing the [MENU] key in the pictureViewer. The current picture
+ will not be rendered again when leaving the colour tuner! So changes only wil become effective
+ for the next picture.
+ Keys in the Picture Viewer:
+ With [OK] you can toggle the status line, With [RED] you can rotate the picture clockwise,
[GREEN] brings up an info box with some picture data. [PLAY] starts the slideshow, |<- and ->| as
well as [UP], [DOWN] travers trough all pictures within the directory.
+ [PAUSE] will pause the slide show and resume it.
<< and >> will slower/fasten the slide show (time getting displayed in the status line). II will
pause the slide show [STOP] will pause and reset time to 5s.
+ [BLUE] rotates through the clipping options (can be seen in the info display).
+ The viewer now handles Exif rotation information if available and rotates the picture accordingly.
+ If the audio player is running you can bring it to front (and back) with the YELLOW key.
-Version 2007/03/23
- Added playing audio files.
- In the moment playing is (on the server side) limited to mp3 (MP3) files. The client side is
- prepared to play all MPEG1 files - although only tested for MP3 CBR/VBR stereo, 44,1kBit.
- Player control is similar to the other available players (recordings).
- You can use 0...9 to position by x0 percent in the file. |<- and ->| will skip each 10s back/ forward.
- In principle >> does also work - but seems not to be very usefull in the moment.
- [UP] and [DOWN] will move backward/forward in a play list.
- You can start playing all MP3's in a dir from the media view by pressing [PLAY], a single file by pressing OK.
- The player window will disappear app. 30s after the last key press.
+AUDIO PLAYER
+ The audioplayer will play mp3 files and has a similar status display like the recordings player.
+ You can pause with [PAUSE], continue with [PLAY].
+ [STOP] halts and rewinds to the beginning.
+ [1]...[9] will postion to 10%...90% of the length.
+ |<- and ->| will skip each 10s back/ forward.
+ [GREEN] toggles the display of an info window with ID3 info.
+ [OK] toggles the status display.
+ [UP] and [DOWN] will change to the next song when the player was activated with [PLAY].
+ The player window will disappear app. 30s after the last key press.
+ [YELLOW] will put the audioplayer into "background". It will continue playing it's current list while
+ you are able to continue browsing the media files and e.g. start a slideshow.
+ Typical seqeunce (in the moment):
+ Got to a directory containing audio files, select a file, press [PLAY]. The audioplayer comes up
+ and starts playing. Press [YELLOW] (selector comes up) and go to a picture directory. Select a picture
+ file and press [PLAY] - the picture viewer starts a slideshow. At any time you can toggle with the
+ [YELLOW] key to the audioplayer and use [UP]/[DOWN] to change the played song.
The players parses ID3V1,V2.2,V2.3 (thanks to Walt for the supported code) and displays selected info.
It also parses VBR headers ("Xing") and uses this info for display and movements.
If the player cannot parse the files, it tries to play them anyway, it will (for the display) assume
128kBit/s CBR.
Currently the player uses the same media stream like the picture viewer -so no parallel viewing and
listening is possible (will be changed soon).
+VIDEO PLAYER
+ all normal keys as for recordings player
+ RED - media info
+ GREEN audio selector
- The media view has some minor changes:
- Added the option to sort also randomly (e.g. for playing audio files).
- Directories are marked with [ ] in the display, they are always displayed on top.
-
- Additionally some bug fixes (thanks to muellerph and Walt for reporting them) for error handling.
-
-
-Development Issues
-1. Major Changes
-1.1 Surface
-To be able to handle deeply nested directories, the number of views has been extended to 120. This made
-dynamic surface handling necessary. Therefore I changed the surface member. Box has a virtual
-getSurface method, that gets implemented by Widget and View. The View really has a surface member,
-Widgets have a parent (Box) member and query this for the surface.
-At the View there is a new unmap() method, that releases the surface. The next getSurface will
-acquire a new one and will redraw the view (calling it's draw method). This has to be used with
-care...
-1.2. Jpeg
-The WJpeg has been extended to be able to load arbitrary jpeg data via a reader class. It will
-scale the jpeg if possible to fit onto the screen and will rotate it on demand.
-1.3. VDR and server
-VDR has new commands to get a media list, to initialize picture data transfer and to transfer
-picture blocks (used a new command there for possible parallel action with audio later on...).
-On the server side the media list reading has been added and a simple file reader to retrieve the
-Jpeg data.
-1.4. extensions
-New classes for Media, MediaList, VMediaList, VPicture, VPicturebanner, VPictureinfo.
-2007/03/23
-New classes for audioplayer, demuxeraudio, vaudioplayer
-
-2. Problems
-2.1. setting up devenv needed some changes...
-2.2. -Wno-format was necessary to allow for %g for the date display
-2.3. merging with today's CVS:
-I encountered big problems with the new timer handling. Dangerous situations:
-- timer retrieved from list, waiting to fire but destination gone (canceled timer),
- nextTimer will not be NULL there... - so need a add. check
-- cancel called within the timer firing - deadlock today, could delete timer from list..
-OK -I added the patch.
-2007/03/23
+Translations
+English and German are there...
-3. Open/Next Steps
-For me the next important steps would be:
-Audio Playing - basicly done 2007/03/23
+Standalone Server
+ With make make standalone in the vompserver you can create a standalone
+ vompserver-standalone that does not need vdr to compile or to run. This enables running it on
+ an arbitrary linux box without any VDR. It expects config files in the current directory. Client side
+ is still very simple - all vdr command will lead to connection lost.
- Performance Improvements
-1. have the transfer being handled in a separate thread (would save 50% on large files)
-2. make a scaling (+pot. decoding) on the server side, could lower the sizes and fit
- better to the screen (but needs some jpeg stuff on the server - I will try to grep from
- mediamvp - worked on this already...).
-Picture Functions
-1. Colour handling - we would need some colour profile for appropriate picture
- viewing...
-4. sorting - multiple sort options for media lists..
- done 2007/03/23
-Translations
-English and German are there...
+Implementation aspects:
+ For easy handling there is now a couple of files (data holders) that is used both on the client and server side.
+ Currently those are: vdrcommand.h serialize.* media.* mediaprovider.h mediaplayer.* mediafile.*
+ With the script copyClientFiles.sh you can replace the files in the server dir by symlinks to the
+ client files. This way they can easily be changed during development.
+ With serialize.* and vdrcommands.h I created some infrastructure for interface compatibility handling.
+ At least for the mediaplayer this will be used, maybe we can extend this to the other commands too (will
+ be discussed at the forum).
+ Now I created a hierarchical mediaprovider structure.
+ Both on the client and server side you can add mediaproviders that implement the MediaProvider interface.
+ Currently we have:
+ client side:
+ LocalMediaFile - providing files below the /media directory
+ VDR - forwarding everything to the server
+ server side:
+ ServerMediaFile - provding the well known functions on the server
+ New providers can be easily added, they must be initialized and registered.
+ Client: Ctor of VMedialist (only register them once!)
+ Server: Ctor of MVPclient
+
#include "recman.h"
#include "vdr.h"
+#include "log.h"
RecMan::RecMan()
{
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "serialize.h"
+#include <stdlib.h>
+#include <arpa/inet.h>
+#ifndef SNPRINTF
+#define SNPRINTF snprintf
+#endif
+
+#define BUFFERINCREASE 1024
+
+int SerializeBuffer::seek(int amount) {
+ UCHAR *np=current+amount;
+ if (np < start || np > end) return -1;
+ current=np;
+ return 0;
+}
+
+void SerializeBuffer::rewind() {
+ current=start;
+}
+
+int SerializeBuffer::checkSpace(int amount) {
+ if ((current+amount) <= end) return 0;
+ if (owning && autoincrease) {
+ if (start+size > current+amount) {
+ end=start+size;
+ return 0;
+ }
+ UCHAR *ns=new UCHAR[size+BUFFERINCREASE];
+ if (!ns) return -1;
+ memcpy(ns,start,end-start);
+ size=size+BUFFERINCREASE;
+ end=ns+size;
+ if (useMalloc) free( start);
+ else delete [] start;
+ start=ns;
+ return 0;
+ }
+ return -1;
+}
+
+SerializeBuffer::~SerializeBuffer() {
+ if (owning) {
+ if (useMalloc) free(start);
+ else delete[] start;
+ start=NULL;
+ }
+}
+SerializeBuffer::SerializeBuffer(ULONG sz,bool isMalloc,bool ai){
+ autoincrease=ai;
+ useMalloc=isMalloc;
+ if (isMalloc) {
+ start=(UCHAR *)malloc(sz);
+ }
+ else {
+ start=new UCHAR[sz];
+ }
+ end=start;
+ current=start;
+ size=sz;
+ owning=true;
+}
+ //constructor for SerializeBuffers with external buffers
+SerializeBuffer::SerializeBuffer(UCHAR *buffer,ULONG sz,bool ow,bool isMalloc,bool ai) {
+ useMalloc=isMalloc;
+ autoincrease=ai;
+ owning=ow;
+ size=sz;
+ start=buffer;
+ current=start;
+ end=start+size;
+}
+/**
+ * helper for serialize and deserialize
+ * always return != if no space
+ * advance buffer pointer
+ */
+
+int SerializeBuffer::encodeLong(ULONG data) {
+ if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
+ *((ULONG *)(current))=htonl(data);
+ current+=sizeof(ULONG);
+ return 0;
+}
+int SerializeBuffer::encodeShort(USHORT data) {
+ if (checkSpace( (int)sizeof(USHORT))!=0) return -1;
+ *((USHORT *)(current))=htons(data);
+ current+=sizeof(USHORT);
+ return 0;
+}
+int SerializeBuffer::encodeByte(UCHAR data) {
+ if (checkSpace( (int)sizeof(UCHAR))!=0) return -1;
+ *((UCHAR *)(current))=data;
+ current+=sizeof(UCHAR);
+ return 0;
+}
+int SerializeBuffer::encodeLongLong(ULLONG data) {
+ if (checkSpace( (int)sizeof(ULLONG))!=0) return -1;
+ *((ULONG *)(current))=htonl((data>>32) & 0xffffffff);
+ current+=sizeof(ULONG);
+ *((ULONG *)(current))=htonl(data & 0xffffffff);
+ current+=sizeof(ULONG);
+ return 0;
+}
+//string: 4 len, string with 0
+int SerializeBuffer::encodeString(const char *str) {
+ if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
+ ULONG len=0;
+ if (str) len=strlen(str)+1;
+ *((ULONG *)(current))=htonl(len);
+ current+=sizeof(ULONG);
+ if (len == 0) return 0;
+ if (checkSpace((int)len)!=0) return -1;
+ strcpy((char *) current,str);
+ current+=len;
+ return 0;
+}
+int SerializeBuffer::decodeLong( int &data) {
+ if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
+ data=(int)ntohl(*((ULONG *)(current)));
+ current+=sizeof(ULONG);
+ return 0;
+}
+int SerializeBuffer::decodeLong(ULONG &data) {
+ if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
+ data=ntohl(*((ULONG *)(current)));
+ current+=sizeof(ULONG);
+ return 0;
+}
+int SerializeBuffer::decodeShort(USHORT &data) {
+ if (checkSpace( (int)sizeof(USHORT))!=0) return -1;
+ data=ntohs(*((USHORT *)(current)));
+ current+=sizeof(USHORT);
+ return 0;
+}
+int SerializeBuffer::decodeByte(UCHAR &data) {
+ if (checkSpace( (int)sizeof(UCHAR))!=0) return -1;
+ data=*((UCHAR *)current);
+ current+=sizeof(UCHAR);
+ return 0;
+}
+int SerializeBuffer::decodeLongLong(ULLONG &data) {
+ if (checkSpace( (int)sizeof(ULLONG))!=0) return -1;
+ ULLONG hd=ntohl(*((ULONG *)(current)));
+ current+=sizeof(ULONG);
+ ULLONG ld=ntohl(*((ULONG *)(current)));
+ current+=sizeof(ULONG);
+ data=(hd << 32) | ld;
+ return 0;
+}
+//string: 4 len, string with 0
+int SerializeBuffer::decodeString(ULONG &len, char *&strbuf) {
+ strbuf=NULL;
+ len=0;
+ if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
+ len=ntohl(*((ULONG *)(current)));
+ current+=sizeof(ULONG);
+ if (len == 0) return 0;
+ if (checkSpace((int)len)!=0) return -1;
+ strbuf=new char[len];
+ strncpy(strbuf,(char *)current,len);
+ *(strbuf+len-1)=0;
+ current+=len;
+ return 0;
+}
+
+
+UCHAR * SerializeBuffer::steelBuffer() {
+ UCHAR *rt=start;
+ owning=false;
+ autoincrease=false;
+ return rt;
+}
+
+int Serializable::getSerializedStringLen(const char * str) {
+ int rt=4;
+ if (str) rt+=strlen(str)+1;
+ return rt;
+}
+
+USHORT Serializable::getVersion() {
+ return version;
+}
+
+
+Serializable::Serializable() {
+ version=1;
+}
+Serializable::~Serializable(){}
+
+int Serializable::getSerializedLen() {
+ //2version+4len
+ return 6 + getSerializedLenImpl();
+}
+int Serializable::serialize(SerializeBuffer *b) {
+ UCHAR *ptr=b->getCurrent();
+ if (b->encodeShort(version) != 0) return -1;
+ if (b->encodeLong(0) != 0) return -1; //dummy len
+ if (serializeImpl(b) != 0) return -1;
+ UCHAR *ep=b->getCurrent();
+ //now write the len
+ int len=ep-ptr-6;
+ if (len < 0) return -1 ; //internal error
+ b->seek(ptr-ep+2); //to len field
+ if (b->encodeLong(len) != 0) return -1;
+ b->seek(ep-b->getCurrent()); //back to end
+ return 0;
+}
+
+int Serializable::deserialize(SerializeBuffer *b) {
+ USHORT vers=0;
+ if (b->decodeShort(vers) != 0) return -1;
+ ULONG len=0;
+ if (b->decodeLong(len) != 0) return -1;
+ UCHAR *data=b->getCurrent();
+ if (data+len > b->getEnd()) return -1;
+ //TODO: set end temp. to current+len
+ //for better error handling in deserializeImpl
+ if (deserializeImpl(b) != 0) return -1;
+ //ensure we go to end of this element regardless of the things we know
+ b->seek(data+len-b->getCurrent());
+ return 0;
+}
+
+SerializableList::SerializableList() {
+ version=1;
+ encodeOnly=false;
+}
+SerializableList::~SerializableList(){}
+
+int SerializableList::addParam(Serializable *p,USHORT v) {
+ if (v < version || p == NULL) return -1;
+ Pentry entry;
+ entry.ptype=TSER;
+ entry.ptr.pser=p;
+ entry.version=v;
+ list.push_back(entry);
+ version=v;
+ return 0;
+}
+int SerializableList::addParam(USHORT *p,USHORT v) {
+ if (v < version || p == NULL) return -1;
+ Pentry entry;
+ entry.ptype=TUSHORT;
+ entry.ptr.pshort=p;
+ entry.version=v;
+ list.push_back(entry);
+ version=v;
+ return 0;
+}
+int SerializableList::addParam(ULONG *p,USHORT v) {
+ if (v < version || p == NULL) return -1;
+ Pentry entry;
+ entry.ptype=TULONG;
+ entry.ptr.plong=p;
+ entry.version=v;
+ list.push_back(entry);
+ version=v;
+ return 0;
+}
+int SerializableList::addParam(ULLONG *p,USHORT v) {
+ if (v < version || p == NULL) return -1;
+ Pentry entry;
+ entry.ptype=TULLONG;
+ entry.ptr.pllong=p;
+ entry.version=v;
+ list.push_back(entry);
+ version=v;
+ return 0;
+}
+int SerializableList::addParam(char **p,USHORT v) {
+ if (v < version || p == NULL) return -1;
+ Pentry entry;
+ entry.ptype=TCHAR;
+ entry.ptr.pchar=p;
+ entry.version=v;
+ list.push_back(entry);
+ version=v;
+ return 0;
+}
+
+bool SerializableList::Pentry::isEqual(void *p,SerializableList::Ptypes t) {
+ void *cmp=NULL;
+ switch(t) {
+ case TUSHORT:
+ cmp=(void *)ptr.pshort;
+ break;
+ case TULONG:
+ cmp=(void *)ptr.plong;
+ break;
+ case TULLONG:
+ cmp=(void *)ptr.pllong;
+ break;
+ case TSER:
+ cmp=(void *)ptr.pser;
+ break;
+ case TCHAR:
+ cmp=(void *)ptr.pchar;
+ break;
+ case TUNKNOWN:
+ break;
+ }
+ return p==cmp;
+}
+
+SerializableList::Pentry *SerializableList::findEntry(void *p,SerializableList::Ptypes t) {
+ for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
+ if ( (*it).isEqual(p,t)) return &(*it);
+ }
+ return NULL;
+}
+bool SerializableList::isDeserialized(Serializable *p){
+ SerializableList::Pentry *e=findEntry(p,TSER);
+ if (!e) return false;
+ return e->isDeserialized;
+}
+bool SerializableList::isDeserialized(USHORT *p){
+ SerializableList::Pentry *e=findEntry(p,TUSHORT);
+ if (!e) return false;
+ return e->isDeserialized;
+}
+bool SerializableList::isDeserialized(ULONG *p){
+ SerializableList::Pentry *e=findEntry(p,TULONG);
+ if (!e) return false;
+ return e->isDeserialized;
+}
+
+bool SerializableList::isDeserialized(ULLONG *p){
+ SerializableList::Pentry *e=findEntry(p,TULLONG);
+ if (!e) return false;
+ return e->isDeserialized;
+}
+
+bool SerializableList::isDeserialized(char **p){
+ SerializableList::Pentry *e=findEntry(p,TCHAR);
+ if (!e) return false;
+ return e->isDeserialized;
+}
+
+int SerializableList::getSerializedLenImpl(){
+ int rt=0;
+ for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
+ switch((*it).ptype){
+ case TUSHORT:
+ rt+=sizeof(USHORT);
+ break;
+ case TULONG:
+ rt+=sizeof(ULONG);
+ break;
+ case TULLONG:
+ rt+=sizeof(ULLONG);
+ break;
+ case TCHAR:
+ rt+=getSerializedStringLen(*((*it).ptr.pchar));
+ break;
+ case TSER:
+ rt+=(*it).ptr.pser->getSerializedLen();
+ break;
+ case TUNKNOWN:
+ break;
+ }
+ }
+ return rt;
+}
+
+int SerializableList::serializeImpl(SerializeBuffer *b){
+ for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
+ switch((*it).ptype){
+ case TUSHORT:
+ if (b->encodeShort(*(*it).ptr.pshort) != 0) return -1;
+ break;
+ case TULONG:
+ if (b->encodeLong(*(*it).ptr.plong) != 0) return -1;
+ break;
+ case TULLONG:
+ if (b->encodeLongLong(*(*it).ptr.pllong) != 0) return -1;
+ break;
+ case TCHAR:
+ if (b->encodeString(*(*it).ptr.pchar) != 0) return -1;
+ break;
+ case TSER:
+ if ((*it).ptr.pser->serialize(b) != 0) return -1;
+ break;
+ case TUNKNOWN:
+ break;
+ }
+ }
+ return 0;
+}
+
+int SerializableList::deserializeImpl(SerializeBuffer *b){
+ ULONG dlen=0;
+ for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
+ if ((*it).version > version) {
+ //OK - we received an older version - stop here
+ break;
+ }
+ switch((*it).ptype){
+ case TUSHORT:
+ if (b->decodeShort(*(*it).ptr.pshort) != 0) return -1;
+ break;
+ case TULONG:
+ if (b->decodeLong(*(*it).ptr.plong) != 0) return -1;
+ break;
+ case TULLONG:
+ if (b->decodeLongLong(*(*it).ptr.pllong) != 0) return -1;
+ break;
+ case TCHAR:
+ if (b->decodeString(dlen,*(*it).ptr.pchar) != 0) return -1;
+ break;
+ case TSER:
+ if ((*it).ptr.pser->deserialize(b) != 0) return -1;
+ break;
+ case TUNKNOWN:
+ break;
+ }
+ (*it).isDeserialized=true;
+ }
+ return 0;
+}
+
+
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef SERIALIZE_H
+#define SERIALIZE_H
+#include <vector>
+using namespace std;
+#include <stdio.h>
+#include <string.h>
+#include "defines.h"
+
+class SerializeBuffer {
+ public:
+ //constructor for send buffers
+ SerializeBuffer(ULONG size,bool isMalloc=false,bool autoincrease=false);
+ //constructor for SerializeBuffers with external buffers
+ SerializeBuffer(UCHAR *buffer,ULONG size,bool owning=false,bool isMalloc=true,bool autoincrease=false);
+ ~SerializeBuffer();
+ //access to bufferpointer
+ UCHAR * getStart(){ return start;}
+ UCHAR * getCurrent(){ return current;}
+ UCHAR * getEnd(){ return end;}
+ //get the buffer and take it away from this object
+ UCHAR * steelBuffer();
+ //seek relative to current
+ int seek(int amount);
+ void rewind();
+
+ //encode/decode functions
+ //always return != 0 on error
+ int encodeLong(ULONG data);
+ int encodeLongLong(ULLONG data);
+ int encodeShort(USHORT data);
+ int encodeString(const char *data);
+ int encodeByte(UCHAR data);
+
+ int decodeLong(ULONG & data);
+ int decodeLong(int & data);
+ int decodeLongLong(ULLONG & data);
+ int decodeShort(USHORT & data);
+ int decodeString(ULONG &len,char * &data);
+ int decodeByte(UCHAR &data);
+
+ private:
+ UCHAR * start;
+ UCHAR * end;
+ UCHAR * current;
+ ULONG size;
+ bool useMalloc;
+ bool owning;
+ bool autoincrease;
+
+ //check buffer space and enlarge if allowed
+ int checkSpace(int size);
+
+};
+
+class Serializable {
+ public:
+ Serializable();
+ virtual ~Serializable();
+ //serialize functions
+ //get the #of bytes needed to serialize
+ int getSerializedLen();
+ //serialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ int serialize(SerializeBuffer *b);
+ //deserialize
+ //advance buffer, check if >= end
+ //return 0 if OK
+ int deserialize(SerializeBuffer *b);
+ //or the received version after deserialize
+ //can be queried with deserializeImpl
+ USHORT getVersion();
+ //helper
+ static int getSerializedStringLen(const char *str);
+ protected:
+ //methods to be overwritten by impl
+ //those methods can use the version info
+ //the length and version is automatically encoded and decoded by the base class
+ virtual int getSerializedLenImpl()=0;
+ virtual int serializeImpl(SerializeBuffer *b)=0;
+ virtual int deserializeImpl(SerializeBuffer *b)=0;
+ USHORT version;
+ };
+
+/**
+ * a class for creating a list of serializable parameters
+ * by including a version handling this automatically maintains compatibility
+ * by correct usage.
+ * usage example:
+ * 1. version
+ * USHORT myP1=0;
+ * ULONG myP2=0;
+ * SerializableList myList();
+ * myList.addParam(&myP1);
+ * myList.addParam(&myP2);
+ * //now serialize/deserialize...
+ * //later - second version:
+ * USHORT myP1=0;
+ * ULONG myP2=0;
+ * char *myString=NULL;
+ * SerializableList myList();
+ * myList.addParam(&myP1);
+ * myList.addParam(&myP2);
+ * myList.addParam(&myString,2); //this parameter is new in version 2
+ * myList.deserialize(buffer);
+ * if (!myList.isDeserialized(&myString)) {
+ * //we got a version 1 message
+ * myString=strcpy(new char[22],"default-for-myString");
+ * }
+ *
+ */
+class SerializableList : public Serializable{
+ public:
+ SerializableList();
+ virtual ~SerializableList();
+ /**
+ * addParam
+ * add a parameter to the list
+ * no life cycle handling included
+ * params should be initialized before!
+ * when adding new params after having released a version
+ * add them to the end with a new version - this will automatically maintain
+ * compatibility
+ * will return !=0 if adding is not possible (e.g. adding with a smaller version)
+ */
+ int addParam(Serializable *p,USHORT version=1);
+ int addParam(USHORT *p,USHORT version=1);
+ int addParam(ULONG *p,USHORT version=1);
+ int addParam(ULLONG *p,USHORT version=1);
+ int addParam(char **p,USHORT version=1);
+
+ /**
+ * for lists only intended for encoding also
+ * const members will be added
+ * this is fully compatible to non const addParams on the other side
+ * so on the sender side you can use the addParam(const ... ) methods, on the receiver
+ * the non-const
+ * After having called one of this methods deserialize will always fail!
+ */
+ int addParam(const Serializable *p,USHORT vs=1){
+ encodeOnly=true;
+ return addParam((Serializable *)p,vs);
+ }
+ int addParam(const USHORT *p,USHORT vs=1){
+ encodeOnly=true;
+ return addParam((USHORT *)p,vs);
+ }
+ int addParam(const ULONG *p,USHORT vs=1){
+ encodeOnly=true;
+ return addParam((ULONG *)p,vs);
+ }
+ int addParam(const int *p,USHORT vs=1){
+ encodeOnly=true;
+ return addParam((ULONG *)p,vs);
+ }
+ int addParam(const ULLONG *p,USHORT vs=1){
+ encodeOnly=true;
+ return addParam((ULLONG *)p,vs);
+ }
+ int addParam(const char **p,USHORT vs=1){
+ encodeOnly=true;
+ return addParam((char **)p,vs);
+ }
+
+
+ /**
+ * check functions to test if a certain parameter has been filled
+ * during deserialize
+ */
+ bool isDeserialized(Serializable *p);
+ bool isDeserialized(USHORT *p);
+ bool isDeserialized(ULONG *p);
+ bool isDeserialized(ULLONG *p);
+ bool isDeserialized(char **p);
+
+ //return the highest version after adding params
+
+
+ protected:
+ virtual int getSerializedLenImpl();
+ virtual int serializeImpl(SerializeBuffer *b);
+ virtual int deserializeImpl(SerializeBuffer *b);
+ bool encodeOnly; //if any addParam(const ...) is called this will be set
+
+ private:
+ typedef enum{
+ TUNKNOWN,
+ TSER,
+ TUSHORT,
+ TULONG,
+ TULLONG,
+ TCHAR } Ptypes;
+ struct Pentry{
+ Ptypes ptype;
+ bool isDeserialized;
+ USHORT version;
+ union {
+ Serializable *pser;
+ USHORT *pshort;
+ ULONG *plong;
+ ULLONG *pllong;
+ char **pchar;
+ } ptr;
+ Pentry() {
+ ptype=TUNKNOWN;
+ version=1;
+ isDeserialized=false;
+ ptr.pser=NULL;
+ }
+ bool isEqual(void *p,Ptypes t);
+ } ;
+ vector<struct Pentry>list;
+ Pentry *findEntry(void *p,Ptypes t);
+};
+
+
+
+#endif
#include <stdio.h>
#include "defines.h"
+#include "colour.h"
// Font stuff
virtual int fillblt(int x, int y, int width, int height, unsigned int c)=0;
virtual void drawPixel(int x, int y, unsigned int c)=0;
+ virtual void drawPixel(int x, int y, Colour& c)=0;
virtual void drawHorzLine(int x1, int x2, int y, unsigned int c)=0;
virtual void drawVertLine(int x, int y1, int y2, unsigned int c)=0;
virtual void drawBitmap(int x, int y, const Bitmap& bm)=0;
/*
* gfx_init() - initialize the RGB to YUV conversion tables
*/
-void SurfaceMVP::initConversionTables(void)
-{
- int i;
+void SurfaceMVP::initConversionTables(int rfactor, int gfactor, int bfactor)
+ {
+ int i;
+ double drfactor=(double)rfactor/(double)100;
+ double dgfactor=(double)gfactor/(double)100;
+ double dbfactor=(double)bfactor/(double)100;
for (i=0; i<256; i++) {
- conv_YB[i] = (int)(0.299 * (double)i);
+ conv_YB[i] = (int)(0.299 * (double)i *dbfactor);
conv_BY[i] = i;
}
for (i=0; i<256; i++) {
- conv_YG[i] = (int)(0.587 * (double)i);
+ conv_YG[i] = (int)(0.587 * (double)i * dgfactor);
conv_GY[i] = i;
}
for (i=0; i<256; i++) {
- conv_YR[i] = (int)(0.114 * (double)i);
+ conv_YR[i] = (int)(0.114 * (double)i *drfactor);
conv_RY[i] = i;
}
for (i=0; i<256; i++) {
- conv_UB[i] = (int)(0.5 * (double)i);
+ conv_UB[i] = (int)(0.5 * (double)i *dbfactor);
conv_BU[i] = (int)(1.732 * (i - 128));
}
for (i=0; i<256; i++) {
- conv_UG[i] = (int)(-0.33126 * (double)i);
+ conv_UG[i] = (int)(-0.33126 * (double)i*dgfactor);
conv_GU[i] = (int)(-0.338 * (i - 128));
}
for (i=0; i<256; i++) {
- conv_UR[i] = (int)(-0.16874 * (double)i);
+ conv_UR[i] = (int)(-0.16874 * (double)i *drfactor);
conv_RU[i] = 0;
}
for (i=0; i<256; i++) {
- conv_VB[i] = (int)(-0.08131 * (double)i);
+ conv_VB[i] = (int)(-0.08131 * (double)i *dbfactor);
conv_BV[i] = 0;
}
for (i=0; i<256; i++) {
- conv_VG[i] = (int)(-0.41869 * (double)i);
+ conv_VG[i] = (int)(-0.41869 * (double)i * dgfactor);
conv_GV[i] = (int)(-0.698 * (i - 128));
}
for (i=0; i<256; i++) {
- conv_VR[i] = (int)(0.5 * (double)i);
+ conv_VR[i] = (int)(0.5 * (double)i * drfactor);
conv_RV[i] = (int)(1.370 * ((double)i - 128));
}
}
-/*
- * rgb2yuv() - convert an RGB pixel to YUV
- */
- //inline me?
-void SurfaceMVP::rgb2yuv(unsigned char r, unsigned char g, unsigned char b, unsigned char *y, unsigned char *u, unsigned char *v)
-{
- int Y, U, V;
-
- Y = conv_YB[b] + conv_YG[g] + conv_YR[r];
- U = conv_UB[b] + conv_UG[g] + conv_UR[r] + 128;
- V = conv_VB[b] + conv_VG[g] + conv_VR[r] + 128;
-
- if (Y > 255)
- Y = 255;
- else if (Y < 0)
- Y = 0;
- if (U > 255)
- U = 255;
- else if (U < 0)
- U = 0;
- if (V > 255)
- V = 255;
- else if (V < 0)
- V = 0;
-
- *y = Y;
- *u = U;
- *v = V;
-}
-
int SurfaceMVP::fillblt(int x, int y, int width, int height, unsigned int c)
{
osd_fillblt_t fblt;
*(surface.base[2] + offset) = a;
}
+void SurfaceMVP::drawPixel(int x, int y, Colour& c)
+{
+ int offset;
+ unsigned char Y, U, V;
+ unsigned int line, remainder;
+
+ if ((x >= (int)surface.sfc.width) || (y >= (int)surface.sfc.height))
+ return;
+
+
+ rgb2yuv(c.red, c.green, c.blue, &Y, &U, &V);
+
+ remainder = (surface.sfc.width % 4);
+ if (remainder == 0)
+ line = surface.sfc.width;
+ else
+ line = surface.sfc.width + (4 - remainder);
+
+ offset = (y * line) + x;
+
+ *(surface.base[0] + offset) = Y;
+ *(surface.base[1] + (offset & 0xfffffffe)) = U;
+ *(surface.base[1] + (offset & 0xfffffffe) + 1) = V;
+ *(surface.base[2] + offset) = 0xff;
+
+}
+
void SurfaceMVP::drawHorzLine(int x1, int x2, int y, unsigned int c)
{
fillblt(x1, y, x2-x1, 1, c);
int fillblt(int x, int y, int width, int height, unsigned int rgba);
void drawPixel(int x, int y, unsigned int c);
+ void drawPixel(int x, int y, Colour& c);
void drawHorzLine(int x1, int x2, int y, unsigned int c);
void drawVertLine(int x, int y1, int y2, unsigned int c);
void drawBitmap(int x, int y, const Bitmap& bm);
void readPixel(int x, int y, unsigned char* r, unsigned char* g, unsigned char* b);
void screenShot(char* fileName);
- static void initConversionTables();
+ static void initConversionTables()
+ {
+ initConversionTables(100,100,100);
+ }
+ //init tables with factors for R,G,B - each in percent
+ static void initConversionTables(int r, int g, int b);
int blt(int fd, unsigned long shandle, int sx, int sy, int width, int height, unsigned long dhandle, int dx, int dy);
osd_surface_t surface;
void yuv2rgb(int y, int u, int v, unsigned char* pr, unsigned char* pg, unsigned char* pb);
- void rgb2yuv(unsigned char r, unsigned char g, unsigned char b, unsigned char *y, unsigned char *u, unsigned char *v);
+ /*
+ * rgb2yuv() - convert an RGB pixel to YUV
+ */
+ inline void rgb2yuv(unsigned char r, unsigned char g, unsigned char b, unsigned char *y, unsigned char *u, unsigned char *v)
+ {
+ int Y, U, V;
+
+ Y = conv_YB[b] + conv_YG[g] + conv_YR[r];
+ U = conv_UB[b] + conv_UG[g] + conv_UR[r] + 128;
+ V = conv_VB[b] + conv_VG[g] + conv_VR[r] + 128;
+
+ if (Y > 255)
+ Y = 255;
+ else if (Y < 0)
+ Y = 0;
+ if (U > 255)
+ U = 255;
+ else if (U < 0)
+ U = 0;
+ if (V > 255)
+ V = 255;
+ else if (V < 0)
+ V = 0;
+
+ *y = Y;
+ *u = U;
+ *v = V;
+ }
+
// Implicit inlines
void c2rgba(unsigned long c, unsigned char *r, unsigned char *g, unsigned char *b, unsigned char *a)
fastdraw=false;
}
+void SurfaceWin::drawPixel(int x, int y, Colour & colour) {
+ int c = ( (0xFF000000 )
+ | (colour.red << 16)
+ | (colour.green << 8)
+ | (colour.blue ) );
+
+ drawPixel(x, y, c);
+ }
void SurfaceWin::drawPixel(int x, int y, unsigned int c)
{
int fillblt(int x, int y, int width, int height, unsigned int c);
void drawPixel(int x, int y, unsigned int c);
+ void drawPixel(int x, int y, Colour& c);
void drawHorzLine(int x1, int x2, int y, unsigned int c);
void drawVertLine(int x, int y1, int y2, unsigned int c);
void drawBitmap(int x, int y, const Bitmap& bm);
+++ /dev/null
-/*
- Copyright 2004-2005 Chris Tallon, Andreas Vogel
-
- This file is part of VOMP.
-
- VOMP 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.
-
- VOMP 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 VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-*/
-
-#include <time.h>
-
-#include "vaudioplayer.h"
-
-#include "audioplayer.h"
-#include "message.h"
-#include "remote.h"
-#include "wsymbol.h"
-#include "boxstack.h"
-#include "vdr.h"
-#include "media.h"
-#include "i18n.h"
-#include "wjpeg.h"
-#include "timers.h"
-#include "video.h"
-#include "command.h"
-
-VAudioplayer::VAudioplayer(VMediaList *p)
-{
- parent=p;
- Video* video = Video::getInstance();
- setSize(video->getScreenWidth(),video->getScreenHeight());
- createBuffer();
- banner=NULL;
- fullname=NULL;
- filename=NULL;
- ftime=0;
- playall=false;
- currentMedia=NULL;
- justPlaying=false;
- numentries=p->getNumEntries(MEDIA_TYPE_AUDIO);
- bannerTime=0;
-
- barBlue.set(0, 0, 150, 150);
-
-}
-
-AudioPlayer * VAudioplayer::getPlayer(bool createIfNeeded)
-{
- AudioPlayer* rt=AudioPlayer::getInstance(this,false);
- if (! createIfNeeded && rt == NULL) return NULL;
- if (rt == NULL) {
- rt=AudioPlayer::getInstance(this);
- rt->run();
- }
- return rt;
-}
-
-void VAudioplayer::preDelete()
-{
- // Another note from Chris:
- // I have moved these timer cancels here from the destructor, please see boxx.h
-
- Timers::getInstance()->cancelTimer(this,1);
- Timers::getInstance()->cancelTimer(this,2);
- Timers::getInstance()->cancelTimer(this,3);
-}
-
-VAudioplayer::~VAudioplayer()
-{
- // Note from Chris:
- // As of > 0.2.7 BoxStack has its own locking, this means returning 4 (delete me)
- // in VAudioPlayer::handleCommand (case BACK) doesn't work as expected any more.
- // BoxStack calls this destructor but BoxStack is locked at that point, so its not
- // possible to call boxstack->remove(banner) here anymore. I left the call in,
- // but inserted a destroyBanner() call in the handleCommand function.
-
- if (banner) BoxStack::getInstance()->remove(banner);
- if (fullname) delete fullname;
- if (filename) delete filename;
-
-
- //TODO leave this to medialist and stop only...
- if (getPlayer(false)) {
- AudioPlayer::getInstance(NULL,false)->shutdown();
- }
-}
-
-
-
-void VAudioplayer::draw()
-{
- Log::getInstance()->log("VAudioplayer::draw", Log::DEBUG, "p=%p", this);
-}
-
-
-int VAudioplayer::handleCommand(int command)
-{
- Log::getInstance()->log("VAudioplayer::handleCommand", Log::DEBUG, "p=%p,cmd=%d", this,command);
- Timers::getInstance()->cancelTimer(this,1);
- int rt=1;
- switch(command)
- {
- case Remote::DF_UP:
- case Remote::UP:
- play(VMediaList::MV_PREV);
- BoxStack::getInstance()->update(this);
- rt= 2;
- break;
- case Remote::FORWARD:
- getPlayer()->fastForward();
- rt=2;
- break;
- case Remote::DF_DOWN:
- case Remote::DOWN:
- play(VMediaList::MV_NEXT);
- BoxStack::getInstance()->update(this);
- rt= 2;
- break;
- case Remote::SKIPFORWARD:
- getPlayer()->skipForward(10);
- rt=2;
- break;
- case Remote::SKIPBACK:
- getPlayer()->skipBackward(10);
- rt=2;
- break;
- case Remote::REVERSE:
- rt=2;
- break;
- case Remote::ZERO:
- getPlayer()->jumpToPercent(0);
- rt=2;
- break;
- case Remote::ONE:
- getPlayer()->jumpToPercent(10);
- rt=2;
- break;
- case Remote::TWO:
- getPlayer()->jumpToPercent(20);
- rt=2;
- break;
- case Remote::THREE:
- getPlayer()->jumpToPercent(30);
- rt=2;
- break;
- case Remote::FOUR:
- getPlayer()->jumpToPercent(40);
- rt=2;
- break;
- case Remote::FIVE:
- getPlayer()->jumpToPercent(50);
- rt=2;
- break;
- case Remote::SIX:
- getPlayer()->jumpToPercent(60);
- rt=2;
- break;
- case Remote::SEVEN:
- getPlayer()->jumpToPercent(70);
- rt=2;
- break;
- case Remote::EIGHT:
- getPlayer()->jumpToPercent(80);
- rt=2;
- break;
- case Remote::NINE:
- getPlayer()->jumpToPercent(90);
- rt=2;
- break;
- case Remote::OK:
- case Remote::GREEN:
- {
- if (banner) {
- destroyBanner();
- }
- else showBanner(true);
- if (getPlayer()->getState() == AudioPlayer::S_ERROR) {
- if (playall) play(VMediaList::MV_NEXT);
- }
- rt= 2;
- }
- break;
- case Remote::PLAY:
- {
- getPlayer()->unpause();
- if (getPlayer()->getState() != AudioPlayer::S_ERROR) justPlaying=true;
- else if (playall) play(VMediaList::MV_NEXT);
- rt= 2;
- }
- break;
- case Remote::PAUSE:
- //playall=false;
- getPlayer()->pause();
- justPlaying=false;
- rt= 2;
- break;
- case Remote::STOP:
- getPlayer()->stop();
- justPlaying=false;
- rt= 2;
- break;
- case Remote::BACK:
- {
- destroyBanner(); // This line inserted to prevent BoxStack deadlock in this class destructor - Chris
- rt= 4;
- }
- break;
- }
- if (playall) startPlayall();
- if (rt == 2) retriggerBanner();
- // stop command getting to any more views
- Log::getInstance()->log("VAudioplayer::handleCommand", Log::DEBUG, "returns p=%p,cmd=%d, rt=%d", this,command,rt);
- return rt;
-}
-
-void VAudioplayer::processMessage(Message* m)
-{
- if (m->message == Message::MOUSE_MOVE)
- {
- ;
- }
- else if (m->message == Message::MOUSE_LBDOWN)
- {
-
- //check if press is outside this view! then simulate cancel
- int x=(m->parameter>>16)-getScreenX();
- int y=(m->parameter&0xFFFF)-getScreenY();
- if (x<0 || y <0 || x>(int)getWidth() || y>(int)getHeight())
- {
- BoxStack::getInstance()->handleCommand(Remote::BACK); //simulate cancel press
- }
- }
- else if (m->message == Message::PLAYER_EVENT) {
- switch (m->parameter) {
- case AudioPlayer::STREAM_ERR:
- case AudioPlayer::STREAM_END:
- if (playall) play(VMediaList::MV_NEXT);
- else sendViewMsg(this,true);
- break;
- case AudioPlayer::STATUS_CHANGE:
- updateBanner(false);
- break;
- case AudioPlayer::SHORT_UPDATE:
- if (banner) {
- drawClocks();
- BoxStack::getInstance()->update(banner,&clocksRegion);
- BoxStack::getInstance()->update(banner,&barRegion);
- Timers::getInstance()->setTimerD(this, 3, 1);
- }
- break;
- case AudioPlayer::NEW_SONG:
- updateBanner(true);
- break;
- case AudioPlayer::CONNECTION_LOST:
- destroyBanner();
- if (AudioPlayer *player=getPlayer(false)) {
- player->shutdown();
- player=NULL;
- }
- Command::getInstance()->connectionLost();
- break;
- }
- }
-}
-
-VAudioplayer * VAudioplayer::createPlayer(VMediaList * mparent, bool bplayall) {
- Log::getInstance()->log("VAudioplayer::createPlayer", Log::DEBUG, "p=%p",
- mparent);
- VAudioplayer *vmn=new VAudioplayer(mparent);
- BoxStack::getInstance()->add(vmn);
- BoxStack::getInstance()->update(vmn);
- vmn->play();
- if (bplayall) vmn->startPlayall();
- BoxStack::getInstance()->update(vmn);
- return vmn;
-}
-
-void VAudioplayer::startPlayall() {
- playall=true;
-}
-
-void VAudioplayer::play(ULONG move) {
- currentMedia=parent->getMedia(MEDIA_TYPE_AUDIO,move);
- mediaError=NULL;
- const char *fname=currentMedia->getFileName();
- ftime=currentMedia->getTime();
- int len=strlen(fname)+2+strlen(parent->getDirname());
- if (fullname) {
- delete fullname;
- fullname=NULL;
- }
- fullname=new char[len];
- sprintf(fullname,"%s/%s",parent->getDirname(),fname);
- if (filename) delete filename;
- len=strlen(fname)+1;
- filename=new char[len];
- strcpy(filename,fname);
- Log::getInstance()->log("VAudioplayer::load", Log::DEBUG, "filename=%s,p=%p",
- fullname,this);
- VDR* vdr=VDR::getInstance();
- if (vdr->isConnected()) {
- Log::getInstance()->log("VAudioplayer", Log::DEBUG, "request file %s",filename);
- int wseq=getPlayer()->play(fullname);
- if (getPlayer()->waitForSequence(wseq,2)<0) {
- mediaError=tr("unable to open audio file");
- }
- justPlaying=true;
- //leave this to the update message from the player:
- //showBanner();
- }
- else {
- if (AudioPlayer * player=getPlayer(false)) {
- player->shutdown();
- }
- Command::getInstance()->connectionLost();
- }
- if (mediaError) {
- showBanner(true);
- }
- Log::getInstance()->log("VAudioplayer", Log::DEBUG, "player started for %s",filename);
-}
-
-void VAudioplayer::retriggerBanner() {
- if (! banner) return;
- bannerTime=time(NULL);
-}
-
-void VAudioplayer::showBanner(bool forceNewTime) {
- //if the loading flag is set,
- //we are in the main thread - so we can (and must) safely hard destroy/create the banner
- Timers::getInstance()->cancelTimer(this,1);
- Timers::getInstance()->cancelTimer(this,3);
- if (! filename || ! currentMedia) {
- //hmm...
- destroyBanner();
- return;
- }
- drawBanner();
- time_t curtime=time(NULL);
- if (forceNewTime) retriggerBanner();
- time_t remainingTime=BANNER_TIME+2-(curtime-bannerTime);
- if (remainingTime < 2) remainingTime=2;
- bool playerError=getPlayer()->getState()==AudioPlayer::S_ERROR;
- if (remainingTime < BANNER_ERROR_TIME+2 && playerError) remainingTime=BANNER_ERROR_TIME+2;
- Timers::getInstance()->setTimerD(this,1,remainingTime);
- if (playerError) Timers::getInstance()->setTimerD(this,2,BANNER_ERROR_TIME);
- Timers::getInstance()->setTimerD(this,3, 1);
- BoxStack::getInstance()->update(banner);
- }
-
-void VAudioplayer::destroyBanner() {
- if (banner) {
- BoxStack::getInstance()->remove(banner);
- banner=NULL;
- }
- Timers::getInstance()->cancelTimer(this,1);
- Timers::getInstance()->cancelTimer(this,3);
-}
-void VAudioplayer::updateBanner(bool restart) {
- time_t currTime=time(NULL);
- time_t lastBanner=bannerTime;
- if (currTime - lastBanner > BANNER_TIME){
- destroyBanner();
- }
- if (banner||restart) {
- showBanner(restart);
- }
-}
-void VAudioplayer::timercall(int clientref) {
- Log::getInstance()->log("VAudioplayer::timercall", Log::DEBUG, "id=%d",clientref);
- switch(clientref)
- {
- case 1:
- case 3:
- {
- Message* m = new Message();
- //we misuse PLAYER_EVENT here
- m->message = Message::PLAYER_EVENT;
- m->to = this;
- m->from = this;
- m->parameter=(clientref==1)?AudioPlayer::STATUS_CHANGE:
- AudioPlayer::SHORT_UPDATE;
- Command::getInstance()->postMessageFromOuterSpace(m);
- break;
- }
- case 2:
- {
- bool stillError=false;
- if (AudioPlayer * player=getPlayer(false)) {
- stillError=player->getState()==AudioPlayer::S_ERROR;
- }
- if (stillError) {
- //send a stream end to trigger nex in playlist
- Message* m = new Message();
- //we misuse PLAYER_EVENT here
- m->message = Message::PLAYER_EVENT;
- m->to = this;
- m->from = this;
- m->parameter=AudioPlayer::STREAM_END;
- Command::getInstance()->postMessageFromOuterSpace(m);
- }
- break;
- }
- }
-
- }
-
-void VAudioplayer::sendViewMsg(Boxx *v,bool vdestroy) {
- Message* m = new Message();
- m->message = vdestroy?Message::CLOSE_ME:Message::ADD_VIEW;
- m->to = BoxStack::getInstance();
- m->from = v;
- m->parameter=(ULONG)v;
- Command::getInstance()->postMessageFromOuterSpace(m);
-}
-
-TBBoxx * VAudioplayer::createBannerView(int numlines) {
- TBBoxx *rt=new TBBoxx();
- UINT height=numlines*30+60;
- UINT vheight=Video::getInstance()->getScreenHeight();
- UINT vwidth=Video::getInstance()->getScreenWidth();
- if (height > vheight-2*BANNER_BOTTOM_MARGIN)
- height=vheight-2*BANNER_BOTTOM_MARGIN;
- rt->setSize(vwidth -2*BANNER_X_MARGIN, height);
- rt->createBuffer();
- if (Video::getInstance()->getFormat() == Video::PAL)
- {
- rt->setPosition(BANNER_X_MARGIN, vheight-height-BANNER_BOTTOM_MARGIN);
- }
- else
- {
- rt->setPosition(BANNER_X_MARGIN, vheight-height-BANNER_BOTTOM_MARGIN);
- }
-
- rt->setTitleBarOn(0);
- //from vvideorec
- //set the regions for the closcks and bars on banner
- barRegion.x = rt->getWidth()-BARLEN-20;
- barRegion.y = rt->getHeight() - 30; // FIXME, need to be - 1? and below?
- barRegion.w = rt->getWidth()-BARLEN+10;
- barRegion.h = 30;
-
- clocksRegion.x = 130;
- clocksRegion.y = barRegion.y + 3;
- clocksRegion.w = 190;
- clocksRegion.h = surface->getFontHeight();
- Log::getInstance()->log("VAudioPlayer",Log::DEBUG,"created banner %p",rt);
- BoxStack::getInstance()->add(rt);
- return rt;
-}
-
-
-void VAudioplayer::drawBanner(){
- Log::getInstance()->log("VAudioPlayer",Log::DEBUG, "draw banner for %p",banner);
- char *title=NULL;
- char *playerTitle=getPlayer()->getTitle();
- if (playerTitle) title=playerTitle;
- else title=filename;
- const char *pl=tr("Playlist");
- int num=parent->getNumEntries(MEDIA_TYPE_AUDIO,currentMedia->index);
- bool playerError=getPlayer()->getState() == AudioPlayer::S_ERROR;
- //1more line for long dirs
- int numlines=playall?5:4;
- int len=0;
- const char *first=NULL;
- char *playerInfo=NULL;
- if (playerError) {
- numlines=3;
- first=tr("Unable to play audio file");
- len=strlen(first)+3;
- }
- else {
- playerInfo=getPlayer()->getID3Info();
- len=strlen(filename)+strlen(pl)+30+strlen(parent->getDirname())+Media::TIMEBUFLEN+100;
- if (playerInfo) {
- for (UINT i=0;i<strlen(playerInfo);i++)
- if (playerInfo[i] == '\n') numlines++;
- len+=strlen(playerInfo);
- first=playerInfo;
- }
- else {
- first="";
- }
- }
- if (numlines != bannerlines) {
- if (banner) destroyBanner();
- banner=createBannerView(numlines);
- }
- if (! banner) {
- banner=createBannerView(numlines);
- }
- bannerlines=numlines;
- char *buf=new char [len];
- if (playerError) {
- SNPRINTF(buf,len,"%s",first);
- }
- else {
- char tbuf[Media::TIMEBUFLEN];
- if (playall) {
- SNPRINTF(buf,len,"%s\n"
- "%s:%s\n"
- "%s: %d/%d\n"
- "%s:%s\n"
- "%s:%s\n",
- first,
- tr("FileName"),currentMedia->getFileName(),
- pl,num,numentries,
- tr("Directory"),parent->getDirname(),
- tr("Time"),currentMedia->getTimeString(tbuf));
- }
- else {
- SNPRINTF(buf,len,"%s\n"
- "%s:%s\n"
- "%s:%s\n"
- "%s:%s\n",
- first,
- tr("FileName"),currentMedia->getFileName(),
- tr("Directory"),parent->getDirname(),
- tr("Time"),currentMedia->getTimeString(tbuf));
- }
- }
- Log::getInstance()->log("VAudioPlayer",Log::DEBUG,"info: (%d)%s",strlen(buf),buf);
- //now the real drawing functions
- banner->draw();
- WSymbol w;
- banner->TEMPADD(&w);
-// w.setSurface(banner->surface);
- //title
- banner->rectangle(0, 0, banner->getWidth(), 30, Colour::TITLEBARBACKGROUND);
- banner->drawText(title, 5, 5, Colour::LIGHTTEXT);
- banner->drawPara(buf,5,32,Colour::LIGHTTEXT);
- delete [] buf;
- int x=10;
- int ybottom=banner->getHeight();
- banner->rectangle(0, ybottom - barRegion.h, banner->getWidth(), barRegion.h, Colour::TITLEBARBACKGROUND);
- bool drawSymbol=true;
- switch(getPlayer()->getState()) {
- case AudioPlayer::S_PAUSE:
- w.nextSymbol = WSymbol::PAUSE;
- break;
- case AudioPlayer::S_PLAY:
- w.nextSymbol = WSymbol::PLAY;
- break;
- case AudioPlayer::S_DONE:
- if (playall)
- w.nextSymbol = WSymbol::PLAY;
- else
- drawSymbol=false;
- break;
- case AudioPlayer::S_BACK:
- w.nextSymbol = WSymbol::FBWD ;
- break;
- case AudioPlayer::S_FF:
- w.nextSymbol = WSymbol::FFWD ;
- break;
- default:
- drawSymbol=false;
- break;
- }
- if (drawSymbol) {
- w.setPosition(x, ybottom-24);
- w.draw();
- }
- else {
- //stop symbol
- banner->rectangle(x, ybottom - 23, 18, 16, Colour::LIGHTTEXT);
- }
- x+=30;
- if (playerInfo) delete playerInfo;
- if (playerTitle) delete playerTitle;
- drawClocks();
-}
-
-void VAudioplayer::drawClocks() {
- if (! banner) return;
- //draw clocks and bar
- banner->rectangle(clocksRegion, Colour::TITLEBARBACKGROUND);
-
- time_t currentSec = (time_t)(getPlayer()->getCurrentTimes());
- time_t lengthSec=(time_t)(getPlayer()->getSonglen());
- struct tm cpos;
- struct tm slen;
-/* gmtime_r(¤tSec,&cpos);
- gmtime_r(&lengthSec,&slen);*/
- cpos.tm_hour=currentSec/3600;
- cpos.tm_min=(currentSec-cpos.tm_hour*3600)/60;
- cpos.tm_sec=(currentSec-cpos.tm_hour*3600-cpos.tm_min*60);
- slen.tm_hour=0;
- slen.tm_min=0;
- slen.tm_sec=0;
-
- char buffer[100];
- if (currentSec >= lengthSec)
- {
- SNPRINTF(buffer,99, "-:--:-- / -:--:-- %03dk",getPlayer()->getCurrentBitrate()/1000);
- }
- else
- {
- SNPRINTF(buffer, 99, "%01i:%02i:%02i / %01i:%02i:%02i %03dk", cpos.tm_hour, cpos.tm_min, cpos.tm_sec, slen.tm_hour, slen.tm_min, slen.tm_sec,
- getPlayer()->getCurrentBitrate()/1000);
- //Log::getInstance()->log("VAudioplayer", Log::DEBUG, buffer);
- }
-
- banner->drawText(buffer, clocksRegion.x, clocksRegion.y, Colour::LIGHTTEXT);
-
- // Draw progress bar
- int progBarXbase = 0;
- int barlen=250;
-
- banner->rectangle(barRegion.x + progBarXbase, barRegion.y + 3, barlen+10, 24, Colour::LIGHTTEXT);
- banner->rectangle(barRegion.x + progBarXbase + 2, barRegion.y + 5, barlen+6, 20, barBlue);
-
- if (currentSec > lengthSec) currentSec=lengthSec;
- if (lengthSec == 0) return;
-
- // Draw yellow portion
- int progressWidth = (barlen+2) * currentSec / lengthSec;
- banner->rectangle(barRegion.x + progBarXbase + 4, barRegion.y + 7, progressWidth, 16, Colour::SELECTHIGHLIGHT);
-
-}
-
-
+++ /dev/null
-/*
- Copyright 2004-2005 Chris Tallon, Andreas Vogel
-
- This file is part of VOMP.
-
- VOMP 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.
-
- VOMP 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 VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-*/
-
-#ifndef VAUDIOPLAYER_H
-#define VAUDIOPLAYER_H
-
-#include <stdio.h>
-#include <string.h>
-#include <vector>
-
-#include "tbboxx.h"
-#include "timerreceiver.h"
-#include "colour.h"
-#include "region.h"
-#include "vmedialist.h"
-
-class Message;
-
-/**
- * the audio player frontend
- * will ineract with the parent List for ff,back, slide show...
- *
-*/
-class AudioPlayer;
-
-class VAudioplayer : public TBBoxx, public TimerReceiver
-{
- public:
- ~VAudioplayer();
-
- void processMessage(Message* m);
- int handleCommand(int command);
- void preDelete();
- void draw();
- void timercall(int clientReference);
- //factory method
- //return NULL on error
- static VAudioplayer *createPlayer(VMediaList * parent, bool startPlayall=false);
- //show the picture currently selected in the parent
- //potentially moving to next/previous one
- void play(ULONG move=VMediaList::MV_NONE);
-
- //start a playall
- void startPlayall();
-
-
- private:
- const static int BANNER_TIME=30;
- //show time of an error
- const static int BANNER_ERROR_TIME=8;
-
-
- //margin on SCREEN on each side
- const static int BANNER_X_MARGIN=50;
- //margin on bottom of screen
- const static int BANNER_BOTTOM_MARGIN=30;
- //length of the progress bar
- const static int BARLEN=250;
-
- VAudioplayer(VMediaList * plist);
- void retriggerBanner();
- void showBanner(bool forceRestart=false);
- void destroyBanner();
- void updateBanner(bool restart=false);
- void drawBanner();
- void drawClocks();
- TBBoxx *createBannerView(int numlines);
- int bannerlines;
- //add or destroy a view (banner, info)
- void sendViewMsg(Boxx *v,bool destroy=false);
- //get the player - create it if necessary
- AudioPlayer* getPlayer(bool create=true);
- VMediaList *parent;
- TBBoxx *banner;
- char * fullname;
- char * filename;
- ULONG ftime;
- bool playall;
- const char * mediaError;
- Media * currentMedia;
- bool justPlaying;
- int numentries;
- time_t bannerTime;
- Region barRegion;
- Region clocksRegion;
- Colour barBlue;
-
-};
-
-#endif
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "vcolourtuner.h"
+
+#include "wsymbol.h"
+#include "remote.h"
+#include "colour.h"
+#include "video.h"
+#include "vinfo.h"
+#include "boxstack.h"
+#include "i18n.h"
+#include "log.h"
+#include "mediaoptions.h"
+
+#define PICTUREFILE "/colourtest.jpg"
+
+int VColourTuner::rfactor=100;
+int VColourTuner::gfactor=100;
+int VColourTuner::bfactor=100;
+
+VColourTuner::VColourTuner()
+{
+ int sw= Video::getInstance()->getScreenWidth();
+ int sh= Video::getInstance()->getScreenHeight();
+ setSize(sw-80,sh-40);
+ setPosition((sw-area.w)/2, (sh-area.h)/2);
+ createBuffer();
+ setTitleBarOn(0);
+ picture.setPosition(160,60);
+ add(&picture);
+ drawPicture=true;
+ vrfactor=rfactor;
+ vbfactor=bfactor;
+ vgfactor=gfactor;
+ hasChanged=false;
+ Log::getInstance()->log("VColourTuner",Log::DEBUG,"created %p",this);
+}
+
+VColourTuner::~VColourTuner()
+{
+ Log::getInstance()->log("VColourTuner",Log::DEBUG,"deleted %p",this);
+}
+
+void VColourTuner::drawBox(int x, int y, int w, int h, Colour &c) {
+ for (int row=y;row<y+h;row++)
+ for (int col=x;col<x+w;col++) {
+ surface->drawPixel(col,row,c);
+ }
+}
+
+
+void VColourTuner::draw()
+{
+ //do not call base classes draw to avoid drawing the picture...
+ Log::getInstance()->log("VColourTuner::draw",Log::DEBUG,"dp %s, rf=%d, gf=%d, bf=%d",
+ (drawPicture?"true":"false"),vrfactor,vgfactor,vbfactor);
+ char valbuf[20];
+ int x=20;
+ int y=20;
+ int bw=50;
+ int bh=50;
+ int picx=picture.getX();
+ Colour bc=Colour(140,140,140);
+ fillColour(bc);
+ bc=Colour(255,255,255);
+ drawText(tr("Colour Tuning"), x+20, y+5, Colour::LIGHTTEXT);
+ drawBox(x, y+50, bw, bh, Colour::RED);
+ drawBox(x, y+130, bw, bh, Colour::GREEN);
+ drawBox(x, y+190, bw, bh, Colour::BLUE);
+ drawBox(x, y+270, bw, bh, bc);
+ sprintf(valbuf,"%03d%%",vrfactor);
+ drawText(valbuf,x+bw+x,y+50, Colour::LIGHTTEXT);
+ drawText("<1 2>",x+bw+x,y+74, Colour::LIGHTTEXT);
+ sprintf(valbuf,"%03d%%",vgfactor);
+ drawText(valbuf,x+bw+x,y+120, Colour::LIGHTTEXT);
+ drawText("<4 5>",x+bw+x,y+144, Colour::LIGHTTEXT);
+ sprintf(valbuf,"%03d%%",vbfactor);
+ drawText(valbuf,x+bw+x,y+190, Colour::LIGHTTEXT);
+ drawText("<7 8>",x+bw+x,y+214, Colour::LIGHTTEXT);
+ sprintf(valbuf,"%03d%%",(vbfactor+vgfactor+vrfactor)/3);
+ drawText(valbuf,x+bw+x,y+270, Colour::LIGHTTEXT);
+ drawText("<3 6>",x+bw+x,y+294, Colour::LIGHTTEXT);
+ drawText("9 norm",x+bw+x,y+318, Colour::LIGHTTEXT);
+ drawText(tr("OK to save, BACK to cancel"), x+20, area.h - 50, Colour::LIGHTTEXT);
+ if (drawPicture) {
+ hasChanged=false;
+ picture.init(PICTUREFILE);
+ picture.draw();
+ drawPicture=false;
+ }
+ int picy=picture.getY();
+ int pich=picture.getHeight();
+ if (hasChanged) drawText(tr("0 to draw picture"), picx+30, picy+pich+10, Colour::LIGHTTEXT);
+}
+
+int VColourTuner::handleCommand(int command)
+{
+ int rt=0;
+ switch(command) {
+ case Remote::ONE:
+ updateFactor(1,-1);
+ rt=2;
+ hasChanged=true;
+ break;
+ case Remote::TWO:
+ updateFactor(1,1);
+ rt=2;
+ hasChanged=true;
+ break;
+ case Remote::FOUR:
+ updateFactor(2,-1);
+ rt=2;
+ hasChanged=true;
+ break;
+ case Remote::FIVE:
+ updateFactor(2,1);
+ rt=2;
+ hasChanged=true;
+ break;
+ case Remote::SEVEN:
+ updateFactor(3,-1);
+ rt=2;
+ hasChanged=true;
+ break;
+ case Remote::EIGHT:
+ updateFactor(3,1);
+ hasChanged=true;
+ rt=2;
+ break;
+ case Remote::THREE:
+ updateFactor(4,-1);
+ hasChanged=true;
+ rt=2;
+ break;
+ case Remote::SIX:
+ updateFactor(4,1);
+ hasChanged=true;
+ rt=2;
+ break;
+ case Remote::NINE:
+ updateFactor(5,0);
+ hasChanged=true;
+ rt=2;
+ break;
+ case Remote::ZERO:
+ drawPicture=true;
+ rt=2;
+ break;
+ case Remote::BACK:
+ vrfactor=rfactor;
+ vgfactor=gfactor;
+ vbfactor=bfactor;
+#ifndef WIN32
+ ((Surface_TYPE *)surface)->initConversionTables(vrfactor,vgfactor,vbfactor);
+#endif
+ rt=4;
+ break;
+ case Remote::OK:
+ rfactor=vrfactor;
+ gfactor=vgfactor;
+ bfactor=vbfactor;
+ MediaOptions::getInstance()->setIntOption("FactorRed",rfactor);
+ MediaOptions::getInstance()->setIntOption("FactorGreen",gfactor);
+ MediaOptions::getInstance()->setIntOption("FactorBlue",bfactor);
+ rt=4;
+ break;
+ }
+ if (rt == 2) {
+#ifndef WIN32
+ ((Surface_TYPE *)surface)->initConversionTables(vrfactor,vgfactor,vbfactor);
+#endif
+ bool updateAll=drawPicture;
+ draw();
+ if (updateAll) {
+ BoxStack::getInstance()->update(this);
+ }
+ else {
+ Region r;
+ r.x=0;
+ r.w=picture.getX()-1;
+ r.y=0;
+ r.h=area.h;
+ BoxStack::getInstance()->update(this,&r);
+ r.x=picture.getX();
+ r.y=picture.getY();
+ r.h=area.h-r.y;
+ r.w=area.w-picture.getX();
+ BoxStack::getInstance()->update(this,&r);
+ }
+ }
+ return rt;
+}
+
+
+
+void VColourTuner::processMessage(Message* m)
+{
+ if (m->message == Message::MOUSE_MOVE)
+ {
+
+ }
+ else if (m->message == Message::MOUSE_LBDOWN)
+ {
+ //check if press is outside this view! then simulate cancel
+ int x=(m->parameter>>16)-getScreenX();
+ int y=(m->parameter&0xFFFF)-getScreenY();
+ if (x<0 || y <0 || x>(int)getWidth() || y>(int)getHeight())
+ {
+ BoxStack::getInstance()->handleCommand(Remote::BACK); //simulate cancel press
+ }
+ else if (y>=(int)area.h-24 && y<=(int)area.h-6)
+ {
+ ;
+ }
+ }
+}
+
+void VColourTuner::updateFactor(int color, int amount) {
+ switch (color) {
+ case 1:
+ vrfactor+=amount;
+ if (vrfactor < 20 ) vrfactor=20;
+ if (vrfactor > 200) vrfactor=200;
+ break;
+ case 2:
+ vgfactor+=amount;
+ if (vgfactor < 20 ) vgfactor=20;
+ if (vgfactor > 200) vgfactor=200;
+ break;
+ case 3:
+ vbfactor+=amount;
+ if (vbfactor < 20 ) vbfactor=20;
+ if (vbfactor > 200) vbfactor=200;
+ break;
+ case 4:
+ updateFactor(1,amount);
+ updateFactor(2,amount);
+ updateFactor(3,amount);
+ break;
+ case 5:
+ while ((vrfactor+vbfactor+vgfactor) > 300) updateFactor(4,-1);
+ while ((vrfactor+vbfactor+vgfactor) < 300) updateFactor(4,1);
+ }
+}
+
+void VColourTuner::initFactors(){
+ MediaOptions * options=MediaOptions::getInstance();
+ int rf=options->getIntOption("FactorRed");
+ int gf=options->getIntOption("FactorGreen");
+ int bf=options->getIntOption("FactorBlue");
+ if (rf >= 20 && bf >= 20 && gf >= 20)
+ rfactor=rf;
+ gfactor=gf;
+ bfactor=bf;
+ Log::getInstance()->log("VColourTuner",Log::DEBUG,"setting initial factors r=%d,g=%d,b=%d",rf,gf,bf);
+#ifndef WIN32
+ Surface_TYPE::initConversionTables(rfactor,gfactor,bfactor);
+#endif
+}
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef VCOLOURTUNER_H
+#define VCOLOURTUNER_H
+
+#include <stdio.h>
+#include <string.h>
+#include <vector>
+#include <algorithm>
+
+#include "tbboxx.h"
+#include "wjpeg.h"
+
+
+class VColourTuner : public TBBoxx
+{
+ public:
+ VColourTuner();
+ ~VColourTuner();
+ int handleCommand(int command);
+ void processMessage(Message* m);
+ void draw();
+ //initialize the static factors
+ static void initFactors();
+
+ private:
+ //colors for factors: 1 red, 2 green, 3 blue
+ // 4 update all, 5 normalize sum to 300 (amount is don't care)
+ //amount in +/- %
+ void updateFactor(int color, int amount);
+ //draw a box with the picture drawing function
+ void drawBox(int x, int y, int w, int h, Colour &c);
+ static int rfactor;
+ static int bfactor;
+ static int gfactor;
+ int vrfactor;
+ int vbfactor;
+ int vgfactor;
+ bool drawPicture;
+ bool hasChanged;
+ WJpeg picture;
+
+};
+
+#endif
#include "vdrrequestpacket.h"
#include "vdrresponsepacket.h"
#include "command.h"
+#include "media.h"
+#include "mediaprovider.h"
+#include "mediaproviderids.h"
+#include "vdrcommand.h"
VDR* VDR::instance = NULL;
+//prepare a request
+//will create a request package from a command variable and fill this
+//caller has to destroy buffer
+static SerializeBuffer * prepareRequest(VDR_Command *cmd) {
+ SerializeBuffer *buf=new SerializeBuffer(512,false,true);
+ if (cmd->serialize(buf) != 0) {
+ delete buf;
+ return NULL;
+ }
+ return buf;
+}
+
+//handle request/response
+//TODO avoid copy of buffer (needs extension of requestpacket)
+//TODO avoid command 2x (needs some more restructuring)
+SerializeBuffer * VDR::doRequestResponse(SerializeBuffer *rq,int cmd) {
+ VDR_RequestPacket *rt=new VDR_RequestPacket;
+ if (! rt) {
+ delete rq;
+ return NULL;
+ }
+ if (! rt->init(cmd,true,rq->getCurrent()-rq->getStart())) {
+ delete rq;
+ delete rt;
+ return NULL;
+ }
+ if (! rt->copyin(rq->getStart(),(ULONG)(rq->getCurrent()-rq->getStart()))) {
+ delete rq;
+ delete rt;
+ return NULL;
+ }
+ delete rq;
+ VDR_ResponsePacket *rp=RequestResponse(rt);
+ logger->log("doRequestResponse",Log::DEBUG,"got response %p",rp);
+ if ( !rp) {
+ delete rt;
+ return NULL;
+ }
+ SerializeBuffer *buf=new SerializeBuffer(rp->getUserData(),rp->getUserDataLength(),true,true,false);
+ delete rp;
+ return buf;
+}
+
+
+
+//deserialize a received response
+//delete the package
+//return !=0 on error
+static int decodeResponse(SerializeBuffer *rp,VDR_Command *c) {
+ ULONG expected=c->command;
+ if (c->deserialize(rp) != 0) {
+ delete rp;
+ Log::getInstance()->log("VDR", Log::ERR, "decodeResponse unable to deserialize for command %lu",expected);
+ return -1;
+ }
+ delete rp;
+ if (c->command != expected) {
+ Log::getInstance()->log("VDR", Log::ERR, "decodeResponse unexpected response received 0x%lx, expected 0x%lx",c->command,expected);
+ return -1;
+ }
+ Log::getInstance()->log("VDR", Log::DEBUG, "decodeResponse successfully decoded command 0x%lx",expected);
+ return 0;
+}
+
+
VDR::VDR()
{
maxChannelNumber = 0;
channelNumberWidth = 1;
TEMP_SINGLE_VDR_PR = NULL;
+ providerId=MPROVIDERID_VDR;
+ subRange=MPROVIDERRANGE_VDR;
+ MediaPlayerRegister::getInstance()->registerMediaProvider(this,MPROVIDERID_VDR,MPROVIDERRANGE_VDR);
}
VDR::~VDR()
return toReturn;
}
-UCHAR* VDR::getImageBlock(ULONG position, UINT maxAmount, UINT* amountReceived)
-{
- return getBlock(position, maxAmount, amountReceived, VDR_GETIMAGEBLOCK);
-}
-
UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived)
-{
- return getBlock(position, maxAmount, amountReceived, VDR_GETBLOCK);
-}
-
-UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived, ULONG cmd)
{
VDR_RequestPacket vrp;
- if (!vrp.init(cmd, true, sizeof(ULLONG) + sizeof(ULONG))) return NULL;
+ if (!vrp.init(VDR_GETBLOCK, true, sizeof(ULLONG) + sizeof(ULONG))) return NULL;
if (!vrp.addULLONG(position)) return NULL;
if (!vrp.addULONG(maxAmount)) return NULL;
return ;
}
+
+MediaList * VDR::getRootList() {
+ return getMediaList(NULL);
+}
/**
* media List Request:
- * 4 flags (currently unused)
- * n dirname
- * n+1 0
+ * mediaURI
* Media List response:
- * 4 length
- * 4 VDR_
- * 4 numentries
- * per entry:
- * 4 media type
- * 4 time stamp
- * 4 flags
- * 4 strlen (incl. 0 Byte)
- * string
- * 0
+ * mediaList
*/
-MediaList* VDR::getMediaList(const char* parent,int mediaType)
+MediaList* VDR::getMediaList(const MediaURI * root)
{
- logger->log("VDR", Log::DEBUG, "getMediaList %s,type=%d", (parent?parent:"NULL"), mediaType);
-
- VDR_RequestPacket vrp;
- if (!vrp.init(VDR_GETMEDIALIST, false, 0)) return NULL;
- if (!vrp.addULONG(0)) return NULL; // unused flags
-
- //name
- if (parent) {
- if (!vrp.addString(parent)) return NULL;
+ logger->log("VDR", Log::DEBUG, "getMediaList %s,d=%s, prov=%d", (root?root->getName():"NULL"),
+ ((root && root->hasDisplayName())?root->getDisplayName():"NULL"),
+ (root?root->getProvider():providerId));
+ MediaURI remoteURI(root);
+ VDR_GetMediaListRequest request(&remoteURI);
+ SerializeBuffer *vrp=prepareRequest(&request);
+ if (!vrp) {
+ logger->log("VDR", Log::ERR, "getMediaList unable to create command");
+ return NULL;
}
- VDR_ResponsePacket* vresp = RequestResponse(&vrp);
- if (vresp->noResponse()) { delete vresp; return NULL; }
-
- if (vresp->serverError())
- {
- delete vresp;
+ SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
+ if (!vresp) {
+ Command::getInstance()->connectionLost();
return NULL;
}
- if (vresp->getUserDataLength() < 12)
- {
- logger->log("VDR", Log::ERR, "receiveMediaList packet too short, expected 12, got %d", vresp->getUserDataLength());
- delete vresp;
+ MediaList *rt=new MediaList(NULL);
+ ULONG rtflags=0;
+ VDR_GetMediaListResponse resp(&rtflags,rt);
+ if (decodeResponse(vresp,&resp) != 0) {
return NULL;
}
-
- MediaList* mediaList = new MediaList();
- ULONG code=0;
- code = vresp->extractULONG();
- ULONG numEntries = vresp->extractULONG();
- Log::getInstance()->log("VDR", Log::DEBUG, "receiveMediaList with %d entries",numEntries);
- while (!vresp->end() && numEntries >0)
- {
- Media* m = new Media();
- ULONG mtype = vresp->extractULONG();
- ULONG mtime=vresp->extractULONG();
- ULONG flags=0;
- flags=vresp->extractULONG();
- ULONG stsize=vresp->extractULONG();
- char * name=vresp->extractString();
- if (! name || stsize != (strlen(name)+1)) {
- Log::getInstance()->log("VDR", Log::ERR, "receiveMediaList invalid packet entry, read size %d, strlen %d", stsize, strlen(name)+1);
- delete m;
- delete mediaList;
- delete vresp;
- return NULL;
- }
- //ignore . and .. entries
- if (strcmp(name,".") == 0 || strcmp(name,"..")==0) {
- delete m;
- continue;
- }
- m->setFileName(name);
- m->setTime(mtime);
- m->setMediaType(mtype);
- mediaList->push_back(m);
- Log::getInstance()->log("VDR", Log::DEBUG, "Have added a media to list. %s, type=%d, time=%d", name,mtype,mtime);
- numEntries--;
- }
-
- delete vresp;
- return mediaList;
+ return rt;
}
/**
* get image Request:
- * 4 flags (currently unused)
- * 4 x size
- * 4 y size
- * n filename
- * n+1 0
- * get image response:
- * 4 length
- * 4 VDR_GETIMAGE
- * 4 len of image
+ * uri,x,y, channel
+ * get media response:
+ * 4 flags
+ * 8 len of image
*/
-ULONG VDR::loadImage(const char* fileName, ULONG x, ULONG y)
+int VDR::openMedium(ULONG channel,const MediaURI *uri, ULLONG * size, ULONG x, ULONG y)
{
- VDR_RequestPacket vrp;
- if (!vrp.init(VDR_GETIMAGE, false, 0)) return 0;
- if (!vrp.addULONG(0)) return 0; // unused flags
- if (!vrp.addULONG(x)) return 0;
- if (!vrp.addULONG(y)) return 0;
- if (!vrp.addString(fileName)) return 0;
-
- VDR_ResponsePacket* vresp = RequestResponse(&vrp);
- if (vresp->noResponse()) { delete vresp; return 0; }
+ MediaURI remoteURI(uri);
+ VDR_OpenMediumRequest request(&channel,&remoteURI,&x,&y);
+ *size=0;
+ SerializeBuffer *vrp=prepareRequest(&request);
+ if (!vrp) {
+ logger->log("VDR", Log::ERR, "openMedium unable to create command");
+ return -1;
+ }
+ SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
+ if (!vresp) {
+ Command::getInstance()->connectionLost();
+ return -1;
+ }
+ ULONG flags=0;
+ VDR_OpenMediumResponse response(&flags,size);
+ if (decodeResponse(vresp,&response) != 0) {
+ return -1;
+ }
+ logger->log("VDR", Log::DEBUG, "openMedia len=%llu", *size);
+ return 0;
+}
- ULONG cmd = vresp->extractULONG();
- ULONG lengthBytes = vresp->extractULONG();
+/**
+ * getMediaBlock - no separate response class - simple data block
+ * resp
+ * packet
+ */
+int VDR::getMediaBlock(ULONG channel, ULLONG position, ULONG maxAmount, ULONG* amountReceived, unsigned char **buffer)
+{
+ *amountReceived=0;
+ VDR_GetMediaBlockRequest request(&channel,&position,&maxAmount);
+ SerializeBuffer *vrp=prepareRequest(&request);
+ if (!vrp) {
+ logger->log("VDR", Log::ERR, "getMediaBlock unable to create command");
+ return -1;
+ }
+ SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
+ if (!vresp) {
+ Command::getInstance()->connectionLost();
+ return -1;
+ }
+
+ // Special handling for getblock
+ *amountReceived = (ULONG)(vresp->getEnd()-vresp->getStart());
+ *buffer = vresp->steelBuffer();
delete vresp;
+ return 0;
+}
- Log::getInstance()->log("VDR", Log::DEBUG, "getImage %s: cmd=%lu len=%lu", fileName, cmd, lengthBytes);
- return lengthBytes;
+/**
+ * VDR_GETMEDIAINFO
+ * channel
+ * rt
+ * flags
+ * info
+ */
+
+int VDR::getMediaInfo(ULONG channel, MediaInfo * result) {
+ if (! result) return -1;
+ VDR_GetMediaInfoRequest request(&channel);
+ SerializeBuffer *vrp=prepareRequest(&request);
+ if (!vrp) {
+ logger->log("VDR", Log::ERR, "getMediaInfo unable to create command");
+ return -1;
+ }
+ SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
+ if (!vresp) {
+ Command::getInstance()->connectionLost();
+ return -1;
+ }
+
+ ULONG flags=0;
+ VDR_GetMediaInfoResponse response(&flags,result);
+ if (decodeResponse(vresp,&response) != 0) {
+ return -1;
+ }
+ return 0;
+}
+
+/**
+ * VDR_CLOSECHANNEL
+ * channel
+ * rt
+ * flags
+ */
+
+int VDR::closeMediaChannel(ULONG channel) {
+ VDR_CloseMediaChannelRequest request(&channel);
+ SerializeBuffer *vrp=prepareRequest(&request);
+ if (!vrp) {
+ logger->log("VDR", Log::ERR, "closeMediaChannel unable to create command");
+ return -1;
+ }
+ SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
+ if (!vresp) {
+ Command::getInstance()->connectionLost();
+ return -1;
+ }
+ ULONG flags;
+ VDR_CloseMediaChannelResponse response(&flags);
+ if (decodeResponse(vresp,&response) != 0) return -1;
+ return (flags != 0)?-1:0;
}
+
+
+
int VDR::deleteTimer(RecTimer* delTimer)
{
- Log::getInstance()->log("VDR", Log::DEBUG, "Delete timer called");
+ logger->log("VDR", Log::DEBUG, "Delete timer called");
VDR_RequestPacket vrp;
if (!vrp.init(VDR_DELETETIMER, false, 0)) return 0;
#include "defines.h"
#include "rectimer.h"
#include "mark.h"
-#include "media.h"
+#include "mediaprovider.h"
#include "eventdispatcher.h"
#include "i18n.h"
class Channel;
class VDR_RequestPacket;
class VDR_ResponsePacket;
+class SerializeBuffer;
using namespace std;
StreamReceiver* streamReceiver;
};
-class VDR : public Thread_TYPE, public EventDispatcher
+class VDR : public Thread_TYPE, public EventDispatcher, public MediaProvider
{
public:
const static ULONG CHANNEL_REQUEST_RESPONSE = 1;
const static ULONG CHANNEL_STREAM = 2;
const static ULONG CHANNEL_KEEPALIVE = 3;
-
+
VDR();
~VDR();
static VDR* getInstance();
int deleteTimer(RecTimer* delTimer);
ChannelList* getChannelsList(ULONG type);
int streamChannel(ULONG number, StreamReceiver*);
+ int streamChannel(ULONG number);
void getChannelPids(Channel* channel);
UCHAR* getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived);
//get image blocks separate - we can do this in parallel
- UCHAR* getImageBlock(ULONG position, UINT maxAmount, UINT* amountReceived);
int stopStreaming();
EventList* getChannelSchedule(ULONG number);
EventList* getChannelSchedule(ULONG number, time_t start, ULONG duration);
ULONG setEventTimer(char* timerString);
RecTimerList* getRecTimersList();
/**
- * ge a list of media entries
- * if parent==NULL this is the configured base list
- */
- MediaList* getMediaList(const char* parent=NULL,int mediaType=MEDIA_TYPE_ALL);
- /**
- * start loading a JPEG image
- * return size, 0 if not found
+ * the MediaProvider functions
+ *
*/
- ULONG loadImage(const char * filename, ULONG xsize=0,ULONG ysize=0);
+ virtual MediaList* getRootList();
+ virtual MediaList* getMediaList(const MediaURI * parent);
+ virtual int openMedium(ULONG channel,const MediaURI *uri,ULLONG * size, ULONG xsize,ULONG ysize);
+ virtual int getMediaBlock(ULONG channel, unsigned long long offset, unsigned long len, unsigned long * outlen,
+ unsigned char ** buffer);
+ virtual int getMediaInfo(ULONG channel, struct MediaInfo * result);
+ virtual int closeMediaChannel(ULONG channel);
+
I18n::lang_code_list getLanguageList();
int getLanguageContent(const string code, I18n::trans_table&);
bool connected;
ULONG maxChannelNumber;
ULONG channelNumberWidth;
-
VDR_PacketReceiver* TEMP_SINGLE_VDR_PR;
- const static ULONG VDR_LOGIN = 1;
- const static ULONG VDR_GETRECORDINGLIST = 2;
- const static ULONG VDR_DELETERECORDING = 3;
- const static ULONG VDR_GETCHANNELLIST = 5;
- const static ULONG VDR_STREAMCHANNEL = 6;
- const static ULONG VDR_GETBLOCK = 7;
- const static ULONG VDR_STOPSTREAMING = 8;
- const static ULONG VDR_STREAMRECORDING = 9;
- const static ULONG VDR_GETCHANNELSCHEDULE = 10;
- const static ULONG VDR_CONFIGSAVE = 11;
- const static ULONG VDR_CONFIGLOAD = 12;
- const static ULONG VDR_RESCANRECORDING = 13; // FIXME obselete
- const static ULONG VDR_GETTIMERS = 14;
- const static ULONG VDR_SETTIMER = 15;
- const static ULONG VDR_POSFROMFRAME = 16;
- const static ULONG VDR_FRAMEFROMPOS = 17;
- const static ULONG VDR_MOVERECORDING = 18;
- const static ULONG VDR_GETNEXTIFRAME = 19;
- const static ULONG VDR_GETRECINFO = 20;
- const static ULONG VDR_GETMARKS = 21;
- const static ULONG VDR_GETCHANNELPIDS = 22;
- const static ULONG VDR_DELETETIMER = 23;
- const static ULONG VDR_GETMEDIALIST = 30;
- const static ULONG VDR_GETIMAGE = 31;
- const static ULONG VDR_GETIMAGEBLOCK = 32;
- const static ULONG VDR_GETLANGUAGELIST = 33;
- const static ULONG VDR_GETLANGUAGECONTENT = 34;
+ ULONG providerId;
+ ULONG subRange;
+ SerializeBuffer * doRequestResponse(SerializeBuffer *in,int cmd);
protected:
// Thread
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef VDRCOMMAND_H
+#define VDRCOMMAND_H
+
+#include "defines.h"
+#include "serialize.h"
+#include "media.h"
+
+/**
+ * data holder for VDR commands
+ * it's only important to add serializable objects
+ * in the same order on both sides
+ */
+
+//until we really have response - commands we simply take
+//the request+this flag for responses
+//not really necessary but for checks it's better to have a command ID at least in some responses
+const static ULONG VDR_RESPONSE_FLAG =0x1000000;
+
+//as this header is only included by vdr.cc the constants are this way private
+//but can easily be used on the server side as well
+
+const static ULONG VDR_LOGIN = 1;
+const static ULONG VDR_GETRECORDINGLIST = 2;
+const static ULONG VDR_DELETERECORDING = 3;
+const static ULONG VDR_GETCHANNELLIST = 5;
+const static ULONG VDR_STREAMCHANNEL = 6;
+const static ULONG VDR_GETBLOCK = 7;
+const static ULONG VDR_STOPSTREAMING = 8;
+const static ULONG VDR_STREAMRECORDING = 9;
+const static ULONG VDR_GETCHANNELSCHEDULE = 10;
+const static ULONG VDR_CONFIGSAVE = 11;
+const static ULONG VDR_CONFIGLOAD = 12;
+const static ULONG VDR_RESCANRECORDING = 13; // FIXME obselete
+const static ULONG VDR_GETTIMERS = 14;
+const static ULONG VDR_SETTIMER = 15;
+const static ULONG VDR_POSFROMFRAME = 16;
+const static ULONG VDR_FRAMEFROMPOS = 17;
+const static ULONG VDR_MOVERECORDING = 18;
+const static ULONG VDR_GETNEXTIFRAME = 19;
+const static ULONG VDR_GETRECINFO = 20;
+const static ULONG VDR_GETMARKS = 21;
+const static ULONG VDR_GETCHANNELPIDS = 22;
+const static ULONG VDR_DELETETIMER = 23;
+const static ULONG VDR_GETLANGUAGELIST = 33;
+const static ULONG VDR_GETLANGUAGECONTENT = 34;
+const static ULONG VDR_GETMEDIALIST = 30;
+const static ULONG VDR_OPENMEDIA = 31;
+const static ULONG VDR_GETMEDIABLOCK = 32;
+const static ULONG VDR_GETMEDIAINFO = 35;
+const static ULONG VDR_CLOSECHANNEL = 36;
+
+class VDR_Command : public SerializableList {
+ public:
+ VDR_Command(const ULONG cmd) {
+ command=cmd;
+ addParam(&command);
+ }
+ virtual ~VDR_Command(){}
+ ULONG command;
+};
+
+class VDR_GetMediaListRequest : public VDR_Command {
+ public:
+ VDR_GetMediaListRequest(MediaURI *root) :VDR_Command(VDR_GETMEDIALIST) {
+ addParam(root);
+ }
+};
+
+class VDR_GetMediaListResponse : public VDR_Command {
+ public:
+ VDR_GetMediaListResponse(ULONG *flags,MediaList *m) : VDR_Command(VDR_GETMEDIALIST|VDR_RESPONSE_FLAG){
+ addParam(flags);
+ addParam(m);
+ }
+};
+
+class VDR_OpenMediumRequest : public VDR_Command {
+ public:
+ VDR_OpenMediumRequest(ULONG *channel,MediaURI *u,ULONG *xsize, ULONG *ysize) :
+ VDR_Command(VDR_OPENMEDIA) {
+ addParam(channel);
+ addParam(u);
+ addParam(xsize);
+ addParam(ysize);
+ }
+};
+class VDR_OpenMediumResponse : public VDR_Command {
+ public:
+ VDR_OpenMediumResponse(ULONG *flags,ULLONG *size) :
+ VDR_Command(VDR_OPENMEDIA|VDR_RESPONSE_FLAG) {
+ addParam(flags);
+ addParam(size);
+ }
+};
+class VDR_GetMediaBlockRequest : public VDR_Command {
+ public:
+ VDR_GetMediaBlockRequest(ULONG * channel, ULLONG *pos, ULONG *max):
+ VDR_Command(VDR_GETMEDIABLOCK) {
+ addParam(channel);
+ addParam(pos);
+ addParam(max);
+ }
+};
+
+//no response class for GetMediaBlock
+
+
+class VDR_CloseMediaChannelRequest : public VDR_Command {
+ public:
+ VDR_CloseMediaChannelRequest(ULONG * channel):
+ VDR_Command(VDR_CLOSECHANNEL) {
+ addParam(channel);
+ }
+};
+
+class VDR_CloseMediaChannelResponse : public VDR_Command {
+ public:
+ VDR_CloseMediaChannelResponse(ULONG * flags):
+ VDR_Command(VDR_CLOSECHANNEL|VDR_RESPONSE_FLAG) {
+ addParam(flags);
+ }
+};
+
+class VDR_GetMediaInfoRequest : public VDR_Command {
+ public:
+ VDR_GetMediaInfoRequest(ULONG * channel):
+ VDR_Command(VDR_GETMEDIAINFO) {
+ addParam(channel);
+ }
+};
+class VDR_GetMediaInfoResponse : public VDR_Command {
+ public:
+ VDR_GetMediaInfoResponse(ULONG * flags,MediaInfo *info):
+ VDR_Command(VDR_GETMEDIAINFO|VDR_RESPONSE_FLAG) {
+ addParam(flags);
+ addParam(info);
+ }
+};
+
+
+
+
+#endif
#include "boxstack.h"
#include "channel.h"
#include "i18n.h"
+#include "log.h"
VEpg* VEpg::instance = NULL;
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+/*
+ Hints for the directory playing:
+ depending on the configValue directoryMode: none|audio|picture|count
+ it will be decided what to do if a directory is selected with [PLAY]:
+ none: as currently - simply go into
+ audio: start picture viewer and audio, audio on top
+ picture: start picture viewer and audio, picture on top
+ count: count occurence of both types, decide for audio/picture
+ Synchronization is done via the "directoryDone" call,
+ this is issued if the Viewer top engine has finished it's list
+ (getMedia returned 0)
+ We will the go back one level and continue
+ Currently we will traverse to new directories only at the beginning
+ or the real end of each dir.
+ This is handled only by playAll (never by getMedia).
+ As we sort always in a way that all directories come first this should be OK.
+ there are 2 situations where we give the user a chance to interrupt (this is handled
+ by starting a 10ms timer and afterwrads sending a PLAYER_EVENT with the timer ref as
+ parameter):
+ empty directory found - timer 1 - call directoryDone
+ after changing to a new directory the first entry is again a directory - timer 2 - playAll
+ controlling flags:
+ directoryPlaying: globally set as long as we play a dir, reset on any key press here
+ startLevel: in DirList - set to the level where we started playing, if we are
+ back to this playing is finished
+ configuredDirmode: configured mode
+
+*/
+
+
+
#include <vector>
#include <time.h>
#include <string.h>
#endif
#include "vmedialist.h"
-#include "vpicture.h"
-#include "vaudioplayer.h"
+#include "vmediaview.h"
+#include "vvideomedia.h"
#include "remote.h"
#include "wsymbol.h"
#include "boxstack.h"
#include "vdr.h"
#include "command.h"
#include "vinfo.h"
+#include "media.h"
+#include "mediaplayer.h"
+#include "log.h"
+#include "localmediafile.h"
+#include "mediaoptions.h"
using namespace std;
+//a ref count holder
+class MediaListHolder {
+ public:
+ MediaListHolder(MediaList *l) {
+ _list=l;
+ _ref=1;
+ }
+ MediaList * list() {
+ return _list;
+ }
+ void ref() {
+ _ref++;
+ Log::getInstance()->log("##MLH",Log::DEBUG,"ref %p now %d",_list,_ref);
+ }
+ void unref() {
+ if (_ref >0 ) _ref--;
+ Log::getInstance()->log("##MLH",Log::DEBUG,"unref %p now %d",_list,_ref);
+ if (_ref == 0) delete this;
+ }
+ ~MediaListHolder() {
+ if (_list) delete _list;
+ }
+ private:
+ UINT _ref;
+ MediaList *_list;
+};
+
class MediaDirectory {
private:
- char * dirname;
- char * displayname;
- char * fullpath;
+ MediaURI *uri;
int selection;
int sortorder;
ULONG mtype;
+ MediaListHolder *holder;
public:
- void setDirname(const char * n) {
- if (dirname) delete dirname;
- dirname=NULL;
- if (!n) return;
- dirname=new char[strlen(n)+1];
- strcpy(dirname,n);
- }
- void setDisplayname(const char * n) {
- if (displayname) delete displayname;
- displayname=NULL;
- if (!n) return;
- displayname=new char[strlen(n)+1];
- strcpy(displayname,n);
- }
- void setFullpath(const char * n) {
- if (fullpath) delete fullpath;
- fullpath=NULL;
- if (!n) return;
- fullpath=new char[strlen(n)+1];
- strcpy(fullpath,n);
- }
- void setSelection(int s) {
- selection=s;
- }
void setMediaType(ULONG n) {mtype=n;}
void setSortorder(int s) {
sortorder=s;
}
- const char * getDirname() {
- return dirname;
- }
- const char * getDisplayname() {
- if (displayname) return displayname;
- if (fullpath) return fullpath;
- if (dirname) return dirname;
- return "/";
- }
- const char * getFullPath() {
- return fullpath;
+ void setSelection(int s) {
+ selection=s;
}
int getSelection() {
return selection;
}
+ bool move(ULONG mv) {
+ if (! holder) return false;
+ switch(mv) {
+ case VMediaList::MV_NEXT:
+ if (selection < ((int)holder->list()->size() -1)) {
+ selection++;
+ return true;
+ }
+ break;
+ case VMediaList::MV_PREV:
+ if (selection > 0) {
+ selection--;
+ return true;
+ }
+ break;
+ }
+ return false;
+ }
+
ULONG getMediaType(){return mtype;}
int getSortorder() {
return sortorder;
}
- public:
- MediaDirectory(const char *d) : dirname(NULL),displayname(NULL),fullpath(NULL),selection(0),
- sortorder(0),mtype(MEDIA_TYPE_ALL){
- setDirname(d);
+ const MediaURI * getURI() {
+ return uri;
+ }
+ const char * getDisplayName() {
+ if (! uri || ! uri->getDisplayName()) return "/";
+ return uri->getDisplayName();
+ }
+ //get the holder (increment refcount)
+ MediaListHolder *getHolder() {
+ if ( !holder) return NULL;
+ holder->ref();
+ return holder;
+ }
+ //assign a holder to the directory (auto ref)
+ void assignHolder(MediaListHolder *h) {
+ if (holder) holder->unref();
+ holder=NULL;
+ if (! h) return;
+ h->ref();
+ holder=h;
+ }
+ //constructor with copy!
+ MediaDirectory(const MediaURI *u) : selection(0),
+ sortorder(0),mtype(MEDIA_TYPE_ALL),holder(NULL){
+ if (u)
+ uri=new MediaURI(u);
+ else
+ uri=NULL;
}
MediaDirectory(MediaDirectory &c) {
- MediaDirectory(c.getDirname());
- setDisplayname(c.getDisplayname());
setSelection(c.getSelection());
setMediaType(c.getMediaType());
setSortorder(c.getSortorder());
+ uri=new MediaURI(c.getURI());
+ holder=c.getHolder();
}
~MediaDirectory() {
- if (dirname) delete dirname;
- if (displayname) delete displayname;
- if (fullpath) delete fullpath;
+ if (uri) delete uri;
+ if (holder) holder->unref();
}
};
class DirList {
private:
int current;
+ int startlevel;
MDirList list;
public:
DirList() {
current=0;
+ startlevel=0;
list.push_back(new MediaDirectory(NULL));
}
+ DirList(DirList *cp) {
+ current=-1;
+ for (MDirList::iterator it=cp->list.begin();it<cp->list.end();it++) {
+ list.push_back(new MediaDirectory(*(*it)));
+ current++;
+ }
+ if (current < 0) {
+ list.push_back(new MediaDirectory(NULL));
+ current=0;
+ }
+ startlevel=cp->startlevel;
+ if (startlevel > current) startlevel=current;
+ }
~DirList() {
MDirList::iterator it;
for (it=list.begin();it<list.end();it++) {
MediaDirectory *getCurrent() {
return list[current];
}
- const char * getPath() {
- return getCurrent()->getFullPath();
+ const MediaURI * getURI() {
+ return getCurrent()->getURI();
}
int dropTop() {
if (current > 0) {
}
return current;
}
- int append(const char *dirname) {
- if (! dirname) return current;
- MediaDirectory* md=new MediaDirectory(dirname);
- const char *cp=getCurrent()->getFullPath();
- int len=strlen(dirname)+2;
- if (cp) len+=strlen(cp);
- char * fp=new char[len];
- *fp=0;
- if (cp) {
- strcpy(fp,cp);
- strcat(fp,"/");
- }
- else if (*dirname != '/' ) strcpy(fp,"/");
- strcat(fp,dirname);
- md->setFullpath(fp);
- delete fp;
+ int append(const MediaURI *uri) {
+ if (! uri) return current;
+ MediaDirectory* md=new MediaDirectory(uri);
list.push_back(md);
current++;
return current;
int getLevel() {
return current;
}
+ void setStartLevel() {
+ startlevel=current;
+ }
+ bool isOnStartLevel() {
+ return (startlevel == current);
+ }
};
{
boxstack = BoxStack::getInstance();
+ Log::getInstance()->log("VMediaList::VMediaList", Log::DEBUG, "start");
dirlist=new DirList();
+ audiodirlist=NULL;
Log::getInstance()->log("VMediaList::VMediaList", Log::DEBUG, "dirlist=%p,curren=%p",dirlist,dirlist->getCurrent());
dirlist->getCurrent()->setSortorder(SORT_NAME);
setSize(570, 420);
sl.addColumn(60);
add(&sl);
- mediaList=NULL;
loading=true;
sortOrder=SORT_NONE;
+ viewer=NULL;
+ dirmode=M_NONE;
+ const char *dmstring=MediaOptions::getInstance()->getStringOption("DirectoryPlayMode");
+ if (dmstring) {
+ if (strcmp(dmstring,"count") == 0) dirmode=M_COUNT;
+ else if (strcmp(dmstring,"audio") == 0) dirmode=M_AUDIO;
+ else if (strcmp(dmstring,"picture") == 0) dirmode=M_PICTURE;
+ }
+ playingAll=false;
+ //init additional providers
+ LocalMediaFile::init();
}
+
VMediaList::~VMediaList()
{
+ Log::getInstance()->log("VMediaList::~VMediaList", Log::DEBUG, "start");
+ Timers::getInstance()->cancelTimer(this,1);
+ Timers::getInstance()->cancelTimer(this,2);
+ removeViewer();
delete dirlist;
- clearMediaList();
+ if (audiodirlist) delete audiodirlist;
+ Log::getInstance()->log("VMediaList::~VMediaList", Log::DEBUG, "finished");
}
-void VMediaList::clearMediaList() {
- if (mediaList)
- {
- for (UINT i = 0; i < mediaList->size(); i++)
- {
- delete (*mediaList)[i];
- }
+void VMediaList::removeViewer() {
+ if (viewer) {
+ BoxStack::getInstance()->remove(viewer);
+ }
+ viewer=NULL;
+}
- mediaList->clear();
- delete mediaList;
+VMediaView * VMediaList::getViewer() {
+ if (! viewer) {
+ viewer=VMediaView::createViewer(this);
}
+ return viewer;
}
+void VMediaList::playAudio(bool all,bool activate, bool showInfo) {
+ MediaListHolder *h=dirlist->getCurrent()->getHolder();
+ if (! h) return;
+ VMediaView *player=getViewer();
+ //OK make a copy of the current active list for audio playing
+ if (audiodirlist) delete audiodirlist;
+ audiodirlist=new DirList(dirlist);
+ player->play(all,activate,MV_NONE,showInfo);
+ h->unref();
+}
+
+void VMediaList::updateAll() {
+ BoxStack::getInstance()->update(this);
+ if (viewer) BoxStack::getInstance()->update(viewer);
+ BoxStack::getInstance()->update(NULL);
+}
+
+
+
-int VMediaList::getNumEntries(int mediaType,int lowerThen) {
- if (mediaType == MEDIA_TYPE_ALL && lowerThen < 0) return mediaList->size();
- if (lowerThen < 0) lowerThen=mediaList->size();
+int VMediaList::getNumEntries(ULONG mediaType,int lowerThen,bool noAudioList) {
+ MediaListHolder *h=dirlist->getCurrent()->getHolder();
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"getNumEntries type=%lu,lt=%d,na=%d,h=%p,l=%p",
+ mediaType,lowerThen,(int)noAudioList,h,(h?h->list():0));
+ if (! h) return 0;
+ if (mediaType == MEDIA_TYPE_ALL && lowerThen < 0) {
+ h->unref();
+ return h->list()->size();
+ }
+ if (lowerThen < 0) lowerThen=h->list()->size();
int rt=0;
- for (int i=0;i<(int)(mediaList->size()) && i <= lowerThen;i++) {
- if ((*mediaList)[i]->getMediaType() & mediaType) rt++;
+ MediaList *ml=h->list();
+ h->unref();
+ if (mediaType == MEDIA_TYPE_AUDIO) {
+ //OK we look into the separate audiolist (if we have it...)
+ if (audiodirlist && ! noAudioList) {
+ MediaListHolder *ah=audiodirlist->getCurrent()->getHolder();
+ if (ah) {
+ ml=ah->list();
+ ah->unref();
+ }
+ }
+ }
+ for (int i=0;i<(int)(ml->size()) && i <= lowerThen;i++) {
+ if ((*ml)[i]->getMediaType() & mediaType) rt++;
}
return rt;
}
-void VMediaList::setList(MediaList* tlist)
+void VMediaList::setList(MediaListHolder* tlist)
{
- if (mediaList != tlist) {
- clearMediaList();
- }
+ dirlist->getCurrent()->assignHolder(tlist);
sortOrder=SORT_NONE;
- mediaList = tlist;
sortList(dirlist->getCurrent()->getSortorder());
updateSelectList(dirlist->getCurrent()->getSelection());
}
updateSelectList(-1);
}
void VMediaList::updateSelectList(int currentNumber){
+ MediaListHolder *h=dirlist->getCurrent()->getHolder();
char str[5000];
char tempA[Media::TIMEBUFLEN];
- Log::getInstance()->log("VMediaList::updateSelectList", Log::DEBUG, "media=%p",mediaList);
+ Log::getInstance()->log("VMediaList::updateSelectList", Log::DEBUG, "media=%p",h);
+ if (! h) return;
ULONG currentSelection=0;
if (sl.getNumOptions() >= 1 && currentNumber < 0) {
Media* media;
int first = 1;
- if (mediaList)
+ if (h && h->list())
{
- for (UINT i = 0; i < mediaList->size(); i++)
+ for (UINT i = 0; i < h->list()->size(); i++)
{
- media = (*mediaList)[i];
+ media = (*h->list())[i];
if (media->getMediaType() == MEDIA_TYPE_DIR) {
sprintf(str, "%04u %s [%s]", i,media->getTimeString(tempA), media->getDisplayName());
//Log::getInstance()->log("VMediaList", Log::DEBUG, "add to select list %s",str);
if (sl.getNumOptions() > 0)
sl.draw();
doShowingBar();
+ if (h) h->unref();
}
-void VMediaList::highlightMedia(Media* media)
-{
- sl.hintSetCurrent(media->index);
- sl.draw();
- doShowingBar();
- boxstack->update(this);
-}
void VMediaList::draw()
{
- Log::getInstance()->log("VMediaList::draw", Log::DEBUG, "namestr=%s",dirlist->getCurrent()->getDisplayname());
+ Log::getInstance()->log("VMediaList::draw", Log::DEBUG, "namestr=%s",dirlist->getCurrent()->getDisplayName());
char title[400];
- SNPRINTF(title, 398, tr("Media - %s"), dirlist->getCurrent()->getDisplayname());
+ SNPRINTF(title, 398, tr("Media - %s"), dirlist->getCurrent()->getDisplayName());
title[399]=0;
setTitleText(title);
if (sl.getNumOptions() == 0) topOption = 0;
char showing[250];
- const char* strmode=tr("Name");
+ const char* strmode=NULL;
switch (sortOrder) {
case SORT_TIME:
- strmode=tr("Rand");
+ strmode=tr("Time");
break;
case SORT_NAME:
- strmode=tr("Time");
+ strmode=tr("Name");
break;
default:
+ strmode=tr("Rand");
break;
}
SNPRINTF(showing, 250,tr("%i to %i of %i"),
if (sl.getCurrentOptionData() != 0) Log::getInstance()->log("VMediaList",Log::DEBUG,"selected %s",((Media *)sl.getCurrentOptionData())->getDisplayName());
}
-Media * VMediaList::getMedia(int ltype,ULONG move) {
- int cur=sl.getCurrentOption();
- Media *m;
- bool more=true;
- while (more) {
- int last=sl.getCurrentOption();
+//find the next entry in the media list
+//return the index in the list (starting with 0)
+//return -1 if none found
+int VMediaList::findNextEntry(int current, MediaList *list,ULONG ltype, ULONG move,bool wrap) {
+ if (! list) return -1;
+ if (current < 0) current=0;
+ if (current >= (int)list->size()) current=list->size()-1;
+ int next=current;
+ int rt=-1;
+ bool again=true;
+ while (again) {
switch (move) {
- case MV_NEXT:
- sl.down();
- break;
case MV_PREV:
- sl.up();
+ next--;
+ break;
+ case MV_NEXT:
+ next++;
break;
default:
- more=false;
+ again=false;
+ break;
+ }
+ if (next < 0) {
+ if (! wrap) {
+ break;
+ }
+ else {
+ next=list->size()-1;
+ }
+ }
+ if (next >= (int)list->size()) {
+ if (! wrap) {
+ break;
+ }
+ else {
+ next=0;
+ }
+ }
+ if (next == current && move != MV_NONE) {
+ break;
+ }
+ if (((*list)[next])->getMediaType() != ltype) {
+ ;
+ }
+ else {
+ rt=next;
break;
}
- m=(Media*)sl.getCurrentOptionData();
- if (m->getMediaType() & ltype) {
- sl.draw();
- return m;
- }
- //stop if we are done
- if (sl.getCurrentOption() == cur || sl.getCurrentOption() == last) break;
}
- return NULL;
+ return rt;
}
+
+
+
+Media * VMediaList::getMedia(ULONG ltype,ULONG move) {
+ Media *rt=NULL;
+ MediaList *list=NULL;
+ MediaListHolder *h=NULL;
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"getMedia, t=%lu, mv=%lu",ltype,move);
+ //we have 2 lists:
+ //the currently active one (dirlist->getCurrent()->getHolder())
+ //and potentially a second one for audio (audiolist)
+ //currently (no recursive playing) we should always have an attached medialist in the audiolist
+ if (ltype == MEDIA_TYPE_AUDIO && audiodirlist != NULL ) {
+ h=audiodirlist->getCurrent()->getHolder();
+ if (! h) {
+ Log::getInstance()->log("VMediaList",Log::ERR,"getMedia AUDIO empty medialist");
+ return NULL;
+ }
+ int nentry=findNextEntry(audiodirlist->getCurrent()->getSelection(),h->list(),ltype,move,false);
+ if (nentry < 0) {
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"getMedia AUDIO no next entry");
+ h->unref();
+ return NULL;
+ }
+ audiodirlist->getCurrent()->setSelection(nentry);
+ list=h->list();
+ rt=new Media((*list)[nentry]);
+ h->unref();
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"getMedia AUDIO next entry %d",nentry);
+ }
+ else {
+ h=dirlist->getCurrent()->getHolder();
+ if (! h) {
+ Log::getInstance()->log("VMediaList",Log::ERR,"getMedia PICTURE empty medialist");
+ return NULL;
+ }
+ int nentry=findNextEntry(dirlist->getCurrent()->getSelection(),h->list(),ltype,move,false);
+ if (nentry < 0) {
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"getMedia type=%lu no next entry",ltype);
+ h->unref();
+ return NULL;
+ }
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"getMedia type=%lu next entry %d",ltype,nentry);
+ dirlist->getCurrent()->setSelection(nentry);
+ updateSelection(true);
+ list=h->list();
+ h->unref();
+ rt=new Media((*list)[nentry]);
+ }
+ if (! rt->getURI()) {
+ MediaURI *uri=list->getURI(rt);
+ rt->setURI(uri);
+ delete uri;
+ }
+ return rt;
+}
+
+void VMediaList::updateSelection(bool toSelectList) {
+ if (! toSelectList)
+ dirlist->getCurrent()->setSelection(sl.getCurrentOption());
+ else {
+ sl.hintSetCurrent(dirlist->getCurrent()->getSelection());
+ sl.draw();
+ }
+}
+
+Media * VMediaList::getCurrentMedia(DirList *dl) {
+ if (! dl) return NULL;
+ MediaDirectory *d=dirlist->getCurrent();
+ if (! d) return NULL;
+ MediaListHolder *h=d->getHolder();
+ if (! h) return NULL;
+ if (d->getSelection() < 0 || d->getSelection() >= (int)h->list()->size()) return NULL;
+ Media *rt= (*h->list())[d->getSelection()];
+ h->unref();
+ return rt;
+}
+
+
int VMediaList::handleCommand(int command)
{
+ playingAll=false;
switch(command)
{
case Remote::ONE:
{
sl.hintSetCurrent(0);
sl.draw();
+ updateSelection();
doShowingBar();
boxstack->update(this);
return 2;
{
sl.up();
sl.draw();
+ updateSelection();
doShowingBar();
boxstack->update(this);
{
sl.down();
sl.draw();
+ updateSelection();
doShowingBar();
boxstack->update(this);
{
sl.pageUp();
sl.draw();
+ updateSelection();
doShowingBar();
boxstack->update(this);
{
sl.pageDown();
sl.draw();
+ updateSelection();
doShowingBar();
boxstack->update(this);
case Remote::PLAY:
{
Media* media = NULL;
- if (mediaList) media = (Media*)sl.getCurrentOptionData();
+ if (dirlist) media = getCurrentMedia(dirlist);
if (media == NULL) return 2;
Log::getInstance()->log("VMediaList", Log::DEBUG, "activated %lu", media->index);
switch(media->getMediaType())
//create child
Log::getInstance()->log("VMediaList", Log::DEBUG, "create child for %s",media->getFileName());
if (media->getFileName() == NULL ) return 2;
- if (sl.getNumOptions() >=1) {
- dirlist->getCurrent()->setSelection(sl.getCurrentOption());
- }
- dirlist->getCurrent()->setSortorder(sortOrder);
- dirlist->append(media->getFileName());
- //same sort order for next level
- dirlist->getCurrent()->setSortorder(sortOrder);
- load();
+ if (command == Remote::PLAY) {
+ dirlist->setStartLevel();
+ playingAll=true;
+ }
+ bool rt=changeDirectory(media);
+ if (command == Remote::PLAY && rt) {
+ playAll();
+ }
+ else {
+ playingAll=false;
+ }
break;
}
case MEDIA_TYPE_AUDIO:
Log::getInstance()->log("VMediaList", Log::DEBUG, "play audio file %s",
media->getFileName());
- VAudioplayer::createPlayer(this,command==Remote::PLAY);
+ if (dirmode != M_NONE && command == Remote::PLAY)
+ playAll();
+ else
+ playAudio(command==Remote::PLAY,true,true);
break;
case MEDIA_TYPE_VIDEO:
Log::getInstance()->log("VMediaList", Log::DEBUG, "play video file %s",
media->getFileName());
+ //OK - simply today
+ if (! media->getURI()) {
+ //addURI
+ MediaListHolder *h=dirlist->getCurrent()->getHolder();
+ if (!h) {
+ Log::getInstance()->log("VMediaList", Log::ERR, "no media List");
+ break;
+ }
+ MediaURI *u=h->list()->getURI(media);
+ media->setURI(u);
+ delete u;
+ h->unref();
+ }
+ removeViewer();
+ VVideoMedia *v=new VVideoMedia(media,this);
+ BoxStack::getInstance()->add(v);
+ BoxStack::getInstance()->update(v);
+ v->go(false);
//play video
break;
case MEDIA_TYPE_PICTURE:
Log::getInstance()->log("VMediaList", Log::DEBUG, "show picture file %s",
media->getFileName());
- VPicture::createViewer(this,command==Remote::PLAY);
- //play video
+ if (dirmode != M_NONE && command == Remote::PLAY)
+ playAll();
+ else
+ getViewer()->showPicture(MV_NONE,command==Remote::PLAY,true);
break;
default:
Log::getInstance()->log("VMediaList", Log::DEBUG, "unknown media type %d file %s",
}
/*
- VVideoLive* v = new VVideoLive(mediaList, media->type, this);
+ VVideoLive* v = new VVideoLive(dirlist->getCurrent()->getHolder(), media->type, this);
v->draw();
boxstack->add(v);
return 1;
}
+//go to the next level dir
+//if OK - delete current medialist
+bool VMediaList::changeDirectory(Media *media) {
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"cd to %s",media->getFileName());
+ updateSelection();
+ dirlist->getCurrent()->setSortorder(sortOrder);
+ if (dirlist->getLevel() > 200) {
+ Log::getInstance()->log("VMediaList",Log::ERR,"above 300 levels, stop here...");
+ return false;
+ }
+ MediaListHolder *h=dirlist->getCurrent()->getHolder();
+ dirlist->getCurrent()->assignHolder(NULL); //prepare old holder for deletion
+ if (! h) {
+ return false;
+ }
+ MediaURI *uri=h->list()->getURI(media);
+ dirlist->append(uri);
+ delete uri;
+ //same sort order for next level
+ dirlist->getCurrent()->setSortorder(sortOrder);
+ int rt=load();
+ if (rt == 0) {
+ h->unref(); //this deletes now the old list
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"cd OK");
+ return true;
+ }
+ //we were no able to load the new list - so go back to our current list
+ dirlist->dropTop();
+ dirlist->getCurrent()->assignHolder(h); //OK so we saved our list...
+ h->unref();
+ Log::getInstance()->log("VMediaList",Log::DEBUG,"cd failed");
+ return false;
+}
+
+void VMediaList::directoryDone() {
+ if (! playingAll) return;
+ //go up until we are on the startlevel
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "DirectoryDone ");
+ while ( ! dirlist->isOnStartLevel()) {
+ dirlist->dropTop();
+ load();
+ if (dirlist->isOnStartLevel()) break;
+ if (dirlist->getCurrent()->move(MV_NEXT))
+ break;
+ }
+ if ( dirlist->isOnStartLevel()) {
+ //OK we are done
+ playingAll=false;
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "finished playing all l=%lu",dirlist->getLevel());
+ return;
+ }
+ updateSelection(true);
+ playAll();
+}
+
+bool VMediaList::playAll() {
+ if (dirmode == M_NONE) return false;
+ bool started=false;
+ if (! playingAll) {
+ //starting now
+ dirlist->setStartLevel();
+ playingAll=true;
+ started=true;
+ }
+ Media *media=getCurrentMedia(dirlist);
+ if (! media) {
+ //empty directory
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "empty dir when calling playall");
+ //directoryDone
+ Timers::getInstance()->setTimerD(this,1,0,10000000l); //10ms
+ return true;
+ }
+ Media *mcopy=new Media(media);
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "playing all name=%s,t=%lu, started=%d",
+ mcopy->getDisplayName(),mcopy->getMediaType(),(int)started);
+ while (mcopy->getMediaType()==MEDIA_TYPE_DIR) {
+ //recurse to the next directory
+ bool rt=changeDirectory(mcopy);
+ if (rt ) {
+ //OK succesfully changed dir
+ int entries=getNumEntries(MEDIA_TYPE_AUDIO|MEDIA_TYPE_DIR|MEDIA_TYPE_PICTURE);
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "cd OK, entries=%d",entries);
+ media=getCurrentMedia(dirlist);
+ if (entries==0 || media == NULL) {
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "playing all name=%s empty",mcopy->getDisplayName());
+ delete mcopy;
+ //trigger directory end with the ability of user intervention
+ Timers::getInstance()->setTimerD(this,1,0,10000000l); //10ms
+ return true;
+ }
+ delete mcopy;
+ mcopy=NULL;
+ if (media->getMediaType()==MEDIA_TYPE_DIR) {
+ //send a defered event to give the user a chance to interrupt
+ //will again call playAll (but this does not chage the start level)
+ Timers::getInstance()->setTimerD(this,2,0,10000000l); //10ms
+ return true;
+ }
+ break;
+ }
+ else
+ {
+ //unable to change to the directory
+ if (dirlist->getCurrent()->move(MV_NEXT)) {
+ //OK there is still a next medium here
+ updateSelection(true);
+ media=getCurrentMedia(dirlist);
+ if (!media) {
+ Timers::getInstance()->setTimerD(this,1,0,10000000l); //10ms
+ return true;
+ }
+ delete mcopy;
+ mcopy=new Media(media);
+ continue;
+ }
+ //hmm - no entries here any more
+ //so we have to stop
+ delete mcopy;
+ playingAll=false;
+ return false;
+ }
+ }
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "playing all on level %d, sele=%d",
+ dirlist->getLevel(),dirlist->getCurrent()->getSelection());
+ delete mcopy;
+ enum Dirmode currentMode=dirmode;
+ //OK now we handled all directories - now deal with the current one
+ //1st determine the number of entries
+ int aentries=getNumEntries(MEDIA_TYPE_AUDIO,-1,true);
+ int pentries=getNumEntries(MEDIA_TYPE_PICTURE,-1,true);
+ if (aentries == 0 && pentries == 0) {
+ directoryDone();
+ return false;
+ }
+ if (currentMode == M_COUNT) {
+ if (aentries > pentries) currentMode=M_AUDIO;
+ else currentMode=M_PICTURE;
+ }
+ Log::getInstance()->log("VMediaList", Log::DEBUG, "mode=%d,ae=%d,pe=%d",currentMode,aentries,pentries);
+ //now find the matching entries and start playing
+ MediaListHolder *h=dirlist->getCurrent()->getHolder();
+ if (! h) {
+ Log::getInstance()->log("VMediaList", Log::ERR, "playing all empty medialist");
+ playingAll=false;
+ return false;
+ }
+ Media *maudio=NULL;
+ Media *mpicture=NULL;
+ int audioselection=-1;
+ int pictureselection=-1;
+ for (int i=dirlist->getCurrent()->getSelection();i<(int)h->list()->size();i++) {
+ Media *m=(*h->list())[i];
+ if (m->getMediaType() == MEDIA_TYPE_AUDIO && maudio == NULL) {
+ maudio=m;
+ audioselection=i;
+ }
+ if (m->getMediaType() == MEDIA_TYPE_PICTURE && mpicture == NULL) {
+ mpicture=m;
+ pictureselection=i;
+ }
+ if (maudio != NULL && mpicture != NULL) break;
+ }
+ //OK now we found the first media for both - start players
+ if (maudio != NULL) {
+ dirlist->getCurrent()->setSelection(audioselection);
+ playAudio(true,currentMode==M_AUDIO,mpicture==NULL); //this makes now a copy of dirlist...
+ }
+ if (mpicture != NULL) {
+ dirlist->getCurrent()->setSelection(pictureselection);
+ getViewer()->showPicture(MV_NONE,true,currentMode==M_PICTURE);
+ }
+ h->unref();
+ updateSelection(true);
+ return true;
+}
+
+
+
+
+
+
+
+
void VMediaList::processMessage(Message* m)
{
if (m->message == Message::MOUSE_MOVE)
}
}
}
+ else if (m->message == Message::PLAYER_EVENT) {
+ switch (m->parameter) {
+ case 1:
+ directoryDone();
+ break;
+ case 2:
+ playAll();
+ break;
+ }
+ }
}
int VMediaList::createList() {
}
void VMediaList::sortList(int newSort) {
+ MediaListHolder *h=dirlist->getCurrent()->getHolder();
+ if (! h) return;
+ Log::getInstance()->log("VMediaList::sortList", Log::DEBUG, "p=%p,sort=%d,osort=%d, size=%d",this,newSort,sortOrder,h->list()->size());
if (sortOrder == newSort) return;
- Log::getInstance()->log("VMediaList::sortList", Log::DEBUG, "p=%p,sort=%d, size=%d",this,newSort,mediaList->size());
- if (mediaList->begin() != mediaList->end()) {
+ if (h->list()->begin() != h->list()->end()) {
switch (newSort) {
case SORT_TIME:
- ::sort(mediaList->begin(),mediaList->end(),MediaSorterTime());
+ ::sort(h->list()->begin(),h->list()->end(),MediaSorterTime());
break;
case SORT_NAME:
- ::sort(mediaList->begin(),mediaList->end(),MediaSorterName());
+ ::sort(h->list()->begin(),h->list()->end(),MediaSorterName());
break;
case SORT_RANDOM:
- ::sort(mediaList->begin(),mediaList->end(),MediaSorterRandom(time(NULL)));
+ ::sort(h->list()->begin(),h->list()->end(),MediaSorterRandom(time(NULL)));
break;
}
}
sortOrder=newSort;
updateSelectList();
+ h->unref();
+ Log::getInstance()->log("VMediaList::sortList", Log::DEBUG, "done ");
}
loading=true;
draw();
boxstack->update(this);
- VDR* vdr=VDR::getInstance();
- Log::getInstance()->log("VMediaList::load", Log::DEBUG, "load list for %s",dirlist->getPath());
- if (vdr->isConnected()) {
- MediaDirectory *md=dirlist->getCurrent();
- MediaList *mn=vdr->getMediaList(md->getFullPath(),md->getMediaType());
- if (mn != NULL) {
- setList(mn);
- draw();
- boxstack->update(this);
- return 0;
- }
- }
- if (! vdr->isConnected()) {
- Command::getInstance()->connectionLost();
+ MediaPlayer * mp=MediaPlayer::getInstance();
+ Log::getInstance()->log("VMediaList::load", Log::DEBUG, "load list for %p",dirlist->getURI());
+ MediaDirectory *md=dirlist->getCurrent();
+ MediaList *mn=NULL;
+ if (md->getURI()) {
+ mn=mp->getMediaList(md->getURI());
+ }
+ else {
+ mn=mp->getRootList();
}
+ if (mn != NULL) {
+ MediaListHolder *h=new MediaListHolder(mn);
+ setList(h);
+ h->unref();
+ h=NULL;
+ draw();
+ boxstack->update(this);
+ return 0;
+ }
else {
- Log::getInstance()->log("VMediaList", Log::ERR, "unable to get MediaList for %s",dirlist->getPath());
+ Log::getInstance()->log("VMediaList", Log::ERR, "unable to get MediaList for %p",dirlist->getURI());
VInfo* vi = new VInfo();
vi->setSize(400, 150);
return 1;
}
-const char * VMediaList::getDirname() const {
- return dirlist->getCurrent()->getFullPath();
+const char * VMediaList::getDirname(ULONG mtype) const {
+ if (mtype == MEDIA_TYPE_AUDIO && audiodirlist) {
+ return audiodirlist->getCurrent()->getDisplayName();
+ }
+ return dirlist->getCurrent()->getDisplayName();
}
+void VMediaList::timercall(int ref) {
+ if (ref == 1 || ref == 2 ) {
+ //send a directory done event
+ Message* m = new Message();
+ m->message = Message::PLAYER_EVENT;
+ m->to = this;
+ m->parameter = ref;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+ }
+}
+
#include "tbboxx.h"
#include "wselectlist.h"
-#include "media.h"
+#include "timers.h"
+#include "timerreceiver.h"
class DirList;
class Message;
class BoxStack;
+class Media;
+class MediaList;
+class MediaURI;
+class VMediaView;
+class MediaListHolder;
-class VMediaList : public TBBoxx
+class VMediaList : public TBBoxx , public TimerReceiver
{
public:
VMediaList();
~VMediaList();
- void setList(MediaList* chanList);
- void highlightMedia(Media* media);
- const char *getDirname() const;
void processMessage(Message* m);
int handleCommand(int command);
void draw();
//move selection to the next matching media
//with the given move
//return NULL if none found
- Media * getMedia(int type,ULONG move=MV_NONE);
+ //the returned Media is a copy and must contain an URI!
+ Media * getMedia(ULONG type,ULONG move=MV_NONE);
//get the number of media entries of particular types in this list
//if lowerThen is set, only count entries lt this one
- int getNumEntries(int mediaType,int lowerThen=-1);
+ int getNumEntries(ULONG mediaType,int lowerThen=-1,bool noAudiolist=false);
+
+ //get the directory of the current medium (display only)
+ const char * getDirname(ULONG mediaType) const;
+
+
+ //update all viewers/players
+ void updateAll();
+
+ //the engine on top of the viewer has finished
+ //its list
+ void directoryDone();
+
+ virtual void timercall(int ref);
+
+
private:
+ //set the media list, this makes no copy, list is owned by me afterwards
+ void setList(MediaListHolder* chanList);
/**
* fill the medialist basing on the current dirname
*/
- int load();
- BoxStack* boxstack;
- MediaList *mediaList;
- WSelectList sl;
- bool loading;
- void doShowingBar();
- int sortOrder;
+ int load();
+ VMediaView *getViewer();
+ void removeViewer();
+ void playAudio(bool all=false,bool activate=false, bool showInfo=false);
+ BoxStack* boxstack;
+ MediaListHolder *mediaList;
+ WSelectList sl;
+ bool loading;
+ void doShowingBar();
+ int sortOrder;
//sort list defined by new order
- void sortList(int order);
+ void sortList(int order);
static const int SORT_NONE=0;
static const int SORT_NAME=1;
static const int SORT_TIME=2;
static const int SORT_RANDOM=3;
- void clearMediaList();
- void updateSelectList();
- void updateSelectList(int current);
- DirList* dirlist;
-
+ void updateSelectList();
+ void updateSelectList(int current);
+ //start playing everything from the current selected Media
+ //the startlevel will be set to the current level
+ bool playAll();
+ //change to the selected directory with updating
+ bool changeDirectory(Media *m);
+ //update the selection in the dirlist from the selectlist
+ //or vice versa
+ void updateSelection(bool toSelectList=false);
+ //find the next entry in a media list
+ //return -1 if none found, otherwise index in list
+ int findNextEntry(int current, MediaList *list,ULONG ltype, ULONG move,bool wrap);
+ //get the currently selected media fro a list
+ Media * getCurrentMedia(DirList *dl);
+ DirList* dirlist;
+ DirList* audiodirlist;
+ VMediaView *viewer;
+
+ enum Dirmode {
+ M_NONE,
+ M_AUDIO,
+ M_PICTURE,
+ M_COUNT
+ };
+ enum Dirmode dirmode;
+ bool playingAll; //flag for combined and recursive playing
};
#endif
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include <time.h>
+
+#include "vmediaview.h"
+
+#include "vpicturebanner.h"
+#include "vcolourtuner.h"
+#include "audioplayer.h"
+#include "timers.h"
+#include "boxx.h"
+#include "wselectlist.h"
+#include "remote.h"
+#include "wsymbol.h"
+#include "boxstack.h"
+#include "vdr.h"
+#include "media.h"
+#include "video.h"
+#include "vinfo.h"
+#include "i18n.h"
+#include "message.h"
+#include "command.h"
+#include "mediaoptions.h"
+#include "mediaplayer.h"
+#include "log.h"
+
+/**
+ * the combined user interface for pictures and audio
+ * has 2 surfaces to enable drawing in a separate thread
+ * the info display can either show a picture info or and audio info
+ * if the audio player comes on top it disables the picture info display
+ * basically we have 3 modes:
+ * - HIDDEN viewer is hidden (pictureEnabled=false, audioEnabled=false)
+ * if justPlaying=true the audioplayer is still running
+ * - PICTURE picture viewer on top ("slide show") - pictureEnabled=true, audioEnabled=false
+ * no AudioBanner visible
+ * if justPlaying=true the audio player runs in bg
+ * - AUDIO audioPlayer on top ("playlist mode") - pictureEnabled=true, audioEnabled=true
+ * the picture viewer is currently halted (should be able to continue if no AudioInfo)
+ * no picture banner (we should have an audio banner to indicate the audio player on top!)
+ * state transitions (via setPictureMode, setAudioMode)
+ * - show Picture -> pictureEnabled=true,
+ * only called from command handler if audioEnabled=false
+ * call from mediaList only possible if audioEnabled=false
+ * *** TODO: would be better to have separate function for external call/internal call
+ * - play [Audio] -> if activate is set -> audioEnabled=true (-> Mode AUDIO)
+ * used for calls from medialist
+ * internal calls do not set activate!
+ * - YELLOW key - toggle
+ * if audioActive==true -> audioActive=false (new mode depends on pictureEnabled - either HIDDEN or PICTURE)
+ * if audioActive==false -> audioActive=true (new mode AUDIO)
+ * *** open handling if no audio file there (ignore key???) - currently empty player
+ * - BACK if mode AUDIO -> audioEnabled=false, justPlaying=false
+ * - BACK if mode PICTURE -> pictureEnabled=false;
+ * - player StreamEnd -> audioEnabled=false (new mode depends on pciture - either HIDDEN or PICTURE)
+ * info/banner handling:
+ * - AudioInfo - alternativ to pictureInfo
+ * off when disabling audio or after timer or with OK in AUDIO mode
+ * on currently any command or player event (end/new song) when audioEnabled==true and retriggerAudioInfo=true
+ * on on OK in AUDIO mode
+ * - Picture Info
+ * off when disabling Picture or after timer, OK, green
+ * on only on green when pictureEnabled==true
+ * - PictureBanner
+ * 2 modes: loading/normal
+ * normal:
+ * off when disabling picture, OK, after timer
+ * on when enabling picture, with OK
+ * loading:
+ * off when disabling picture and when loading done
+ * on on start loading
+ * *** open: do not show when audio enabled and slide show running (currently slideshow is paused)
+ * - AudioBanner
+ * always shown when audioEnabled=true
+ * on when enabling Audio
+ * off when disabling audio
+ * update in play
+ * timers: 1 - slide show
+ * 2 - pictureBanner
+ * 3 - info showtime
+ * 4 - audio short update
+ */
+
+#define DRAWING_THREAD
+
+Colour VMediaView::pictureBack=Colour(140,140,140);
+Colour VMediaView::infoBack=Colour(110,110,110);
+Colour VMediaView::audioBannerBack=Colour(110,110,110,20);
+//the jpeg reader
+
+//how long do we wait for a single picture chunk
+//the unit is 100ms (the timeout on the server side)
+#define MAXTRY 100
+class VPreader : public JpegReader {
+ private:
+ ImageReader *reader;
+ VMediaView * parent;
+ ULLONG size;
+ bool dobreak;;
+ public:
+ VPreader(VMediaView *p,ImageReader *r){
+ parent=p;
+ size=0;
+ reader=r;
+ dobreak=false;
+ };
+ virtual ULONG readChunk(ULONG offset,ULONG len,char ** buf) {
+ Log::getInstance()->log("VMediaView::jpegReader", Log::DEBUG, "read chunk o=%d,len=%d,buf=%p",
+ offset,len,*buf);
+ UINT numrec=0;
+ int rt=0;
+ for (int trycount=0;trycount < MAXTRY && ! dobreak && numrec == 0 && rt == 0;trycount++) {
+ if (dobreak) {
+ *buf=NULL;
+ rt=-1;
+ }
+ else {
+ rt=reader->getImageChunk((ULLONG)offset,(UINT)len,&numrec,(UCHAR **)buf);
+ }
+ }
+ Log::getInstance()->log("VMediaView::jpegReader", Log::DEBUG, "got n=%d,buf=%p,rt=%d",
+ numrec,*buf,rt);
+ return numrec;
+ }
+ virtual int initRead(const MediaURI *uri,ULLONG *sz,ULONG factor=100) {
+ Log::getInstance()->log("VMediaView::jpegReader", Log::DEBUG, "load image %s",uri->getDisplayName());
+ Video* video = Video::getInstance();
+ dobreak=false;
+ int rt=MediaPlayer::getInstance()->openMedium(1,uri,sz,video->getScreenWidth()*factor/100, video->getScreenHeight()*factor/100);
+ if (rt < 0) *sz=0;
+ size=*sz;
+ Log::getInstance()->log("VMediaView::jpegReader", Log::DEBUG, "load image %s returned %llu",uri->getDisplayName(),size);
+ return rt;
+ }
+ virtual ULONG getSize() {return size;}
+ //seems to be thread safe (more or less...)
+ void setBreak() {
+ dobreak=true;
+ }
+};
+
+/**
+ * a separate thread for drawing pictures
+ * will be started with the sfc and the draw control
+ * will send a player event when done
+ */
+class DrawingThread : public Thread_TYPE {
+ private:
+ VMediaView *_parent;
+ VPreader * _reader;
+ WJpeg::JpegControl *_ctl;
+ Surface *_sfc;
+ Colour _colour;
+ bool _interrupted;
+ public:
+ DrawingThread(VMediaView *parent) {
+ _parent=parent;
+ _reader=NULL;
+ _ctl=NULL;
+ _sfc=NULL;
+ _interrupted=false;
+ }
+ virtual ~DrawingThread(){}
+ bool isRunning() {
+ return (threadIsActive()!=0);
+ }
+ bool start(WJpeg::JpegControl *ctl,Surface *sfc,VPreader *reader,Colour &c) {
+ if (isRunning()) {
+ return false;
+ }
+ _interrupted=false;
+ _ctl=ctl;
+ _sfc=sfc;
+ _reader=reader;
+ _colour=c;
+ return (threadStart() == 1);
+ }
+ bool stop() {
+ Log::getInstance()->log("DrawingThread",Log::DEBUG,"stop initiated");
+ if (threadIsActive()) {
+ _interrupted=true;
+ if (_reader) _reader->setBreak();
+ threadStop();
+ }
+ Log::getInstance()->log("DrawingThread",Log::DEBUG,"stop done");
+ _reader=NULL;
+ return true;
+ }
+ protected:
+ virtual void threadMethod() {
+ Log::getInstance()->log("DrawingThread",Log::DEBUG,"started");
+ bool rt=WJpeg::drawJpeg(_ctl,_sfc,_reader,_colour);
+ _reader=NULL;
+ if (! _interrupted) {
+ Message* m = new Message();
+ //we misuse PLAYER_EVENT here
+ m->message = Message::PLAYER_EVENT;
+ m->to = _parent;
+ m->from = _parent;
+ m->parameter= rt?VMediaView::EVENT_DRAWINGDONE:VMediaView::EVENT_DRAWINGERROR;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+ }
+ Log::getInstance()->log("DrawingThread",Log::DEBUG,"finishing interrupt=%d",(int)_interrupted);
+ }
+ virtual void threadPostStopCleanup() {}
+
+};
+
+
+VMediaView::VMediaView(VMediaList *p)
+{
+ Log::getInstance()->log("VMediaView::VMediaView", Log::DEBUG, "p=%p", this);
+ audioEnabled=false;
+ pictureEnabled=false;
+ parent=p;
+ ireader=new ImageReader(1,MediaPlayer::getInstance());
+ reader=new VPreader(this,ireader);
+ //the surface handling
+ Video* video = Video::getInstance();
+ setSize(video->getScreenWidth(), video->getScreenHeight());
+ createBuffer();
+ sfc2=getSurface();
+ surface=NULL;
+ //create the second surface
+ createBuffer();
+ sfc1=getSurface();
+ originalh=area.h;
+ originalw=area.w;
+ //disable the surface
+ area.h=1;
+ area.w=1;
+ //banners and infos
+ pictureBanner=NULL;
+ slideshow=false;
+ pictureError=NULL;
+ currentPicture=NULL;
+ info=NULL;
+ pictureLoading=false;
+
+ //picture settings
+ showtime=INITIAL_SHOWTIME;
+ rotate=WJpeg::ROT_0;
+ currentScale=1;
+ options=MediaOptions::getInstance();
+ VColourTuner::initFactors();
+ int st=options->getIntOption("SlideShowInterval");
+ if (st > 0) showtime=st;
+ ctl.area.w=originalw;
+ ctl.area.h=originalh;
+ ctl.enlarge=false;
+ ctl.scaleafter=options->getIntOption("ScaleFactor");
+ const char * mode=options->getStringOption("PictureMode");
+ if (strcmp(mode,"clip") == 0) ctl.mode=WJpeg::CROP;
+ else if (strcmp(mode,"letter") == 0) ctl.mode=WJpeg::LETTER;
+ else if (strcmp(mode,"clipfactor") == 0) ctl.mode=WJpeg::CROPPERCENT;
+ ctl.scaleAmount=options->getIntOption("PictureSize");
+ if (ctl.scaleAmount < 10) ctl.scaleAmount=10;
+ if (ctl.scaleAmount > 200) ctl.scaleAmount=200;
+ ctl2=ctl;
+ cropmode=ctl.mode;
+ //current control is the one used for DISPLAY (not the one for drawing - this is the other one)
+ //this is closely coupled to the surface - i.e. ctl is for sfc1, ctl2 for sfc2
+ currentControl=&ctl;
+ bannerEnabled=true;
+ pictureShowing=false;
+
+ //audio player
+
+ barBlue.set(0, 0, 150, 150);
+ audioError=NULL;
+ currentAudio=NULL;
+ justPlaying=false;
+ playall=false;
+ retriggerAudioInfo=false;
+ audioBanner=NULL;
+ drawingThread=new DrawingThread(this);
+}
+
+VMediaView::~VMediaView()
+{
+ Log::getInstance()->log("VMediaView::~VMediaView", Log::DEBUG, "p=%p,secondSfc=%s", this,(secondSurface()?"true":"false"));
+ destroyPictureBanner();
+ if (currentPicture) delete currentPicture;
+ Timers::getInstance()->cancelTimer(this,1);
+ Timers::getInstance()->cancelTimer(this,2);
+ Timers::getInstance()->cancelTimer(this,3);
+ Timers::getInstance()->cancelTimer(this,4);
+ Timers::getInstance()->cancelTimer(this,5);
+ destroyInfo();
+ destroyAudioBanner();
+ if (getPlayer(false)) {
+ AudioPlayer::getInstance(NULL,false)->shutdown();
+ }
+ if (currentAudio) delete currentAudio;
+ drawingThread->stop();
+ ireader->shutdown();
+ delete ireader;
+ delete reader;
+ if (secondSurface()) {
+ delete sfc1;
+ sfc1=NULL;
+ }
+ else {
+ delete sfc2;
+ sfc2=NULL;
+ }
+ MediaPlayer::getInstance()->closeMediaChannel(1);
+ MediaPlayer::getInstance()->closeMediaChannel(2);
+ Log::getInstance()->log("VMediaView::~VMediaView", Log::DEBUG, "done p=%p", this);
+}
+
+void VMediaView::setPictureMode(bool act) {
+ Log::getInstance()->log("VMediaView", Log::DEBUG, "set pictureMode %d p=%d, a=%d", (int)act,(int)pictureEnabled,(int)audioEnabled);
+ if ( act) {
+ if ( ! pictureEnabled && ! audioEnabled) {
+ area.h=originalh;
+ area.w=originalw;
+ showPictureBanner();
+ parent->updateAll();
+ }
+ if (! pictureEnabled) {
+ //we newly enable the picture - so clear the screen
+ draw();
+ BoxStack::getInstance()->update(this);
+ if (slideshow) startSlideshow();
+ }
+ }
+ else
+ {
+ if ( pictureEnabled) {
+ destroyPictureBanner();
+ stopSlideshow(false);
+#ifdef DRAWING_THREAD
+ drawingThread->stop();
+#endif
+ if (! audioEnabled) {
+ destroyInfo();
+ area.w=1;
+ area.h=1;
+ draw();
+ parent->updateAll();
+ }
+ }
+ pictureShowing=false;
+ }
+ pictureEnabled=act;
+}
+
+//we can disable audio without automatically hiding us
+//this will become strange - we are visible but do not handle
+//keys - so if you call setAudioMode(false,false) be sure
+//to call setAudioMode(false,true) afterwards
+//it is only here to give the list a chance to start a new play
+//when we call directoryDone
+void VMediaView::setAudioMode(bool act,bool doHiding) {
+ Log::getInstance()->log("VMediaView", Log::DEBUG, "setAudioMode %d p=%d, a=%d", (int)act,(int)pictureEnabled,(int)audioEnabled);
+ if ( act) {
+ if (! audioEnabled) {
+ if (! pictureEnabled) {
+ area.w=originalw;
+ area.h=originalh;
+ draw(); //empty screen if no picture
+ parent->updateAll();
+ }
+ destroyPictureBanner();
+
+ }
+ audioEnabled=true;
+ showAudioBanner();
+ showAudioInfo();
+ }
+ else
+ {
+ if ( audioEnabled) {
+ audioEnabled=false;
+ destroyInfo();
+ destroyAudioBanner();
+ }
+ if (! pictureEnabled && doHiding) {
+ area.w=1;
+ area.h=1;
+ draw();
+ parent->updateAll();
+ }
+ else {
+ //picture now on top
+ if (havePictureBanner && ! pictureBanner) showPictureBanner();
+ }
+ }
+}
+
+
+
+void VMediaView::draw()
+{
+ Log::getInstance()->log("VMediaView::draw", Log::DEBUG, "pictureError=%s,p=%p", pictureError,this);
+
+ if (pictureShowing ) fillColour(pictureBack);
+ else fillColour(Colour::BLACK);
+ if (pictureError) {
+ drawText(pictureError,100,area.h/2,Colour::LIGHTTEXT);
+ return;
+ }
+}
+
+
+int VMediaView::handleCommand(int command)
+{
+ Log::getInstance()->log("VMediaView::handleCommand", Log::DEBUG, "cmd=%d,p=%p", command,this);
+ if ( !audioEnabled && ! pictureEnabled ) {
+ //only handle YELLOW
+ if (command == Remote::YELLOW) {
+ setAudioMode(true);
+ return 1;
+ }
+ return 0;
+ }
+ if ( ! audioEnabled) {
+ //------------------------- command in mode PICTURE (i.e. picture is on top) ----------------
+ //picture on top
+ int rt=1;
+ switch(command)
+ {
+ case Remote::DF_UP:
+ case Remote::UP:
+ case Remote::SKIPBACK:
+ rotate=WJpeg::ROT_0;
+ showPicture(VMediaList::MV_PREV,slideshow,true);
+ rt= 2;
+ break;
+ case Remote::FORWARD:
+ if (showtime > 1) showtime--;
+ updatePictureBanner(true);
+ break;
+ case Remote::DF_DOWN:
+ case Remote::DOWN:
+ case Remote::SKIPFORWARD:
+ rotate=WJpeg::ROT_0;
+ showPicture(VMediaList::MV_NEXT,slideshow,true);
+ rt= 2;
+ break;
+ case Remote::REVERSE:
+ if (showtime < 50 ) showtime++;
+ updatePictureBanner(true);
+ break;
+ case Remote::OK:
+ {
+ if (pictureBanner) {
+ destroyPictureBanner();
+ destroyInfo();
+ havePictureBanner=false;
+ }
+ else {
+ havePictureBanner=true;
+ showPictureBanner(pictureLoading);
+ }
+ rt= 2;
+ }
+ break;
+ case Remote::PLAY:
+ {
+ slideshow=true;
+ rotate=WJpeg::ROT_0;
+ showPicture(VMediaList::MV_NEXT,slideshow,true);
+ rt= 2;
+ }
+ break;
+ case Remote::PAUSE:
+ if (slideshow) {
+ stopSlideshow(true);
+ updatePictureBanner();
+ }
+ else {
+ slideshow=true;
+ rotate=WJpeg::ROT_0;
+ showPicture(VMediaList::MV_NEXT,slideshow,true);
+ }
+ rt= 2;
+ break;
+ case Remote::STOP:
+ stopSlideshow(true);
+ showtime=INITIAL_SHOWTIME;
+ updatePictureBanner();
+ rt= 2;
+ break;
+ case Remote::RED:
+ switch(rotate) {
+ case WJpeg::ROT_0:
+ rotate=WJpeg::ROT_90;
+ break;
+ case WJpeg::ROT_90:
+ rotate=WJpeg::ROT_180;
+ break;
+ case WJpeg::ROT_180:
+ rotate=WJpeg::ROT_270;
+ break;
+ case WJpeg::ROT_270:
+ rotate=WJpeg::ROT_0;
+ break;
+ }
+ showPicture(VMediaList::MV_NONE,slideshow,true);
+ rt=2;
+ break;
+ case Remote::GREEN:
+ if (info) destroyInfo();
+ else showPictureInfo();
+ rt=2;
+ break;
+ case Remote::BLUE:
+ switch (cropmode) {
+ case WJpeg::CROP:
+ cropmode=WJpeg::LETTER;
+ break;
+ case WJpeg::LETTER:
+ cropmode=WJpeg::CROPPERCENT;
+ break;
+ default:
+ cropmode=WJpeg::CROP;
+ break;
+ }
+ showPicture(VMediaList::MV_NONE,slideshow,true);
+ rt=2;
+ break;
+ case Remote::MENU:
+ stopSlideshow(true);
+ destroyPictureBanner();
+ destroyInfo();
+ VColourTuner *ct=new VColourTuner();
+ BoxStack::getInstance()->add(ct);
+ ct->draw();
+ BoxStack::getInstance()->update(ct);
+ rt=2;
+ break;
+ case Remote::BACK:
+ {
+ setPictureMode(false);
+ rt= 2;
+ }
+ break;
+ case Remote::YELLOW:
+ {
+ setAudioMode(true);
+ }
+ }
+ return rt;
+ }
+ else
+ {
+ int rt=1;
+ bool updateInfo=false;
+ //------------------------- command in mode AUDIO (i.e. audio is on top) ----------------
+ switch(command)
+ {
+ case Remote::YELLOW:
+ setAudioMode(false);
+ rt=2;
+ break;
+ case Remote::DF_UP:
+ case Remote::UP:
+ play(playall,false,VMediaList::MV_PREV);
+ rt= 2;
+ break;
+ case Remote::FORWARD:
+ if (! audioError) getPlayer()->fastForward();
+ updateInfo=true;
+ rt=2;
+ break;
+ case Remote::DF_DOWN:
+ case Remote::DOWN:
+ play(playall,false,VMediaList::MV_NEXT);
+ rt= 2;
+ break;
+ case Remote::SKIPFORWARD:
+ if (! audioError) getPlayer()->skipForward(10);
+ rt=2;
+ break;
+ case Remote::SKIPBACK:
+ if (! audioError) getPlayer()->skipBackward(10);
+ rt=2;
+ break;
+ case Remote::REVERSE:
+ rt=2;
+ break;
+ case Remote::ZERO:
+ if (! audioError) getPlayer()->jumpToPercent(0);
+ rt=2;
+ break;
+ case Remote::ONE:
+ if (! audioError) getPlayer()->jumpToPercent(10);
+ rt=2;
+ break;
+ case Remote::TWO:
+ if (! audioError) getPlayer()->jumpToPercent(20);
+ rt=2;
+ break;
+ case Remote::THREE:
+ if (! audioError) getPlayer()->jumpToPercent(30);
+ rt=2;
+ break;
+ case Remote::FOUR:
+ if (! audioError) getPlayer()->jumpToPercent(40);
+ rt=2;
+ break;
+ case Remote::FIVE:
+ if (! audioError) getPlayer()->jumpToPercent(50);
+ rt=2;
+ break;
+ case Remote::SIX:
+ if (! audioError) getPlayer()->jumpToPercent(60);
+ rt=2;
+ break;
+ case Remote::SEVEN:
+ if (! audioError) getPlayer()->jumpToPercent(70);
+ rt=2;
+ break;
+ case Remote::EIGHT:
+ if (! audioError) getPlayer()->jumpToPercent(80);
+ rt=2;
+ break;
+ case Remote::NINE:
+ if (! audioError) getPlayer()->jumpToPercent(90);
+ rt=2;
+ break;
+ case Remote::OK:
+ case Remote::GREEN:
+ {
+ if (info) {
+ destroyInfo();
+ retriggerAudioInfo=false;
+ }
+ else {
+ retriggerAudioInfo=true;
+ showAudioInfo();
+ }
+ if (getPlayer()->getState() == AudioPlayer::S_ERROR) {
+ if (playall) play(playall,false,VMediaList::MV_NEXT);
+ }
+ rt= 2;
+ }
+ break;
+ case Remote::PLAY:
+ {
+ if (! audioError) getPlayer()->unpause();
+ updateInfo=true;
+ if (getPlayer()->getState() != AudioPlayer::S_ERROR) ;
+ else if (playall) play(playall,false,VMediaList::MV_NEXT);
+ rt= 2;
+ }
+ break;
+ case Remote::PAUSE:
+ if (! audioError) getPlayer()->pause();
+ updateInfo=true;
+ rt= 2;
+ break;
+ case Remote::STOP:
+ getPlayer()->stop();
+ justPlaying=false;
+ updateInfo=true;
+ rt= 2;
+ break;
+ case Remote::BACK:
+ {
+ getPlayer()->stop();
+ playall=false;
+ retriggerAudioInfo=false;
+ justPlaying=false;
+ setAudioMode(false);
+ if (! pictureShowing) setPictureMode(false); //could have been delayed
+ rt= 2;
+ }
+ break;
+ }
+ if (audioEnabled && updateInfo) updateAudioInfo();
+ return rt;
+ }
+}
+
+void VMediaView::processMessage(Message* m)
+{
+ Log::getInstance()->log("VMediaView::processMessage", Log::DEBUG, "cmd=%lu,p=%lu", m->message,m->parameter);
+ if (m->message == Message::MOUSE_MOVE)
+ {
+ ;
+ }
+ else if (m->message == Message::MOUSE_LBDOWN)
+ {
+
+ //check if press is outside this view! then simulate cancel
+ int x=(m->parameter>>16)-getScreenX();
+ int y=(m->parameter&0xFFFF)-getScreenY();
+ if (x<0 || y <0 || x>(int)getWidth() || y>(int)getHeight())
+ {
+ BoxStack::getInstance()->handleCommand(Remote::BACK); //simulate cancel press
+ }
+ }
+ else if (m->message = Message::PLAYER_EVENT) {
+ switch (m->parameter) {
+ case EVENT_SLIDESHOW:
+ if (! pictureEnabled) break; //old timer msg...
+ //if (! audioEnabled) {
+ if (true) {
+ if (slideshow) {
+ rotate=WJpeg::ROT_0;
+ showPicture(VMediaList::MV_NEXT,true,false);
+ startSlideshow();
+ }
+ }
+ break;
+ case EVENT_DRAWINGERROR:
+ drawingDone(true);
+ break;
+ case EVENT_DRAWINGDONE:
+ drawingDone(false);
+ break;
+ case EVENT_DIRECTORYDONE:
+ //just disable audio without (poetntially) hiding us
+ //this gives the list a chance to decide whether audio
+ //should be on top afterwards without showing the list
+ //immediately
+ setAudioMode(false,false);
+ parent->directoryDone();
+ if (! pictureShowing) setPictureMode(false);
+ if (! justPlaying) setAudioMode(false);
+ break;
+ case AudioPlayer::STREAM_ERR:
+ case AudioPlayer::STREAM_END:
+ if (playall) play(playall,false,VMediaList::MV_NEXT);
+ else {
+ setAudioMode(false);
+ justPlaying=false;
+ }
+ break;
+ case AudioPlayer::SHORT_UPDATE:
+ if (info && audioEnabled ) {
+ drawAudioClocks();
+ BoxStack::getInstance()->update(info,&clocksRegion);
+ BoxStack::getInstance()->update(info,&barRegion);
+ Timers::getInstance()->setTimerD(this, 4, 1);
+ }
+ break;
+ case AudioPlayer::NEW_SONG:
+ if (audioEnabled) updateAudioInfo();
+ break;
+ case AudioPlayer::CONNECTION_LOST:
+ if (audioEnabled) destroyInfo();
+ if (AudioPlayer *player=getPlayer(false)) {
+ player->shutdown();
+ player=NULL;
+ }
+ Command::getInstance()->connectionLost();
+ break;
+ }
+ }
+}
+
+
+VMediaView * VMediaView::createViewer(VMediaList * mparent) {
+ Log::getInstance()->log("VMediaView::createViewer", Log::DEBUG, "p=%p",
+ mparent);
+ VMediaView *vmn=new VMediaView(mparent);
+ BoxStack::getInstance()->add(vmn);
+ vmn->draw();
+ BoxStack::getInstance()->update(vmn);
+ return vmn;
+}
+
+void VMediaView::startSlideshow() {
+ slideshow=true;
+ if (! pictureLoading) Timers::getInstance()->setTimerD(this,1,showtime);
+}
+
+void VMediaView::stopSlideshow(bool hard) {
+ if (hard) slideshow=false;
+ Timers::getInstance()->cancelTimer(this,1);
+}
+
+
+void VMediaView::showPicture(ULONG move,bool bslideshow,bool activateBanner) {
+ pictureShowing=true;
+ setPictureMode(true);
+ stopSlideshow(true);
+#ifdef DRAWING_THREAD
+ drawingThread->stop();
+#endif
+ slideshow=bslideshow;
+ Media *newPicture=parent->getMedia(MEDIA_TYPE_PICTURE,move);
+ if ( ! newPicture) {
+ pictureShowing=false;
+ if (!audioEnabled) {
+ //within the event handler first directoryDone is called
+ //and afterwards everything is stopped if nothing new
+ sendCommandMsg(EVENT_DIRECTORYDONE);
+ }
+ slideshow=false;
+ }
+ else
+ {
+ pictureShowing=true;
+ if (currentPicture) {
+ delete currentPicture;
+ currentPicture=NULL;
+ }
+ currentPicture=newPicture;
+ loadPicture(currentPicture,activateBanner);
+ }
+}
+
+//the real picture drawing method
+//will start drawing on a new surface and will switch it wehn done
+
+int VMediaView::loadPicture(Media *md,bool activateBanner) {
+ pictureError=NULL;
+ if (! md) return 1;
+ if (! md->getURI()) {
+ pictureError=tr("No media found");
+ Log::getInstance()->log("VMediaView::load",Log::ERR,"no URI in media");
+ return 1;
+ }
+ Log::getInstance()->log("VMediaView::load", Log::DEBUG, "filename=%s,p=%p",
+ md->getURI()->getName(),this);
+ //do we have a pictureBanner?
+ havePictureBanner=pictureBanner!=NULL || activateBanner;
+ pictureLoading=true;
+#ifdef DRAWING_THREAD
+ if (!audioEnabled && havePictureBanner ) showPictureBanner(true);
+ drawingThread->stop();
+#else
+ showPictureBanner(true);
+#endif
+ ireader->stop();
+ ULLONG size=0;
+ int rtok=reader->initRead(md->getURI(),&size,ctl.scaleAmount); //scaleAmount is the same for both...
+ if (rtok == 0) {
+ //now we can really draw
+ //get the surface for drawing
+ Surface * drawSurface=NULL;
+ WJpeg::JpegControl *drawCtl=NULL;
+ getDrawingParam(drawSurface,drawCtl);
+ drawCtl->error[0]=0;
+ drawCtl->rotation=rotate;
+ drawCtl->mode=cropmode;
+ drawCtl->compressedSize=size;
+#ifdef DRAWING_THREAD
+ bool ok=drawingThread->start(drawCtl,drawSurface,reader,pictureBack);
+ if (! ok) {
+ Log::getInstance()->log("VMediaView::load", Log::ERR, "unable to start drawing thread");
+ pictureError=tr("JpegError");
+ pictureLoading=false;
+ destroyPictureBanner();
+ return 1;
+ }
+ return 0;
+#else
+ //here we could hand this over to the drawing thread
+ bool ok=WJpeg::drawJpeg(drawCtl,drawSurface,reader,pictureBack);
+ drawingDone(!ok);
+ return ok?0:1;
+#endif
+ }
+ pictureLoading=false;
+ return 1;
+}
+
+void VMediaView::drawingDone(bool hasError) {
+ pictureLoading=false;
+ destroyPictureBanner(); //disable loading indication (or real banner)
+ if (! hasError) {
+ switchSurface();
+ Log::getInstance()->log("VMediaView::drawingDone", Log::DEBUG, "success: sfc now=%p",surface);
+ pictureError=NULL;
+ //only show the pictureBanner if it was there before
+ if (havePictureBanner && ! audioEnabled) showPictureBanner();
+ Log::getInstance()->log("VMediaView::load", Log::DEBUG, "success" );
+ updatePictureInfo(); //will only do somethng if pictureEnabled
+ }
+ else
+ {
+ pictureError=tr("JpegError");
+ if (pictureEnabled) {
+ draw();
+ destroyInfo();
+ }
+ }
+ MediaPlayer::getInstance()->closeMediaChannel(1);
+#ifndef DRAWING_THREAD
+ if (audioEnabled) showAudioBanner();
+#endif
+ if (slideshow) startSlideshow();
+ BoxStack::getInstance()->update(this);
+}
+
+void VMediaView::showPictureBanner(bool loading) {
+ //we are in the main thread - so we can (and must) safely hard destroy/create the banner
+ Timers::getInstance()->cancelTimer(this,2);
+ if (! currentPicture) {
+ //hmm...
+ destroyPictureBanner(false);
+ return;
+ }
+ if (pictureBanner) destroyPictureBanner(false);
+ if (! pictureEnabled || ! bannerEnabled) return;
+ pictureBanner= new VPictureBanner(loading, slideshow);
+ pictureBanner->fillColour(infoBack);
+ if (! loading) {
+ int len=strlen(currentPicture->getFileName())+Media::TIMEBUFLEN+20;
+ char *buf=new char[len];
+ char tbuf[Media::TIMEBUFLEN];
+ SNPRINTF(buf,len,"%c%02ds%c %s %s " ,
+ slideshow?' ':'[',
+ showtime,
+ slideshow?' ':']',
+ currentPicture->getTimeString(tbuf),
+ currentPicture->getFileName()
+ );
+ pictureBanner->setText(buf);
+ delete [] buf;
+ }
+ else {
+ char *buf=new char[strlen(currentPicture->getDisplayName())+50];
+ SNPRINTF(buf,50,"%s %s",tr("Loading"), currentPicture->getDisplayName());
+ pictureBanner->setText(buf);
+ delete buf;
+ }
+ pictureBanner->draw();
+ if (! loading ) Timers::getInstance()->setTimerD(this,2,8);
+ BoxStack::getInstance()->add(pictureBanner);
+ BoxStack::getInstance()->update(pictureBanner);
+ }
+
+void VMediaView::destroyPictureBanner(bool fromTimer) {
+ if (pictureBanner) {
+ if (fromTimer) sendViewMsg(pictureBanner);
+ else BoxStack::getInstance()->remove(pictureBanner);
+ pictureBanner=NULL;
+ if (! fromTimer) Timers::getInstance()->cancelTimer(this,2);
+ }
+}
+void VMediaView::updatePictureBanner(bool loading) {
+ if (pictureBanner ) {
+ showPictureBanner(loading);
+ }
+}
+void VMediaView::timercall(int clientref) {
+ Log::getInstance()->log("VMediaView::timercall", Log::DEBUG, "id=%d",clientref);
+ switch(clientref)
+ {
+ case 4:
+ {
+ sendCommandMsg(AudioPlayer::SHORT_UPDATE);
+ break;
+ }
+ case 3:
+ {
+ Log::getInstance()->log("VMediaView::timercall", Log::DEBUG, "infoEnd");
+ destroyInfo(true);
+ if (audioEnabled) {
+ //we only did show the audio error info if audio is enabled
+ bool stillError=false;
+ if (AudioPlayer * player=getPlayer(false)) {
+ stillError=player->getState()==AudioPlayer::S_ERROR;
+ }
+ if (stillError) {
+ sendCommandMsg(AudioPlayer::STREAM_END);
+ }
+ }
+ break;
+ }
+ case 1:
+ if (! slideshow) return;
+ Log::getInstance()->log("VMediaView::timercall", Log::DEBUG, "slideshow");
+ sendCommandMsg(EVENT_SLIDESHOW);
+ break;
+ case 2:
+ Log::getInstance()->log("VMediaView::timercall", Log::DEBUG, "pictureBannerEnd");
+ destroyPictureBanner(true);
+ break;
+ }
+
+ }
+
+#define INFOBUF 2000
+void VMediaView::showPictureInfo(){
+ if (! pictureEnabled || audioEnabled) return;
+ if (info) destroyInfo();
+ if (! currentPicture) return;
+
+ info=new VInfo();
+ info->setTitleText(currentPicture->getFileName());
+ info->setDropThrough();
+ info->setSize(500, 300);
+ info->createBuffer();
+ info->setBorderOn(1);
+ info->setTitleBarOn(1);
+
+ if (Video::getInstance()->getFormat() == Video::PAL)
+ info->setPosition(100, 180);
+ else
+ info->setPosition(100, 150);
+ char buf[INFOBUF];
+ char tbuf[Media::TIMEBUFLEN];
+ //modes should come from mediaoptions...
+ const char *mode=NULL;
+ switch (currentControl->mode) {
+ case WJpeg::CROPPERCENT:
+ mode="clipfactor";
+ break;
+ case WJpeg::LETTER:
+ mode="letter";
+ break;
+ default:
+ mode="clip";
+ break;
+ }
+ const char *dirname=parent->getDirname(MEDIA_TYPE_PICTURE);
+ int ldir=0;
+ const char *prfx="";
+ if (dirname) ldir=strlen(dirname);
+ if (ldir > 35){
+ dirname=dirname+ldir-35;
+ prfx="...";
+ }
+ SNPRINTF(buf,INFOBUF,"%s= %s%s\n%s= %u x %u\n%s= %lu kBytes\n%s= %s\n%s= %u\n%s= %u%%\n%s= %s",
+ tr("Directory"), prfx,dirname,
+ tr("Format(px)"),currentControl->picw,currentControl->pich,
+ tr("Filesize"),currentControl->compressedSize/1000,
+ tr("Time"),currentPicture->getTimeString(tbuf),
+ tr("Rotation"),90*currentControl->finalRotation,
+ tr("Scale"),currentControl->scale,
+ tr("Picture Mode"),mode );
+ info->setMainText(buf);
+ info->draw();
+ BoxStack::getInstance()->add(info);
+ BoxStack::getInstance()->update(info);
+ Timers::getInstance()->setTimerD(this,3,8);
+}
+void VMediaView::updatePictureInfo(){
+ if (info) {
+ showPictureInfo();
+ }
+}
+void VMediaView::destroyInfo(bool fromTimer){
+ if (info) {
+ if (! fromTimer) {
+ Log::getInstance()->log("VMediaView",Log::DEBUG,"remove info %p",info);
+ BoxStack::getInstance()->remove(info);
+ }
+ else {
+ Log::getInstance()->log("VMediaView",Log::DEBUG,"trigger remove info %p",info);
+ sendViewMsg(info);
+ }
+ info=NULL;
+ }
+ if (! fromTimer) Timers::getInstance()->cancelTimer(this,3);
+ if (! fromTimer) Timers::getInstance()->cancelTimer(this,4);
+}
+
+void VMediaView::sendViewMsg(Boxx *v) {
+ Message* m = new Message();
+ m->message = Message::CLOSE_ME;
+ m->to = BoxStack::getInstance();
+ m->from = v;
+ m->parameter=(ULONG)v;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+}
+void VMediaView::sendCommandMsg(int command) {
+ Message* m = new Message();
+ //we misuse PLAYER_EVENT here
+ m->message = Message::PLAYER_EVENT;
+ m->to = this;
+ m->from = this;
+ m->parameter= command;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+}
+
+void VMediaView::enableBanner(bool enable) {
+ bannerEnabled=false;
+ updatePictureBanner();
+}
+
+void VMediaView::getDrawingParam(Surface *&sfc,WJpeg::JpegControl *&c){
+ if (secondSurface()) {
+ //we currently display on sfc2
+ sfc=sfc1;
+ c=&ctl;
+ }
+ else {
+ sfc=sfc2;
+ c=&ctl2;
+ }
+}
+void VMediaView::switchSurface(){
+ if (secondSurface()) {
+ //now we switch to sfc1
+ surface=sfc1;
+ currentControl=&ctl;
+ }
+ else {
+ surface=sfc2;
+ currentControl=&ctl2;
+ }
+}
+
+AudioPlayer * VMediaView::getPlayer(bool createIfNeeded)
+{
+ AudioPlayer* rt=AudioPlayer::getInstance(this,false);
+ if (! createIfNeeded && rt == NULL) return NULL;
+ if (rt == NULL) {
+ rt=AudioPlayer::getInstance(this);
+ rt->run();
+ }
+ return rt;
+}
+
+bool VMediaView::isAudioPlaying() {
+ Log::getInstance()->log("VMediaView::isPlaying", Log::DEBUG, "rt=%s", justPlaying?"true":"false");
+ return justPlaying;
+}
+
+
+
+
+
+
+int VMediaView::play(bool all,bool activate,ULONG move,bool showInfo) {
+ int rt=0;
+ if (getPlayer(false)) getPlayer(false)->stop();
+ justPlaying=false;
+ if (currentAudio) delete currentAudio;
+ currentAudio=NULL;
+ playall=all;
+ currentAudio=parent->getMedia(MEDIA_TYPE_AUDIO,move);
+ audioError=NULL;
+ if ( ! currentAudio || ! currentAudio->getURI()) {
+ Log::getInstance()->log("VMediaView::load", Log::ERR, "no URI in media");
+ audioError=tr("no audio file");
+ if (audioEnabled) sendCommandMsg(EVENT_DIRECTORYDONE);
+ rt= -1;
+ }
+ else {
+ Log::getInstance()->log("VMediaView::load", Log::DEBUG, "filename=%s,p=%p",
+ currentAudio->getURI()->getName(),this);
+ int wseq=getPlayer()->play(currentAudio->getURI());
+ if (getPlayer()->waitForSequence(5,wseq)<0) {
+ audioError=tr("unable to open audio file");
+ rt= -1;
+ }
+ else {
+ justPlaying=true;
+ rt=0;
+ }
+ Log::getInstance()->log("VMediaView", Log::DEBUG, "player started for %s",currentAudio->getURI()->getName());
+ }
+ if (activate && ! audioEnabled){
+ if (showInfo) retriggerAudioInfo=true;
+ setAudioMode(true);
+ }
+ else {
+ //avoid duplicate creation of banner and info
+ showAudioBanner();
+ showAudioInfo();
+ }
+ if (activate && (! currentPicture || ! pictureShowing)) draw();
+ BoxStack::getInstance()->update(this);
+ return rt;
+}
+
+void VMediaView::showAudioInfo() {
+ if (! audioEnabled) return;
+ Timers::getInstance()->cancelTimer(this,4);
+ Timers::getInstance()->cancelTimer(this,3);
+ if (info) destroyInfo();
+ if (! retriggerAudioInfo) return;
+ drawAudioInfo();
+ bool playerError=getPlayer()->getState()==AudioPlayer::S_ERROR || audioError;
+ if (! playerError) Timers::getInstance()->setTimerD(this,3,AUDIOBANNER_TIME);
+ else Timers::getInstance()->setTimerD(this,3,AUDIOERROR_TIME);
+ if (! playerError) Timers::getInstance()->setTimerD(this,4, 1);
+ BoxStack::getInstance()->update(info);
+ }
+
+void VMediaView::updateAudioInfo() {
+ if (info) {
+ showAudioInfo();
+ }
+}
+
+void VMediaView::drawAudioInfo(){
+ Log::getInstance()->log("VMediaView",Log::DEBUG, "draw banner for %p",info);
+ const char *title=NULL;
+ char *playerTitle=NULL;
+ bool playerError=false;
+ int numlines=0;
+ int len=0;
+ int num=0;
+ const char *pl=tr("Playlist");
+ const char *first=NULL;
+ char *playerInfo=NULL;
+ if (audioError) {
+ if (getPlayer()->getState() == AudioPlayer::S_PLAY) audioError=NULL;
+ }
+ if (! currentAudio && ! audioError) audioError=tr("no audio file");
+ if (audioError ) {
+ title=tr("MediaError");
+ }
+ else {
+ playerTitle=getPlayer()->getTitle();
+ if (playerTitle) title=playerTitle;
+ else title=currentAudio->getDisplayName();
+ num=parent->getNumEntries(MEDIA_TYPE_AUDIO,currentAudio->index);
+ playerError=getPlayer()->getState() == AudioPlayer::S_ERROR;
+ //1more line for long dirs
+ numlines=playall?5:4;
+ }
+ if (playerError) {
+ numlines=3;
+ first=tr("Unable to play audio file");
+ len=strlen(first)+3;
+ }
+ else if (audioError) {
+ numlines=3;
+ first=audioError;
+ len=strlen(first)+3;
+ }
+ else {
+ playerInfo=getPlayer()->getID3Info();drawText(tr("Loading"),5,3,Colour::LIGHTTEXT);
+ len=strlen(currentAudio->getDisplayName())+strlen(pl)+30+strlen(parent->getDirname(MEDIA_TYPE_AUDIO))+Media::TIMEBUFLEN+110;
+ if (playerInfo) {
+ for (UINT i=0;i<strlen(playerInfo);i++)
+ if (playerInfo[i] == '\n') numlines++;
+ len+=strlen(playerInfo);
+ first=playerInfo;
+ }
+ else {
+ first="";
+ }
+ }
+ destroyInfo();
+ info=new VInfo();
+ UINT height=numlines*30+60;
+ UINT vheight=Video::getInstance()->getScreenHeight();
+ UINT vwidth=Video::getInstance()->getScreenWidth();
+ if (height > vheight-2*AUDIOBANNER_BOTTOM_MARGIN)
+ height=vheight-2*AUDIOBANNER_BOTTOM_MARGIN;
+ info->setSize(vwidth -2*AUDIOBANNER_X_MARGIN, height);
+ info->createBuffer();
+ if (Video::getInstance()->getFormat() == Video::PAL)
+ {
+ info->setPosition(AUDIOBANNER_X_MARGIN, vheight-height-AUDIOBANNER_BOTTOM_MARGIN);
+ }
+ else
+ {
+ info->setPosition(AUDIOBANNER_X_MARGIN, vheight-height-AUDIOBANNER_BOTTOM_MARGIN);
+ }
+
+ info->setTitleBarOn(0);
+ info->setDropThrough();
+ //from vvideorec
+ //set the regions for the closcks and bars on banner
+ barRegion.x = info->getWidth()-AUDIOBARLEN-20;
+ barRegion.y = info->getHeight() - 30; // FIXME, need to be - 1? and below?
+ barRegion.w = info->getWidth()-AUDIOBARLEN+10;
+ barRegion.h = 30;
+
+ clocksRegion.x = 130;
+ clocksRegion.y = barRegion.y + 3;
+ clocksRegion.w = 190;
+ clocksRegion.h = surface->getFontHeight();
+ Log::getInstance()->log("VMediaView",Log::DEBUG,"created AudioInfo %p",info);
+ BoxStack::getInstance()->add(info);
+ char *buf=new char [len];
+ if (playerError || audioError) {
+ SNPRINTF(buf,len,"%s",first);
+ }
+ else {
+ char tbuf[Media::TIMEBUFLEN];
+ if (playall) {
+ SNPRINTF(buf,len,"%s\n"
+ "%s:%s\n"
+ "%s: %d/%d\n"
+ "%s:%s\n"
+ "%s:%s\n",
+ first,
+ tr("FileName"),currentAudio->getDisplayName(),
+ pl,num,parent->getNumEntries(MEDIA_TYPE_AUDIO),
+ tr("Directory"),parent->getDirname(MEDIA_TYPE_AUDIO),
+ tr("Time"),currentAudio->getTimeString(tbuf));
+ }
+ else {
+ SNPRINTF(buf,len,"%s\n"
+ "%s:%s\n"
+ "%s:%s\n"
+ "%s:%s\n",
+ first,
+ tr("FileName"),currentAudio->getDisplayName(),
+ tr("Directory"),parent->getDirname(MEDIA_TYPE_AUDIO),
+ tr("Time"),currentAudio->getTimeString(tbuf));
+ }
+ }
+ Log::getInstance()->log("VMediaView",Log::DEBUG,"info: (%d)%s",strlen(buf),buf);
+ //now the real drawing functions
+ info->draw();
+ //title
+ info->rectangle(0, 0, info->getWidth(), 30, Colour::TITLEBARBACKGROUND);
+ info->drawText(title, 5, 5, Colour::LIGHTTEXT);
+ info->drawPara(buf,5,32,Colour::LIGHTTEXT);
+ delete [] buf;
+ if (! audioError) {
+ WSymbol w;
+ info->TEMPADD(&w);
+ int x=10;
+ int ybottom=info->getHeight();
+ info->rectangle(0, ybottom - barRegion.h, info->getWidth(), barRegion.h, Colour::TITLEBARBACKGROUND);
+ bool drawSymbol=true;
+ switch(getPlayer()->getState()) {
+ case AudioPlayer::S_PAUSE:
+ w.nextSymbol = WSymbol::PAUSE;
+ break;
+ case AudioPlayer::S_PLAY:
+ w.nextSymbol = WSymbol::PLAY;
+ break;
+ case AudioPlayer::S_DONE:
+ if (playall)
+ w.nextSymbol = WSymbol::PLAY;
+ else
+ drawSymbol=false;
+ break;
+ case AudioPlayer::S_BACK:
+ w.nextSymbol = WSymbol::FBWD ;
+ break;
+ case AudioPlayer::S_FF:
+ w.nextSymbol = WSymbol::FFWD ;
+ break;
+ default:
+ drawSymbol=false;
+ break;
+ }
+ if (drawSymbol) {
+ w.setPosition(x, ybottom-24);
+ w.draw();
+ }
+ else {
+ //stop symbol
+ info->rectangle(x, ybottom - 23, 18, 16, Colour::LIGHTTEXT);
+ }
+ x+=30;
+ drawAudioClocks();
+ }
+ if (playerInfo) delete playerInfo;
+ if (playerTitle) delete playerTitle;
+}
+
+void VMediaView::drawAudioClocks() {
+ if (! info || ! audioEnabled) return;
+ Log::getInstance()->log("VMediaView::drawAudioClocks", Log::DEBUG, "");
+ //draw clocks and bar
+ info->rectangle(clocksRegion, Colour::TITLEBARBACKGROUND);
+
+ time_t currentSec = (time_t)(getPlayer()->getCurrentTimes());
+ time_t lengthSec=(time_t)(getPlayer()->getSonglen());
+ struct tm cpos;
+ struct tm slen;
+/* gmtime_r(¤tSec,&cpos);
+ gmtime_r(&lengthSec,&slen);*/
+ cpos.tm_hour=currentSec/3600;
+ cpos.tm_min=(currentSec-cpos.tm_hour*3600)/60;
+ cpos.tm_sec=(currentSec-cpos.tm_hour*3600-cpos.tm_min*60);
+ slen.tm_hour=lengthSec/3600;;
+ slen.tm_min=(lengthSec-slen.tm_hour*3600)/60;
+ slen.tm_sec=(lengthSec-slen.tm_hour*3600-slen.tm_min*60);
+
+ char buffer[100];
+ if (currentSec >= lengthSec)
+ {
+ SNPRINTF(buffer,99, "-:--:-- / -:--:-- %03dk",getPlayer()->getCurrentBitrate()/1000);
+ }
+ else
+ {
+ SNPRINTF(buffer, 99, "%01i:%02i:%02i / %01i:%02i:%02i %03dk", cpos.tm_hour, cpos.tm_min, cpos.tm_sec, slen.tm_hour, slen.tm_min, slen.tm_sec,
+ getPlayer()->getCurrentBitrate()/1000);
+ //Log::getInstance()->log("VMediaView", Log::DEBUG, buffer);
+ }
+
+ info->drawText(buffer, clocksRegion.x, clocksRegion.y, Colour::LIGHTTEXT);
+
+ // Draw progress bar
+ int progBarXbase = 0;
+ int barlen=250;
+
+ info->rectangle(barRegion.x + progBarXbase, barRegion.y + 3, barlen+10, 24, Colour::LIGHTTEXT);
+ info->rectangle(barRegion.x + progBarXbase + 2, barRegion.y + 5, barlen+6, 20, barBlue);
+
+ if (currentSec > lengthSec) currentSec=lengthSec;
+ if (lengthSec == 0) return;
+
+ // Draw yellow portion
+ int progressWidth = (barlen+2) * currentSec / lengthSec;
+ info->rectangle(barRegion.x + progBarXbase + 4, barRegion.y + 7, progressWidth, 16, Colour::SELECTHIGHLIGHT);
+
+}
+
+void VMediaView::showAudioBanner() {
+ destroyAudioBanner();
+ if (! audioEnabled) return;
+ audioBanner=new VInfo();
+ Log::getInstance()->log("VMediaView",Log::DEBUG,"creating AudioBanner %p", audioBanner);
+ Video *v=Video::getInstance();
+ audioBanner->setSize(v->getScreenWidth()-100, 36);
+ audioBanner->createBuffer();
+ audioBanner->setPosition(50, v->getScreenHeight()-50);
+ audioBanner->fillColour(audioBannerBack);
+ audioBanner->setTitleBarOn(0);
+ audioBanner->setDropThrough();
+ if ( ! currentAudio || ! currentAudio->getDisplayName() || audioError) {
+ audioBanner->drawText(tr("AudioPlayer - not playing"),5,3,Colour::LIGHTTEXT);
+ }
+ else {
+ char * buf=new char[strlen(currentAudio->getDisplayName())+50];
+ SNPRINTF(buf,50,"%s %s",tr("AudioPlayer"),currentAudio->getDisplayName());
+ audioBanner->drawText(buf,5,3,Colour::LIGHTTEXT);
+ delete buf;
+ }
+ BoxStack::getInstance()->add(audioBanner);
+ BoxStack::getInstance()->update(audioBanner);
+}
+
+void VMediaView::destroyAudioBanner() {
+ if (audioBanner) {
+ Log::getInstance()->log("VMediaView",Log::DEBUG,"deleting AudioBanner %p",audioBanner);
+ BoxStack::getInstance()->remove(audioBanner);
+ audioBanner=NULL;
+ }
+}
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon, Andreas Vogel
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef VMEDIAVIEW_H
+#define VMEDIAVIEW_H
+
+#include <stdio.h>
+#include <string.h>
+#include <vector>
+
+#include "boxx.h"
+#include "timerreceiver.h"
+#include "vmedialist.h"
+#include "colour.h"
+#include "wjpeg.h"
+#include "imagereader.h"
+
+#define TESTCOLOURS
+class Message;
+class VInfo;
+class AudioPlayer;
+class DrawingThread;
+
+/**
+ * the picture viewer
+ * will ineract with the parent List for ff,back, slide show...
+ *
+*/
+class VPictureBanner;
+class MediaOptions;
+class VPreader;
+
+class VMediaView : public Boxx, public TimerReceiver
+{
+ friend class VPReader;
+ public:
+ ~VMediaView();
+
+ void processMessage(Message* m);
+ int handleCommand(int command);
+ void draw();
+ void timercall(int clientReference);
+ //factory method, create an instance (setting it disabled)
+ //return NULL on error
+ static VMediaView *createViewer(VMediaList * parent);
+ //show the picture currently selected in the parent
+ //potentially moving to next/previous one
+ void showPicture(ULONG move,bool bslideshow,bool forceBanner);
+
+ void enableBanner(bool enable);
+
+ //play audio
+ //if activate is false no info will be shown
+ int play(bool all,bool activate,ULONG move=VMediaList::MV_NONE,bool showInfo=false);
+
+ //check if the audio player is still running
+ //to decide wether to shutdown or not
+ bool isAudioPlaying();
+
+ //player event parameters - no interference with audioplayer! - so we start at 100
+ const static int EVENT_SLIDESHOW=100;
+ const static int EVENT_DRAWINGDONE=101;
+ const static int EVENT_DRAWINGERROR=102;
+ const static int EVENT_DIRECTORYDONE=103;
+
+ private:
+
+ /**
+ * Common functions
+ * *************************************************************
+ */
+ void setPictureMode(bool enabled);
+ void setAudioMode(bool enabled,bool doHiding=true);
+ //destroy a view (banner, info) - from timer calls
+ void sendViewMsg(Boxx *v);
+ //send command in main thread - especially if this view is not on top
+ void sendCommandMsg(int command);
+ VMediaList *parent;
+ VMediaView(VMediaList * plist);
+ bool audioEnabled;
+ bool pictureEnabled;
+
+
+
+ /**
+ * Picture viewer
+ * *************************************************************
+ */
+ const static int PICTUREBANNER_TIME=8;
+ //start a slideshow
+ void startSlideshow();
+ //stop the sliedshow
+ void stopSlideshow(bool hard=true);
+ //showXXX functions enable the corresponding banner and restart the timer
+ //updateXXX functions update the content but do not retrigger the timer
+ void showPictureBanner(bool loading=false);
+ void destroyPictureBanner(bool fromTimer=false);
+ void updatePictureBanner(bool loading=false);
+ void showPictureInfo();
+ void updatePictureInfo();
+ void destroyInfo(bool fromTimer=false);
+ int loadPicture(Media *m,bool forceBanner);
+ void getDrawingParam(Surface *&sfc,WJpeg::JpegControl *&ctl);
+ void switchSurface(); //will switch surface and currentControl
+ void drawingDone(bool hasError);
+
+ // Picture member variables
+ VPreader *reader; //the reader for the drawing part
+ ImageReader *ireader;//the buffered media reader
+ VPictureBanner *pictureBanner;
+ bool havePictureBanner; //dow we have a normal banner (except during loading)
+ bool pictureLoading;
+ bool pictureShowing; //set to false if loading next is impossible
+ bool slideshow;
+ int showtime;
+ const char * pictureError;
+ Media * currentPicture;
+ const static int INITIAL_SHOWTIME=5;
+ WJpeg::Rotation rotate;
+ WJpeg::ScaleMode cropmode;
+ VInfo * info;
+ static Colour pictureBack;
+ static Colour infoBack;
+ static Colour audioBannerBack;
+ int currentScale;
+ MediaOptions *options;
+ WJpeg::JpegControl ctl;
+ WJpeg::JpegControl ctl2;
+ WJpeg::JpegControl *currentControl;
+ Surface *sfc1;
+ Surface *sfc2;
+ //which is the active surface
+ bool secondSurface(){
+ return surface == sfc2;
+ }
+ UINT originalw;
+ UINT originalh;
+ bool bannerEnabled;
+
+ DrawingThread *drawingThread;
+ /**
+ * Audio player
+ * *************************************************************
+ */
+ const static int AUDIOBANNER_TIME=30;
+ const static int AUDIOERROR_TIME=5;
+
+
+ //margin on SCREEN on each side
+ const static int AUDIOBANNER_X_MARGIN=50;
+ //margin on bottom of screen
+ const static int AUDIOBANNER_BOTTOM_MARGIN=30;
+ //length of the progress bar
+ const static int AUDIOBARLEN=250;
+
+ //the AudioInfo uses the same member as the PictureInfo
+ //so only one of them can be active at the same time
+ void updateAudioInfo();
+ void showAudioInfo();
+ void drawAudioInfo();
+ void drawAudioClocks();
+ void showAudioBanner();
+ void destroyAudioBanner(); //currently not called from timer!
+ //get the player - create it if necessary
+ AudioPlayer* getPlayer(bool create=true);
+ bool playall;
+ const char * audioError;
+ Media * currentAudio;
+ bool justPlaying;
+ Region barRegion;
+ Region clocksRegion;
+ Colour barBlue;
+ //retrigger info on events?
+ bool retriggerAudioInfo;
+ VInfo *audioBanner;
+
+
+ };
+
+#endif
#include "option.h"
#include "vdr.h"
#include "command.h"
+#include "mediaoptions.h"
//#include "vdr.h"
//#include "command.h"
Video::getInstance()->addOptionPagesToWTB(&tabbar);
Audio::getInstance()->addOptionPagesToWTB(&tabbar);
+ MediaOptions::getInstance()->addOptionPagesToWTB(&tabbar);
wop = new WOptionPane();
Remote::getInstance()->saveOptionstoServer(); //Remote
Video::getInstance()->saveOptionstoServer(); //Video
Audio::getInstance()->saveOptionstoServer(); //Remote
+ MediaOptions::getInstance()->saveOptionstoServer(); //Media
// Damn, and the dynamic idea was going *so* well...
//Whats about a check with typeid operator?
+++ /dev/null
-/*
- Copyright 2004-2005 Chris Tallon, Andreas Vogel
-
- This file is part of VOMP.
-
- VOMP 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.
-
- VOMP 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 VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-*/
-
-#include <time.h>
-
-#include "vpicture.h"
-
-#include "vpicturebanner.h"
-#include "timers.h"
-#include "boxx.h"
-#include "wselectlist.h"
-#include "remote.h"
-#include "wsymbol.h"
-#include "boxstack.h"
-#include "vdr.h"
-#include "media.h"
-#include "video.h"
-#include "vinfo.h"
-#include "i18n.h"
-#include "message.h"
-#include "command.h"
-
-Colour VPicture::pictureBack=Colour(140,140,140);
-Colour VPicture::infoBack=Colour(110,110,110);
-//the jpeg reader
-
-class VPreader : public JpegReader {
- private:
- VPicture * parent;
- public:
- VPreader(VPicture *p){
- parent=p;};
- virtual ULONG readChunk(ULONG offset,ULONG len,char ** buf) {
- Log::getInstance()->log("VPicture::jpegReader", Log::DEBUG, "read chunk o=%d,len=%d,buf=%p",
- offset,len,*buf);
- UINT numrec=0;
- *buf=(char *)VDR::getInstance()->getImageBlock(offset,(UINT)len,&numrec);
- Log::getInstance()->log("VPicture::jpegReader", Log::DEBUG, "got n=%d,buf=%p",
- numrec,*buf);
- return numrec;
- }
- virtual ULONG initRead(const char *filename) {
- Log::getInstance()->log("VPicture::jpegReader", Log::DEBUG, "load image %s",filename);
- Video* video = Video::getInstance();
- ULONG size=VDR::getInstance()->loadImage(filename,video->getScreenWidth(), video->getScreenHeight());
- Log::getInstance()->log("VPicture::jpegReader", Log::DEBUG, "load image %s returned %d",filename,size);
- return size;
- }
-};
-
-VPicture::VPicture(VMediaList *p)
-{
- parent=p;
- reader=new VPreader(this);
- needDraw=false;
- Video* video = Video::getInstance();
- setSize(video->getScreenWidth(), video->getScreenHeight());
- createBuffer();
-// jpeg.setSurface(surface);
- jpeg.setDimensions(area.w,area.h);
- banner=NULL;
- fullname=NULL;
- filename=NULL;
- ftime=0;
- slideshow=false;
- showtime=INITIAL_SHOWTIME;
- mediaError=NULL;
- currentMedia=NULL;
- shortBanner=false;
- rotate=0;
- info=NULL;
- jpeg.setBackgroundColour(pictureBack);
- add(&jpeg);
-}
-
-void VPicture::preDelete()
-{
- Timers::getInstance()->cancelTimer(this,1);
- Timers::getInstance()->cancelTimer(this,2);
- Timers::getInstance()->cancelTimer(this,3);
-}
-
-VPicture::~VPicture()
-{
- delete reader;
- if (banner) BoxStack::getInstance()->remove(banner);
- if (fullname) delete fullname;
- if (filename) delete filename;
-
- destroyInfo();
-
-}
-
-void VPicture::draw()
-{
- Log::getInstance()->log("VPicture::draw", Log::DEBUG, "needDraw=%d,p=%p", needDraw,this);
- Boxx::draw();
-
- if (mediaError) {
- drawText(mediaError,20,area.h-10,Colour::LIGHTTEXT);
- return;
- }
-}
-
-
-int VPicture::handleCommand(int command)
-{
- Timers::getInstance()->cancelTimer(this,1);
- int rt=1;
- switch(command)
- {
- case Remote::DF_UP:
- case Remote::UP:
- case Remote::SKIPBACK:
- showPicture(VMediaList::MV_PREV);
- BoxStack::getInstance()->update(this);
- rt= 2;
- break;
- case Remote::FORWARD:
- if (showtime > 1) showtime--;
- updateBanner(true);
- break;
- case Remote::DF_DOWN:
- case Remote::DOWN:
- case Remote::SKIPFORWARD:
- showPicture(VMediaList::MV_NEXT);
- BoxStack::getInstance()->update(this);
- rt= 2;
- break;
- case Remote::REVERSE:
- if (showtime < 50 ) showtime++;
- updateBanner(true);
- break;
- case Remote::OK:
- {
- if (banner) {
- destroyBanner();
- destroyInfo();
- }
- else showBanner();
- rt= 2;
- }
- break;
- case Remote::PLAY:
- {
- slideshow=true;
- showPicture(VMediaList::MV_NEXT);
- BoxStack::getInstance()->update(this);
- rt= 2;
- }
- break;
- case Remote::PAUSE:
- slideshow=false;
- updateBanner();
- rt= 2;
- break;
- case Remote::STOP:
- slideshow=false;
- showtime=INITIAL_SHOWTIME;
- updateBanner();
- rt= 2;
- break;
- case Remote::RED:
- switch(rotate) {
- case WJpeg::ROT_0:
- rotate=WJpeg::ROT_90;
- break;
- case WJpeg::ROT_90:
- rotate=WJpeg::ROT_180;
- break;
- case WJpeg::ROT_180:
- rotate=WJpeg::ROT_270;
- break;
- case WJpeg::ROT_270:
- rotate=WJpeg::ROT_0;
- break;
- }
- showPicture(VMediaList::MV_NONE,rotate);
- BoxStack::getInstance()->update(this);
- rt=2;
- break;
- case Remote::GREEN:
- if (info) destroyInfo();
- else showInfo();
- rt=2;
- break;
- case Remote::BACK:
- {
- destroyBanner();
- rt= 4;
- }
- break;
- }
- if (slideshow) startSlideshow();
- // stop command getting to any more views
- return rt;
-}
-
-void VPicture::processMessage(Message* m)
-{
- if (m->message == Message::MOUSE_MOVE)
- {
- ;
- }
- else if (m->message == Message::MOUSE_LBDOWN)
- {
-
- //check if press is outside this view! then simulate cancel
- int x=(m->parameter>>16)-getScreenX();
- int y=(m->parameter&0xFFFF)-getScreenY();
- if (x<0 || y <0 || x>(int)getWidth() || y>(int)getHeight())
- {
- BoxStack::getInstance()->handleCommand(Remote::BACK); //simulate cancel press
- }
- }
-}
-
-VPicture * VPicture::createViewer(VMediaList * mparent, bool bslideshow) {
- Log::getInstance()->log("VPicture::createViewer", Log::DEBUG, "p=%p",
- mparent);
- VPicture *vmn=new VPicture(mparent);
- BoxStack::getInstance()->add(vmn);
- BoxStack::getInstance()->update(vmn);
- vmn->showPicture();
- if (bslideshow) vmn->startSlideshow();
- vmn->showBanner();
- BoxStack::getInstance()->update(vmn);
- return vmn;
-}
-
-void VPicture::startSlideshow() {
- slideshow=true;
- Timers::getInstance()->setTimerD(this,1,showtime);
-}
-
-void VPicture::showPicture(ULONG move, int rt) {
- rotate=rt;
- currentMedia=parent->getMedia(MEDIA_TYPE_PICTURE,move);
- load(currentMedia);
- if (mediaError || jpeg.hasError()) destroyInfo();
- else updateInfo();
- BoxStack::getInstance()->update(this);
-}
-
-
-int VPicture::load(Media *md) {
- jpeg.init(NULL,false,NULL);
- mediaError=tr("No media found");
- needDraw=false;
- if (! md) return 1;
- const char *fname=md->getFileName();
- ftime=md->getTime();
- int len=strlen(fname)+2+strlen(parent->getDirname());
- if (fullname) {
- delete fullname;
- fullname=NULL;
- }
- fullname=new char[len];
- sprintf(fullname,"%s/%s",parent->getDirname(),fname);
- if (filename) delete filename;
- len=strlen(fname)+1;
- filename=new char[len];
- strcpy(filename,fname);
- Log::getInstance()->log("VPicture::load", Log::DEBUG, "filename=%s,p=%p",
- fullname,this);
- VDR* vdr=VDR::getInstance();
- //do we have a banner?
- bool haveBanner=banner!=NULL && ! shortBanner;
- if (vdr->isConnected()) {
- showBanner(true);
- jpeg.init(fullname,false,reader);
- jpeg.setRotate(rotate);
- needDraw=true;
- mediaError=NULL;
- draw();
- //only show the banner if it was there before
- if (haveBanner) showBanner();
- else {
- if(banner) destroyBanner();
- }
- Log::getInstance()->log("VPicture::load", Log::DEBUG, "success: filename=%s,p=%p",
- fullname,this);
- return 0;
- }
- else {
- mediaError=tr("no VDR connection");
- }
- return 1;
-}
-
-void VPicture::showBanner(bool loading,int shortDisplay) {
- //we are in the main thread - so we can (and must) safely hard destroy/create the banner
- Timers::getInstance()->cancelTimer(this,2);
- if (! filename || ! currentMedia) {
- //hmm...
- destroyBanner(!loading);
- return;
- }
- if (banner) destroyBanner(!loading);
- banner= new VPictureBanner(this, loading, slideshow);
- banner->fillColour(infoBack);
- if (! loading) {
- int len=strlen(filename)+Media::TIMEBUFLEN+20;
- char *buf=new char[len];
- char tbuf[Media::TIMEBUFLEN];
- SNPRINTF(buf,len,"%c%02ds%c %s %s ",
- slideshow?' ':'[',
- showtime,
- slideshow?' ':']',
- currentMedia->getTimeString(tbuf),
- filename);
- banner->setText(buf);
- delete [] buf;
- }
- else {
- banner->setText(filename);
- }
- banner->draw();
- if (shortDisplay != 0) shortBanner=true;
- if (! slideshow && shortDisplay == 0) shortDisplay=8;
- //OK we start timer if we don't load and either shortDisplay or no slideshow
- if (! loading && shortDisplay != 0) Timers::getInstance()->setTimerD(this,2,shortDisplay);
- BoxStack::getInstance()->add(banner);
- BoxStack::getInstance()->update(banner);
-
- }
-
-void VPicture::destroyBanner(bool fromTimer) {
- shortBanner=false;
- if (banner) {
- if (fromTimer) sendViewMsg(banner,true);
- else BoxStack::getInstance()->remove(banner);
- banner=NULL;
- if (! fromTimer) Timers::getInstance()->cancelTimer(this,2);
- }
-}
-void VPicture::updateBanner(bool shortDisplay) {
- if (banner && ! shortBanner) {
- showBanner(false);
- }
- else if (shortDisplay) {
- showBanner(false,2);
- }
-}
-void VPicture::timercall(int clientref) {
- switch(clientref)
- {
- case 1:
- if (! slideshow) return;
- Log::getInstance()->log("VPicture::timercall", Log::DEBUG, "slideshow");
- sendCommandMsg(Remote::PLAY);
- break;
- case 2:
- destroyBanner(true);
- break;
- case 3:
- destroyInfo(true);
- break;
- }
-
- }
-
-#define INFOBUF 1000
-void VPicture::showInfo(){
- if (info) destroyInfo();
- if (! currentMedia) return;
-
- info=new VInfo();
- info->setTitleText(currentMedia->getFileName());
- info->setDropThrough();
- info->setSize(500, 300);
- info->createBuffer();
- info->setBorderOn(1);
- info->setTitleBarOn(1);
-
- if (Video::getInstance()->getFormat() == Video::PAL)
- info->setPosition(100, 180);
- else
- info->setPosition(100, 150);
- char buf[INFOBUF];
- char tbuf[Media::TIMEBUFLEN];
- SNPRINTF(buf,INFOBUF,"%s= %s\n%s= %ld x %ld\n%s= %ld kBytes\n%s= %s\n%s= %ld\n%s= 1/%ld",
- tr("Directory"), parent->getDirname(),
- tr("Format(px)"),jpeg.getJpegInfo(WJpeg::JPEG_WIDTH),jpeg.getJpegInfo(WJpeg::JPEG_HEIGHT),
- tr("Filesize"),jpeg.getJpegInfo(WJpeg::JPEG_SIZE)/1000,
- tr("Time"),currentMedia->getTimeString(tbuf),
- tr("Rotation"),90*jpeg.getJpegInfo(WJpeg::JPEG_ROTATE),
- tr("Scale"),jpeg.getJpegInfo(WJpeg::JPEG_SCALE));
- info->setMainText(buf);
- info->draw();
- sendViewMsg(info,false);
- Timers::getInstance()->setTimerD(this,3,8);
-}
-void VPicture::updateInfo(){
- if (info) {
- showInfo();
- }
-}
-void VPicture::destroyInfo(bool fromTimer){
- if (info) {
- sendViewMsg(info,true);
- info=NULL;
- }
- if (! fromTimer) Timers::getInstance()->cancelTimer(this,3);
-}
-
-void VPicture::sendViewMsg(Boxx *v,bool vdestroy) {
- Message* m = new Message();
- m->message = vdestroy?Message::CLOSE_ME:Message::ADD_VIEW;
- m->to = BoxStack::getInstance();
- m->from = v;
- m->parameter=(ULONG)v;
- Command::getInstance()->postMessageFromOuterSpace(m);
-}
-void VPicture::sendCommandMsg(int command) {
- Message* m = new Message();
- m->message = Message::UDP_BUTTON;
- m->to = Command::getInstance();
- m->from = this;
- m->parameter=command;
- Command::getInstance()->postMessageFromOuterSpace(m);
-}
+++ /dev/null
-/*
- Copyright 2004-2005 Chris Tallon, Andreas Vogel
-
- This file is part of VOMP.
-
- VOMP 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.
-
- VOMP 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 VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-*/
-
-#ifndef VPICTURE_H
-#define VPICTURE_H
-
-#include <stdio.h>
-#include <string.h>
-#include <vector>
-
-#include "boxx.h"
-#include "timerreceiver.h"
-#include "vmedialist.h"
-#include "colour.h"
-#include "wjpeg.h"
-
-class Message;
-class VInfo;
-
-/**
- * the picture viewer
- * will ineract with the parent List for ff,back, slide show...
- *
-*/
-class VPictureBanner;
-
-class VPicture : public Boxx, public TimerReceiver
-{
- public:
- ~VPicture();
-
- void preDelete();
- void processMessage(Message* m);
- int handleCommand(int command);
- void draw();
- void timercall(int clientReference);
- //factory method
- //return NULL on error
- static VPicture *createViewer(VMediaList * parent, bool startSlideshow=false);
- //show the picture currently selected in the parent
- //potentially moving to next/previous one
- void showPicture(ULONG move=VMediaList::MV_NONE,int rotate=WJpeg::ROT_0);
-
- //start a slideshow
- void startSlideshow();
-
-
- private:
- VPicture(VMediaList * plist);
- void showBanner(bool loading=false, int shortDisplayTime=0);
- void destroyBanner(bool fromTimer=false);
- void updateBanner(bool shortDisplay=false);
- void showInfo();
- void updateInfo();
- void destroyInfo(bool fromTimer=false);
- //add or destroy a view (banner, info)
- void sendViewMsg(Boxx *v,bool destroy=false);
- //send command in main thread
- void sendCommandMsg(int command);
- VMediaList *parent;
- int load(Media *m);
- JpegReader *reader;
- bool needDraw;
- WJpeg jpeg;
- VPictureBanner *banner;
- char * fullname;
- char * filename;
- ULONG ftime;
- bool slideshow;
- int showtime;
- const char * mediaError;
- Media * currentMedia;
- const static int INITIAL_SHOWTIME=5;
- bool shortBanner;
- int rotate;
- VInfo * info;
- static Colour pictureBack;
- static Colour infoBack;
-};
-
-#endif
#include "vpicturebanner.h"
-#include "vpicture.h"
#include "wsymbol.h"
#include "remote.h"
#include "colour.h"
#include "vinfo.h"
#include "boxstack.h"
#include "i18n.h"
+#include "log.h"
-VPictureBanner::VPictureBanner(VPicture *p, bool ld, bool sl)
+VPictureBanner::VPictureBanner(bool ld, bool sl)
{
- loading=ld;
+ shortInfo=ld;
slideshow=sl;
- parent=p;
Video *v=Video::getInstance();
setSize(v->getScreenWidth()-100, 36);
createBuffer();
void VPictureBanner::draw()
{
// View::draw();
- if (loading) {
+ if (shortInfo) {
if (info) {
- char *buf=new char[strlen(info)+100];
- sprintf(buf,"%s %s",tr("Loading"),info);
- drawText(buf,5,area.h-25,Colour::LIGHTTEXT);
- delete buf;
+ drawText(info,5,area.h-25,Colour::LIGHTTEXT);
}
else drawText(tr("Loading"),5,3,Colour::LIGHTTEXT);
}
x+=infsize+3;
WSymbol w;
TEMPADD(&w);
- if (slideshow) {
+ if (!slideshow) {
w.nextSymbol = WSymbol::PAUSE;
}
else {
class VPictureBanner : public TBBoxx
{
public:
- VPictureBanner(VPicture *p,bool loading, bool slideshow);
+ VPictureBanner(bool shortInfo, bool slideshow);
~VPictureBanner();
int handleCommand(int command);
void processMessage(Message* m);
void setText(const char * text);
private:
- VPicture * parent;
char * info;
- bool loading;
+ bool shortInfo;
bool slideshow;
int rotsize;
int infsize;
#include "remote.h"
#include "vinfo.h"
#include "i18n.h"
+#include "log.h"
VRadioRec::VRadioRec(Recording* rec)
{
#include "i18n.h"
#include "command.h"
#include "vinfo.h"
+#include "log.h"
VRecordingList::VRecordingList()
{
#include "vrecordingmenu.h"
#include "remote.h"
+#include "recinfo.h"
#include "vquestion.h"
#include "vinfo.h"
#include "vdr.h"
#include "boxstack.h"
#include "vdr.h"
#include "vinfo.h"
+#include "log.h"
VTimerList::VTimerList()
{
#include "timers.h"
#include "vepg.h"
#include "bitmap.h"
+#include "log.h"
VVideoLiveTV::VVideoLiveTV(ChannelList* tchanList, ULONG initialChannelNumber, VChannelList* tvchannelList)
{
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include "vvideomedia.h"
+#include "vmedialist.h"
+#include "media.h"
+#include "mediaplayer.h"
+
+#include "command.h"
+#include "osd.h"
+#include "wsymbol.h"
+#include "audio.h"
+#include "video.h"
+#include "timers.h"
+#include "playermedia.h"
+#include "recording.h"
+#include "vaudioselector.h"
+#include "message.h"
+#include "remote.h"
+#include "boxstack.h"
+#include "vinfo.h"
+#include "i18n.h"
+#include "log.h"
+#include "recinfo.h"
+
+//use the picture channel
+#define MEDIACHANNEL 1
+
+//we misuse PLAYER_EVENTS for timer messages
+//this should be larger then any player message
+#define PLAYER_TIMER_BASE 100
+
+VVideoMedia::VVideoMedia(Media* media, VMediaList *p)
+{
+ lparent=p;
+ boxstack = BoxStack::getInstance();
+ video = Video::getInstance();
+ timers = Timers::getInstance();
+ vas = NULL;
+ vsummary = NULL;
+ lengthBytes=0;
+ myMedia = new Media(media);
+
+ player = new PlayerMedia(this);
+ player->run();
+
+ videoMode = video->getMode();
+
+ playing = false;
+
+
+ setSize(video->getScreenWidth(), video->getScreenHeight());
+ createBuffer();
+ transparent.set(0, 0, 0, 0);
+ setBackgroundColour(transparent);
+
+ barRegion.x = 0;
+ barRegion.y = video->getScreenHeight() - 58; // FIXME, need to be - 1? and below?
+ barRegion.w = video->getScreenWidth();
+ barRegion.h = 58;
+
+ clocksRegion.x = barRegion.x + 140;
+ clocksRegion.y = barRegion.y + 12;
+ clocksRegion.w = 170;
+ clocksRegion.h = surface->getFontHeight();
+
+
+ barBlue.set(0, 0, 150, 150);
+
+ barShowing = false;
+ barGenHold = false;
+ barScanHold = false;
+ barVasHold = false;
+
+ dowss = false;
+ char* optionWSS = VDR::getInstance()->configLoad("General", "WSS");
+ if (optionWSS)
+ {
+ if (strstr(optionWSS, "Yes")) dowss = true;
+ delete[] optionWSS;
+ }
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Do WSS: %u", dowss);
+
+ if (dowss)
+ {
+ wss.setFormat(video->getFormat());
+ wss.setWide(true);
+ add(&wss);
+
+ wssRegion.x = 0;
+ wssRegion.y = 0;
+ wssRegion.w = video->getScreenWidth();
+ wssRegion.h = 300;
+ }
+}
+
+VVideoMedia::~VVideoMedia()
+{
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Entering destructor");
+
+ if (vas)
+ {
+ boxstack->remove(vas);
+ vas = NULL;
+ }
+
+ if (vsummary) {
+ remove(vsummary);
+ delete vsummary;
+ }
+
+ if (playing) stopPlay();
+ video->setDefaultAspect();
+
+ timers->cancelTimer(this, 1);
+ timers->cancelTimer(this, 2);
+
+ delete myMedia;
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "shutting down player");
+ player->shutdown();
+ delete player;
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "deleted");
+}
+
+void VVideoMedia::go(bool resume)
+{
+ ULONG startFrameNum=0;
+
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Starting stream: %s at frame: %lu", myMedia->getFileName(), startFrameNum);
+
+ lengthBytes = 0;
+
+ int rt=0;
+ const MediaURI *u=myMedia->getURI();
+ if (!u) {
+ Log::getInstance()->log("VVideoMedia", Log::ERR, "stream: %s has no URI", myMedia->getFileName());
+ rt=-1;
+ }
+ else {
+ rt=MediaPlayer::getInstance()->openMedium(MEDIACHANNEL,u,&lengthBytes,area.w,area.h);
+ }
+ if (rt==0)
+ {
+ //TODO: figure out len in frames
+ int seq=player->playNew(MEDIACHANNEL,lengthBytes,0);
+ int ok=player->waitForSequence(2,seq);
+ if (ok < 0) rt=-1;
+ else {
+ playing = true;
+ doBar(0);
+ }
+ }
+ if (rt != 0)
+ {
+ stopPlay(); // clean up
+
+ Message* m = new Message();
+ m->message = Message::CLOSE_ME;
+ m->from = this;
+ m->to = boxstack;
+ Command::getInstance()->postMessageNoLock(m);
+
+ VInfo* vi = new VInfo();
+ vi->setSize(400, 150);
+ vi->createBuffer();
+ if (video->getFormat() == Video::PAL)
+ vi->setPosition(170, 200);
+ else
+ vi->setPosition(160, 150);
+ vi->setExitable();
+ vi->setBorderOn(1);
+ vi->setTitleBarOn(0);
+ vi->setOneLiner(tr("Error playing media"));
+ vi->draw();
+
+ m = new Message();
+ m->message = Message::ADD_VIEW;
+ m->to = boxstack;
+ m->parameter = (ULONG)vi;
+ Command::getInstance()->postMessageNoLock(m);
+ }
+}
+
+int VVideoMedia::handleCommand(int command)
+{
+ switch(command)
+ {
+ case Remote::PLAY:
+ {
+ player->play();
+ doBar(0);
+ return 2;
+ }
+
+ case Remote::BACK:
+ {
+ if (vsummary)
+ {
+ removeSummary();
+ return 2;
+ }
+ } // DROP THROUGH
+ case Remote::STOP:
+ case Remote::MENU:
+ {
+ if (playing) stopPlay();
+
+ return 4;
+ }
+ case Remote::PAUSE:
+ {
+ player->pause();
+ doBar(0);
+ return 2;
+ }
+ case Remote::SKIPFORWARD:
+ {
+ doBar(3);
+ player->skipForward(60);
+ return 2;
+ }
+ case Remote::SKIPBACK:
+ {
+ doBar(4);
+ player->skipBackward(60);
+ return 2;
+ }
+ case Remote::FORWARD:
+ {
+ player->fastForward();
+ doBar(0);
+ return 2;
+ }
+ case Remote::REVERSE:
+ {
+ player->fastBackward();
+ doBar(0);
+ return 2;
+ }
+ case Remote::RED:
+ {
+ if (vsummary) removeSummary();
+ else doSummary();
+ return 2;
+ }
+ case Remote::GREEN:
+ {
+ doAudioSelector();
+ return 2;
+ }
+ case Remote::YELLOW:
+ {
+ doBar(2);
+ player->skipBackward(10);
+ return 2;
+ }
+ case Remote::BLUE:
+ {
+ doBar(1);
+ player->skipForward(10);
+ return 2;
+ }
+ case Remote::STAR:
+ {
+ doBar(2);
+ player->skipBackward(10);
+ return 2;
+ }
+ case Remote::HASH:
+ {
+ doBar(1);
+ player->skipForward(10);
+ return 2;
+ }
+ case Remote::FULL:
+ case Remote::TV:
+ {
+ toggleChopSides();
+ return 2;
+ }
+
+ case Remote::OK:
+ {
+ if (vsummary)
+ {
+ removeSummary();
+ return 2;
+ }
+
+ if (barShowing) removeBar();
+ else {
+ doBar(0);
+ barGenHold=true;
+ }
+ return 2;
+ }
+
+ case Remote::ZERO: player->jumpToPercent(0); doBar(0); return 2;
+ case Remote::ONE: player->jumpToPercent(10); doBar(0); return 2;
+ case Remote::TWO: player->jumpToPercent(20); doBar(0); return 2;
+ case Remote::THREE: player->jumpToPercent(30); doBar(0); return 2;
+ case Remote::FOUR: player->jumpToPercent(40); doBar(0); return 2;
+ case Remote::FIVE: player->jumpToPercent(50); doBar(0); return 2;
+ case Remote::SIX: player->jumpToPercent(60); doBar(0); return 2;
+ case Remote::SEVEN: player->jumpToPercent(70); doBar(0); return 2;
+ case Remote::EIGHT: player->jumpToPercent(80); doBar(0); return 2;
+ case Remote::NINE: player->jumpToPercent(90); doBar(0); return 2;
+
+
+ }
+
+ return 1;
+}
+
+void VVideoMedia::processMessage(Message* m)
+{
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Message received");
+
+ if (m->message == Message::MOUSE_LBDOWN)
+ {
+ UINT x = (m->parameter>>16) - getScreenX();
+ UINT y = (m->parameter&0xFFFF) - getScreenY();
+
+ if (!barShowing)
+ {
+ BoxStack::getInstance()->handleCommand(Remote::OK); //simulate rok press
+ }
+ else if (barRegion.x<=x && barRegion.y<=y && (barRegion.x+barRegion.w)>=x && (barRegion.y+barRegion.h)>=y)
+ {
+ int progBarXbase = barRegion.x + 300;
+ if (x>=barRegion.x + progBarXbase + 24
+ && x<=barRegion.x + progBarXbase + 4 + 302
+ && y>=barRegion.y + 12 - 2
+ && y<=barRegion.y + 12 - 2+28)
+ {
+ int cx=x-(barRegion.x + progBarXbase + 4);
+ double percent=((double)cx)/302.*100.;
+ player->jumpToPercent(percent);
+ doBar(3);
+ return;
+ // int progressWidth = 302 * currentFrameNum / lengthFrames;
+ // rectangle(barRegion.x + progBarXbase + 4, barRegion.y + 16, progressWidth, 16, Colour::SELECTHIGHLIGHT);
+ }
+ }
+ else
+ {
+ BoxStack::getInstance()->handleCommand(Remote::OK); //simulate rok press
+ }
+ }
+ else if (m->message == Message::PLAYER_EVENT)
+ {
+ switch(m->parameter)
+ {
+ case PlayerMedia::CONNECTION_LOST: // connection lost detected
+ {
+ // I can't handle this, send it to command
+ Message* m2 = new Message();
+ m2->to = Command::getInstance();
+ m2->message = Message::CONNECTION_LOST;
+ Command::getInstance()->postMessageNoLock(m2);
+ break;
+ }
+ case PlayerMedia::STREAM_END:
+ {
+ Message* m2 = new Message(); // Must be done after this thread finishes, and must break into master mutex
+ m2->to = BoxStack::getInstance();
+ m2->message = Message::CLOSE_ME;
+ Command::getInstance()->postMessageNoLock(m2);
+ break;
+ }
+ case PlayerMedia::STATUS_CHANGE:
+ doBar(0);
+ break;
+ case PlayerMedia::ASPECT43:
+ {
+ if (dowss)
+ {
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Received do WSS 43");
+ wss.setWide(false);
+ wss.draw();
+ boxstack->update(this, &wssRegion);
+ }
+ break;
+ }
+ case PlayerMedia::ASPECT169:
+ {
+ if (dowss)
+ {
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Received do WSS 169");
+ wss.setWide(true);
+ wss.draw();
+ boxstack->update(this, &wssRegion);
+ }
+ break;
+ }
+ case (PLAYER_TIMER_BASE+1) :
+ //timer1:
+ // Remove bar
+ removeBar();
+ break;
+ case (PLAYER_TIMER_BASE+2) :
+ //timer2:
+ // Update clock
+ if (!barShowing) break;
+ drawBarClocks();
+ BoxStack::getInstance()->update(this,&barRegion);
+ if (player->getLengthFrames() != 0) timers->setTimerD(this, 2, 0, 200000000);
+ else timers->setTimerD(this, 2, 1);
+ break;
+ }
+ }
+ else if (m->message == Message::AUDIO_CHANGE_CHANNEL)
+ {
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Received change audio channel to %i", m->parameter);
+ player->setAudioChannel(m->parameter);
+ }
+ else if (m->message == Message::CHILD_CLOSE)
+ {
+ if (m->from == vas)
+ {
+ vas = NULL;
+ barVasHold = false;
+ if (!barGenHold && !barScanHold && !barVasHold) removeBar();
+ }
+ }
+}
+
+void VVideoMedia::stopPlay()
+{
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Pre stopPlay");
+
+ removeBar();
+
+ player->stop();
+
+ playing = false;
+ MediaPlayer::getInstance()->closeMediaChannel(MEDIACHANNEL);
+
+ Log::getInstance()->log("VVideoMedia", Log::DEBUG, "Post stopPlay");
+}
+
+void VVideoMedia::toggleChopSides()
+{
+ if (video->getTVsize() == Video::ASPECT16X9) return; // Means nothing for 16:9 TVs
+
+ if (videoMode == Video::NORMAL)
+ {
+ videoMode = Video::LETTERBOX;
+ video->setMode(Video::LETTERBOX);
+ }
+ else
+ {
+ videoMode = Video::NORMAL;
+ video->setMode(Video::NORMAL);
+ }
+}
+
+void VVideoMedia::doAudioSelector()
+{
+ bool* availableMpegAudioChannels = player->getDemuxerMpegAudioChannels();
+ bool* availableAc3AudioChannels = 0;
+ int currentAudioChannel = player->getCurrentAudioChannel();
+ if (Audio::getInstance()->supportsAc3())
+ {
+ availableAc3AudioChannels = player->getDemuxerAc3AudioChannels();
+ }
+
+
+ RecInfo ri;
+ ri.summary=new char[strlen(myMedia->getDisplayName())+1];
+ strcpy(ri.summary,myMedia->getDisplayName());
+ vas = new VAudioSelector(this, availableMpegAudioChannels, availableAc3AudioChannels, currentAudioChannel, &ri);
+ vas->setBackgroundColour(barBlue);
+ vas->setPosition(0, barRegion.y - 120);
+
+// pal 62, ntsc 57
+
+ barVasHold = true;
+ doBar(0);
+
+ vas->draw();
+ boxstack->add(vas);
+ boxstack->update(vas);
+}
+
+void VVideoMedia::doBar(int action)
+{
+ Log::getInstance()->log("VVideoMedia",Log::DEBUG,"doBar %d",action);
+ barShowing = true;
+
+ rectangle(barRegion, barBlue);
+
+ /* Work out what to display - choices:
+
+ Playing >
+ Paused ||
+ FFwd >>
+ FBwd <<
+
+ Specials, informed by parameter
+
+ Skip forward 10s >|
+ Skip backward 10s |<
+ Skip forward 1m >>|
+ Skip backward 1m |<<
+
+ */
+
+ WSymbol w;
+ TEMPADD(&w);
+ w.nextSymbol = 0;
+ w.setPosition(barRegion.x + 66, barRegion.y + 16);
+
+ UCHAR playerState = 0;
+
+ if (action)
+ {
+ if (action == 1) w.nextSymbol = WSymbol::SKIPFORWARD;
+ else if (action == 2) w.nextSymbol = WSymbol::SKIPBACK;
+ else if (action == 3) w.nextSymbol = WSymbol::SKIPFORWARD2;
+ else if (action == 4) w.nextSymbol = WSymbol::SKIPBACK2;
+ }
+ else
+ {
+ playerState = player->getState();
+ if (playerState == PlayerMedia::S_PLAY) w.nextSymbol = WSymbol::PLAY;
+ else if (playerState == PlayerMedia::S_FF) w.nextSymbol = WSymbol::FFWD;
+ else if (playerState == PlayerMedia::S_BACK) w.nextSymbol = WSymbol::FBWD;
+ else if (playerState == PlayerMedia::S_SEEK) w.nextSymbol = WSymbol::RIGHTARROW;
+ else if (playerState == PlayerMedia::S_STOP) w.nextSymbol = WSymbol::PAUSE;
+ else w.nextSymbol = WSymbol::PAUSE;
+ }
+
+ w.draw();
+
+ if ((playerState == PlayerMedia::S_FF) || (playerState == PlayerMedia::S_BACK))
+ {
+ // draw blips to show how fast the scan is
+ UCHAR scanrate = 2;//player->getIScanRate();
+ if (scanrate >= 2)
+ {
+ char text[5];
+ SNPRINTF(text, 5, "%ux", scanrate);
+ drawText(text, barRegion.x + 102, barRegion.y + 12, Colour::LIGHTTEXT);
+ }
+ }
+
+ drawBarClocks();
+ boxstack->update(this, &barRegion);
+
+ timers->cancelTimer(this, 1);
+
+
+ if ((playerState == PlayerMedia::S_FF) || (playerState == PlayerMedia::S_BACK)) barScanHold = true;
+ else barScanHold = false;
+
+ if (!barGenHold && !barScanHold && !barVasHold) timers->setTimerD(this, 1, 4);
+
+ if (player->getLengthFrames() != 0) timers->setTimerD(this, 2, 0, 200000000);
+ else timers->setTimerD(this, 2, 1);
+}
+
+void VVideoMedia::timercall(int clientReference)
+{
+ Message *m=new Message();
+ m->message=Message::PLAYER_EVENT;
+ m->to=this;
+ m->from=this;
+ m->parameter=PLAYER_TIMER_BASE+clientReference;
+ Command::getInstance()->postMessageFromOuterSpace(m);
+}
+
+void VVideoMedia::drawBarClocks()
+{
+ if (barScanHold)
+ {
+ UCHAR playerState = player->getState();
+ // sticky bar is set if we are in ffwd/fbwd mode
+ // if player has gone to S_PLAY then kill stickyBar, and run doBar(0) which
+ // will repaint all the bar (it will call this function again, but
+ // this section won't run because stickyBarF will then == false)
+
+ if ((playerState != PlayerMedia::S_FF) && (playerState != PlayerMedia::S_BACK))
+ {
+ barScanHold = false;
+ doBar(0);
+ return;
+ }
+ }
+
+ Log* logger = Log::getInstance();
+ logger->log("VVideoMedia", Log::DEBUG, "Draw bar clocks");
+
+ // Draw RTC
+ // Blank the area first
+ rectangle(barRegion.x + 624, barRegion.y + 12, 60, 30, barBlue);
+ char timeString[20];
+ time_t t;
+ time(&t);
+ struct tm* tms = localtime(&t);
+ strftime(timeString, 19, "%H:%M", tms);
+ drawText(timeString, barRegion.x + 624, barRegion.y + 12, Colour::LIGHTTEXT);
+
+ ULLONG lenPTS=player->getLenPTS();
+ // Draw clocks
+
+ rectangle(clocksRegion, barBlue);
+
+ ULLONG currentPTS = player->getCurrentPTS();
+
+ hmsf currentFrameHMSF = ptsToHMS(currentPTS);
+ hmsf lengthHMSF = ptsToHMS(lenPTS);
+
+ char buffer[100];
+ if (currentPTS > lenPTS && lenPTS != 0)
+ {
+ strcpy(buffer, "-:--:-- / -:--:--");
+ }
+ else
+ {
+ SNPRINTF(buffer, 99, "%01i:%02i:%02i / %01i:%02i:%02i", currentFrameHMSF.hours, currentFrameHMSF.minutes, currentFrameHMSF.seconds, lengthHMSF.hours, lengthHMSF.minutes, lengthHMSF.seconds);
+ }
+ logger->log("VVideoMedia", Log::DEBUG, "cur %llu,len %llu, txt %s",currentPTS,lenPTS,buffer);
+
+ drawText(buffer, clocksRegion.x, clocksRegion.y, Colour::LIGHTTEXT);
+
+
+
+
+
+
+
+ // Draw progress bar
+ int progBarXbase = barRegion.x + 300;
+
+ if (lenPTS == 0) return;
+ rectangle(barRegion.x + progBarXbase, barRegion.y + 12, 310, 24, Colour::LIGHTTEXT);
+ rectangle(barRegion.x + progBarXbase + 2, barRegion.y + 14, 306, 20, barBlue);
+
+ if (currentPTS > lenPTS) return;
+
+ // Draw yellow portion
+ int progressWidth = 302 * currentPTS / lenPTS;
+ rectangle(barRegion.x + progBarXbase + 4, barRegion.y + 16, progressWidth, 16, Colour::SELECTHIGHLIGHT);
+
+}
+
+void VVideoMedia::removeBar()
+{
+ if (!barShowing) return;
+ timers->cancelTimer(this, 2);
+ barShowing = false;
+ barGenHold = false;
+ barScanHold = false;
+ barVasHold = false;
+ rectangle(barRegion, transparent);
+ BoxStack::getInstance()->update(this, &barRegion);
+}
+
+void VVideoMedia::doSummary()
+{
+ vsummary = new VInfo();
+ vsummary->setTitleText(myMedia->getDisplayName());
+ vsummary->setBorderOn(1);
+ vsummary->setExitable();
+ const MediaURI *u=myMedia->getURI();
+ int stlen=0;
+ if (u) {
+ stlen+=strlen(myMedia->getFileName());
+ stlen+=strlen(tr("FileName"))+10;
+ }
+ stlen+=strlen(tr("Size"))+50;
+ stlen+=strlen(tr("Directory"))+500;
+ stlen+=strlen(tr("Time"))+50;
+ char *pinfo=player->getInfo();
+ stlen+=strlen(pinfo)+10;
+ char buf[stlen];
+ char tsbuf[stlen];
+ char tsbuf2[stlen];
+ char tbuf[Media::TIMEBUFLEN];
+ snprintf(buf,stlen,"%s\n"
+ "%s: %llu Bytes\n"
+ "%s\n"
+ "%s: %s\n"
+ "%s",
+ shortendedText(tr("FileName"),": ",myMedia->getFileName(),tsbuf,vsummary->getWidth()),
+ tr("Size"),
+ lengthBytes,
+ shortendedText(tr("Directory"),": ",lparent->getDirname(MEDIA_TYPE_VIDEO),tsbuf2,vsummary->getWidth()),
+ tr("Time"),
+ myMedia->getTimeString(tbuf),
+ pinfo
+ );
+ //TODO more info
+ if (u) {
+ Log::getInstance()->log("VVideoMedia",Log::DEBUG,"info %s",buf);
+ vsummary->setMainText(buf);
+ }
+ else vsummary->setMainText(tr("Info unavailable"));
+ delete pinfo;
+ if (Video::getInstance()->getFormat() == Video::PAL)
+ {
+ vsummary->setPosition(70, 100);
+ }
+ else
+ {
+ vsummary->setPosition(40, 70);
+ }
+ vsummary->setSize(580, 350);
+ add(vsummary);
+ vsummary->draw();
+
+ BoxStack::getInstance()->update(this);
+}
+
+void VVideoMedia::removeSummary()
+{
+ if (vsummary)
+ {
+ remove(vsummary);
+ delete vsummary;
+ vsummary = NULL;
+ draw();
+ BoxStack::getInstance()->update(this);
+ }
+}
+
+
+hmsf VVideoMedia::ptsToHMS(ULLONG pts) {
+ ULLONG secs=pts/90000;
+ hmsf rt;
+ rt.frames=0;
+ rt.seconds=secs%60;
+ secs=secs/60;
+ rt.minutes=secs%60;
+ secs=secs/60;
+ rt.hours=secs;
+ return rt;
+}
+
+char * VVideoMedia::shortendedText(const char * title, const char * title2,const char * intext,char *buffer,UINT width) {
+ if (! intext) {
+ intext="";
+ }
+ UINT twidth=0;
+ for (const char *p=title;*p!=0;p++) twidth+=charWidth(*p);
+ for (const char *p=title2;*p!=0;p++) twidth+=charWidth(*p);
+ const char *prfx="...";
+ UINT prfwidth=3*charWidth('.');
+ const char *istart=intext+strlen(intext);
+ UINT iwidth=0;
+ while (twidth+iwidth+prfwidth < width-2*paraMargin && istart> intext) {
+ istart--;
+ iwidth+=charWidth(*istart);
+ }
+ if (twidth+iwidth+prfwidth >= width-2*paraMargin && istart < intext+strlen(intext)) istart++;
+ if (istart == intext) prfx="";
+ sprintf(buffer,"%s%s%s%s",title,title2,prfx,intext);
+ return buffer;
+}
+
+
--- /dev/null
+/*
+ Copyright 2004-2005 Chris Tallon
+
+ This file is part of VOMP.
+
+ VOMP 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.
+
+ VOMP 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 VOMP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#ifndef VVIDEOMEDIA_H
+#define VVIDEOMEDIA_H
+
+#include <stdio.h>
+
+#include "boxx.h"
+#include "timerreceiver.h"
+#include "wwss.h"
+#include "region.h"
+#include "colour.h"
+#include "video.h"
+
+class Timers;
+class PlayerMedia;
+class Recording;
+class VAudioSelector;
+class Message;
+class BoxStack;
+class VInfo;
+class Media;
+class VMediaList;
+
+
+class VVideoMedia : public Boxx, public TimerReceiver
+{
+ public:
+ VVideoMedia(Media* myMedia,VMediaList *lparent); //media has to contain URI
+ virtual ~VVideoMedia();
+ int handleCommand(int command);
+ void go(bool resume);
+
+ void timercall(int clientReference);
+ void processMessage(Message* m);
+
+
+
+ private:
+ BoxStack* boxstack;
+ Video* video;
+ Timers* timers;
+ PlayerMedia* player;
+ Media* myMedia;
+
+ VAudioSelector* vas;
+
+ Colour transparent;
+ Colour barBlue;
+
+ UCHAR videoMode;
+ void toggleChopSides();
+
+ bool playing;
+
+ bool barShowing;
+ bool barGenHold;
+ bool barScanHold;
+ bool barVasHold;
+
+ void doAudioSelector();
+ void doBar(int action);
+ void drawBarClocks();
+ void stopPlay();
+ void removeBar();
+ void doSummary();
+ void removeSummary();
+ //create an abbreviated text
+ //buffer must be len(title,intext)+3
+ //returns buffer
+ char * shortendedText(const char *title,const char *title2,const char *intext,char *buffer,UINT width);
+ hmsf ptsToHMS(ULLONG pts);
+ Region barRegion;
+ Region clocksRegion;
+
+
+ Wwss wss;
+ Region wssRegion;
+ bool dowss;
+
+ VInfo* vsummary;
+ VMediaList *lparent;
+ ULLONG lengthBytes;
+};
+
+#endif
#include "vinfo.h"
#include "i18n.h"
#include "bitmap.h"
-
+#include "recinfo.h"
+#include "log.h"
+
VVideoRec::VVideoRec(Recording* rec)
{
boxstack = BoxStack::getInstance();
#include "boxx.h"
#include "wjpeg.h"
#include <setjmp.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
#include "i18n.h"
#include "log.h"
#include "surface.h"
+extern "C"
+{
+ #include <jpeglib.h>
+}
-extern "C" void
-jpeg_memio_src (j_decompress_ptr cinfo, void * userdata);
-extern "C" void
-jpeg_memio_cleanup (j_decompress_ptr cinfo);
+//#define USE_BUFFER
+//#define EXTENDED_JPEGLIB
+
+//a struct to store user data for the jpeg decompressor
+class jpegUserData{
+ public:
+ WJpeg::JpegControl * ctl;
+ JpegReader *reader;
+ jpegUserData() {
+ ctl=NULL;
+ reader=NULL;
+ }
+ };
+
+//the scale factors supported by the jpeg lib
+
+struct scale{
+ UINT num;
+ UINT denom;
+};
+
+struct scale jpegFactors[]={
+#ifndef EXTENDED_JPEGLIB
+ {1,1},{1,2},{1,4},{1,8}
+#else
+ {1,1},{7,8},{3,4},{5,8},{1,2},{3,8},{1,4},{1,8}
+#endif
+};
+
#ifdef WIN32
+#define LocalReader WindowsResourceJpegReader
+class WindowsResourceJpegReader: public JpegReader {
+ public:
+ virtual ULONG initRead(const char *filename);
+ virtual ULONG readChunk(ULONG offset,ULONG len,char **buf);
+ virtual ULONG getSize();
+ virtual ~WindowsResourceJpegReader();
+protected:
+ HGLOBAL hres;
+ LPVOID buffer;
+ DWORD size;
+};
+
ULONG WindowsResourceJpegReader::initRead(const char *filename)
{
HRSRC res=FindResource(NULL,filename,RT_RCDATA);
size=0;
FreeResource(hres);
+ ULONG WindowsResourceJpegReader::getSize(){
+ return (ULONG)size;
}
-#endif
-
-WJpeg::WJpeg(){
- fileName=NULL;
-#ifndef WIN32
- reader=NULL;
#else
- reader=&winread;
-#endif
- useImageDimensions=true;
- jheight=0;
- jwidth=0;
- jsize=0;
- jerror=true;
- rotate=0;
- jscale=1;
-}
+#define LocalReader LocalJpegReader
+class LocalJpegReader: public JpegReader {
+ public:
+ virtual ULONG initRead(const char *filename);
+ virtual ULONG readChunk(ULONG offset,ULONG len,char **buf);
+ virtual ~LocalJpegReader();
+ virtual ULONG getSize();
+ LocalJpegReader();
+protected:
+ FILE *file;
+ ULONG size;
+};
-WJpeg::~WJpeg() {
- if (fileName) delete fileName;
+LocalJpegReader::LocalJpegReader(){
+ file=NULL;
+ size=0;
}
-int WJpeg::init(char* tfileName,bool useImage, JpegReader *rdr)
+ULONG LocalJpegReader::initRead(const char *filename)
{
- rotate=0;
- if (fileName) delete fileName;
- fileName=NULL;
- if (tfileName) {
- fileName = new char[strlen(tfileName)+1];
- strcpy(fileName,tfileName);
- }
- if (rdr!=NULL) {
- reader=rdr;
- } else {
-#ifdef WIN32
- reader=&winread;
-#else
- reader=NULL;
-#endif
- }
- useImageDimensions=useImage;
- return 1;
+ if (file) fclose(file);
+ size=0;
+ file=fopen(filename,"r");
+ if (file) {
+ struct stat st;
+ if (fstat(fileno(file), &st) != 0) return 0;
+ size= st.st_size;
+ return size;
+ }
+ Log::getInstance()->log("WJepg", Log::ERR, "localReader unable to open File %s", filename);
+ return 0;
}
-
-ULONG WJpeg::getJpegInfo(ULONG tag){
- switch(tag) {
- case JPEG_HEIGHT:
- return jheight;
- break;
- case JPEG_WIDTH:
- return jwidth;
- break;
- case JPEG_SIZE:
- return jsize;
- break;
- case JPEG_ROTATE:
- return rotate;
- break;
- case JPEG_SCALE:
- return jscale;
- break;
- }
- return 0;
+ULONG LocalJpegReader::readChunk(ULONG offset,ULONG len,char **buf)
+{
+ *buf=NULL;
+ ULONG bread=0;
+ if (file) {
+ ULLONG cpos=ftell(file);
+ if (offset != cpos) {
+ fseek(file,offset-cpos,SEEK_CUR);
+ }
+ if (offset != (ULONG)ftell(file)) {
+ Log::getInstance()->log("WJepg", Log::ERR, "readChunk pos = %lu not available", offset);
+ }
+ else {
+ *buf=(char *)malloc(len);
+ if ( ! (*buf)) {
+ Log::getInstance()->log("WJepg", Log::ERR, "readChunk pos = %lu not available", offset);
+ }
+ else {
+ bread=fread(*buf,1,len,file);
+ }
+ }
+ }
+ return bread;
}
-int WJpeg::getJpegInfo(ULONG tag, char * buffer) {
- switch (tag) {
- case JPEG_FILENAME:
- strncpy(buffer,fileName,INFO_BUFFER-1);
- buffer[INFO_BUFFER-1]=0;
- return 0;
- break;
- }
- return -1;
+LocalJpegReader::~LocalJpegReader(){
+ if (file) fclose(file);
+ file=NULL;
}
-
-void WJpeg::setRotate(int amount) {
- rotate=amount;
+ULONG LocalJpegReader::getSize(){
+ return size;
}
+#endif
-
+/*----------------------------------------------------------------
+ the jpeg lib routines
+ ----------------------------------------------------------------
+ */
extern "C" {
struct my_error_mgr {
- struct jpeg_error_mgr pub; /* "public" fields */
- FILE *infile; /* to be used in error handler */
+ struct jpeg_error_mgr pub; /* "public" fields */
- jmp_buf setjmp_buffer; /* for return to caller */
+ jmp_buf setjmp_buffer; /* for return to caller */
};
typedef struct my_error_mgr * my_error_ptr;
/* Always display the message. */
/* We could postpone this until after returning, if we chose. */
(*cinfo->err->output_message) (cinfo);
- if (myerr->infile) fclose(myerr->infile);
/* Return control to the setjmp point */
longjmp(myerr->setjmp_buffer, 1);
}
-}
-
-bool WJpeg::hasError() {
- return jerror;
-}
-void WJpeg::draw()
-{
- jerror=false;
- if (drawJpeg() != 0) {
- jerror=true;
- drawTextCentre(tr("Jpeg ERROR"), 240, 180, Colour::LIGHTTEXT);
- }
-}
-
-/* handle picture rotation
- 90: xr=h-y
- yr=x
- 180:xr=w-x
- yr=h-y
- 270:xr=y
- yr=w-x
-*/
-void WJpeg::drawPixel(int x, int y,int w,int h,int xpos, int ypos, const Colour& c){
- int xb=0;
- int yb=0;
- switch(rotate) {
- case ROT_0:
- xb=x;
- yb=y;
- break;
- case ROT_90:
- xb=h-y;
- yb=x;
- break;
- case ROT_180:
- xb=w-x;
- yb=h-y;
- break;
- case ROT_270:
- xb=y;
- yb=w-x;
- break;
- }
- xb+=xpos;
- yb+=ypos;
- if (xb < 0 || yb < 0 ) {
- Log::getInstance()->log("WJpeg:drawPixel",Log::ERR,"pixpos < 0 x=%d, y=%d",xb,yb);
- return;
- }
- Boxx::drawPixel((UINT)xb,(UINT)yb,c);
-}
-
-int WJpeg::drawJpeg() {
-//#ifndef WIN32
- Log* logger = Log::getInstance();
- unsigned char* buffer =NULL;
- struct jpeg_decompress_struct cinfo;
- struct my_error_mgr jerr;
- jerr.infile=NULL;
- cinfo.err = jpeg_std_error(&jerr.pub);
- jerr.pub.error_exit = my_error_exit;
- /* Establish the setjmp return context for my_error_exit to use. */
- if (setjmp(jerr.setjmp_buffer)) {
- /* If we get here, the JPEG code has signaled an error.
- * We need to clean up the JPEG object, close the input file, and return.
- */
- if (reader) jpeg_memio_cleanup(&cinfo);
- jpeg_destroy_decompress(&cinfo);
- logger->log("BJpeg", Log::ERR, "JPEG error");
- if (buffer) free(buffer);
- return 1;
- }
- int xpos=0;
- int ypos=0;
- jpeg_create_decompress(&cinfo);
- if (fileName && ! reader) {
- jsize=0; //TODO: compute size for local files
-#ifdef WIN32
- jerr.infile=fopen(fileName+1, "rb");
-#else
- jerr.infile=fopen(fileName, "rb");
-#endif
- if (jerr.infile == NULL)
- {
- logger->log("BJpeg", Log::ERR, "Can't open JPEG");
- jpeg_destroy_decompress(&cinfo);
- return 1;
- }
- logger->log("BJpeg", Log::DEBUG, "File opened");
- jpeg_stdio_src(&cinfo, jerr.infile);
- }
- else if (reader) {
- jsize=reader->initRead(fileName);
- if (jsize <= 0) {
- logger->log("BJpeg", Log::ERR, "Can't init JPEG transfer");
- jpeg_destroy_decompress(&cinfo);
- return 1;
- }
- jpeg_memio_src(&cinfo,(void *)reader);
- }
- else {
- logger->log("BJpeg", Log::ERR, "neither filename nor reader set");
- jpeg_destroy_decompress(&cinfo);
- return 1;
- }
- jpeg_read_header(&cinfo, TRUE);
- logger->log("BJpeg", Log::DEBUG, "JPEG read header w=%i h=%i, rot=%i", cinfo.image_width, cinfo.image_height, rotate);
- int picturew=cinfo.image_width;
- int pictureh=cinfo.image_height;
- switch (rotate){
- case ROT_90:
- case ROT_270:
- pictureh=cinfo.image_width;
- picturew=cinfo.image_height;
- break;
- }
- if (! useImageDimensions) {
- //scale - we can have factors 1,2,4,8
- int scalew=getWidth()*1000/picturew;
- int scaleh=getHeight()*1000/pictureh;
- int scale=scaleh;
- if (scalew < scaleh) scale=scalew;
- int fac=8;
- //we allow for 10% bigger...
- if (scale >= 900) fac=1;
- else if (scale >= 450 ) fac=2;
- else if (scale >= 225 ) fac=4;
- cinfo.scale_denom=fac;
- logger->log("BJpeg", Log::DEBUG, "JPEG scaling (1/1000) pw=%i ph=%i w=%i h=%i r=%i f=%i",
- getWidth(),
- getHeight(),
- scalew,scaleh,scale,fac);
- jscale=fac;
- }
-
- //remember picture parameters
- jheight=pictureh;
- jwidth=picturew;
-
- jpeg_start_decompress(&cinfo);
- //recompute width based on rotation (consider scale)
- picturew=cinfo.output_width;
- pictureh=cinfo.output_height;
- switch (rotate){
- case ROT_90:
- case ROT_270:
- pictureh=cinfo.output_width;
- picturew=cinfo.output_height;
- break;
- }
- //if our image is smaller - center it
- if (! useImageDimensions) {
- xpos=(((int)getWidth())-picturew)/2;
- if (xpos <0) xpos=0;
- ypos=(((int)getHeight())-pictureh)/2;
- if (ypos <0) ypos=0;
- }
- //center point for rotation
- int w=cinfo.output_width;
- int h=cinfo.output_height;
- logger->log("BJpeg", Log::DEBUG, "JPEG startup done pw=%i ph=%i, xo=%i,yo=%i, iw=%i, ih=%i", picturew, pictureh,xpos,ypos,w,h);
-
-
- if (useImageDimensions) setDimensions(picturew, pictureh);
- fillColour(backgroundColour);
-
-
- //line len in bytes (3 bytes per Pixel) - for buffer (can be bigger then surface)
- int linelen=cinfo.output_width*3;
-#ifdef USE_BUFFER
- // MAKE THE 2D ARRAY
- buffer = (unsigned char*)malloc(config.output_height * linelen);
- logger->log("BJpeg", Log::DEBUG, "Buffer allocated at %p, width = %i height = %i", buffer, cinfo.output_height, linelen);
- if (buffer == NULL) {
- if (reader) jpeg_memio_cleanup(&cinfo);
- jpeg_destroy_decompress(&cinfo);
- if (jerr.infile) fclose(jerr.infile);
- logger->log("BJpeg", Log::ERR, "JPEG error - no room for buffer");
- return 1;
- }
-#endif
-
- //unsigned char* bufferPointers[area.h];
- //for(UINT ps = 0; ps < area.h; ps++) bufferPointers[ps] = buffer + (ps * area.w * 3);
-
- logger->log("BJpeg", Log::DEBUG, "header w=%d,h=%d",cinfo.output_width,cinfo.output_height);
-#ifndef USE_BUFFER
- //unsigned char lbuf[linelen];
- unsigned char *lbuf=new unsigned char[linelen];
- unsigned char * ptr=lbuf;
-#else
- unsigned char * ptr=buffer;
-#endif
-
- int rowsread = 0;
-
- Colour c;
- startFastDraw();//Tell the surface, that we will draw a lot of pixel,
- //so that performance, can be optimized
- while (cinfo.output_scanline < cinfo.output_height)
- {
-// logger->log("BJpeg", Log::DEBUG, "%i", rowsread);
- rowsread += jpeg_read_scanlines(&cinfo,&ptr,1);
-#ifdef USE_BUFFER
- ptr+=linelen;
-#else
- int x=0;
- for (unsigned char * lp=ptr;lp < (ptr+linelen);lp+=3,x++) {
- c.red=*lp ;
- c.green=*(lp+1);
- c.blue=*(lp+2);
- drawPixel(x, rowsread-1,w,h,xpos,ypos, c);
- }
-
-#endif
- }
- endFastDraw();
-
- logger->log("BJpeg", Log::DEBUG, "Done all jpeg_read");
-
- jpeg_finish_decompress(&cinfo);
- if (reader) jpeg_memio_cleanup(&cinfo);
- jpeg_destroy_decompress(&cinfo);
-
- if (jerr.infile) fclose(jerr.infile);
-
- logger->log("BJpeg", Log::DEBUG, "jpeg shutdown done, x, y %u %u", area.w, area.h);
-#ifdef USE_BUFFER
- Colour c;
- UINT x, y, xoff;
- unsigned char* p;
- surface->startFastDraw();//Tell the surface, that we will draw a lot of pixel,
- //so that performance, can be optimized
- for (y = 0; y < numlines; y++)
- {
- p = bufferPointers[y];
-
- for (x = 0; x < sfclen; x++)
- {
- xoff = x * 3;
-
-// c = ( (0xFF000000 )
-// | (p[xoff ] << 16)
-// | (p[xoff + 1] << 8)
-// | (p[xoff + 2] ) );
-
- c.red = p[xoff];
- c.green = p[xoff + 1];
- c.blue = p[xoff + 2];
-
- drawPixel(x, y, w,h,xpos,ypos,c);
- }
- }
- surface->endFastDraw();
- delete [] lbuf;
- free(buffer);
-#endif
- logger->log("BJpeg", Log::DEBUG, "deleted buffer");
-/*#else
- DWORD width,height;
- width=height=1;
- if (!reader)
- {
- ((SurfaceWin*)surface)->drawJpeg(fileName+1,offsetX,offsetY,&width,&height);//This should went into the abstract base classes?
- //Windows has a problem with the leading / fixme
- } else {
- ULONG jsize;
- jsize=reader->initRead(fileName);
- char *buffer;
- if (jsize==reader->readChunk(0,jsize,&buffer))
- {
- ((SurfaceWin*)surface)->drawJpeg(buffer,jsize,offsetX,offsetY,&width,&height);//This should went into the abstract base classes?
- free(buffer);
- }
-
- }
-
- // setDimensions(width, height);
- jwidth=width;
- jheight=height;
-
-#endif*/
- return 0;
-}
-
-
-extern "C" {
ULONG jpeg_call_reader(ULONG offset,ULONG size,char ** buf,void *cb) {
- JpegReader *rd=(JpegReader *)cb;
- return rd->readChunk(offset,size,buf);
-}
+ jpegUserData *user=(jpegUserData *)cb;
+ return user->reader->readChunk(offset,size,buf);
}
//the memory buffer reader for the jpeg lib
//taken from jdatasrc.c
-extern "C" {
-/* Expanded data source object for stdio input */
#include "jinclude.h"
#include "jpeglib.h"
-#include "jerror.h"/* Expanded data source object for stdio input */
+#include "jerror.h"
+
typedef struct {
- struct jpeg_source_mgr pub; /* public fields */
+ struct jpeg_source_mgr pub; /* public fields */
- JOCTET * buffer; /* start of buffer */
- boolean start_of_file; /* have we gotten any data yet? */
+ JOCTET * buffer; /* start of buffer */
+ boolean start_of_file; /* have we gotten any data yet? */
void * userdata; /* used for callback */
ULONG offset;
} my_source_mgr;
typedef my_source_mgr * my_src_ptr;
-#define INPUT_BUF_SIZE (64*4096) /* choose an efficiently fread'able size */
+#define INPUT_BUF_SIZE (64*4096) /* choose an efficiently fread'able size */
/*
* This makes it unsafe to use this manager and a different source
* manager serially with the same JPEG object. Caveat programmer.
*/
- if (cinfo->src == NULL) { /* first time for this JPEG object? */
+ if (cinfo->src == NULL) { /* first time for this JPEG object? */
cinfo->src = (struct jpeg_source_mgr *)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
- SIZEOF(my_source_mgr));
+ SIZEOF(my_source_mgr));
src = (my_src_ptr) cinfo->src;
src->buffer = NULL;
}
src->buffer=NULL;
}
}
+
+//taken from mvpmc
+//http://git.mvpmc.org/cgi-bin/gitweb.cgi?p=mvpmc.git;a=blob_plain;h=02d4354c0cbbed802a9aa1478918a49fcbf61d00;f=libs/libwidget/image_jpeg.c
+
+#define GET2BYTES(cinfo, V, swap, offset) do { \
+ if (cinfo->src->bytes_in_buffer == 0) (*mysrc->pub.fill_input_buffer)(cinfo); \
+ cinfo->src->bytes_in_buffer--; \
+ V = (*cinfo->src->next_input_byte++) << (swap?0:8); \
+ if (cinfo->src->bytes_in_buffer == 0) (*mysrc->pub.fill_input_buffer)(cinfo); \
+ cinfo->src->bytes_in_buffer--; \
+ V += (*cinfo->src->next_input_byte++) << (swap?8:0); \
+ offset += 2; } while(0)
+
+#define GET4BYTES(cinfo, V, swap, offset) do { \
+ if (cinfo->src->bytes_in_buffer == 0) (*mysrc->pub.fill_input_buffer)(cinfo); \
+ cinfo->src->bytes_in_buffer--; \
+ V = (*cinfo->src->next_input_byte++) << (swap?0:24); \
+ if (cinfo->src->bytes_in_buffer == 0) (*mysrc->pub.fill_input_buffer)(cinfo); \
+ cinfo->src->bytes_in_buffer--; \
+ V += (*cinfo->src->next_input_byte++) << (swap?8:16); \
+ if (cinfo->src->bytes_in_buffer == 0) (*mysrc->pub.fill_input_buffer)(cinfo); \
+ cinfo->src->bytes_in_buffer--; \
+ V += (*cinfo->src->next_input_byte++) << (swap?16:8); \
+ if (cinfo->src->bytes_in_buffer == 0) (*mysrc->pub.fill_input_buffer)(cinfo); \
+ cinfo->src->bytes_in_buffer--; \
+ V += (*cinfo->src->next_input_byte++) << (swap?24:0); \
+ offset += 4; } while(0)
+
+static boolean
+get_exif_orient (j_decompress_ptr cinfo)
+/* Get the Exif orientation info */
+{
+ unsigned int tmp, offset, length, numtags;
+ int orient=-1;
+ boolean swap;
+ orient = 1;
+ offset = 0;
+ my_src_ptr mysrc = (my_src_ptr) cinfo->src;
+
+ /* marker length */
+ GET2BYTES(cinfo, length, 0, offset);
+ if (length<8) goto err;
+ /* Exif header */
+ GET4BYTES(cinfo, tmp, 0, offset);
+ if (tmp != 0x45786966) goto err;
+ GET2BYTES(cinfo, tmp, 0, offset);
+ if (tmp != 0x0000) goto err;
+ /* Byte-order */
+ GET2BYTES(cinfo, tmp, 0, offset);
+ if (tmp == 0x4949) swap = 1;
+ else if (tmp == 0x4d4d) swap = 0;
+ else goto err;
+ GET2BYTES(cinfo, tmp, swap, offset);
+ if (tmp != 0x002A) goto err;
+ /* offset to first IFD */
+ GET4BYTES(cinfo, tmp, swap, offset);
+ offset += tmp-8;
+ (*mysrc->pub.skip_input_data)(cinfo, tmp-8);
+ /* number of tags in IFD */
+ GET2BYTES(cinfo, numtags, swap, offset);
+ if (numtags == 0) goto err;
+
+ /* Search for Orientation Tag in IFD0 */
+ for (;;) {
+ if (offset > length-12) goto err;
+ GET2BYTES(cinfo, tmp, swap, offset);
+ if (tmp == 0x0112) break; /* found Orientation Tag */
+ if (--numtags == 0) goto err;
+ offset += 10;
+ (*mysrc->pub.skip_input_data)(cinfo, 10);
+ }
+ offset += 6;
+ (*mysrc->pub.skip_input_data)(cinfo, 6);
+ GET2BYTES(cinfo, orient, swap, offset);
+ if( orient==0 || orient>8 ) orient = 1;
+
+ Log::getInstance()->log("WJpeg", Log::DEBUG, "read exif orientation %u", orient);
+ jpegUserData * ud=(jpegUserData *)(mysrc->userdata);
+ switch(orient) {
+ case 3:
+ ud->ctl->exifRotation=WJpeg::ROT_180;
+ break;
+ case 6:
+ ud->ctl->exifRotation=WJpeg::ROT_90;
+ break;
+ case 8:
+ ud->ctl->exifRotation=WJpeg::ROT_270;
+ break;
+ }
+
+err:
+ (*mysrc->pub.skip_input_data)(cinfo, length-offset);
+ return TRUE;
+}
+}
+
+/*----------------------------------------------------------------
+ the implementation
+ ----------------------------------------------------------------
+ */
+
+
+WJpeg::WJpeg(){
+ reader=NULL;
+ owningReader=false;
+ errbuf[0]=0;
+}
+
+WJpeg::~WJpeg() {
+ if (owningReader && reader) delete reader;
+}
+
+int WJpeg::init(char* tfileName)
+{
+ if (owningReader && reader) delete reader;
+ errbuf[0]=0; //clean error state
+ LocalReader *myreader=new LocalReader();
+ reader=myreader;
+ owningReader=true;
+ ULONG psize=myreader->initRead(tfileName);
+ if (psize == 0) {
+ delete reader;
+ reader=NULL;
+ owningReader=false;
+ snprintf(errbuf,200,"unable to open %s",tfileName);
+ return 0;
+ }
+ return 1;
+}
+
+
+
+
+bool WJpeg::hasError() {
+ return (errbuf[0] != 0);
+}
+void WJpeg::draw()
+{
+ bool ok=false;
+ JpegControl ctl;
+ if (reader) {
+ Region myRegion;
+ Surface *sfc=getSurface(myRegion);
+ myRegion.w=area.w;
+ myRegion.h=area.h;
+ ctl.area=myRegion;
+ ctl.enlarge=true;
+ if (drawJpeg(&ctl,sfc,reader,backgroundColour) ) ok=true;
+ }
+ else {
+ snprintf(errbuf,200,"jpeg reader not initialized");
+ }
+ if (! ok) {
+ drawTextCentre(tr("Jpeg ERROR"), 240, 170, Colour::LIGHTTEXT);
+ if (errbuf[0] != 0) drawTextCentre(errbuf,240,200, Colour::LIGHTTEXT);
+ if (ctl.error[0] != 0) drawTextCentre(ctl.error,240,230, Colour::LIGHTTEXT);
+ }
+}
+
+/**
+ the main drawing function
+ this will read the pciture via the reader
+ and draw directly into the surface
+ it will compute an appropriate scale and set the infos in the
+ JpegControl structure
+**/
+
+bool WJpeg::drawJpeg(JpegControl * ctl,Surface * sfc,JpegReader *rdr, Colour & backgroundColour) {
+ Log* logger = Log::getInstance();
+ if (! rdr || ! sfc) {
+ logger->log("BJpeg", Log::ERR, "JPEG error rdr=NULL or sfc=NULL");
+ return false;
+ }
+ logger->log("BJpeg", Log::DEBUG, "draw Jpeg Started sfc=%p, rdr=%p",sfc,rdr);
+ unsigned char* buffer =NULL;
+ struct jpeg_decompress_struct cinfo;
+ struct my_error_mgr jerr;
+ cinfo.err = jpeg_std_error(&jerr.pub);
+ jerr.pub.error_exit = my_error_exit;
+ /* Establish the setjmp return context for my_error_exit to use. */
+ if (setjmp(jerr.setjmp_buffer)) {
+ /* If we get here, the JPEG code has signaled an error.
+ * We need to clean up the JPEG object, close the input file, and return.
+ */
+ if (rdr) jpeg_memio_cleanup(&cinfo);
+ jpeg_destroy_decompress(&cinfo);
+ logger->log("BJpeg", Log::ERR, "JPEG error");
+ if (buffer) free(buffer);
+ return false;
+ }
+ jpegUserData userdata;
+ int xpos=0;
+ int ypos=0;
+ jpeg_create_decompress(&cinfo);
+ userdata.reader=rdr;
+ userdata.ctl=ctl;
+ ctl->exifRotation=ROT_0;
+ ctl->error[0]=0;
+ ctl->exifDate[0]=0;
+ //create the input for the jpeg lib
+ jpeg_memio_src(&cinfo,(void *)(&userdata));
+ //processor for EXIF data
+ jpeg_set_marker_processor(&cinfo, JPEG_APP0+1, get_exif_orient);
+ //read in header info
+ jpeg_read_header(&cinfo, TRUE);
+ ctl->picw=cinfo.image_width;
+ ctl->pich=cinfo.image_height;
+ ctl->compressedSize=rdr->getSize();
+ //now we have important info available in ctl (pictuerw,h, exif orientation,size)
+ //compute rotation due to the defined enum values we can simply add them
+ ctl->finalRotation=(enum Rotation)((ctl->rotation+ctl->exifRotation)%4);
+ logger->log("BJpeg", Log::DEBUG, "JPEG read header w=%i h=%i, rot=%i", ctl->picw,ctl->pich,ctl->finalRotation);
+ //now we have to compute the scale
+ //input: ctl->picw,ctl->pich,ctl->finalRotation,ctl->mode,ctl->scaleAmount, ctl->scaleafter
+ // list of available jpeg scale factors
+ //out: scalenum,scaledenom,scaleafter
+
+ UINT picturew=ctl->picw;
+ UINT pictureh=ctl->pich;
+ switch (ctl->finalRotation){
+ case ROT_90:
+ case ROT_270:
+ pictureh=ctl->picw;
+ picturew=ctl->pich;
+ break;
+ default:
+ break;
+ }
+ UINT scalenum=1;
+ UINT scaledenom=1;
+ UINT scaleafter=1;
+ if (! ctl->enlarge) {
+ //scale - compute the factors to fit 100%
+ int scalew=1000*picturew/ctl->area.w;
+ int scaleh=1000*pictureh/ctl->area.h;
+ int scale=scaleh;
+ if (scalew > scaleh) scale=scalew;
+
+ //OK now find out which is the optimal setting
+ //rule: find settings being nearest to:
+ // mode=LETTER - smaller or equal screen size (i.e. scale*scalefactor <= 1000)
+ // mode=CROP - bigger or equal screen size (i.e. scale *scalefactor>= 1000)
+ // mode=CROPPERCENT - smaller or equal screensize*scaleamount (i.e. scale*scalefactor<= 1000*scaleamount)
+ // scaleamount is in % - so in reality we use scaleamount*10 instead scaleamount*1000
+ //the scalefactor computes as scalenum/(scaledenom*scaleafter)
+ scaledenom=8;
+ int minDiff=1000;
+ logger->log("BJpeg", Log::DEBUG, "start scaling screenw=%u, screenh=%u, pw=%u,ph=%u, scale=%d, mode=%d, %%=%u, after=%u",
+ ctl->area.w,ctl->area.h,picturew,pictureh,scale,(int)ctl->mode,ctl->scaleAmount, ctl->scaleafter);
+ for (UINT j=0;j<sizeof(jpegFactors)/sizeof(jpegFactors[0]);j++) {
+ for (UINT sa=1;sa<=ctl->scaleafter;sa++) {
+ int curf=(scale*jpegFactors[j].num)/(jpegFactors[j].denom*sa);
+ bool setThis=false;
+ logger->log("BJpeg", Log::DEBUG, "testing scale curf=%d,num=%u,denom=%u,after=%u,minDiff=%d",
+ curf,jpegFactors[j].num,jpegFactors[j].denom,sa,minDiff);
+ switch(ctl->mode) {
+ case CROP:
+ if (curf >= 1000 && curf < (minDiff +1000)) {
+ setThis=true;
+ minDiff=curf-1000;
+ }
+ break;
+ case LETTER:
+ if (curf <= 1000 && curf > (1000-minDiff)) {
+ setThis=true;
+ minDiff=1000-curf;
+ }
+ break;
+ case CROPPERCENT:
+ if (curf <= 10*(int)ctl->scaleAmount ) {
+ int abs=curf-1000;
+ if (abs < 0) abs=-abs;
+ if (abs < minDiff) {
+ setThis=true;
+ minDiff=abs;
+ }
+ }
+ break;
+ }
+ if (setThis) {
+ logger->log("BJpeg", Log::DEBUG, "testing scale curf=%d,take this",curf);
+ scalenum=jpegFactors[j].num;
+ scaledenom=jpegFactors[j].denom;
+ scaleafter=sa;
+ }
+ }
+ }
+ ctl->scale=100*scalenum/(scaledenom*scaleafter);
+
+ logger->log("BJpeg", Log::DEBUG, "JPEG scaling found scale=%i num=%i denom=%i after=%i result=%i scale=%i%% ",
+ scale,scalenum,scaledenom,scaleafter,scale*ctl->scale/100,ctl->scale);
+
+ cinfo.scale_denom=scaledenom;
+ cinfo.scale_num=scalenum;
+ }
+ else
+ {
+ //set drawing area according to picture
+ ctl->area.w=ctl->picw;
+ ctl->area.h=ctl->pich;
+ }
+
+ //now we know the scaling
+ //compute the scaled size and position
+
+ jpeg_start_decompress(&cinfo);
+ //picturew/h is now the output width from the decompressor and afterscaler
+ //this is unrotated
+ picturew=cinfo.output_width;
+ pictureh=cinfo.output_height;
+ if (scaleafter > 1) {
+ picturew=picturew/scaleafter;
+ pictureh=pictureh/scaleafter;
+ }
+ //if our image is smaller - center it
+ if (! ctl->enlarge) {
+ if (ctl->finalRotation == ROT_90 || ctl->finalRotation == ROT_270) {
+ int dim=pictureh;
+ xpos=(((int)ctl->area.w)-dim)/2;
+ dim=picturew;
+ ypos=(((int)ctl->area.h)-dim)/2;
+ } else {
+ int dim=picturew;
+ xpos=(((int)ctl->area.w)-dim)/2;
+ dim=pictureh;
+ ypos=(((int)ctl->area.h)-dim)/2;
+ }
+ if (xpos <0) xpos=0;
+ if (ypos <0) ypos=0;
+ }
+ xpos+=ctl->area.x;
+ ypos+=ctl->area.y;
+ //remember the jpeg dimensions for computing the buffer
+ UINT jpegwidth=cinfo.output_width;
+ UINT jpegheight=cinfo.output_height;
+ logger->log("BJpeg", Log::DEBUG, "JPEG startup done pw=%i ph=%i, xo=%i,yo=%i, jw=%i, jh=%i, rot=%d",
+ picturew, pictureh,xpos,ypos,jpegwidth,jpegheight,(int)ctl->finalRotation*90);
+
+ //fill the background
+ sfc->fillblt(ctl->area.x,ctl->area.y,ctl->area.w,ctl->area.h,backgroundColour.rgba());
+
+ //line len in bytes (3 bytes per Pixel) - for buffer (can be bigger then surface)
+ int linelen=jpegwidth*3;
+#ifdef USE_BUFFER
+ // MAKE THE 2D ARRAY
+ buffer = (unsigned char*)malloc(jpegheight * linelen);
+ logger->log("BJpeg", Log::DEBUG, "Buffer allocated at %p, lines = %i linelen = %i", buffer, jpegheight, linelen);
+ if (buffer == NULL) {
+ if (rdr) jpeg_memio_cleanup(&cinfo);
+ jpeg_destroy_decompress(&cinfo);
+ logger->log("BJpeg", Log::ERR, "JPEG error - no room for buffer");
+ snprintf(ctl->error,100,"no room for buffer");
+ return false;
+ }
+#endif
+
+#ifndef USE_BUFFER
+ //unsigned char lbuf[linelen];
+ unsigned char *lbuf=new unsigned char[linelen*scaleafter];
+ unsigned char * ptr=lbuf;
+ UINT outy=0;
+#else
+ unsigned char * ptr=buffer;
+#endif
+
+ int rowsread = 0;
+
+ Colour c;
+ sfc->startFastDraw();//Tell the surface, that we will draw a lot of pixel,
+ //so that performance, can be optimized
+ logger->log("BJpeg", Log::DEBUG, "start drawing ");
+ UINT colincr=0;
+ //factors to base 1024
+ UINT fac=1024;
+ if (scaleafter > 1) {
+ colincr=3*scaleafter-3;
+ fac=1024/(scaleafter*scaleafter);
+ }
+ logger->log("BJpeg", Log::DEBUG, "jpeg draw scale %d image: %u %u, picture: %u %u", scaleafter,picturew,pictureh,jpegwidth,jpegheight);
+ while (cinfo.output_scanline < jpegheight)
+ {
+// logger->log("BJpeg", Log::DEBUG, "%i", rowsread);
+ rowsread += jpeg_read_scanlines(&cinfo,&ptr,1);
+#ifdef USE_BUFFER
+ ptr+=linelen;
+#else
+ if (scaleafter > 1) {
+ if (rowsread % scaleafter != scaleafter-1) {
+ //this simple approach wold maybe forget scaleafter -1 lines at the end...
+ ptr+=linelen;
+ continue;
+ }
+ ptr=lbuf;
+ }
+ drawLine(sfc,ctl->finalRotation,ptr,scaleafter,picturew,pictureh,xpos,ypos,outy,linelen,colincr,scaleafter,fac);
+ outy++;
+
+#endif
+ }
+ sfc->endFastDraw();
+
+ logger->log("BJpeg", Log::DEBUG, "Done all jpeg_read");
+
+ jpeg_finish_decompress(&cinfo);
+ jpeg_memio_cleanup(&cinfo);
+ jpeg_destroy_decompress(&cinfo);
+
+ logger->log("BJpeg", Log::DEBUG, "jpeg shutdown done");
+ rdr->drawingDone();
+
+#ifdef USE_BUFFER
+ UINT y;
+ //Tell the surface, that we will draw a lot of pixel,
+ //so that performance, can be optimized
+ sfc->startFastDraw();
+ logger->log("BJpeg", Log::DEBUG, "jpeg start buffer draw" );
+ unsigned char* p=buffer; //start of first row
+ UINT rowincr=linelen*scaleafter;
+ //for simplicity omit last line to avoid running out of buffer
+ for (y = 0; y < pictureh-1 ;y++)
+ {
+ drawLine(sfc,ctl->finalRotation,p,scaleafter,picturew,pictureh,xpos,ypos,y,linelen,colincr,scaleafter,fac);
+ p+=rowincr;
+ }
+ sfc->endFastDraw();
+ logger->log("BJpeg", Log::DEBUG, "end draw");
+ free(buffer);
+#else
+ delete[] lbuf;
+#endif
+ logger->log("BJpeg", Log::DEBUG, "deleted buffer");
+ return true;
+}
+
+//get my own surface
+Surface * WJpeg::getSurface(Region & r) {
+ r.x=getRootBoxOffsetX();
+ r.y=getRootBoxOffsetY();
+ r.w=area.w;
+ r.h=area.h;
+ return Boxx::getSurface();
}
+
#define XMD_H //workaround some compiling issues
#endif
-//#ifndef WIN32
-extern "C"
-{
- #include <jpeglib.h>
-}
-/*#else
-//TODO find a replacement on WIN32
-#endif*/
-
class Surface;
class Boxx;
//a reader to be implemented by the caller
class JpegReader {
public:
- //init reading the file
- //return <=0 if error or size of image
- virtual ULONG initRead(const char *filename)=0;
//read the next chunk of jpeg data
//offset - from start of file
//len I buf len (max bytes to read)
//return read len, 0 on EOF, -1 on error, *buf set to buffer
//will be released with free(!!!) after decoding
virtual ULONG readChunk(ULONG offset,ULONG len,char **buf)=0;
+ //a callback when the drawing is complete
+ //the implementation is optional
+ virtual void drawingDone(){};
+ //get the size of the current picture
+ virtual ULONG getSize(){ return 0;}
virtual ~JpegReader(){};
};
-#ifdef WIN32
-class WindowsResourceJpegReader: public JpegReader {
- public:
- virtual ULONG initRead(const char *filename);
- virtual ULONG readChunk(ULONG offset,ULONG len,char **buf);
- virtual ~WindowsResourceJpegReader();
-protected:
- HGLOBAL hres;
- LPVOID buffer;
- DWORD size;
-};
-#endif
-
class WJpeg : public Boxx
{
public:
WJpeg();
virtual ~WJpeg();
- int init(char* fileName, bool useImage=true, JpegReader *rdr=NULL);
- //rotate (with next draw!) by 90/180/270
- void setRotate(int amount);
- static const int ROT_0=0;
- static const int ROT_90=1;
- static const int ROT_180=2;
- static const int ROT_270=3;
+ //old style usage - load local file
+ //the sequence is init(filename), draw
+ //the new usage is drawJpeg (with having the right offsets computed)
+ int init(char* fileName);
void draw();
+
bool hasError();
- /**
- * get an integer info from the current picture
- */
- ULONG getJpegInfo(ULONG tag);
- //in tags
- static const ULONG JPEG_WIDTH=1; //picture width
- static const ULONG JPEG_HEIGHT=2; //picture height
- static const ULONG JPEG_SIZE=3; //picture (compressed) size
- static const ULONG JPEG_ROTATE=4; //rotate setting
- static const ULONG JPEG_SCALE=5; //scale setting (1/n)
- /**
- * get a string info from the picture
- * the user must provide a buffer of
- * INFO_BUFFER size
- */
- int getJpegInfo(ULONG tag, char * buffer);
- static const int INFO_BUFFER=200;
- //string info tags
- static const ULONG JPEG_FILENAME=100; //abbreviated filename
+
+ //mode for scaling pictures
+ enum ScaleMode {
+ LETTER=0,
+ CROP=1,
+ CROPPERCENT=2};
+ //rotations
+ enum Rotation{
+ ROT_0=0,
+ ROT_90=1,
+ ROT_180=2,
+ ROT_270=3
+ };
+ //jpeg info
+ struct JpegControl {
+ public:
+ //the available drawing area
+ Region area;
+ bool enlarge;
+ //the maximum allowed scale factor after decompress
+ UINT scaleafter;
+ //the scale mode
+ enum ScaleMode mode;
+ //the size value if scaleMode==cropPercent
+ //%of the drawing area size
+ UINT scaleAmount;
+ //the rotation (user defined as input)
+ //if exif rotation is found this will be added
+ enum Rotation rotation;
+
+ //paremeters filled during Jpeg parsing
+ enum Rotation exifRotation;
+ char exifDate[30];
+ char error[100];
+ UINT picw;
+ UINT pich;
+ ULONG compressedSize;
+
+ //parameters computed to display picture
+ enum Rotation finalRotation;
+ //scale in %
+ UINT scale;
+ JpegControl() {
+ area.x=0;
+ area.y=0;
+ area.w=0;
+ area.h=0;
+ enlarge=false;
+ scaleafter=3;
+ scaleAmount=110;
+ mode=CROPPERCENT;
+ rotation=ROT_0;
+ exifRotation=ROT_0;
+ finalRotation=ROT_0;
+ exifDate[0]='\0';
+ error[0]='\0';
+ picw=0;
+ pich=0;
+ compressedSize=0;
+ scale=100;
+ }
+ };
+
+ //the standalone drawing function
+ //this will draw into the provided surface
+ //the reader has to be initialized before
+ //calling this function does not need a WJpeg being instantiated
+ //it simply draws into the surface
+ bool static drawJpeg(JpegControl * control, Surface* sfc, JpegReader *rdr, Colour & backgroundColour);
private:
- int drawJpeg();
//our drawPixel with considers rotation
- void drawPixel(int x, int y,int w,int h,int xpos, int ypos, const Colour& c);
- char* fileName;
+ /* handle picture rotation
+ 90: xr=h-y
+ yr=x
+ 180:xr=w-x
+ yr=h-y
+ 270:xr=y
+ yr=w-x
+ */
+ inline static void drawPixel(Surface * sfc,enum Rotation rotate,int x, int y,int w,int h,int xpos, int ypos,Colour c){
+ int xb=0;
+ int yb=0;
+ switch(rotate) {
+ case ROT_0:
+ xb=x;
+ yb=y;
+ break;
+ case ROT_90:
+ xb=h-y;
+ yb=x;
+ break;
+ case ROT_180:
+ xb=w-x;
+ yb=h-y;
+ break;
+ case ROT_270:
+ xb=y;
+ yb=w-x;
+ break;
+ }
+ xb+=xpos;
+ yb+=ypos;
+ if (xb < 0 || yb < 0 ) {
+ return;
+ }
+ sfc->drawPixel((UINT)xb,(UINT)yb,c);
+ }
+
+ /**
+ draw a line of pixels coming from the decompressor
+ if scaleafter > 1 we draw that many lines (numlines is the# lines in the buffer)
+ picturew is the resulting width of the picture
+ **/
+ inline static void drawLine(Surface *sfc,enum Rotation rotate, unsigned char *cp,UINT scaleafter,UINT picturew,UINT pictureh,
+ UINT xpos, UINT ypos, UINT outy, UINT linelen,UINT pixeloffset, UINT numlines, UINT fac) {
+ Colour c;
+ for (UINT x = 0; x < picturew; x++)
+ {
+ if (scaleafter > 1 ) {
+ //boxfilter scalefactor*scalefactor
+ //take 0...scalefactor pixels in x and y direction
+ for (int colornum=0;colornum<3;colornum++) {
+ UINT comp=0;
+ unsigned char * accp=cp;
+ for (UINT rows=0;rows<scaleafter;rows++) {
+ unsigned char * pp=accp;
+ for (UINT cols=0;cols<scaleafter;cols++) {
+ comp+=(UINT)*pp;
+ if (pp-accp < (int)linelen-3) pp+=3;
+ }
+ if (rows < numlines) accp+=linelen;
+ }
+ comp=(comp*fac) >> 10;
+ if (colornum == 0) c.red=comp;
+ if (colornum == 1) c.green=comp;
+ if (colornum == 2) c.blue=comp;
+ cp++;
+ }
+
+ }
+ else {
+ c.red = *cp;cp++;
+ c.green = *cp;cp++;
+ c.blue = *cp;cp++;
+ }
+ cp+=pixeloffset;
+ drawPixel(sfc,rotate,x, outy, picturew,pictureh,xpos,ypos,c);
+ }
+ }
+ //find my own surface and fill the area with my x and y offset within
+ Surface * getSurface(Region &a);
+
JpegReader *reader;
-#ifdef WIN32
- WindowsResourceJpegReader winread;
-#endif
- bool useImageDimensions;
- ULONG jsize;
- ULONG jheight;
- ULONG jwidth;
- ULONG jscale;
- bool jerror;
- int rotate;
+ bool owningReader;
+ char errbuf[200];
};
#endif
projects / vompclient-marten.git / commitdiff