auto insertInt = [&] (const char* s, const char* k, int v) { if (jconfig[s][k].isNull()) jconfig[s][k] = v; };
insertBool("main", "daemonize", true);
+ insertInt("main", "start_to_live_tv", 0);
insertBool("log", "enabled", false);
insertString("log", "filename", "stdout");
{
"main":
{
- "daemonize": true
+ "daemonize": true,
+ "start_to_live_tv": 1 // Channel number
},
"log":
#include "sleeptimer.h"
#include "wjpeg.h"
#include "osdvector.h"
+#include "config.h"
+#include "vvideolivetv.h"
+#include "channel.h"
#ifdef VOMP_PLATFORM_RASPBERRY
VWelcome* vw = new VWelcome();
vw->draw();
boxstack->add(vw);
- boxstack->update(vw);
+ // No boxstack->update yet
+
+ Config* localConfig = Config::getInstance();
+ int startToLiveTV{};
+ localConfig->getInt("main", "start_to_live_tv", startToLiveTV);
+ if (startToLiveTV)
+ {
+ std::shared_ptr<ChannelList> chanList = VDR::getInstance()->getChannelsList(VDR::VIDEO);
+ if (chanList && chanList->size())
+ {
+ Channel* chan = NULL;
+ for (UINT i = 0; i < chanList->size(); i++)
+ {
+ if ((*chanList)[i]->number == static_cast<ULONG>(startToLiveTV))
+ {
+ chan = (*chanList)[i];
+ break;
+ }
+ }
+ if (chan)
+ {
+ VVideoLiveTV* v = new VVideoLiveTV(chanList, chan->number, NULL);
+ boxstack->add(v);
+ v->go();
+ }
+ else
+ {
+ // Could not find channel, no VVideoLiveTV was made, update vw instead
+ boxstack->update(vw);
+ }
+ }
+ else
+ {
+ Control::getInstance()->connectionLost();
+ }
+ }
+ else // Not starting to live TV
+ {
+ boxstack->update(vw);
+ }
// Enter pre-keys here
// handleCommand(Input::OK);
// ----------------------------------- Called from outside, one offs or info funcs
-PlayerRadioLive::PlayerRadioLive(MessageQueue* tmessageQueue, MessageReceiver* tmessageReceiver, ChannelList* tchanList)
+PlayerRadioLive::PlayerRadioLive(MessageQueue* tmessageQueue, MessageReceiver* tmessageReceiver, std::shared_ptr<ChannelList> tchanList)
: messageQueue(tmessageQueue), messageReceiver(tmessageReceiver), afeed(this), chanList(tchanList)
{
audio = Audio::getInstance();
#include <mutex>
#include <thread>
#include <condition_variable>
-
#include <queue>
+#include <memory>
#include "log.h"
#include "playerlive.h"
class PlayerRadioLive : public PlayerLive, public Callback, public StreamReceiver
{
public:
- PlayerRadioLive(MessageQueue* messageQueue, MessageReceiver* messageReceiver, ChannelList* chanList);
+ PlayerRadioLive(MessageQueue* messageQueue, MessageReceiver* messageReceiver, std::shared_ptr<ChannelList> chanList);
virtual ~PlayerRadioLive();
virtual int init();
DemuxerTS* demuxer;
VDR* vdr;
AFeed afeed;
- ChannelList* chanList;
+ std::shared_ptr<ChannelList> chanList;
std::queue<PLInstruction> instructions;
const static UCHAR I_SETCHANNEL = 1;
// ----------------------------------- Called from outside, one offs or info funcs
-PlayerVideoLive::PlayerVideoLive(MessageQueue* tmessageQueue, MessageReceiver* tmessageReceiver, OSDReceiver* tosdReceiver, ChannelList* tchanList)
+PlayerVideoLive::PlayerVideoLive(MessageQueue* tmessageQueue, MessageReceiver* tmessageReceiver, OSDReceiver* tosdReceiver, std::shared_ptr<ChannelList> tchanList)
: vfeed(this), afeed(this), tfeed(this),
messageQueue(tmessageQueue), messageReceiver(tmessageReceiver), osdReceiver(tosdReceiver), chanList(tchanList)
{
#include <mutex>
#include <thread>
#include <condition_variable>
+#include <memory>
#include <queue>
class PlayerVideoLive : public PlayerLive, public Callback, public StreamReceiver
{
public:
- PlayerVideoLive(MessageQueue* messageQueue, MessageReceiver* messageReceiver, OSDReceiver* tosdReceiver, ChannelList* chanList);
+ PlayerVideoLive(MessageQueue* messageQueue, MessageReceiver* messageReceiver, OSDReceiver* tosdReceiver, std::shared_ptr<ChannelList> chanList);
virtual ~PlayerVideoLive();
virtual int init();
MessageQueue* messageQueue;
MessageReceiver* messageReceiver;
OSDReceiver* osdReceiver;
- ChannelList* chanList;
+ std::shared_ptr<ChannelList> chanList;
LogNT* logger;
Audio* audio;
Video* video;
VChannelList::~VChannelList()
{
MessageQueue::getInstance()->removeReceiver(this);
-
- if (chanList)
- {
- for (UINT i = 0; i < chanList->size(); i++)
- {
- delete (*chanList)[i];
- }
-
- chanList->clear();
- delete chanList;
- }
}
-void VChannelList::setList(ChannelList* tlist)
+void VChannelList::setList(std::shared_ptr<ChannelList> tlist)
{
char str[500];
OsdVector *osdv=dynamic_cast<OsdVector*>(Osd::getInstance());
#include <stdio.h>
#include <string.h>
#include <vector>
+#include <memory>
#include "tbboxx.h"
#include "messagequeue.h"
VChannelList(ULONG type);
virtual ~VChannelList();
- void setList(ChannelList* chanList);
+ void setList(std::shared_ptr<ChannelList> chanList);
void highlightChannel(Channel* channel);
void processMessage(Message* m);
int handleCommand(int command);
private:
BoxStack* boxstack;
- ChannelList* chanList;
+ std::shared_ptr<ChannelList> chanList;
WSelectList sl;
ULONG type;
return toReturn;
}
-ChannelList* VDR::getChannelsList(ULONG type)
+std::shared_ptr<ChannelList> VDR::getChannelsList(ULONG type)
{
VDR_RequestPacket vrp;
if (!vrp.init(VDR_GETCHANNELLIST, true, 0)) return NULL;
VDR_ResponsePacket* vresp = RequestResponse(&vrp);
if (vresp->noResponse()) { delete vresp; return NULL; }
- ChannelList* chanList = new ChannelList();
+ //ChannelList* chanList = new ChannelList();
+ std::shared_ptr<ChannelList> chanList = std::make_shared<ChannelList>();
bool h264support=Video::getInstance()->supportsh264();
bool mpeg2support=Video::getInstance()->supportsmpeg2();
#include <algorithm>
#include <thread>
#include <mutex>
+#include <memory>
#include "defines.h"
#include "log.h"
#include "i18n.h"
#include "control.h"
#include "tcp.h"
+#include "channel.h"
class RecInfo;
class Event;
-class Channel;
+//class Channel;
class VDR_RequestPacket;
class VDR_ResponsePacket;
#ifdef VOMP_MEDIAPLAYER
class TVMediaInfo;
typedef std::vector<Event*> EventList;
-typedef std::vector<Channel*> ChannelList;
+//typedef std::vector<Channel*> ChannelList;
typedef std::vector<RecTimer*> RecTimerList;
+// Subclass vector to add custom delete behaviour for the contents
+class ChannelList : public std::vector<Channel*>
+{
+ public:
+ ~ChannelList()
+ {
+ for (Channel* p : *this) delete p;
+ }
+};
+
struct RecTimerSorter // : public binary_function<double, double, bool>
{
bool operator() (const RecTimer* a, const RecTimer* b)
// Direction: 0=backwards, 1=forwards
MarkList* getMarks(char* fileName);
int deleteTimer(RecTimer* delTimer);
- ChannelList* getChannelsList(ULONG type);
+ std::shared_ptr<ChannelList> getChannelsList(ULONG type);
int streamChannel(ULONG number, StreamReceiver*);
int streamChannel(ULONG number);
void getChannelPids(Channel* channel);
VEpg* VEpg::instance = NULL;
-VEpg::VEpg(MessageReceiver* tparent, UINT tcurrentChannelIndex, ChannelList* tchanList)
+VEpg::VEpg(MessageReceiver* tparent, UINT tcurrentChannelIndex, std::shared_ptr<ChannelList> tchanList)
{
instance = this;
currentChannelIndex = tcurrentChannelIndex;
#define VEPG_H
#include <vector>
+#include <memory>
#include "boxx.h"
#include "messagequeue.h"
class VEpg : public Boxx, public MessageReceiver, public TimerReceiver
{
public:
- VEpg(MessageReceiver* parent, UINT currentChannel, ChannelList* tchanList);
+ VEpg(MessageReceiver* parent, UINT currentChannel, std::shared_ptr<ChannelList> tchanList);
~VEpg();
static VEpg* getInstance();
Event thisEvent; // the selected event
time_t selTime; // current selection time
UINT e; // temp used to point to an event
- ChannelList* chanList; // list of available channels
+ std::shared_ptr<ChannelList> chanList; // list of available channels
tm* epgtime; // selected time within epg
tm* Ltime; // time of LHS of epg view
time_t ltime; // time of LHS of epg view
static const char* TAG = "VEpgListAdvanced";
-VEpgListAdvanced::VEpgListAdvanced(MessageReceiver* tvideolive, ChannelList* tchanList, ULONG initialChannelNumber)
+VEpgListAdvanced::VEpgListAdvanced(MessageReceiver* tvideolive, std::shared_ptr<ChannelList> tchanList, ULONG initialChannelNumber)
{
channelNumber = initialChannelNumber;
chanList = tchanList;
#define VEPGLIST_ADVANCED_H
#include <stack>
+#include <memory>
#include "tbboxx.h"
#include "messagequeue.h"
class VEpgListAdvanced : public TBBoxx, public MessageReceiver
{
public:
- VEpgListAdvanced(MessageReceiver* tvideolive, ChannelList* tchanList, ULONG initialChannelNumber);
+ VEpgListAdvanced(MessageReceiver* tvideolive, std::shared_ptr<ChannelList> tchanList, ULONG initialChannelNumber);
virtual ~VEpgListAdvanced();
void draw() { draw(false); }
Event* getCurrentOptionEvent(ULONG& channel);
- ChannelList* chanList;
+ std::shared_ptr<ChannelList> chanList;
ULONG channelNumber;
MessageReceiver* videolive;
static const char* TAG = "VVideoLiveTV";
-VVideoLiveTV::VVideoLiveTV(ChannelList* tchanList, ULONG initialChannelNumber, VChannelList* tvchannelList)
+VVideoLiveTV::VVideoLiveTV(std::shared_ptr<ChannelList> tchanList, ULONG initialChannelNumber, VChannelList* tvchannelList)
+: chanList(tchanList), vchannelList(tvchannelList)
{
vdr = VDR::getInstance();
boxstack = BoxStack::getInstance();
vas = NULL;
- chanList = tchanList;
- vchannelList = tvchannelList;
numberWidth = VDR::getInstance()->getChannelNumberWidth();
currentChannelIndex = 0;
case Input::STOP:
{
stop();
- vchannelList->highlightChannel((*chanList)[currentChannelIndex]);
+ if (vchannelList) vchannelList->highlightChannel((*chanList)[currentChannelIndex]);
return BoxStack::DELETE_ME;
}
#include <stdio.h>
#include <vector>
#include <math.h>
+#include <memory>
#include "messagequeue.h"
#include "boxx.h"
class VVideoLiveTV : public Boxx, public MessageReceiver, public TimerReceiver, public OSDReceiver
{
public:
- VVideoLiveTV(ChannelList* chanList, ULONG initialChannelNumber, VChannelList* vchannelList);
+ VVideoLiveTV(std::shared_ptr<ChannelList> chanList, ULONG initialChannelNumber, VChannelList* vchannelList);
virtual ~VVideoLiveTV();
void preDelete();
int handleCommand(int command);
Video* video;
PlayerLive* player;
bool playing;
- ChannelList* chanList;
+ std::shared_ptr<ChannelList> chanList;
VChannelList* vchannelList;
EventList* eventList;
int numberWidth;
void VWelcome::doChannelsList()
{
- ChannelList* chanList = VDR::getInstance()->getChannelsList(VDR::VIDEO);
+ std::shared_ptr<ChannelList> chanList = VDR::getInstance()->getChannelsList(VDR::VIDEO);
if (chanList)
{
void VWelcome::doRadioList()
{
- ChannelList* chanList = VDR::getInstance()->getChannelsList(VDR::RADIO);
+ std::shared_ptr<ChannelList> chanList = VDR::getInstance()->getChannelsList(VDR::RADIO);
if (chanList)
{