Ticket #2287: multi-pip-v7.patch

libs/libmythtv/NuppelVideoPlayer.cpp

@@ -214 +214 @@
       audio_channels(2),            audio_bits(-1),
       audio_samplerate(44100),      audio_stretchfactor(1.0f),
       audio_codec(NULL),
-      // Picture-in-Picture
-      setpipplayer(NULL),           needsetpipplayer(false),
+      // Picture-in-Picture stuff
+      pip_active(false),
       // Preview window support
       argb_buf(NULL),               argb_size(0,0),
       yuv2argb_conv(yuv2rgb_init_mmx(32, MODE_RGB)),
@@ -1152 +1152 @@
     SetDecoder(dec);
 }
 
+extern "C" {
+#include "libavutil/crc.h"
+}
 int NuppelVideoPlayer::OpenFile(bool skipDsp, uint retries,
                                 bool allow_libmpeg2)
 {
@@ -1189 +1192 @@
             return -1;
         }
 
+        long long pos = player_ctx->buffer->Seek(0, SEEK_CUR);
+        uint checksum = av_crc(av_crc_get_table(AV_CRC_32_IEEE),
+                               (uint32_t) -1,
+                               (uint8_t*)testbuf, testreadsize - 1);
+        VERBOSE(VB_PLAYBACK, LOC +
+                QString("Looking for decoder for '%1'@%2 "
+                        "probe size %3 crc 0x%4")
+                .arg(player_ctx->buffer->GetFilename())
+                .arg(pos).arg(testreadsize).arg(checksum,0,16));
+
         player_ctx->LockPlayingInfo(__FILE__, __LINE__);
         if (NuppelDecoder::CanHandle(testbuf, testreadsize))
             SetDecoder(new NuppelDecoder(this, *player_ctx->playingInfo));
@@ -2956 +2969 @@
 
     while (!killvideo)
     {
-        if (needsetpipplayer)
-        {
-            pip_players.clear();
-            if (setpipplayer)
-            {
-                pip_players[setpipplayer] = 
-                    (PIPLocation) gContext->GetNumSetting("PIPLocation", 0);
-            }
-            needsetpipplayer = false;
-            PIPState state = player_ctx->GetPIPState();
-            if (m_tv && (state == kPIPOff  || state == kPBPLeft))
-                m_tv->WakeSetPIPPlayerCond();
-        }
+        HandlePIPPlayerLists(4);
 
         if (player_ctx->buffer->isDVD())
         {
@@ -3051 +3052 @@
 
     while (!killvideo)
     {
-        if (needsetpipplayer)
-        {
-            pip_players.clear();
-            if (setpipplayer)
-            {
-                pip_players[setpipplayer] = 
-                    (PIPLocation) gContext->GetNumSetting("PIPLocation", 0);
-            }
-            needsetpipplayer = false;
-        }
+        HandlePIPPlayerLists(1);
 
         resetvideo = false;
         SetVideoActuallyPaused(pausevideo);
@@ -3260 +3252 @@
     }
     else
     {
+        if (player_ctx)
+            player_ctx->SetNVPChangingBuffers(true);
         GetDecoder()->SetReadAdjust(player_ctx->buffer->SetAdjustFilesize());
         GetDecoder()->SetWaitForChange();
-        if (m_tv && player_ctx && !player_ctx->isPIP())
-            m_tv->SetIgnoreKeys(true);
     }
 
     delete pginfo;
@@ -3303 +3295 @@
 
     player_ctx->buffer->Unpause();
 
-    if (m_tv && player_ctx && !player_ctx->isPIP())
-        m_tv->SetIgnoreKeys(false);
+    player_ctx->SetNVPChangingBuffers(false);
 
     player_ctx->LockPlayingInfo(__FILE__, __LINE__);
     player_ctx->tvchain->SetProgram(*player_ctx->playingInfo);
@@ -3877 +3868 @@
         GetDecoder()->setTranscoding(value);
 };
 
+bool NuppelVideoPlayer::AddPIPPlayer(
+    NuppelVideoPlayer *pip, PIPLocation loc, uint timeout)
+{
+    QMutexLocker locker(&pip_players_lock);
+    pip_players_add[pip] = loc;
+
+    pip_players_wait.wait(&pip_players_lock, timeout);
+
+    if (pip_players.find(pip) != pip_players.end())
+        return true;
+
+    PIPMap::iterator it = pip_players_add.find(pip);
+    if (it != pip_players_add.end())
+        pip_players_add.erase(it);
+
+    return false;
+}
+
+bool NuppelVideoPlayer::RemovePIPPlayer(NuppelVideoPlayer *pip, uint timeout)
+{
+    QMutexLocker locker(&pip_players_lock);
+
+    pip_players_rm[pip] = kPIP_END;
+
+    pip_players_wait.wait(&pip_players_lock, timeout);
+
+    if (pip_players.find(pip) == pip_players.end())
+        return true;
+
+    PIPMap::iterator it = pip_players_rm.find(pip);
+    if (it != pip_players_rm.end())
+        pip_players_rm.erase(it);
+
+    return false;
+}
+
+void NuppelVideoPlayer::HandlePIPPlayerLists(uint max_cnt)
+{
+    QMutexLocker locker(&pip_players_lock);
+    PIPMap::const_iterator it = pip_players_rm.begin();
+    for (; it != pip_players_rm.end(); ++it)
+    {
+        PIPMap::iterator it2 = pip_players.find(it.key());
+        if (it2 != pip_players.end())
+            pip_players.erase(it2);
+    }
+
+    for (it = pip_players_add.begin();
+         (it != pip_players_add.end()) &&
+         ((uint)pip_players.size() <= max_cnt); ++it)
+    {
+        if (pip_players.find(it.key())    == pip_players.end() &&
+            pip_players_rm.find(it.key()) == pip_players_rm.end())
+        {
+            pip_players[it.key()] = *it;
+        }
+    }
+    pip_players_add.clear();
+    pip_players_rm.clear();
+    pip_players_wait.wakeAll();
+}
+
+PIPLocation NuppelVideoPlayer::GetNextPIPLocation(void) const
+{
+    QMutexLocker locker(&pip_players_lock);
+    PIPMap sim_pip_players = pip_players;
+
+    PIPMap::const_iterator it = pip_players_rm.begin();
+    for (; it != pip_players_rm.end(); ++it)
+    {
+        PIPMap::iterator it2 = sim_pip_players.find(it.key());
+        if (it2 != sim_pip_players.end())
+            sim_pip_players.erase(it2);
+    }
+
+    for (it = pip_players_add.begin(); it != pip_players_add.end(); ++it)
+    {
+        if (sim_pip_players.find(it.key()) == sim_pip_players.end() &&
+            pip_players_rm.find(it.key())  == pip_players_rm.end())
+        {
+            sim_pip_players[it.key()] = *it;
+        }
+    }
+
+    // order of preference, could be stored in db if we want it configurable
+    PIPLocation ols[] =
+        { kPIPTopLeft, kPIPTopRight, kPIPBottomLeft, kPIPBottomRight };
+
+    for (uint i = 0; i < sizeof(ols)/sizeof(PIPLocation); i++)
+    {
+        PIPMap::const_iterator it = sim_pip_players.begin();
+        for (; it != sim_pip_players.end() && (*it != ols[i]); ++it);
+
+        if (it == sim_pip_players.end())
+            return ols[i];
+    }
+
+    return kPIP_END;
+}
+
 void NuppelVideoPlayer::WrapTimecode(long long &timecode, TCTypes tc_type) 
 {
     if ((tc_type == TC_AUDIO) && (tc_wrap[TC_AUDIO] == LONG_LONG_MIN))

libs/libmythtv/avformatdecoder.cpp

@@ -873 +873 @@
  *  \param novideo if true then no video is sought in ScanSreams.
  *  \param testbuf this parameter is not used by AvFormatDecoder.
  */
+extern "C" {
+#include "libavutil/crc.h"
+}
 int AvFormatDecoder::OpenFile(RingBuffer *rbuffer, bool novideo, 
                               char testbuf[kDecoderProbeBufferSize],
                               int testbufsize)
@@ -899 +902 @@
         probe.buf_size = kDecoderProbeBufferSize - AVPROBE_PADDING_SIZE;
 
     fmt = av_probe_input_format(&probe, true);
+    uint checksum = av_crc(av_crc_get_table(AV_CRC_32_IEEE),
+                           (uint32_t) -1,
+                           (uint8_t*)testbuf, probe.buf_size - 1);
     if (!fmt)
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR +
-                QString("Probe failed for file: \"%1\".").arg(filename));
+                QString("Probe failed for file: '%1' probe size %2 crc 0x%3")
+                .arg(filename).arg(probe.buf_size).arg(checksum,0,16));
         return -1;
     }
+    VERBOSE(VB_IMPORTANT, LOC +
+            QString("Probe suceeded for file: '%1' probe size %2 crc 0x%3")
+            .arg(filename).arg(probe.buf_size).arg(checksum,0,16));
 
     fmt->flags |= AVFMT_NOFILE;
 

libs/libmythtv/tv_play.h

@@ -150 +150 @@
 
     // LiveTV commands
     bool LiveTV(bool showDialogs = true, bool startInGuide = false);
-    /// This command is used to exit the player in order to record using
-    /// the recording being used by LiveTV.
-    void StopLiveTV(void) { SetExitPlayer(true, true); }
 
     // Embedding commands for the guidegrid to use in LiveTV
     void EmbedOutput(PlayerContext*, WId wid, int x, int y, int w, int h);
@@ -184 +181 @@
     bool IsBookmarkAllowed(const PlayerContext*) const;
     bool IsDeleteAllowed(const PlayerContext*) const;
 
-    bool CreatePBP(PlayerContext*, const ProgramInfo *info);
-    bool CreatePIP(PlayerContext*, const ProgramInfo *info);
-    void ResizePIPWindow(PlayerContext*);
+    bool CreatePBP(PlayerContext *lctx, const ProgramInfo *info);
+    bool CreatePIP(PlayerContext *lctx, const ProgramInfo *info);
+    bool ResizePIPWindow(PlayerContext*);
     bool IsPIPSupported(const PlayerContext *ctx = NULL) const;
 
     // Boolean queries
@@ -238 +235 @@
                         bool inPlaylist = false, bool initByNetworkCommand = false);
     static void SetFuncPtr(const char *, void *);
 
-    void SetIgnoreKeys(bool ignore) { ignoreKeys = ignore; }
-
     // Used by EPG
     void ChangeVolume(PlayerContext*, bool up);
     void ToggleMute(PlayerContext*);
 
-    void WakeSetPIPPlayerCond(void);
-    void SetNextProgPIPState(PIPState state) { nextProgPIPState = state; }
+    void SetNextProgPIPState(PIPState state) { jumpToProgramPIPState = state; }
 
     // Used for UDPNotify
     bool HasUDPNotifyEvent(void) const;
@@ -276 +270 @@
     static EMBEDRETURNVOID RunViewScheduledPtr;
 
   private:
-    void SetActive(PlayerContext *, int index);
+    void SetActive(PlayerContext *lctx, int index, bool osd_msg);
 
     PlayerContext       *GetPlayerWriteLock(
         int which, const char *file, int location);
@@ -297 +291 @@
 
     int  StartTimer(int interval, int line);
     void KillTimer(int id);
-    void ForceNextStateNone(PlayerContext*);
+    void ForceNextStateNone(PlayerContext*, int line);
     void ScheduleStateChange(PlayerContext*);
     void SetErrored(PlayerContext*);
-    void SetExitPlayer(bool set_it, bool wants_to) const;
+    void SetExitPlayerReal(bool set_it, bool wants_to, int line) const;
     void SetUpdateOSDPosition(bool set_it);
 
-    bool PIPHandleAction(PlayerContext*,const QStringList &actions);
+    bool PxPHandleAction(PlayerContext*,const QStringList &actions);
     bool ToggleHandleAction(PlayerContext*,
                             const QStringList &actions, bool isDVD);
     bool FFRewHandleAction(PlayerContext*, const QStringList &actions);
     bool ActivePostQHandleAction(PlayerContext*,
                                  const QStringList &actions, bool isDVD);
+    bool HandleJumpToProgramAction(PlayerContext *ctx,
+                                   const QStringList   &actions);
 
     bool RequestNextRecorder(PlayerContext *, bool);
     void DeleteRecorder();
@@ -422 +418 @@
                                 const QStringList &actions);
 
     void DoDisplayJumpMenu(void);
-    void SetJumpToProgram(QString progKey = "", int progIndex = 0);
  
     bool ClearOSD(const PlayerContext*);
     void ToggleOSD(const PlayerContext*, bool includeStatusOSD); 
@@ -442 +437 @@
                       int editType = kScheduleProgramGuide);
 
     void TeardownPlayer(PlayerContext *mctx, PlayerContext *ctx);
-    void TeardownPBP(PlayerContext*);
 
     void HandleStateChange(PlayerContext *mctx, PlayerContext *ctx);
 
     bool StartPlayer(PlayerContext *mctx, PlayerContext *ctx,
-                     TVState desiredState, bool ispip = false);
-    bool StartPIPPlayer(PlayerContext *mctx, PlayerContext *pipctx,
-                        TVState desiredState);
-    void SetPIPPlayer(PlayerContext *mctx, PlayerContext *pipctx);
-    void TogglePIPView(PlayerContext*, bool ispbp = false);
-    void ToggleActiveWindow(PlayerContext*, int ctx_index);
-    void SwapPIP(PlayerContext *lctx, int ctx_index, bool ispbp);
-    void TogglePIPState(PlayerContext*, PIPState changeTo);
-    void RestartPIPWindows(PlayerContext *lctx, const vector<long long> &pos,
-                           MuteState mctx_mute);
-    void TeardownPIPWindows(PlayerContext*);
+                     TVState desiredState);
 
+    vector<long long> TeardownAllNVPs(PlayerContext*);
+    void RestartAllNVPs(PlayerContext *lctx,
+                        const vector<long long> &pos,
+                        MuteState mctx_mute);
+
+    void PxPToggleView(  PlayerContext *actx, bool wantPBP);
+    void PxPCreateView(  PlayerContext *actx, bool wantPBP);
+    void PxPTeardownView(PlayerContext *actx);
+    void PxPToggleType(  PlayerContext *mctx, bool wantPBP);
+    void PxPSwap(        PlayerContext *mctx, int ctx_index = -1);
+    bool HandlePxPTimerEvent(void);
+
+    bool PIPAddPlayer(   PlayerContext *mctx, PlayerContext *ctx);
+    bool PIPRemovePlayer(PlayerContext *mctx, PlayerContext *ctx);
+    void PBPRestartMainNVP(PlayerContext *mctx);
+
     void ToggleAutoExpire(PlayerContext*);
 
     void BrowseStart(PlayerContext*);
@@ -479 +479 @@
 
     void BuildOSDTreeMenu(const PlayerContext*);
     void ShowOSDTreeMenu(const PlayerContext*);
+    void FillMenuPxP(const PlayerContext*, OSDGenericTree *treeMenu,
+                     bool freeRecorders);
     void FillMenuLiveTV(OSDGenericTree *treeMenu);
     void FillMenuPlaying(const PlayerContext*, OSDGenericTree *treeMenu);
 
@@ -509 +511 @@
     void IdleDialogTimeout(void);
 
     // Program jumping stuff
-    void setLastProgram(ProgramInfo *rcinfo);
-    ProgramInfo *getLastProgram(void) { return lastProgram; }
+    void SetLastProgram(ProgramInfo *rcinfo);
+    ProgramInfo *GetLastProgram(void) const;
 
     static bool LoadExternalSubtitles(NuppelVideoPlayer *nvp,
                                       const QString &videoFile);
@@ -537 +539 @@
     QString db_time_format;
     QString db_short_date_format;
     uint    db_idle_timeout;
+    uint    db_udpnotify_port;
+    int     db_playback_exit_prompt;
+    int     db_autoexpire_default;
     bool    db_auto_set_watched;
     bool    db_end_of_rec_exit_prompt;
+    bool    db_jump_prefer_osd;
+    bool    db_use_gui_size_for_tv;
+    bool    db_start_in_guide;
+    bool    db_toggle_bookmark;
+    bool    db_run_jobs_on_remote;
+    bool    db_use_dvd_bookmark;
+    bool    db_continue_embedded;
+    bool    db_use_fixed_size;
+
     bool    smartChannelChange;
     bool    MuteIndividualChannels;
     bool    arrowAccel;
@@ -582 +596 @@
     QMap<QString,AskProgramInfo> askAllowPrograms;
     QMutex                       askAllowLock;
 
-    bool ignoreKeys;
-    PIPState needToMakePIPChange;
-    PIPState nextProgPIPState;
+    MythDeque<QString> changePxP;
+    QMutex progListsLock;
     QMap<QString,ProgramList> progLists;
 
     mutable QMutex chanEditMapLock; ///< Lock for chanEditMap and ddMap
@@ -639 +652 @@
 
     // Program Info for currently playing video
     // (or next video if InChangeState() is true)
+    mutable QMutex lastProgramLock;
     ProgramInfo *lastProgram;   ///< last program played with this player
-    bool         jumpToProgram;
-
     bool         inPlaylist; ///< show is part of a playlist
     bool         underNetworkControl; ///< initial show started via by the network control interface
     bool         isnearend;
 
+    // Program Jumping
+    PIPState     jumpToProgramPIPState;
+    bool         jumpToProgram;
+
     // Video Players
     vector<PlayerContext*>  player;
     /// Video Player to which events are sent to
     int                     playerActive;
     /// lock on player and playerActive changes
     mutable QReadWriteLock  playerLock;
-    QWaitCondition pipPlayerSetCondition;
 
     // Remote Encoders
     /// Main recorder to use after a successful SwitchCards() call.
@@ -741 +756 @@
     static const uint kInputKeysMax; ///< When to start discarding early keys
     static const uint kNextSource;
     static const uint kPreviousSource;
+    static const uint kMaxPIPCount;
+    static const uint kMaxPBPCount;
 
     ///< Timeout for entry modes in msec
     static const uint kInputModeTimeout;

libs/libmythtv/playercontext.cpp

@@ -30 +30 @@
 }
 
 PlayerContext::PlayerContext() :
-    nvp(NULL), recorder(NULL),
+    nvp(NULL), nvpUnsafe(false), recorder(NULL),
     tvchain(NULL), buffer(NULL), playingInfo(NULL),
     decoding(false), last_cardid(-1), last_framerate(30.0f),
     // Fast forward state
@@ -102 +102 @@
         newPlaygroup = playingInfo->playgroup;
     }
 
-    ChangeState(newState);
+    ChangeState(newState, __LINE__);
     SetPlayGroup(newPlaygroup);
 }
 
@@ -141 +141 @@
     if (pos > -1)
     {
         pipLocation = pos;
-        name = QString("pip player %1")
-                .arg(PIPLocationToString());
+        name = QString("pip player %1").arg(toString((PIPLocation)pos));
     }
     else
         name = "pip player";
@@ -216 +215 @@
     }
 }
 
-QString PlayerContext::PIPLocationToString(void)
-{
-    QString pipstr = QString ("Unknown PIP Location %1").arg(pipLocation);
-    switch (pipLocation)
-    {
-        case (kPIPTopLeft):
-            pipstr = "PIP: Top Left";
-            break;
-        case (kPIPTopRight):
-            pipstr = "PIP: Top Right";
-            break;
-        case (kPIPBottomLeft):
-            pipstr = "PIP: Bottom Left";
-            break;
-        case (kPIPBottomRight):
-            pipstr = "PIP: Bottom Right";
-            break;
-    }
-
-    return pipstr;
-}
-
-QString PlayerContext::PIPStateToString(void)
-{
-    QString pipstr = QString("Unknown PIP State %1").arg(pipState);
-    switch (pipState)
-    {
-        case (kPIPOff):
-            pipstr = "PIP is off";
-            break;
-        case (kPIPonTV):
-            pipstr = "PIP is visible on TV";
-            break;
-        case (kPIPStandAlone):
-            pipstr = "Standalone PIP";
-            break;
-        case (kPBPLeft):
-            pipstr = "Left side Picture-by-Picture";
-            break;
-        case (kPBPRight):
-            pipstr = "Right side Picture-by-Picture";
-            break;
-        case (kPIPToPBP):
-            pipstr = "Preparing to switch from PIP to PBP";
-            break;
-        case (kPBPToPIP):
-            pipstr = "Preparing to switch from PBP to PIP";
-            break;
-        case (kPBPToggle):
-            pipstr = "Disabling PBP/PIP";
-            break;
-        case (kPIPSwap):
-            pipstr = "Swapping PBP/PIP";
-            break;
-    }
-
-    return pipstr;
-}
-
 bool PlayerContext::StartPIPPlayer(TV *tv, TVState desiredState)
 {
     bool ok = false;
@@ -440 +380 @@
         nvp->SetMuted(true);
 
     int maxWait = -1;
-    if (isPIP())
-       maxWait = 1000; 
+    //if (isPIP())
+    //   maxWait = 1000; 
 
     return StartDecoderThread(maxWait);
 }
@@ -649 +589 @@
 /**
 *   \brief Puts a state change on the nextState queue.
 */
-void PlayerContext::ChangeState(TVState newState)
+void PlayerContext::ChangeState(TVState newState, int line)
 {
+    VERBOSE(VB_IMPORTANT, QString("ChangeState(%1,%2)")
+            .arg(StateToString(newState)).arg(line));
     QMutexLocker locker(&stateLock);
     nextState.enqueue(newState);
 }
@@ -664 +606 @@
 /**
  * \brief Removes any pending state changes, and puts kState_None on the queue.
  */
-void PlayerContext::ForceNextStateNone(void)
+void PlayerContext::ForceNextStateNone(int line)
 {
+    VERBOSE(VB_IMPORTANT, QString("ForceNextStateNone(%2)").arg(line));
     QMutexLocker locker(&stateLock);
     nextState.clear();
     nextState.push_back(kState_None);

libs/libmythtv/NuppelVideoPlayer.h

@@ -149 +149 @@
     void SetVideoFilters(const QString &override);
     void SetFramesPlayed(long long played)    { framesPlayed = played; }
     void SetEof(void)                         { eof = true; }
-    void SetPIPPlayer(NuppelVideoPlayer *pip)
-        { setpipplayer = pip; needsetpipplayer = true; }
+    void SetPIPActive(bool is_active)         { pip_active = is_active; }
+    bool AddPIPPlayer(NuppelVideoPlayer *pip, PIPLocation loc, uint timeout);
+    bool RemovePIPPlayer(NuppelVideoPlayer *pip, uint timeout);
 
     void SetTranscoding(bool value);
     void SetWatchingRecording(bool mode);
@@ -203 +204 @@
     QString   GetXDS(const QString &key) const;
     QString   GetErrorMsg(void) const { return errmsg; }
     bool      GetAudioBufferStatus(uint &fill, uint &total) const;
+    PIPLocation GetNextPIPLocation(void) const;
 
     // Bool Gets
     bool    GetRawAudioState(void) const;
     bool    GetLimitKeyRepeat(void) const     { return limitKeyRepeat; }
     bool    GetEof(void) const                { return eof; }
-    bool    PipPlayerSet(void) const          { return !needsetpipplayer; }
     bool    IsErrored(void) const             { return errored; }
     bool    IsPlaying(uint wait_ms = 0, bool wait_for = true) const;
     bool    AtNormalSpeed(void) const         { return next_normal_speed; }
@@ -218 +219 @@
     bool    PlayingSlowForPrebuffer(void) const { return m_playing_slower; }
     bool    HasAudioIn(void) const            { return !no_audio_in; }
     bool    HasAudioOut(void) const           { return !no_audio_out; }
+    bool    IsPIPActive(void) const           { return pip_active; }
     bool    IsMuted(void) const        { return GetMuteState() == kMuteAll; }
     bool    IsIVTVDecoder(void) const;
     bool    UsingNullVideo(void) const { return using_null_videoout; }
@@ -530 +532 @@
     long long GetDVDBookmark(void) const;
     void SetDVDBookmark(long long frames);
 
+    // Private PIP stuff
+    void HandlePIPPlayerLists(uint max_pip_players);
+
   private:
     DecoderBase   *decoder;
     QMutex         decoder_change_lock;
@@ -702 +707 @@
     bool     audio_passthru;
 
     // Picture-in-Picture
+    mutable QMutex pip_players_lock;
+    QWaitCondition pip_players_wait;
     PIPMap         pip_players;
-    NuppelVideoPlayer *setpipplayer;
-    bool needsetpipplayer;
+    PIPMap         pip_players_add;
+    PIPMap         pip_players_rm;
+    volatile bool  pip_active;
 
     // Preview window support
     unsigned char      *argb_buf;

libs/libmythtv/tv_play.cpp

@@ -65 +65 @@
 
 #define GetPlayer(X,Y) GetPlayerHaveLock(X, Y, __FILE__ , __LINE__)
 #define GetOSDLock(X) GetOSDL(X, __FILE__, __LINE__)
+#define SetExitPlayer(X,Y) SetExitPlayerReal(X,Y,__LINE__)
 
 const int  TV::kInitFFRWSpeed                = 0;
 const uint TV::kInputKeysMax                 = 6;
 const uint TV::kNextSource                   = 1;
 const uint TV::kPreviousSource               = 2;
+const uint TV::kMaxPIPCount                  = 4;
+const uint TV::kMaxPBPCount                  = 2;
 
+
 const uint TV::kInputModeTimeout             = 5000;
 const uint TV::kMuteTimeout                  = 800;
 const uint TV::kLCDTimeout                   = 1000;
@@ -154 +158 @@
     if (!lastProgramStringList.empty())
     {
         ProgramInfo *p = new ProgramInfo();
-        p->FromStringList(lastProgramStringList, 0);
-        tv->setLastProgram(p);
+        if (p->FromStringList(lastProgramStringList, 0))
+            tv->SetLastProgram(p);
         delete p;
     }
 
@@ -175 +179 @@
             VERBOSE(VB_PLAYBACK, LOC + "tv->LiveTV() -- begin");
             if (!tv->LiveTV(showDialogs, startInGuide))
             {
-                tv->StopLiveTV();
+                tv->SetExitPlayerReal(true, true, __LINE__);
                 quitAll = true;
             }
             VERBOSE(VB_PLAYBACK, LOC + "tv->LiveTV() -- end");
@@ -270 +274 @@
 
         if (tv->getJumpToProgram())
         {
+            ProgramInfo *nextProgram = tv->GetLastProgram();
 
-            ProgramInfo *tmpProgram  = tv->getLastProgram();
-            ProgramInfo *nextProgram = new ProgramInfo(*tmpProgram);
-
+            tv->SetLastProgram(curProgram);
             if (curProgram)
-            {
-                tv->setLastProgram(curProgram);
                 delete curProgram;
-            }
-            else
-                tv->setLastProgram(NULL);
 
             curProgram = nextProgram;
 
@@ -420 +418 @@
     REG_KEY("TV Playback", "VOLUMEDOWN", "Volume down", "[,{,F10,Volume Down");
     REG_KEY("TV Playback", "VOLUMEUP",   "Volume up",   "],},F11,Volume Up");
     REG_KEY("TV Playback", "MUTE",       "Mute",        "|,\\,F9,Volume Mute");
-    REG_KEY("TV Playback", "TOGGLEPIPMODE", "Toggle Picture-in-Picture mode",
+    REG_KEY("TV Playback", "TOGGLEPIPMODE", "Toggle Picture-in-Picture view",
             "V");
-    REG_KEY("TV Playback", "TOGGLEPBPMODE", "Toggle Picture-by-Picture mode",
+    REG_KEY("TV Playback", "TOGGLEPBPMODE", "Toggle Picture-by-Picture view",
             "Ctrl+V");
-    REG_KEY("TV Playback", "TOGGLEPIPWINDOW", "Toggle active PIP/PBP window", "B");
+    REG_KEY("TV Playback", "CREATEPIPVIEW", "Create Picture-in-Picture view",
+            "1");
+    REG_KEY("TV Playback", "CREATEPBPVIEW", "Create Picture-by-Picture view",
+            "Ctrl+1");
+    REG_KEY("TV Playback", "NEXTPIPWINDOW", "Toggle active PIP/PBP window", "B");
     REG_KEY("TV Playback", "SWAPPIP", "Swap PBP/PIP Windows", "N");
-    REG_KEY("TV Playback", "TOGGLEPIPSTATE", "Change PIP from PBP or visa versa"
-            ,"");
+    REG_KEY("TV Playback", "TOGGLEPIPSTATE", "Change PxP view", "");
     REG_KEY("TV Playback", "TOGGLEASPECT",
             "Toggle the video aspect ratio", "Ctrl+W");
     REG_KEY("TV Playback", "TOGGLEFILL", "Next Preconfigured Zoom mode", "W");
@@ -569 +570 @@
       baseFilters(""),
       db_channel_format("<num> <sign>"),
       db_time_format("h:mm AP"), db_short_date_format("M/d"),
-      db_idle_timeout(0),
-      db_auto_set_watched(false),
-      db_end_of_rec_exit_prompt(false),
+      db_idle_timeout(0),           db_udpnotify_port(0),
+      db_playback_exit_prompt(0),   db_autoexpire_default(0),
+      db_auto_set_watched(false),   db_end_of_rec_exit_prompt(false),
+      db_jump_prefer_osd(true),     db_use_gui_size_for_tv(false),
+      db_start_in_guide(false),     db_toggle_bookmark(false),
+      db_run_jobs_on_remote(false), db_use_dvd_bookmark(false),
+      db_continue_embedded(false),  db_use_fixed_size(true),
+
       smartChannelChange(false),
       MuteIndividualChannels(false), arrowAccel(false),
       osd_general_timeout(2), osd_prog_info_timeout(3),
@@ -594 +600 @@
       adjustingPicture(kAdjustingPicture_None),
       adjustingPictureAttribute(kPictureAttribute_None),
       askAllowType(kAskAllowCancel), askAllowLock(QMutex::Recursive),
-      ignoreKeys(false),
-      needToMakePIPChange(kPIPOff),
-      nextProgPIPState(kPIPOff),
       // Channel Editing
       chanEditMapLock(QMutex::Recursive),
       ddMapSourceId(0), ddMapLoaderRunning(false),
@@ -615 +618 @@
       browsemode(false), persistentbrowsemode(false),
       browsechannum(""), browsechanid(""), browsestarttime(""),
       // Program Info for currently playing video
-      lastProgram(NULL), jumpToProgram(false),
+      lastProgram(NULL),
       inPlaylist(false), underNetworkControl(false),
       isnearend(false),
+      // Jump to program stuff
+      jumpToProgramPIPState(kPIPOff),
+      jumpToProgram(false),
       // Video Player currently receiving UI input
       playerActive(-1),
       //Recorder switching info
@@ -647 +653 @@
 
     db_idle_timeout = gContext->GetNumSetting("LiveTVIdleTimeout", 0);
     db_idle_timeout *= 60 * 1000; // convert from minutes to ms.
-    db_auto_set_watched = gContext->GetNumSetting("AutomaticSetWatched", 0);
+    db_udpnotify_port      = gContext->GetNumSetting("UDPNotifyPort", 0);
+    db_playback_exit_prompt= gContext->GetNumSetting("PlaybackExitPrompt", 0);
+    db_autoexpire_default  = gContext->GetNumSetting("AutoExpireDefault", 0);
+
+    db_auto_set_watched     = gContext->GetNumSetting("AutomaticSetWatched", 0);
     db_end_of_rec_exit_prompt =
         gContext->GetNumSetting("EndOfRecordingExitPrompt", 0);
+    db_jump_prefer_osd     = gContext->GetNumSetting("JumpToProgramOSD", 1);
+    db_use_gui_size_for_tv = gContext->GetNumSetting("GuiSizeForTV", 0);
+    db_start_in_guide      = gContext->GetNumSetting("WatchTVGuide", 0);
+    db_toggle_bookmark     = gContext->GetNumSetting("AltClearSavedPosition",1);
+    db_run_jobs_on_remote  = gContext->GetNumSetting("JobsRunOnRecordHost", 0);
+    db_use_dvd_bookmark    = gContext->GetNumSetting("EnableDVDBookmark", 0);
+    db_continue_embedded   = gContext->GetNumSetting(
+        "ContinueEmbeddedTVPlay", 0);
+    db_use_fixed_size      = gContext->GetNumSettingOnHost(
+        "UseFixedWindowSize", gContext->GetHostName(), 1);
 
     sleep_times.push_back(SleepTimerInfo(QObject::tr("Off"),       0));
     sleep_times.push_back(SleepTimerInfo(QObject::tr("30m"),   30*60));
@@ -662 +682 @@
 
     playerLock.lockForWrite();
     player.push_back(new PlayerContext());
+    playerActive = 0;
     playerLock.unlock();
-    SetActive(NULL, 0);
 }
 
 /** \fn TV::Init(bool)
@@ -768 +788 @@
             }
         }
 
-        bool use_fixed_size = gContext->GetNumSettingOnHost(
-            "UseFixedWindowSize", gContext->GetHostName(), 1);
-
         // player window sizing
         myWindow = new MythDialog(mainWindow, "video playback window");
 
@@ -780 +797 @@
         myWindow->setGeometry(win_bounds);
         myWindow->setBaseSize(win_bounds.size());
         myWindow->setMinimumSize(
-            (use_fixed_size) ? win_bounds.size() : QSize(16, 16));
+            (db_use_fixed_size) ? win_bounds.size() : QSize(16, 16));
         myWindow->setMaximumSize(
-            (use_fixed_size) ? win_bounds.size() :
+            (db_use_fixed_size) ? win_bounds.size() :
             QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
 
         // resize main window
         mainWindow->setGeometry(player_bounds);
         mainWindow->setBaseSize(player_bounds.size());
         mainWindow->setMinimumSize(
-            (use_fixed_size) ? player_bounds.size() : QSize(16, 16));
+            (db_use_fixed_size) ? player_bounds.size() : QSize(16, 16));
         mainWindow->setMaximumSize(
-            (use_fixed_size) ? player_bounds.size() :
+            (db_use_fixed_size) ? player_bounds.size() :
             QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
         mainWindow->installEventFilter(this);
 
@@ -834 +851 @@
         mwnd->resize(saved_gui_bounds.size());
         mwnd->setFixedSize(saved_gui_bounds.size());
         mwnd->show();
-        if (!gContext->GetNumSetting("GuiSizeForTV", 0))
+        if (!db_use_gui_size_for_tv)
             mwnd->move(saved_gui_bounds.topLeft());
     }
 
@@ -923 +940 @@
                     .arg(db_idle_timeout*(1.0f/60000.0f)));
         }
 
-        if (startInGuide || gContext->GetNumSetting("WatchTVGuide", 0))
+        if (startInGuide || db_start_in_guide)
         {
             MSqlQuery query(MSqlQuery::InitCon());
             query.prepare("SELECT keylist FROM keybindings WHERE "
@@ -1336 +1353 @@
                 break;
             case 2:
                 // return to main menu
-                StopLiveTV();
+                SetExitPlayer(true, true);
                 break;
             case 3:
                 // cancel scheduled recording
@@ -1353 +1370 @@
             default:
             case 1:
                 // return to main menu
-                StopLiveTV();
+                SetExitPlayer(true, true);
                 break;
             case 2:
             {
@@ -1628 +1645 @@
         {
             // Cache starting frame rate for this recorder
             ctx->last_framerate = ctx->recorder->GetFrameRate();
-            ok = StartPlayer(mctx, ctx, desiredNextState, ctx->isPIP());
+            ok = StartPlayer(mctx, ctx, desiredNextState);
         }
         if (!ok)
         {
@@ -1648 +1665 @@
                 lockTimerOn = true;
             }
         }
+
+        if (mctx != ctx)
+            SetActive(ctx, find_player_index(ctx), false);
     }
     else if (TRANSITION(kState_WatchingLiveTV, kState_None))
     {
         SET_NEXT();
         RestoreScreenSaver(ctx);
         StopStuff(mctx, ctx, true, true, true);
+
+        if ((mctx != ctx) && (GetPlayer(ctx,-1) == ctx))
+            SetActive(mctx, 0, true);
     }
     else if (TRANSITION(kState_WatchingRecording, kState_WatchingPreRecorded))
     {
@@ -1704 +1727 @@
                 }
             }
 
-            ok = StartPlayer(mctx, ctx, desiredNextState, ctx->isPIP());
+            ok = StartPlayer(mctx, ctx, desiredNextState);
 
             if (ok)
             {
@@ -1727 +1750 @@
             SET_LAST();
             SetErrored(ctx);
         }
+        else if (mctx != ctx)
+        {
+            SetActive(ctx, find_player_index(ctx), false);
+        }
     }
     else if (TRANSITION(kState_WatchingPreRecorded, kState_None) ||
              TRANSITION(kState_WatchingRecording, kState_None))
@@ -1735 +1762 @@
 
         RestoreScreenSaver(ctx);
         StopStuff(mctx, ctx, true, true, false);
+
+        if ((mctx != ctx) && (GetPlayer(ctx,-1) == ctx))
+            SetActive(mctx, 0, true);
     }
     else if (TRANSITION(kState_None, kState_None))
     {
@@ -1754 +1784 @@
 
         nextState = kState_None;
         changed = true;
+
+        if ((mctx != ctx) && (GetPlayer(ctx,-1) == ctx))
+            SetActive(mctx, 0, true);
     }
 
     // Print state changed message...
@@ -1901 +1934 @@
             LOC + QString("StopStuff() for player ctx %1 -- begin")
             .arg(find_player_index(ctx)));
 
-    SetActive(mctx, 0);
+    SetActive(mctx, 0, false);
 
     if (ctx->buffer && ctx->buffer->isDVD())
     {
@@ -1951 +1984 @@
     QString loc = LOC + QString("TeardownPlayer() player ctx %1")
         .arg(ctx_index);
 
-    SetActive(mctx, 0);
+    if (!mctx || !ctx || ctx_index < 0)
+    {
+        VERBOSE(VB_IMPORTANT, loc + "-- error");
+        return;
+    }
 
+    VERBOSE(VB_PLAYBACK, loc);
+
     if (mctx != ctx)
     {
         if (ctx->nvp)
         {
+            PIPRemovePlayer(mctx, ctx);
             ctx->nvp->StopPlaying();
             ctx->SetNVP(NULL);
         }
 
-        SetPIPPlayer(mctx, ctx);
         player.erase(player.begin() + ctx_index);
         delete ctx;
-        TeardownPBP(ctx);
+        PBPRestartMainNVP(mctx);
+        SetActive(mctx, playerActive, false);
         return;
     }
 
@@ -2022 +2062 @@
     mctx = GetPlayerWriteLock(0, __FILE__, __LINE__);
     if (!mctx->IsErrored() && (GetState(mctx) != kState_None))
     {
-        mctx->ForceNextStateNone();
+        mctx->ForceNextStateNone(__LINE__);
         HandleStateChange(mctx, mctx);
         if (jumpToProgram)
             TeardownPlayer(mctx, mctx);
@@ -2076 +2116 @@
         HandlePseudoLiveTVTimerEvent();
     else if (timer_id == speedChangeTimerId)
         HandleSpeedChangeTimerEvent();
+    else if (timer_id == pipChangeTimerId)
+        HandlePxPTimerEvent();
     else
         handled = false;
 
@@ -2275 +2317 @@
 
     // Check if it matches networkControlTimerId
     QString netCmd = QString::null;
-    if (!ignoreKeys)
     {
         QMutexLocker locker(&timerIdLock);
         if (timer_id == networkControlTimerId)
@@ -2292 +2333 @@
 
     if (!netCmd.isEmpty())
     {
-        PlayerContext *actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
+        PlayerContext *actx = GetPlayerWriteLock(-1, __FILE__, __LINE__);
         ProcessNetworkControlCommand(actx, netCmd);
         ReturnPlayerLock(actx);
         handled = true;
@@ -2329 +2370 @@
                 }
                 ReturnOSDLock(mctx, osd);
                 lastProgramStringList.clear();
-                setLastProgram(NULL);
+                SetLastProgram(NULL);
                 VERBOSE(VB_PLAYBACK, LOC_ERR +
                             "Last Program File does not exist");
                 jumpToProgram = false;
             }
             else
-                ForceNextStateNone(mctx);
+                ForceNextStateNone(mctx, __LINE__);
         }
         else
-            ForceNextStateNone(mctx);
+            ForceNextStateNone(mctx, __LINE__);
 
         ReturnPlayerLock(mctx);
 
@@ -2364 +2405 @@
     if (handled)
         return;
 
-    if (timer_id == pipChangeTimerId)
-    {
-        if (needToMakePIPChange > kPIPOff)
-        {
-            PlayerContext *mctx = GetPlayerWriteLock(0, __FILE__, __LINE__);
-            ClearOSD(mctx);
-
-            switch (needToMakePIPChange)
-            {
-                case (kPIPSwap):
-                    SwapPIP(mctx, 1, false);
-                    break;
-                case (kPBPSwap):
-                    SwapPIP(mctx, 1, true);
-                    break;
-                case (kPIPToPBP):
-                    TogglePIPState(mctx, needToMakePIPChange);
-                    break;
-                case (kPBPToPIP):
-                    TogglePIPState(mctx, needToMakePIPChange);
-                    break;
-                case (kPBPToggle):
-                {
-                    if (mctx && (player.size() > 1))
-                        TeardownPlayer(mctx, GetPlayer(mctx, 1));
-                    else
-                        TogglePIPView(mctx, true);
-                    break;
-                }
-            }
-            ReturnPlayerLock(mctx);
-
-            needToMakePIPChange = kPIPOff;
-        }
-
-        QMutexLocker locker(&timerIdLock);
-        if (pipChangeTimerId)
-            KillTimer(pipChangeTimerId);
-        pipChangeTimerId = 0;
-        handled = true;
-    }
-
-    if (handled)
-        return;
-
     if (timer_id == udpNotifyTimerId)
     {
         while (HasUDPNotifyEvent())
@@ -2555 +2551 @@
     {
         PlayerContext *actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
         OSD *osd = GetOSDLock(actx);
-        OSDSet *oset = osd->GetSet("status");
+        OSDSet *oset = NULL;
+        if (osd)
+            oset = osd->GetSet("status");
         if (osd && oset && oset->Displaying() &&
             (StateIsLiveTV(actx->GetState()) ||
              StateIsPlaying(actx->GetState())))
@@ -2580 +2578 @@
             (mctx->nvp && mctx->nvp->IsErrored()) || mctx->IsErrored())
         {
             SetExitPlayer(true, false);
-            ForceNextStateNone(mctx);
+            ForceNextStateNone(mctx, __LINE__);
             error = true;
         }
 
@@ -2588 +2586 @@
         {
             PlayerContext *ctx = GetPlayer(mctx, i);
             if (error || ctx->IsErrored())
-                ForceNextStateNone(ctx);
+                ForceNextStateNone(ctx, __LINE__);
         }
         ReturnPlayerLock(mctx);
 
@@ -2600 +2598 @@
     }
 }
 
+bool TV::HandlePxPTimerEvent(void)
+{
+    QString cmd = QString::null;
+
+    {
+        QMutexLocker locker(&timerIdLock);
+        if (changePxP.empty())
+        {
+            if (pipChangeTimerId)
+                KillTimer(pipChangeTimerId);
+            pipChangeTimerId = 0;
+            return true;
+        }
+        cmd = changePxP.dequeue();
+    }
+
+    PlayerContext *mctx = GetPlayerWriteLock(0, __FILE__, __LINE__);
+    PlayerContext *actx = GetPlayer(mctx, -1);
+
+    if (cmd == "TOGGLEPIPMODE")
+        PxPToggleView(actx, false);
+    else if (cmd == "TOGGLEPBPMODE")
+        PxPToggleView(actx, true);
+    else if (cmd == "CREATEPIPVIEW")
+        PxPCreateView(actx, false);
+    else if (cmd == "CREATEPBPVIEW")
+        PxPCreateView(actx, true);
+    else if (cmd == "SWAPPIP")
+        PxPSwap(mctx);
+    else if (cmd == "TOGGLEPIPSTATE")
+        PxPToggleType(mctx, !mctx->isPBP());
+
+    ReturnPlayerLock(mctx);
+
+    QMutexLocker locker(&timerIdLock);
+
+    if (pipChangeTimerId)
+        KillTimer(pipChangeTimerId);
+
+    if (changePxP.empty())
+        pipChangeTimerId = 0;
+    else
+        pipChangeTimerId = StartTimer(20, __LINE__);
+
+    return true;
+}
+
 bool TV::HandleLCDTimerEvent(void)
 {
     PlayerContext *actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
@@ -2654 +2699 @@
     QObject::killTimer(id);
 }
 
-void TV::ForceNextStateNone(PlayerContext *ctx)
+void TV::ForceNextStateNone(PlayerContext *ctx, int line)
 {
-    ctx->ForceNextStateNone();
+    ctx->ForceNextStateNone(line);
     ScheduleStateChange(ctx);
 }
 
@@ -2674 +2719 @@
     errorRecoveryTimerId = StartTimer(1, __LINE__);
 }
 
-void TV::SetExitPlayer(bool set_it, bool wants_to) const
+void TV::SetExitPlayerReal(bool set_it, bool wants_to, int line) const
 {
+    VERBOSE(VB_IMPORTANT,
+            LOC + "SetExitPlayer("<<set_it<<","<<wants_to<<","<<line<<")");
+
     QMutexLocker locker(&timerIdLock);
     if (set_it)
     {
@@ -2731 +2779 @@
             continue;
         }
 
-        ForceNextStateNone(ctx);
+        ForceNextStateNone(ctx, __LINE__);
         if (mctx == ctx)
         {
             endOfRecording = true;
@@ -3065 +3113 @@
 
 void TV::ProcessKeypress(PlayerContext *actx, QKeyEvent *e)
 {
+    bool ignoreKeys = actx->IsNVPChangingBuffers();
 #if DEBUG_ACTIONS
-    VERBOSE(VB_IMPORTANT, LOC + "ProcessKeypress() ignoreKeys: "<<ignoreKeys);
+    VERBOSE(VB_IMPORTANT, LOC + QString("ProcessKeypress() ignoreKeys: %1")
+            .arg(ignoreKeys));
 #endif // DEBUG_ACTIONS
 
     if (db_idle_timeout > 0)
@@ -3191 +3241 @@
     handled = handled || DVDMenuHandleAction(actx, actions, isDVD, isDVDStill);
     handled = handled || ActiveHandleAction(actx, actions, isDVD, isDVDStill);
     handled = handled || ToggleHandleAction(actx, actions, isDVD);
-    handled = handled || PIPHandleAction(actx, actions);
+    handled = handled || PxPHandleAction(actx, actions);
     handled = handled || FFRewHandleAction(actx, actions);
     handled = handled || ActivePostQHandleAction(actx, actions, isDVD);
 
@@ -3223 +3273 @@
 
 bool TV::BrowseHandleAction(PlayerContext *ctx, const QStringList &actions)
 {
-    bool handled = false;
     if (!browsemode)
-        return handled;
+        return false;
 
-    handled = true;
+    bool handled = true;
 
     if (has_action("UP", actions) || has_action("CHANNELUP", actions))
         BrowseDispInfo(ctx, BROWSE_UP);
@@ -3254 +3303 @@
         ToggleRecord(ctx);
     else
     {
+        handled = false;
         QStringList::const_iterator it = actions.begin();
         for (; it != actions.end(); ++it)
         {
@@ -3262 +3312 @@
             {
                 CommitQueuedInput(ctx);
                 BrowseEnd(ctx, false);
+                handled = true;
             }
         }
     }
 
     // only pass-through actions listed below
-    return !(has_action("VOLUMEDOWN",      actions) ||
-             has_action("VOLUMEUP",        actions) ||
-             has_action("STRETCHINC",      actions) ||
-             has_action("STRETCHDEC",      actions) ||
-             has_action("MUTE",            actions) ||
-             has_action("TOGGLEASPECT",    actions) ||
-             has_action("TOGGLEPIPWINDOW", actions) ||
-             has_action("TOGGLEPIPMODE",   actions) ||
-             has_action("TOGGLEPIPSTATE",  actions) ||
-             has_action("SWAPPIP",         actions));
-
-    // TODO FIXME this is never reached.. must be a logic error
-    return handled;
+    return handled ||
+        !(has_action("VOLUMEDOWN",      actions) ||
+          has_action("VOLUMEUP",        actions) ||
+          has_action("STRETCHINC",      actions) ||
+          has_action("STRETCHDEC",      actions) ||
+          has_action("MUTE",            actions) ||
+          has_action("TOGGLEASPECT",    actions) ||
+          has_action("TOGGLEPIPMODE",   actions) ||
+          has_action("TOGGLEPIPSTATE",  actions) ||
+          has_action("NEXTPIPWINDOW",   actions) ||
+          has_action("CREATEPIPVIEW",   actions) ||
+          has_action("CREATEPBPVIEW",   actions) ||
+          has_action("SWAPPIP",         actions));
 }
 
 bool TV::ManualZoomHandleAction(PlayerContext *actx, const QStringList &actions)
@@ -3467 +3518 @@
         }
         else if (dialogname == "allowrecordingbox")
         {
-            int result = osd->GetDialogResponse(dialogname);
-
-            if (result == 1)
-                actx->recorder->CancelNextRecording(false);
-            else if (result == 2)
-                StopLiveTV();
-            else if (result == 3)
-                actx->recorder->CancelNextRecording(true);
+            HandleOSDAskAllowResponse();
         }
         else if (dialogname == "idletimeout")
         {
@@ -3831 +3875 @@
     {
         ClearOSD(ctx);
     }
-    else if (has_action("JUMPPREV", actions))
-    {
-        if (PromptRecGroupPassword(ctx))
-        {
-            ctx->nvp->SetBookmark();
-            SetExitPlayer(true, true);
-        }
-    }
     else if (has_action("VIEWSCHEDULED", actions))
         EditSchedule(ctx, kViewSchedule);
-    else if (has_action("JUMPREC", actions))
+    else if (HandleJumpToProgramAction(ctx, actions))
     {
-        if (gContext->GetNumSetting("JumpToProgramOSD", 1) &&
-            StateIsPlaying(ctx->GetState()))
-        {
-            if (jumpMenuTimerId)
-                KillTimer(jumpMenuTimerId);
-            jumpMenuTimerId = StartTimer(1, __LINE__);
-        }
-        else if (RunPlaybackBoxPtr)
-            EditSchedule(ctx, kPlaybackBox);
     }
     else if (has_action("SIGNALMON", actions))
     {
@@ -3898 +3925 @@
     }
     else if (has_action("ESCAPE", actions))
     {
-        SetActive(ctx, 0);
+        VERBOSE(VB_IMPORTANT, LOC + "ESCAPE");
+
         osd = GetOSDLock(ctx);
         if (StateIsLiveTV(ctx->GetState()) &&
             (ctx->lastSignalMsgTime.elapsed() <
@@ -3917 +3945 @@
 
         StopFFRew(ctx);
 
+        bool do_exit = false;
+
         if (StateIsLiveTV(GetState(ctx)))
         {
             if (ctx->nvp &&
-                (12 & gContext->GetNumSetting("PlaybackExitPrompt")))
+                (12 & db_playback_exit_prompt))
             {
                 PromptStopWatchingRecording(ctx);
             }
             else
             {
-                SetExitPlayer(true, true);
+                do_exit = true;
             }
         }
         else
         {
             if (ctx->nvp &&
-                (5 & gContext->GetNumSetting("PlaybackExitPrompt")) &&
+                (5 & db_playback_exit_prompt) &&
                 !underNetworkControl && !isDVDStill)
             {
                 PromptStopWatchingRecording(ctx);
                 return handled;
             }
             else if (ctx->nvp &&
-                     (gContext->GetNumSetting("PlaybackExitPrompt") == 2))
+                     (db_playback_exit_prompt == 2))
             {
                 ctx->nvp->SetBookmark();
             }
             if (ctx->nvp &&
-                gContext->GetNumSetting("AutomaticSetWatched", 0))
+                db_auto_set_watched)
             {
                 ctx->nvp->SetWatched();
             }
             requestDelete = false;
-            SetExitPlayer(true, true);
+            do_exit = true;
         }
+
+        if (do_exit)
+        {
+            PlayerContext *mctx = GetPlayer(ctx, 0);
+            if (mctx != ctx)
+            { // A PIP is active, just tear it down..
+                PxPTeardownView(ctx);
+                return handled;
+            }
+            else
+            {
+                SetExitPlayer(true, true);
+            }
+        }
+
+        SetActive(ctx, 0, false);
     }
     else if (has_action("VOLUMEDOWN", actions))
         ChangeVolume(ctx, false);
@@ -4075 +4121 @@
     return handled;
 }
 
-bool TV::PIPHandleAction(PlayerContext *ctx, const QStringList &actions)
+bool TV::PxPHandleAction(PlayerContext *ctx, const QStringList &actions)
 {
-    bool handled = true;
-
     if (!IsPIPSupported(ctx))
-        return handled;
+        return false;
 
-    if (has_action("TOGGLEPIPMODE", actions))
-        TogglePIPView(ctx);
-    else if (has_action("TOGGLEPBPMODE", actions))
+    bool handled = true;
     {
-        needToMakePIPChange = kPBPToggle;
-        if (pipChangeTimerId)
-            KillTimer(pipChangeTimerId);
-        pipChangeTimerId = StartTimer(1, __LINE__);
+        QMutexLocker locker(&timerIdLock);
+
+        if (has_action("TOGGLEPIPMODE", actions))
+            changePxP.enqueue("TOGGLEPIPMODE");
+        else if (has_action("TOGGLEPBPMODE", actions))
+            changePxP.enqueue("TOGGLEPBPMODE");
+        else if (has_action("CREATEPIPVIEW", actions))
+            changePxP.enqueue("CREATEPIPVIEW");
+        else if (has_action("CREATEPBPVIEW", actions))
+            changePxP.enqueue("CREATEPBPVIEW");
+        else if (has_action("SWAPPIP", actions))
+            changePxP.enqueue("SWAPPIP");
+        else if (has_action("TOGGLEPIPSTATE", actions))
+            changePxP.enqueue("TOGGLEPIPSTATE");
+        else
+            handled = false;
+        
+        if (!changePxP.empty() && !pipChangeTimerId)
+            pipChangeTimerId = StartTimer(1, __LINE__);
     }
-    else if (has_action("SWAPPIP", actions))
+
+    if (has_action("NEXTPIPWINDOW", actions))
     {
-        needToMakePIPChange = (ctx->isPBP()) ? kPBPSwap : kPIPSwap;
-        if (pipChangeTimerId)
-            KillTimer(pipChangeTimerId);
-        pipChangeTimerId = StartTimer(1, __LINE__);
+        SetActive(ctx, -1, true);
+        handled = true;
     }
-    else if (has_action("TOGGLEPIPSTATE", actions))
-    {
-        if (ctx && player.size() > 1)
-        {
-            needToMakePIPChange = (ctx->isPBP()) ? kPBPToPIP : kPIPToPBP;
-            if (pipChangeTimerId)
-                KillTimer(pipChangeTimerId);
-            pipChangeTimerId = StartTimer(1, __LINE__);
-        }
-    }
-    else if (has_action("TOGGLEPIPWINDOW", actions))
-        ToggleActiveWindow(ctx, 1);
-    else
-        handled = false;
 
     return handled;
 }
@@ -4131 +4173 @@
             if (isDVD && ctx->buffer && ctx->buffer->DVD())
                 ctx->buffer->DVD()->JumpToTitle(false);
 
-            int clearpos = gContext->GetNumSetting("AltClearSavedPosition", 1);
             ctx->LockDeleteNVP(__FILE__, __LINE__);
             if (ctx->nvp)
             {
-                if (clearpos && ctx->nvp->GetBookmark())
+                if (db_toggle_bookmark && ctx->nvp->GetBookmark())
                     ctx->nvp->ClearBookmark();
                 else
                     ctx->nvp->SetBookmark();
@@ -4200 +4241 @@
 void TV::ProcessNetworkControlCommand(PlayerContext *ctx,
                                       const QString &command)
 {
+    bool ignoreKeys = ctx->IsNVPChangingBuffers();
 #ifdef DEBUG_ACTIONS
     VERBOSE(VB_IMPORTANT, LOC + "ProcessNetworkControlCommand(" +
-            QString("%1)").arg(command));
+            QString("%1) ignoreKeys: %2").arg(command).arg(ignoreKeys));
 #endif
 
+    if (ignoreKeys)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                "Ignoring network control command"
+                "\n\t\t\tbecause ignoreKeys is set");
+        return;
+    }
+
     QStringList tokens = command.split(" ", QString::SkipEmptyParts);
     if (tokens.size() < 2)
     {
@@ -4365 +4415 @@
     {
         if (ctx->nvp)
             ctx->nvp->SetBookmark();
-        if (ctx->nvp && gContext->GetNumSetting("AutomaticSetWatched", 0))
+        if (ctx->nvp && db_auto_set_watched)
             ctx->nvp->SetWatched();
         SetExitPlayer(true, true);
     }
@@ -4549 +4599 @@
         swap(player[0],player[1]);
         player[0]->SetPIPState(kPIPOff);
         // End the old main context..
-        ForceNextStateNone(mctx);
+        ForceNextStateNone(mctx, __LINE__);
     }
 
     VERBOSE(VB_PLAYBACK, LOC + "CreatePBP() -- end : "<<ok);
@@ -4557 +4607 @@
 }
 
 /**
- * \brief tear down remaining PBP video and restore
- * fullscreen display 
+ * \brief create PIP.
+ * \param info programinfo for PIP to create. is NULL for LiveTV PIP
  */
-void TV::TeardownPBP(PlayerContext *ctx)
+bool TV::CreatePIP(PlayerContext *ctx, const ProgramInfo *info)
 {
     PlayerContext *mctx = GetPlayer(ctx, 0);
+    if (!mctx)
+        return false;
 
-    if (!mctx->nvp || !mctx->nvp->IsPlaying() || 
-        mctx->GetPIPState() < kPBPLeft || exitPlayerTimerId)
-    {
-        return;
-    }
+    VERBOSE(VB_PLAYBACK, LOC + "CreatePIP -- begin");
 
-    VERBOSE(VB_PLAYBACK, LOC  + "TeardownPBP -- begin");
-
-    long long mctx_frame = mctx->nvp->GetFramesPlayed();
-    mctx->PIPTeardown();
-    mctx->SetPIPState(kPIPOff);
-    mctx->buffer->Seek(0, SEEK_SET);
-    if (mctx->CreateNVP(this, myWindow, mctx->GetState(),
-                        embedWinID, &embedBounds))
+    if (mctx->isPBP())
     {
-        ScheduleStateChange(mctx);
-        mctx->StartOSD(this);
-        mctx->nvp->JumpToFrame(mctx_frame);
-
-        //TODO find out where wantsToQuit is been enabled
-        wantsToQuit = false;
-
-        SetSpeedChangeTimer(25, __LINE__);
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "CreatePIP called, but we're in PBP mode already, ignoring.");
+        return false;
     }
-    else
-        ForceNextStateNone(mctx);
 
-    VERBOSE(VB_PLAYBACK, LOC + "TeardownPBP -- end");
-}
+    bool has_vo = false, using_xvmc = false;
 
-/**
- * \brief create PIP.
- * \param info programinfo for PIP to create. is NULL for LiveTV PIP
- */
-bool TV::CreatePIP(PlayerContext *ctx, const ProgramInfo *info)
-{
-    bool ret = false;
-    PlayerContext *mctx = GetPlayer(ctx, 0);
-
-    VERBOSE(VB_PLAYBACK, LOC + "Starting CreatePIP -- begin");
-    bool using_xvmc = false;
-    QRect rect;
-    PIPLocation pip_location;
-    if (mctx && mctx->nvp && mctx->nvp->getVideoOutput())
+    mctx->LockDeleteNVP(__FILE__, __LINE__);
+    if (mctx->nvp && mctx->nvp->getVideoOutput())
     {
-        pip_location = (PIPLocation)gContext->GetNumSetting("PIPLocation", 0);
-        rect = mctx->nvp->getVideoOutput()->GetPIPRect(pip_location, NULL);
+        has_vo = true;
         using_xvmc = mctx->nvp->getVideoOutput()->hasMCAcceleration();
     }
-    else
-    {
-        return ret;
-    }
+    mctx->UnlockDeleteNVP(__FILE__, __LINE__);
 
+    if (!has_vo)
+        return false;
+
     /* TODO implement PIP solution for Xvmc playback */
     if (using_xvmc)
     {
         VERBOSE(VB_IMPORTANT, LOC + "PiP is not supported for XvMC");
-        return ret;
+        return false;
     }
 
     PlayerContext *pipctx = new PlayerContext();
@@ -4643 +4663 @@
     else
     {
         delete pipctx;
-        return ret;
+        return false;
     }
 
     // this is safe because we are already holding lock for ctx
     player.push_back(pipctx);
 
-    ret = true;
-    return ret;
+    return true;
 }
 
 int TV::find_player_index(const PlayerContext *ctx) const
@@ -4662 +4681 @@
 }
 
 bool TV::StartPlayer(PlayerContext *mctx, PlayerContext *ctx,
-                     TVState desiredState, bool ispip)
+                     TVState desiredState)
 {
-    if (ispip)
-        return StartPIPPlayer(mctx, ctx, desiredState);
+    bool wantPiP = ctx->isPIP();
 
-    VERBOSE(VB_IMPORTANT, LOC + QString("StartPlayer(%1, %2, not pip) -- begin")
-            .arg(find_player_index(ctx)).arg(StateToString(desiredState)));
+    VERBOSE(VB_IMPORTANT, LOC + QString("StartPlayer(%1, %2, %3) -- begin")
+            .arg(find_player_index(ctx)).arg(StateToString(desiredState))
+            .arg((wantPiP) ? "PiP" : "main"));
 
+    if (wantPiP)
+    {
+        if (mctx->nvp && ctx->StartPIPPlayer(this, desiredState) &&
+            ctx->nvp && PIPAddPlayer(mctx, ctx))
+        {
+            ScheduleStateChange(ctx);
+            VERBOSE(VB_IMPORTANT, "StartPlayer PiP -- end : ok");
+            return true;
+        }
+
+        ForceNextStateNone(ctx, __LINE__);
+        VERBOSE(VB_IMPORTANT, "StartPlayer PiP -- end : !ok");
+        return false;
+    }
+
     InitUDPNotifyEvent();
     bool ok = false;
     if (ctx->UseNullVideo())
@@ -4677 +4711 @@
         ok = ctx->CreateNVP(this, NULL, desiredState, 0, NULL);
         ScheduleStateChange(ctx);
         if (ok)
-            SetPIPPlayer(mctx, ctx);
+            ok = PIPAddPlayer(mctx, ctx);
     }
     else
     {
@@ -4692 +4726 @@
         SetSpeedChangeTimer(25, __LINE__);
     }
 
-    VERBOSE(VB_IMPORTANT, LOC +
-            QString("StartPlayer(%1, %2, not pip) -- end %3")
+    VERBOSE(VB_IMPORTANT, LOC + QString("StartPlayer(%1, %2, %3) -- end %4")
             .arg(find_player_index(ctx)).arg(StateToString(desiredState))
-            .arg((ok) ? "ok" : "error"));
+            .arg((wantPiP) ? "PiP" : "main").arg((ok) ? "ok" : "error"));
 
     return ok;
 }
 
-bool TV::StartPIPPlayer(PlayerContext *mctx, PlayerContext *ctx,
-                        TVState desiredState)
+/// \brief Maps NVP of software scaled PIP to the NVP of the main player
+bool TV::PIPAddPlayer(PlayerContext *mctx, PlayerContext *pipctx)
 {
-    if (mctx->nvp && ctx->StartPIPPlayer(this, desiredState) && ctx->nvp)
+    if (!mctx || !pipctx)
+        return false;
+
+    if (!mctx->nvp || !mctx->nvp->IsPlaying())
+        return false;
+
+    bool ok = false, addCondition = false;
+    if (pipctx->nvp)
     {
-        SetPIPPlayer(mctx, ctx);
-        ScheduleStateChange(ctx);
-        return true;
+        if (pipctx->nvp->UsingNullVideo())
+        {
+            addCondition = true;
+            PIPLocation loc = mctx->nvp->GetNextPIPLocation();
+            ok = mctx->nvp->AddPIPPlayer(pipctx->nvp, loc, 4000);
+        }
+        else if (pipctx->isPIP())
+        {
+            ok = ResizePIPWindow(pipctx);
+        }
     }
-    return false;
+
+    VERBOSE(VB_IMPORTANT,
+            QString("AddPIPPlayer null: %1 isPIP: %2 addCond: %3 ok: %4")
+            .arg(pipctx->nvp->UsingNullVideo())
+            .arg(pipctx->isPIP()).arg(addCondition).arg(ok));
+
+    return ok;
 }
 
-/**
- * \brief maps NVP of software scaled PIP  to the NVP of player
- * context 0.
- */
-void TV::SetPIPPlayer(PlayerContext *mctx, PlayerContext *pipctx)
+/// \brief Unmaps NVP of software scaled PIP from the NVP of the main player
+bool TV::PIPRemovePlayer(PlayerContext *mctx, PlayerContext *pipctx)
 {
     if (!mctx || !pipctx)
+        return false;
+
+    bool ok = false;
+    if (mctx->nvp && pipctx->nvp)
+        ok = mctx->nvp->RemovePIPPlayer(pipctx->nvp, 4000);
+
+    VERBOSE(VB_IMPORTANT, QString("PIPRemovePlayer ok: %1").arg(ok));
+
+    return ok;
+}
+
+/// \brief start/stop PIP/PBP
+void TV::PxPToggleView(PlayerContext *actx, bool wantPBP)
+{
+    if (player.size() <= 1)
+        PxPCreateView(actx, wantPBP);
+    else
+        PxPTeardownView(actx);
+}
+
+/// \brief start PIP/PBP
+void TV::PxPCreateView(PlayerContext *actx, bool wantPBP)
+{
+    if (!actx)
         return;
 
-    bool setCondition = false;
-    if (mctx->nvp && mctx->nvp->IsPlaying())
+    QString err_msg = QString::null;
+    if ((player.size() > kMaxPBPCount) && (wantPBP || actx->isPBP()))
     {
-        if (pipctx->nvp)
-        {
-            if (pipctx->nvp->UsingNullVideo())
-                setCondition = true;
-            else if (playerActive == 0 && pipctx->isPIP())
-                ResizePIPWindow(pipctx);
-        }
-        else
-            setCondition = true;
+        err_msg = tr("Sorry, PBP only supports %1 video streams")
+            .arg(kMaxPBPCount);
+    }
 
-        if (setCondition)
-        {
-            QMutex piplock;
-            piplock.lock();
-            mctx->nvp->SetPIPPlayer(pipctx->nvp);
-            pipPlayerSetCondition.wait(&piplock);
-            piplock.unlock();
-        }
+    if ((player.size() > kMaxPIPCount) &&
+        (!wantPBP || GetPlayer(actx,1)->isPIP()))
+    {
+        err_msg = tr("Sorry, PIP only supports %1 video streams")
+            .arg(kMaxPIPCount);
     }
+
+    if ((player.size() > 1) && (wantPBP ^ actx->isPBP()))
+        err_msg = tr("Sorry, can not mix PBP and PIP views");
+
+    if (!err_msg.isEmpty())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + err_msg);
+        OSD *osd = GetOSDLock(actx);
+        if (osd)
+            osd->SetSettingsText(err_msg, 3);
+        ReturnOSDLock(actx, osd);
+        return;
+    }
+
+    bool ok = false;
+    if (wantPBP)
+        ok = CreatePBP(actx, NULL);
+    else
+        ok = CreatePIP(actx, NULL);
+    actx = GetPlayer(actx, -1); // CreatePBP/PIP mess with ctx's
+
+    QString msg = (ok) ?
+        ((wantPBP) ? tr("Creating PBP")      : tr("Creating PIP")) :
+        ((wantPBP) ? tr("Cannot create PBP") : tr("Cannot create PIP"));
+    
+    OSD *osd = GetOSDLock(actx);
+    if (osd)
+        osd->SetSettingsText(msg, 3);
+    ReturnOSDLock(actx, osd);
 }
 
-/**
- * \brief start/stop PIP/PBP
- *
- */
-void TV::TogglePIPView(PlayerContext *lctx, bool ispbp)
+/// \brief stop PIP/PBP
+void TV::PxPTeardownView(PlayerContext *actx)
 {
+    VERBOSE(VB_IMPORTANT, "PxPTeardownView()");
+
     QString msg;
+    PlayerContext *mctx = GetPlayer(actx, 0);
+    PlayerContext *dctx = NULL;
+    dctx = (mctx != actx)       ? actx               : dctx;
+    dctx = (2 == player.size()) ? GetPlayer(actx, 1) : dctx;
 
-    if (player.size() > 1)
+    SetActive(actx, 0, false);
+
+    PlayerContext *ctx1 = GetPlayer(actx, 1);
+    msg = (ctx1->isPIP()) ? tr("Stopping PIP") : tr("Stopping PBP");
+    if (dctx)
     {
-        PlayerContext *ctx = player.back();
-        msg = "Stopping ";
-        msg += (ctx->isPIP()) ? "PIP" : "PBP";
-        if (playerActive != 0)
-            ToggleActiveWindow(lctx, 1);
-        ForceNextStateNone(ctx);
+        ForceNextStateNone(dctx, __LINE__);
     }
     else
     {
-        bool ok = false;
-        if (ispbp)
-            ok = CreatePBP(lctx, NULL);
-        else
-            ok = CreatePIP(lctx, NULL);
-        lctx = GetPlayer(lctx, -1); // CreatePBP/PIP mess with ctx's
-
-        if (!ok)
+        if (player.size() > 2)
         {
-            msg = "Cannot Start ";
-            msg += (ispbp) ? "PBP" : "PIP";
+            msg = (ctx1->isPIP()) ?
+                tr("Stopping all PIPs") : tr("Stopping all PBPs");
         }
+
+        for (uint i = player.size() - 1; i > 0; i--)
+            ForceNextStateNone(GetPlayer(actx,i), __LINE__);
     }
 
-    OSD *osd = GetOSDLock(lctx);
+    OSD *osd = GetOSDLock(mctx);
     if (osd)
         osd->SetSettingsText(msg, 3);
-    ReturnOSDLock(lctx, osd);
+    ReturnOSDLock(mctx, osd);
 }
 
 /**
 * \brief Change PIP View from PIP to PBP and visa versa
 */
-void TV::TogglePIPState(PlayerContext *mctx, PIPState changeTo)
+void TV::PxPToggleType(PlayerContext *mctx, bool wantPBP)
 {
-    QString before = (changeTo == kPIPToPBP) ? "PIP" : "PBP";
-    QString after  = (changeTo == kPIPToPBP) ? "PBP" : "PIP";
+    const QString before = (mctx->isPBP()) ? "PBP" : "PIP";
+    const QString after  = (wantPBP)       ? "PBP" : "PIP";
+
     VERBOSE(VB_PLAYBACK, LOC +
-            QString("TogglePIPState() converting from %1 to %2 -- begin")
-                    .arg(before).arg(after));
+            QString("PxPToggleType() converting from %1 to %2 -- begin")
+            .arg(before).arg(after));
 
-    if (2 != player.size())
+    if (mctx->isPBP() == wantPBP)
     {
-        VERBOSE(VB_IMPORTANT, LOC_ERR +
-                QString("TogglePIPState() -- end: # player contexts must be 2, "
-                        "but it is currently %1").arg(player.size()));
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                "PxPToggleType() -- end: already in desired mode");
         return;
     }
 
-    SetActive(mctx, 0);
+    uint max_cnt = min(kMaxPBPCount, kMaxPIPCount);
+    if (player.size() > max_cnt)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                QString("PxPToggleType() -- end: "
+                        "# player contexts must be %1 or less, "
+                        "but it is currently %1")
+                .arg(max_cnt).arg(player.size()));
 
-    PlayerContext *pipctx = GetPlayer(mctx, 1);
+        QString err_msg = tr("Too many views to switch");
 
-    if (!mctx->nvp || !pipctx->nvp || !pipctx->nvp->IsPlaying())
+        PlayerContext *actx = GetPlayer(mctx, -1);
+        OSD *osd = GetOSDLock(actx);
+        if (osd)
+            osd->SetSettingsText(err_msg, 3);
+        ReturnOSDLock(actx, osd);
         return;
+    }
 
+    for (uint i = 0; i < player.size(); i++)
+    {
+        PlayerContext *ctx = GetPlayer(mctx, i);
+        ctx->LockDeleteNVP(__FILE__, __LINE__);
+        if (!ctx->nvp || !ctx->nvp->IsPlaying())
+        {
+            ctx->UnlockDeleteNVP(__FILE__, __LINE__);
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "PxPToggleType() -- end: " +
+                    QString("nvp #%1 is not active, exiting without "
+                            "doing anything to avoid danger").arg(i));
+            return;
+        }
+        ctx->UnlockDeleteNVP(__FILE__, __LINE__);
+    }
+
     MuteState mctx_mute = mctx->nvp->GetMuteState();
 
-    vector<long long> pos;
-    pos.push_back(mctx->nvp->GetFramesPlayed());
-    pos.push_back(pipctx->nvp->GetFramesPlayed());
+    vector<long long> pos = TeardownAllNVPs(mctx);
 
-    TeardownPIPWindows(mctx);
-
-    if (changeTo == kPIPToPBP)
+    if (wantPBP)
     {
-        mctx->SetPIPState(kPBPLeft);
-        pipctx->SetPIPState(kPBPRight);
+        GetPlayer(mctx, 0)->SetPIPState(kPBPLeft);
+        GetPlayer(mctx, 1)->SetPIPState(kPBPRight);
     }
     else
     {
-        mctx->SetPIPState(kPIPOff);
-        pipctx->SetPIPState(kPIPonTV);
-        pipctx->SetNullVideo(true);
+        GetPlayer(mctx, 0)->SetPIPState(kPIPOff);
+        for (uint i = 1; i < player.size(); i++)
+        {
+            GetPlayer(mctx, i)->SetPIPState(kPIPonTV);
+            GetPlayer(mctx, i)->SetNullVideo(true);
+        }
     }
 
-    RestartPIPWindows(mctx, pos, mctx_mute);
+    RestartAllNVPs(mctx, pos, mctx_mute);
 
     VERBOSE(VB_PLAYBACK, LOC +
-            QString("TogglePIPState() converting from %1 to %2 -- end")
+            QString("PxPToggleType() converting from %1 to %2 -- end")
             .arg(before).arg(after));
 }
 
-void TV::ToggleActiveWindow(PlayerContext *lctx, int ctx_index)
-{
-    if (player.size() == 1 || ctx_index < 1)
-        return;
-
-    ClearOSD(lctx);
-
-    PlayerContext *ctx = GetPlayer(lctx, ctx_index);
-    if (ctx->nvp)
-    {
-        int new_index = 0;
-        lockTimerOn = false;
-
-        if (playerActive != ctx_index)
-            new_index = ctx_index;
-
-        SetActive(lctx, new_index);
-    }
-
-    PlayerContext *actx = GetPlayer(lctx, -1);
-    OSD *osd = GetOSDLock(actx);
-    if (osd)
-        osd->SetSettingsText(tr("Changed Active Window"), 3);
-    ReturnOSDLock(actx, osd);
-}
-
 /**
- * \brief wake TV thread when pip player var is set in the main NVP
- */
-void TV::WakeSetPIPPlayerCond(void)
-{
-    pipPlayerSetCondition.wakeAll();
-}
-
-/**
  * \brief resize PIP Window. done when changing channels or swapping PIP
  */
-void TV::ResizePIPWindow(PlayerContext *ctx)
+bool TV::ResizePIPWindow(PlayerContext *ctx)
 {
-    PlayerContext *actx = GetPlayer(ctx, -1);
-    PIPLocation loc = (PIPLocation) gContext->GetNumSetting("PIPLocation", 0);
-    if (actx->nvp && ctx->nvp)
+    VERBOSE(VB_PLAYBACK, LOC + "ResizePIPWindow -- begin");
+    PlayerContext *mctx = GetPlayer(ctx, 0);
+    if (mctx->nvp && ctx->nvp)
     {
-        QRect rect = 
-            actx->nvp->getVideoOutput()->GetPIPRect(loc, ctx->nvp, false);
-        ctx->ResizePIPWindow(rect);
+        QRect rect;
+
+        mctx->LockDeleteNVP(__FILE__, __LINE__);
+        if (mctx->nvp)
+        {
+            PIPLocation loc = mctx->nvp->GetNextPIPLocation();
+            VERBOSE(VB_PLAYBACK, LOC + "ResizePIPWindow -- loc "<<loc);
+            if (loc != kPIP_END)
+            {
+                rect = mctx->nvp->getVideoOutput()->GetPIPRect(
+                    loc, ctx->nvp, false);
+            }
+        }
+        mctx->UnlockDeleteNVP(__FILE__, __LINE__);
+
+        if (rect.isValid())
+        {
+            ctx->ResizePIPWindow(rect);
+            VERBOSE(VB_PLAYBACK, LOC + "ResizePIPWindow -- end : ok");
+            return true;
+        }
     }
+    VERBOSE(VB_PLAYBACK, LOC + "ResizePIPWindow -- end : !ok");
+    return false;
 }
 
 bool TV::IsPIPSupported(const PlayerContext *ctx) const
@@ -4902 +5006 @@
     return yes;
 }
 
-/**
-* \brief Teardown all NVP's in preparation for PIP Swap or change from PIP <-> PBP
-*/
-void TV::TeardownPIPWindows(PlayerContext *lctx)
+/** \brief Teardown all NVP's in preparation for PxP Swap or
+ *         change from PIP -> PBP or PBP -> PIP
+ */
+vector<long long> TV::TeardownAllNVPs(PlayerContext *lctx)
 {
-    SetActive(lctx, 0);
+    vector<long long> pos;
+    for (uint i = 0; i < player.size(); i++)
+    {
+        const PlayerContext *ctx = GetPlayer(lctx, i);
+        ctx->LockDeleteNVP(__FILE__, __LINE__);
+        pos.push_back((ctx->nvp) ? ctx->nvp->GetFramesPlayed() : 0);
+        ctx->UnlockDeleteNVP(__FILE__, __LINE__);
+    }
 
     for (uint i = 0; i < player.size(); i++)
     {
         PlayerContext *ctx = GetPlayer(lctx, i);
         ctx->PIPTeardown();
     }
+
+    return pos;
 }
 
 /**
+ * \brief tear down remaining PBP video and restore
+ * fullscreen display 
+ */
+void TV::PBPRestartMainNVP(PlayerContext *mctx)
+{
+    VERBOSE(VB_PLAYBACK, LOC  + "PBPRestartMainNVP -- begin");
+
+    mctx->LockDeleteNVP(__FILE__, __LINE__);
+    if (!mctx->nvp || !mctx->nvp->IsPlaying() || 
+        mctx->GetPIPState() != kPBPLeft || exitPlayerTimerId)
+    {
+        mctx->UnlockDeleteNVP(__FILE__, __LINE__);
+        VERBOSE(VB_PLAYBACK, LOC  + "PBPRestartMainNVP -- end !ok !valid");
+        return;
+    }
+
+    long long mctx_frame = mctx->nvp->GetFramesPlayed();
+    mctx->UnlockDeleteNVP(__FILE__, __LINE__);
+
+    mctx->PIPTeardown();
+    mctx->SetPIPState(kPIPOff);
+    mctx->buffer->Seek(0, SEEK_SET);
+
+    if (mctx->CreateNVP(this, myWindow, mctx->GetState(),
+                        embedWinID, &embedBounds))
+    {
+        ScheduleStateChange(mctx);
+        mctx->StartOSD(this);
+        mctx->nvp->JumpToFrame(mctx_frame);
+        SetSpeedChangeTimer(25, __LINE__);
+        VERBOSE(VB_PLAYBACK, LOC + "PBPRestartMainNVP -- end ok");
+        return;
+    }
+
+    ForceNextStateNone(mctx, __LINE__);
+    VERBOSE(VB_PLAYBACK, LOC +
+            "PBPRestartMainNVP -- end !ok NVP did not restart");
+}
+
+/**
 * \brief Recreate Main and PIP windows. Could be either PIP or PBP views.
 */
-void TV::RestartPIPWindows(PlayerContext *lctx,
-                           const vector<long long> &pos,
-                           MuteState mctx_mute)
+void TV::RestartAllNVPs(PlayerContext *lctx,
+                        const vector<long long> &pos,
+                        MuteState mctx_mute)
 {
-    QString loc = LOC + QString("RestartPIPWindows()");
+    QString loc = LOC + QString("RestartAllNVPs(): ");
 
     PlayerContext *mctx = GetPlayer(lctx, 0);
 
@@ -4935 +5088 @@
     if (StateIsLiveTV(mctx->GetState()))
         mctx->buffer->Unpause();
 
-    bool ok = StartPlayer(mctx, mctx, mctx->GetState(), false);
+    bool ok = StartPlayer(mctx, mctx, mctx->GetState());
 
     if (ok)
     {
@@ -4945 +5098 @@
     {
         VERBOSE(VB_IMPORTANT, loc +
                 "Failed to restart new main context (was pip context)");
-        ForceNextStateNone(mctx);
+        ForceNextStateNone(mctx, __LINE__);
         return;
     }
 
@@ -4958 +5111 @@
         if (StateIsLiveTV(pipctx->GetState()))
             pipctx->buffer->Unpause();
 
-        ok = StartPlayer(mctx, pipctx, pipctx->GetState(), pipctx->isPIP());
+        ok = StartPlayer(mctx, pipctx, pipctx->GetState());
 
         if (ok)
         {
@@ -4970 +5123 @@
         { // TODO print OSD informing user of Swap failure ?
             VERBOSE(VB_IMPORTANT, loc +
                     "Failed to restart new pip context (was main context)");
-            ForceNextStateNone(pipctx);
+            ForceNextStateNone(pipctx, __LINE__);
         }
     }
 
@@ -4980 +5133 @@
         mctx->nvp->SetMuteState(mctx_mute);
 }
 
-void TV::SwapPIP(PlayerContext *lctx, int ctx_index, bool ispbp)
+void TV::PxPSwap(PlayerContext *mctx, int ctx_index)
 {
     lockTimerOn = false;
 
-    PlayerContext *mctx = GetPlayer(lctx, 0);
-    if (player.size() == 1)
+    if (player.size() <= 1 || !mctx)
         return;
 
-    PlayerContext *pipctx = GetPlayer(lctx, ctx_index);
+    PlayerContext *pipctx = GetPlayer(mctx, ctx_index);
+    ctx_index = find_player_index(pipctx);
+    if (ctx_index < 0 || !pipctx)
+        return;
 
     if (!mctx->nvp || !pipctx->nvp || !pipctx->nvp->IsPlaying())
         return;
@@ -4996 +5151 @@
     VERBOSE(VB_PLAYBACK, LOC + "SwapPIP -- begin");
 
     MuteState mctx_mute = mctx->nvp->GetMuteState();
-
-    vector<long long> pos;
-    for (uint i = 0; i < player.size(); i++)
-    {
-        const PlayerContext *ctx = GetPlayer(lctx, i);
-        ctx->LockDeleteNVP(__FILE__, __LINE__);
-        pos.push_back((ctx->nvp) ? ctx->nvp->GetFramesPlayed() : 0);
-        ctx->UnlockDeleteNVP(__FILE__, __LINE__);
-    }
-
     bool useNullVideo = pipctx->UseNullVideo();
 
-    TeardownPIPWindows(lctx);
+    vector<long long> pos = TeardownAllNVPs(mctx);
 
-    swap(player[0], player[ctx_index]);
-    swap(pos[0],    pos[ctx_index]);
-
-    pipctx->SetPIPState((ispbp) ? kPBPLeft: kPIPOff);
-
+    swap(player[0],           player[ctx_index]);
+    swap(pos[0],              pos[ctx_index]);
+    swap(player[0]->pipState, player[ctx_index]->pipState);
+    playerActive = (ctx_index == playerActive) ?
+        0 : ((ctx_index == 0) ? ctx_index : playerActive);
+    
     if (useNullVideo)
         mctx->SetNullVideo(true);
 
-    mctx->SetPIPState((ispbp) ? kPBPRight: kPIPonTV);
-
-    RestartPIPWindows(mctx, pos, mctx_mute);
+    RestartAllNVPs(mctx, pos, mctx_mute);
 }
 
 void TV::DoPlay(PlayerContext *ctx)
@@ -5379 +5523 @@
             ctx->playingInfo->ApplyTranscoderProfileChange(profile);
             QString jobHost = "";
 
-            if (gContext->GetNumSetting("JobsRunOnRecordHost", 0))
+            if (db_run_jobs_on_remote)
                 jobHost = ctx->playingInfo->hostname;
 
             OSD *osd = GetOSDLock(ctx);
@@ -5590 +5734 @@
 
     if (testrec && testrec->IsValidRecorder())
     {
-        // pause the decoder first, so we're not reading to close to the end.
+        PlayerContext *mctx = GetPlayer(ctx, 0);
+        if (mctx != ctx)
+            PIPRemovePlayer(mctx, ctx);
 
+        // pause the decoder first, so we're not reading too close to the end.
         ctx->buffer->IgnoreLiveEOF(true);
         ctx->buffer->StopReads();
         ctx->nvp->PauseDecoder();
@@ -5601 +5748 @@
         ctx->buffer->WaitForPause();
         ctx->nvp->StopPlaying();
         ctx->recorder->StopLiveTV();
-        {
-            ctx->SetNVP(NULL);
-            PlayerContext *mctx = GetPlayer(ctx, 0);
-            if (ctx != mctx)
-                SetPIPPlayer(mctx, ctx);
-        }
+        ctx->SetNVP(NULL);
 
         // now restart stuff
         ctx->lastSignalUIInfo.clear();
@@ -5650 +5792 @@
                 ok = true;
                 ctx->StartOSD(this);
                 ctx->PushPreviousChannel();
-                if (ctx && (player.size() > 1))
-                {
-                    if (0 == playerActive)
-                    {
-                        PlayerContext *ctx1 = GetPlayer(ctx, 1);
-                        SetPIPPlayer(mctx, ctx1);
-                    }
-                    else
-                    {
-                        PlayerContext *mctx = GetPlayer(ctx, 0);
-                        SetPIPPlayer(mctx, ctx);
-                    }
-                }
+                for (uint i = 1; i < player.size(); i++)
+                    PIPAddPlayer(mctx, GetPlayer(ctx, i));
 
                 SetSpeedChangeTimer(25, __LINE__);
             }
@@ -6949 +7080 @@
     margin = margin * 5;
     QDomElement xmldata;
     XMLParse *theme = new XMLParse();
-    if (!allowembed ||
-        !theme->LoadTheme(xmldata, str) ||
-        !gContext->GetNumSetting("ContinueEmbeddedTVPlay", 0) ||
-        ctx->nvp->IsNearEnd(margin) ||
-        ctx->paused)
+    if (!allowembed || !theme->LoadTheme(xmldata, str) ||
+        !db_continue_embedded || ctx->nvp->IsNearEnd(margin) || ctx->paused)
     {
         if (!stayPaused)
             DoPause(ctx, false);
@@ -6968 +7096 @@
 
 void TV::DoEditSchedule(int editType)
 {
-    PlayerContext *mctx = GetPlayerReadLock(0, __FILE__, __LINE__);
-    mctx->LockPlayingInfo(__FILE__, __LINE__);
-    if (!mctx->playingInfo)
+    PlayerContext *actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
+
+    actx->LockPlayingInfo(__FILE__, __LINE__);
+    if (!actx->playingInfo)
     {
         VERBOSE(VB_IMPORTANT,
-                LOC_ERR + "doEditSchedule(): no active mctx->playingInfo.");
-        mctx->UnlockPlayingInfo(__FILE__, __LINE__);
-        ReturnPlayerLock(mctx);
+                LOC_ERR + "doEditSchedule(): no active ctx playingInfo.");
+        actx->UnlockPlayingInfo(__FILE__, __LINE__);
+        ReturnPlayerLock(actx);
         return;
     }
 
     // Collect channel info
-    uint    chanid  = mctx->playingInfo->chanid.toUInt();
-    QString channum = mctx->playingInfo->chanstr;
-    mctx->UnlockPlayingInfo(__FILE__, __LINE__);
+    uint    chanid  = actx->playingInfo->chanid.toUInt();
+    QString channum = actx->playingInfo->chanstr; channum.detach();
+    actx->UnlockPlayingInfo(__FILE__, __LINE__);
 
-    ClearOSD(mctx);
+    ClearOSD(actx);
 
     // Resize window to the MythTV GUI size
-
+    PlayerContext *mctx = GetPlayer(actx, 0);
     if (mctx->nvp && mctx->nvp->getVideoOutput()) 
         mctx->nvp->getVideoOutput()->ResizeForGui(); 
     MythMainWindow *mwnd = gContext->GetMainWindow();
-    bool using_gui_size_for_tv = gContext->GetNumSetting("GuiSizeForTV", 0);
-    if (!using_gui_size_for_tv)
+
+    if (!db_use_gui_size_for_tv)
     {
         mwnd->setGeometry(saved_gui_bounds.left(), saved_gui_bounds.top(),
                           saved_gui_bounds.width(), saved_gui_bounds.height());
@@ -7018 +7147 @@
                 player = this;
             if (StateIsLiveTV(GetState(mctx)))
             {
-                ReturnPlayerLock(mctx);
+                ReturnPlayerLock(actx);
                 changeChannel = GuideGrid::Run(chanid, channum, false,
                                                player, allowsecondary);
-                mctx = GetPlayerReadLock(0, __FILE__, __LINE__);
+                actx = GetPlayerReadLock(0, __FILE__, __LINE__);
             }
             else
             {
-                ReturnPlayerLock(mctx);
+                ReturnPlayerLock(actx);
                 GuideGrid::Run(chanid, channum, false, player);
-                mctx = GetPlayerReadLock(0, __FILE__, __LINE__);
+                actx = GetPlayerReadLock(0, __FILE__, __LINE__);
             }
             break;
         }
         case kScheduleProgramFinder:
             if (!mctx->paused)
                 DoPause(mctx, false);
+            ReturnPlayerLock(actx);
             RunProgramFind(false, false);
+            actx = GetPlayerReadLock(0, __FILE__, __LINE__);
             break;
         case kScheduledRecording:
         {
             if (mctx->paused)
                 DoPause(mctx, false);
+
             mctx->LockPlayingInfo(__FILE__, __LINE__);
+            const ProgramInfo pginfo(*mctx->playingInfo);
+            mctx->UnlockPlayingInfo(__FILE__, __LINE__);
+            ReturnPlayerLock(actx);
+
             ScheduledRecording *record = new ScheduledRecording();
-            record->loadByProgram(mctx->playingInfo);
+            record->loadByProgram(&pginfo);
             record->exec();
             record->deleteLater();
-            mctx->UnlockPlayingInfo(__FILE__, __LINE__);
+
+            actx = GetPlayerReadLock(0, __FILE__, __LINE__);
             break;
         }
         case kViewSchedule:
         {
             showvideo = VideoThemeCheck(mctx, "conflict-video", stayPaused);
+            ReturnPlayerLock(actx);
             RunViewScheduledPtr((void *)this, showvideo);
+            actx = GetPlayerReadLock(0, __FILE__, __LINE__);
             break;
         }
         case kPlaybackBox:
         {
             showvideo = VideoThemeCheck(mctx, "playback-video", stayPaused);
+            ReturnPlayerLock(actx);
             nextProgram = RunPlaybackBoxPtr((void *)this, showvideo);
+            actx = GetPlayerReadLock(0, __FILE__, __LINE__);
         }
     }
 
@@ -7072 +7213 @@
         embedCheckTimerId = 0;
     }
 
-    if (StateIsPlaying(GetState(mctx)) && 
+    VERBOSE(VB_PLAYBACK, LOC 
+            <<"state: "<<StateToString(GetState(mctx))
+            <<"!stayPaused: "<<stayPaused<<" mctx->paused: "<<mctx->paused);
+    if ((StateIsPlaying(GetState(mctx)) || StateIsLiveTV(GetState(mctx))) &&
         !stayPaused && mctx->paused)
     {
+        VERBOSE(VB_PLAYBACK, LOC + "Unpausing video");
+        // this should unpause video..
         DoPause(mctx, true);
     }
-    ReturnPlayerLock(mctx);
+    ReturnPlayerLock(actx);
 
     mctx = GetPlayerWriteLock(0, __FILE__, __LINE__);
     if (nextProgram)
     {
-        if (nextProgPIPState == kPIPonTV)
+        if (jumpToProgramPIPState == kPIPonTV)
             CreatePIP(mctx, nextProgram);
-        else if (nextProgPIPState == kPBPLeft)
+        else if (jumpToProgramPIPState == kPBPLeft)
             CreatePBP(mctx, nextProgram);
         else
         {
-            setLastProgram(nextProgram);
+            SetLastProgram(nextProgram);
             jumpToProgram = true;
             SetExitPlayer(true, true);
         }
         mctx = GetPlayer(mctx, 0); // CreatePBP/PIP mess with ctx's
 
-        nextProgPIPState = kPIPOff;
+        jumpToProgramPIPState = kPIPOff;
         delete nextProgram;
         nextProgram = NULL;
     }
@@ -7102 +7248 @@
 
     mctx = GetPlayerReadLock(0, __FILE__, __LINE__);
     // Resize the window back to the MythTV Player size
-    if (!using_gui_size_for_tv)
+    if (!db_use_gui_size_for_tv)
     {
         mwnd->setGeometry(player_bounds.left(), player_bounds.top(),
                           player_bounds.width(), player_bounds.height());
@@ -7124 +7270 @@
 
 void TV::EditSchedule(const PlayerContext *ctx, int editType)
 {
-    if (ctx && (player.size() > 1))
-        return;
-
     // post the request to the main UI thread
     // it will be caught in eventFilter and processed as CustomEvent
     // this will create the program guide window (widget)
@@ -7486 +7629 @@
                 {
                     ctx->nvp->SetWatchingRecording(false);
                     ctx->nvp->SetLength(filelen);
-                    ctx->ChangeState(kState_WatchingPreRecorded);
+                    ctx->ChangeState(kState_WatchingPreRecorded, __LINE__);
                     ScheduleStateChange(ctx);
                 }
             }
@@ -7636 +7779 @@
 
     if (message.left(12) == "EXIT_TO_MENU")
     {
-        int exitprompt = gContext->GetNumSetting("PlaybackExitPrompt");
-
         PlayerContext *mctx = GetPlayerReadLock(0, __FILE__, __LINE__);
         for (uint i = 0; mctx && (i < player.size()); i++)
         {
             PlayerContext *ctx = GetPlayer(mctx, i);
             if (!ctx->nvp)
                 continue;
-            if (exitprompt == 1 || exitprompt == 2)
+            if (db_playback_exit_prompt == 1 || db_playback_exit_prompt == 2)
                 ctx->nvp->SetBookmark();
-            if (ctx->nvp && gContext->GetNumSetting("AutomaticSetWatched", 0))
+            if (ctx->nvp && db_auto_set_watched)
                 ctx->nvp->SetWatched();
         }
 
@@ -7725 +7866 @@
         }
     }
 
-    int player_cnt = 0;
+    if (message.left(9) == "START_EPG")
     {
-        PlayerContext *mctx = GetPlayerReadLock(0, __FILE__, __LINE__);
-        player_cnt = player.size();
-        ReturnPlayerLock(mctx);
-    }
-
-    if (message.left(9) == "START_EPG" && (1 == player_cnt))
-    {
         int editType = tokens[1].toInt();
         DoEditSchedule(editType);
     }
@@ -7836 +7970 @@
         browsechannum   = ctx->playingInfo->chanstr;
         browsechanid    = ctx->playingInfo->chanid;
         browsestarttime = ctx->playingInfo->startts.toString();
+        ctx->UnlockPlayingInfo(__FILE__, __LINE__);
 
         BrowseDispInfo(ctx, BROWSE_SAME);
 
@@ -7844 +7979 @@
             KillTimer(browseTimerId);
         browseTimerId = StartTimer(kBrowseTimeout, __LINE__);
     }
-    ctx->UnlockPlayingInfo(__FILE__, __LINE__);
+    else
+    {
+        ctx->UnlockPlayingInfo(__FILE__, __LINE__);
+    }
 }
 
 /** \fn TV::BrowseEnd(PlayerContext*, bool)
@@ -7978 +8116 @@
     QString cmdmsg("");
     if (ctx->playingInfo->GetAutoExpireFromRecorded() == kLiveTVAutoExpire)
     {
-        int autoexpiredef = gContext->GetNumSetting("AutoExpireDefault", 0);
-        ctx->playingInfo->SetAutoExpire(autoexpiredef);
+        ctx->playingInfo->SetAutoExpire(db_autoexpire_default);
         ctx->playingInfo->ApplyRecordRecGroupChange("Default");
         cmdmsg = tr("Record");
         ctx->SetPseudoLiveTV(ctx->playingInfo, kPseudoRecording);
@@ -8147 +8284 @@
     SetUpdateOSDPosition(false);
 }
 
-void TV::SetActive(PlayerContext *ctx, int index)
+#include <cassert>
+void TV::SetActive(PlayerContext *lctx, int index, bool osd_msg)
 {
-    VERBOSE(VB_PLAYBACK, "TV::SetActive -- begin");
+    assert(lctx);
+    if (!lctx)
+        return;
 
+    QString loc = LOC + QString("SetActive(%1,%2) was %3")
+        .arg(index).arg((osd_msg) ? "with OSD" : "w/o OSD").arg(playerActive);
+
+    VERBOSE(VB_PLAYBACK, loc + " -- begin");
+
     if (playerActive == index)
     {
-        VERBOSE(VB_PLAYBACK, "TV::SetActive -- index == active context");
+        VERBOSE(VB_PLAYBACK, loc + " -- end (index == playerActive)");
         return;
     }
 
-    VERBOSE(VB_PLAYBACK, "TV::SetActive -- lock");
+    index = (index < 0) ? (playerActive+1) % player.size() : index;
+    index = (index >= (int)player.size()) ? 0 : index;
 
-    PlayerContext *actx = NULL;
+    playerActive = index;
 
-    if (playerActive > -1 && !ctx)
+    for (int i = 0; i < (int)player.size(); i++)
     {
-        actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
-        ReturnPlayerLock(actx);
+        PlayerContext *ctx = GetPlayer(lctx, i);
+        ctx->LockDeleteNVP(__FILE__, __LINE__);
+        if (ctx->nvp)
+            ctx->nvp->SetPIPActive(i == playerActive);
+        ctx->UnlockDeleteNVP(__FILE__, __LINE__);
     }
 
-    VERBOSE(VB_PLAYBACK,
-            QString("TV::SetActive changing playerActive "
-                    "from %1 to %2")
-                    .arg(playerActive).arg(index));
-
-    playerActive = index;
-
-    if (!ctx)
+#if 0
+    // seems reduntant, except maybe for main player? -dtk
+    if (osd_msg)
     {
-        actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
-        ReturnPlayerLock(actx);
+        PlayerContext *actx = GetPlayer(lctx, -1);
+        OSD *osd = GetOSDLock(actx);
+        if (osd)
+            osd->SetSettingsText(tr("Active").arg(playerActive), 3);
+        ReturnOSDLock(actx, osd);
     }
+#endif
+
+    VERBOSE(VB_PLAYBACK, loc + " -- end");
 }
 
 void TV::TreeMenuEntered(OSDListTreeType *tree, OSDGenericTree *item)
@@ -8725 +8875 @@
         EditSchedule(actx, kScheduleProgramFinder);
     else if (action == "SCHEDULE")
         EditSchedule(actx, kScheduledRecording);
-    else if ((action == "JUMPPREV") ||
-             ((action == "PREVCHAN") && (!StateIsLiveTV(GetState(actx)))))
-    {
-        if (PromptRecGroupPassword(actx))
-        {
-            actx->nvp->SetBookmark();
-            jumpToProgram = true;
-            SetExitPlayer(true, true);
-        }
-    }
     else if (action == "VIEWSCHEDULED")
         EditSchedule(actx, kViewSchedule);
-    else if (action == "JUMPREC")
+    else if (HandleJumpToProgramAction(actx, QStringList(action)))
     {
-        if (gContext->GetNumSetting("JumpToProgramOSD", 1) &&
-            StateIsPlaying(actx->GetState()))
-        {
-            if (jumpMenuTimerId)
-                KillTimer(jumpMenuTimerId);
-            jumpMenuTimerId = StartTimer(1, __LINE__);
-        }
-        else if (RunPlaybackBoxPtr)
-            EditSchedule(actx, kPlaybackBox);
     }
-    else if (action == "TOGGLEPIPMODE")
+    else if (PxPHandleAction(actx, QStringList(action)))
     {
-        ReturnPlayerLock(actx);
+        // Hide the tree on this old active context..
+        tree->SetVisible(false);
+        tree->disconnect();
+        OSD *osd = GetOSDLock(actx);
+        if (osd)
+            osd->HideTreeMenu();
+        ReturnOSDLock(actx, osd);
+        ClearOSD(actx);
 
-        actx = GetPlayerWriteLock(-1, __FILE__, __LINE__);
-        TogglePIPView(actx);
-        ReturnPlayerLock(actx);
+        hidetree = true;
 
-        actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
+        actx = GetPlayer(actx,-1); // "NEXTPIPWINDOW" changes active context..
     }
-    else if (action == "TOGGLEPBPMODE")
-    {
-        needToMakePIPChange = kPBPToggle;
-        if (pipChangeTimerId)
-            KillTimer(pipChangeTimerId);
-        pipChangeTimerId = StartTimer(1, __LINE__);
-    }
-    else if (action == "TOGGLEPIPWINDOW")
-        ToggleActiveWindow(actx, 1);
-    else if (action == "TOGGLEPIPSTATE")
-    {
-        needToMakePIPChange = (actx->isPBP()) ? kPBPToPIP : kPIPToPBP;
-        if (pipChangeTimerId)
-            KillTimer(pipChangeTimerId);
-        pipChangeTimerId = StartTimer(1, __LINE__);
-    }
-    else if (action == "SWAPPIP")
-    {
-        needToMakePIPChange = (actx->isPBP()) ? kPBPSwap : kPIPSwap;
-        if (pipChangeTimerId)
-            KillTimer(pipChangeTimerId);
-        pipChangeTimerId = StartTimer(1, __LINE__);
-    }
     else if (StateIsLiveTV(GetState(actx)))
     {
         if (action == "TOGGLEBROWSE")
@@ -8825 +8938 @@
             DoQueueTranscode(actx, "Medium Quality");
         else if (action == "QUEUETRANSCODE_LOW")
             DoQueueTranscode(actx, "Low Quality");
-        else if (action.left(8) == "JUMPPROG")
-        {
-            SetJumpToProgram(action.section(" ",1,-2),
-                             action.section(" ",-1,-1).toInt());
-            actx->nvp->SetBookmark();
-            jumpToProgram = true;
-            SetExitPlayer(true, true);
-        }
         else
         {
             VERBOSE(VB_IMPORTANT, LOC_ERR +
@@ -8893 +8998 @@
         delete treeMenu;
 
     treeMenu = new OSDGenericTree(NULL, "treeMenu");
-    OSDGenericTree *item, *subitem;
 
     bool freeRecorders = RemoteGetFreeRecorderCount();
 
-    if (IsPIPSupported(ctx) && ((ctx && (player.size() > 1)) || freeRecorders))
-    {
-        // Picture-in-Picture
-        item = new OSDGenericTree(treeMenu, tr("Picture-in-Picture"));
-        if (ctx && (player.size() == 1))
-        {
-            subitem = new OSDGenericTree(item, tr("Enable PIP"),
-                                         "TOGGLEPIPMODE");
-            subitem = new OSDGenericTree(item, tr("Enable PBP"),
-                                         "TOGGLEPBPMODE");
-        }
-        else
-        {
-            QString option = "Disable ";
-            QString switchTo = "Switch to ";
-            QString pipType = (ctx->isPBP()) ? "PBP" : "PIP";
-            QString changeTo = (ctx->isPBP()) ? "PIP" : "PBP";
-            option += pipType;
-            switchTo += changeTo;
-            QString toggleMode = QString("TOGGLE%1MODE").arg(pipType);
-            subitem = new OSDGenericTree(item, option, toggleMode);
-            subitem = new OSDGenericTree(item, tr("Swap Windows"), 
-                                         "SWAPPIP");
-            subitem = new OSDGenericTree(item, tr("Change Active Window"),
-                                         "TOGGLEPIPWINDOW");
-            subitem = new OSDGenericTree(item, switchTo, "TOGGLEPIPSTATE");
-        }
-    }
-
     if (freeRecorders && ctx->recorder)
     {
         // Input switching
@@ -9003 +9078 @@
         }
     }
 
+    FillMenuPxP(ctx, treeMenu, freeRecorders);
+
     if ((ctx != GetPlayer(ctx, 0)))
         return;
 
@@ -9153 +9230 @@
     new OSDGenericTree(s_item, "120 " + tr("minutes"), "TOGGLESLEEP120");
 }
 
-void TV::FillMenuLiveTV(OSDGenericTree *treeMenu)
+/// \brief Constructs Picture-X-Picture portion of menu
+void TV::FillMenuPxP(
+    const PlayerContext *ctx, OSDGenericTree *treeMenu, bool freeRecorders)
 {
-    new OSDGenericTree(treeMenu, tr("Program Guide"), "GUIDE");
+    if (!ctx || !IsPIPSupported(ctx))
+        return;
 
-    if (!gContext->GetNumSetting("JumpToProgramOSD", 1))
+    if ((player.size() <= 1) && !freeRecorders)
+        return;
+
+    OSDGenericTree *item =
+        new OSDGenericTree(treeMenu, tr("Picture-in-Picture"));
+
+    if (freeRecorders)
     {
-        OSDGenericTree *jtpo_item =
-            new OSDGenericTree(treeMenu, tr("Jump to Program"));
-        new OSDGenericTree(jtpo_item, tr("Recorded Program"), "JUMPREC");
-        if (lastProgram != NULL)
-            new OSDGenericTree(jtpo_item, lastProgram->title, "JUMPPREV");
+        if (player.size() <= kMaxPIPCount)
+            new OSDGenericTree(item, tr("Open Live TV PIP"), "CREATEPIPVIEW");
+        if (player.size() <= kMaxPBPCount)
+            new OSDGenericTree(item, tr("Open Live TV PBP"), "CREATEPBPVIEW");
     }
 
+    if (player.size() <= kMaxPIPCount)
+        new OSDGenericTree(item, tr("Open Recording PIP"), "JUMPRECPIP");
+    if (player.size() <= kMaxPBPCount)
+        new OSDGenericTree(item, tr("Open Recording PBP"), "JUMPRECPBP");
+
+    if (player.size() <= 1)
+        return;
+
+    new OSDGenericTree(item, tr("Change Active Window"), "NEXTPIPWINDOW");
+
+    QString pipType  = (ctx->isPBP()) ? "PBP" : "PIP";
+    QString toggleMode = QString("TOGGLE%1MODE").arg(pipType);
+
+    bool isPBP = ctx->isPBP();
+    const PlayerContext *mctx = GetPlayer(ctx, 0);
+    QString pipClose = (isPBP) ? tr("Close PBP") : tr("Close PIP");
+    if (mctx == ctx)
+    {
+        if (player.size() > 2)
+            pipClose = (isPBP) ? tr("Close PBPs") : tr("Close PIPs");
+
+        new OSDGenericTree(item, pipClose, toggleMode);
+
+        if (player.size() == 2)
+            new OSDGenericTree(item, tr("Swap Windows"), "SWAPPIP");
+    }
+    else
+    {
+        new OSDGenericTree(item, pipClose, toggleMode);
+        new OSDGenericTree(item, tr("Swap Windows"), "SWAPPIP");
+    }
+
+    uint max_cnt = min(kMaxPBPCount, kMaxPIPCount);
+    if (player.size() <= max_cnt)
+    {
+        QString switchTo = (isPBP) ? tr("Switch to PIP") : tr("Switch to PBP");
+        new OSDGenericTree(item, switchTo, "TOGGLEPIPSTATE");
+    }
+}
+
+
+void TV::FillMenuLiveTV(OSDGenericTree *treeMenu)
+{
+    new OSDGenericTree(treeMenu, tr("Program Guide"), "GUIDE");
+
+    OSDGenericTree *jtpo_item =
+        new OSDGenericTree(treeMenu, tr("Jump to Program"));
+    new OSDGenericTree(jtpo_item, tr("Recorded Program"), "JUMPREC");
+    if (lastProgram != NULL)
+        new OSDGenericTree(jtpo_item, lastProgram->title, "JUMPPREV");
+
     if (!persistentbrowsemode)
         new OSDGenericTree(treeMenu, tr("Enable Browse Mode"), "TOGGLEBROWSE");
 
@@ -9395 +9531 @@
     ReturnOSDLock(ctx, osd);
 }
 
-void TV::SetJumpToProgram(QString progKey, int progIndex)
+bool TV::HandleJumpToProgramAction(
+    PlayerContext *ctx, const QStringList &actions)
 {
-    QMap<QString,ProgramList>::Iterator Iprog;
-    Iprog = progLists.find(progKey);
-    ProgramList plist = *Iprog;
-    ProgramInfo *p = plist.at(progIndex);
-    VERBOSE(VB_IMPORTANT, QString("Switching to program: %1: %2")
-            .arg(p->title).arg(p->subtitle));
-    setLastProgram(p);
+    const PlayerContext *mctx = GetPlayer(ctx, 0);
+    TVState s = ctx->GetState();
+    if (has_action("JUMPPREV", actions) ||
+        (has_action("PREVCHAN", actions) && !StateIsLiveTV(s)))
+    {
+        if (PromptRecGroupPassword(ctx))
+        {
+            if (mctx == ctx)
+            {
+                ctx->LockDeleteNVP(__FILE__, __LINE__);
+                ctx->nvp->SetBookmark();
+                ctx->UnlockDeleteNVP(__FILE__, __LINE__);
+                jumpToProgram = true;
+                SetExitPlayer(true, true);
+            }
+            else
+            {
+                // TODO
+            }
+        }
+        return true;
+    }
+
+    QStringList::const_iterator it = actions.begin();
+    for (; it != actions.end(); ++it)
+    {
+        if ((*it).left(8) != "JUMPPROG")
+            continue;
+
+        const QString &action = *it;
+
+        bool ok;
+        QString progKey   = action.section(" ",1,-2);
+        uint    progIndex = action.section(" ",-1,-1).toUInt(&ok);
+        ProgramInfo *p = NULL;
+
+        if (!ok)
+        {
+            QMutexLocker locker(&progListsLock);
+            QMap<QString,ProgramList>::const_iterator it =
+                progLists.find(progKey);
+            if (it != progLists.end())
+            {
+                const ProgramInfo *tmp = (*it)[progIndex];
+                if (tmp)
+                    p = new ProgramInfo(*tmp);
+            }
+        }
+
+        if (!p)
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR +
+                    QString("Failed to locate jump to program '%1' @ %2")
+                    .arg(progKey).arg(action.section(" ",-1,-1).toUInt(&ok)));
+            return true;
+        }
+
+        PIPState state = kPIPOff;
+        {
+            QMutexLocker locker(&timerIdLock);
+            state = jumpToProgramPIPState;
+        }
+
+        if (kPIPOff == state)
+        {
+            if (mctx == ctx)
+            {
+                VERBOSE(VB_GENERAL, LOC +
+                        QString("Switching to program: %1: %2")
+                        .arg(p->title).arg(p->subtitle));
+            
+                SetLastProgram(p);
+                ctx->LockDeleteNVP(__FILE__, __LINE__);
+                ctx->nvp->SetBookmark();
+                ctx->UnlockDeleteNVP(__FILE__, __LINE__);
+                jumpToProgram = true;
+                SetExitPlayer(true, true);
+            }
+            else
+            {
+                // TODO
+            }
+        }
+        else
+        {
+            QString type = (kPIPonTV == jumpToProgramPIPState) ? "PIP" : "PBP";
+            VERBOSE(VB_GENERAL, LOC + QString("Creating %1 with program: %2: %3")
+                    .arg(type).arg(p->title).arg(p->subtitle));
+
+            if (jumpToProgramPIPState == kPIPonTV)
+                CreatePIP(ctx, p);
+            else if (jumpToProgramPIPState == kPBPLeft)
+                CreatePBP(ctx, p);
+        }
+
+        delete p;
+
+        return true;
+    }
+
+    bool wants_jump = has_action("JUMPREC", actions);
+    bool wants_pip = !wants_jump && has_action("JUMPRECPIP", actions);
+    bool wants_pbp = !wants_jump && !wants_pip &&
+        has_action("JUMPRECPBP", actions);
+
+    if (!wants_jump && !wants_pip && !wants_pbp)
+        return false;
+
+    {
+        QMutexLocker locker(&timerIdLock);
+        jumpToProgramPIPState = wants_pip ? kPIPonTV :
+            (wants_pbp ? kPBPLeft : kPIPOff);
+    }
+
+    if (db_jump_prefer_osd && (StateIsPlaying(s) || StateIsLiveTV(s)))
+    {
+        QMutexLocker locker(&timerIdLock);
+        if (jumpMenuTimerId)
+            KillTimer(jumpMenuTimerId);
+        jumpMenuTimerId = StartTimer(1, __LINE__);
+    }
+    else if (RunPlaybackBoxPtr)
+        EditSchedule(ctx, kPlaybackBox);
+    else
+        VERBOSE(VB_IMPORTANT, "Failed to open jump to program GUI");
+
+    return true;
 }
 
 void TV::ToggleSleepTimer(const PlayerContext *ctx, const QString &time)
@@ -9761 +10018 @@
 
     ctx->UnlockPlayingInfo(__FILE__, __LINE__);
 
-    if (isDVD && (!gContext->GetNumSetting("EnableDVDBookmark", 0) ||
-                  ctx->buffer->DVD()->GetTotalTimeOfTitle() < 120))
-    {
-        return false;
-    }
-
-    return true;
+    return (!isDVD || (db_use_dvd_bookmark &&
+                       ctx->buffer->DVD()->GetTotalTimeOfTitle() >= 120));
 }
 
 /* \fn TV::IsDeleteAllowed(const PlayerContext*) const
@@ -9909 +10161 @@
             dialogname == "exitplayoptions");
 }
 
-void TV::setLastProgram(ProgramInfo *rcinfo)
+void TV::SetLastProgram(ProgramInfo *rcinfo)
 {
+    QMutexLocker locker(&lastProgramLock);
+
     if (lastProgram)
         delete lastProgram;
 
@@ -9920 +10174 @@
         lastProgram = NULL;
 }
 
+ProgramInfo *TV::GetLastProgram(void) const
+{
+    QMutexLocker locker(&lastProgramLock);
+    if (lastProgram)
+        return new ProgramInfo(*lastProgram);
+    return NULL;
+}
+
 QString TV::GetRecordingGroup(int player_idx) const
 {
     QString ret = QString::null;
@@ -10014 +10276 @@
     treeMenu = new OSDGenericTree(NULL, "treeMenu");
 
     // Build jumpMenu of recorded program titles
-    ProgramInfo *p;
+    QMutexLocker locker(&progListsLock);
     progLists.clear();
-    vector<ProgramInfo *> *infoList;
-    infoList = RemoteGetRecordedList(false);
+    vector<ProgramInfo *> *infoList = RemoteGetRecordedList(false);
 
     //bool LiveTVInAllPrograms = gContext->GetNumSetting("LiveTVInAllPrograms",0);
     if (infoList)
     {
         PlayerContext *actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
         actx->LockPlayingInfo(__FILE__, __LINE__);
-        vector<ProgramInfo *>::iterator i = infoList->begin();
-        for ( ; i != infoList->end(); i++)
+        vector<ProgramInfo *>::const_iterator it = infoList->begin();
+        for ( ; it != infoList->end(); it++)
         {
-            p = *i;
             //if (p->recgroup != "LiveTV" || LiveTVInAllPrograms)
-            if (p->recgroup == actx->playingInfo->recgroup)
-                progLists[p->title].prepend(p); 
+            if ((*it)->recgroup == actx->playingInfo->recgroup)
+                progLists[(*it)->title].push_front(new ProgramInfo(*(*it)));
         }
         actx->UnlockPlayingInfo(__FILE__, __LINE__);
         ReturnPlayerLock(actx);
 
-        QMap<QString,ProgramList>::Iterator Iprog; 
+        QMap<QString,ProgramList>::const_iterator Iprog; 
         for (Iprog = progLists.begin(); Iprog != progLists.end(); Iprog++)
         {
-            ProgramList plist = *Iprog;
+            const ProgramList &plist = *Iprog;
             int progIndex = plist.count();
             if (progIndex == 1)
             {
@@ -10053 +10313 @@
 
                 for (int i = 0; i < progIndex; i++)
                 {
-                    p = plist.at(i);
-                    if (p->subtitle.size())
+                    const ProgramInfo *p = plist[i];
+                    if (!p->subtitle.isEmpty())
                         new OSDGenericTree(j_item, p->subtitle,
                             QString("JUMPPROG %1 %2").arg(Iprog.key()).arg(i));
                     else
@@ -10064 +10324 @@
             }
         }
     }
+    while (!infoList->empty())
+    {
+        delete infoList->back();
+        infoList->pop_back();
+    }
+    delete infoList;
 
     PlayerContext *actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
     OSD *osd = GetOSDLock(actx);
@@ -10085 +10351 @@
         }
     }
     ReturnOSDLock(actx, osd);
-
+    ReturnPlayerLock(actx);
 }
 
 void TV::RestoreScreenSaver(const PlayerContext *ctx)
@@ -10096 +10362 @@
 
 void TV::InitUDPNotifyEvent(void)
 {
-    uint udp_port = gContext->GetNumSetting("UDPNotifyPort");
-    if (udp_port && !udpnotify)
+    if (db_udpnotify_port && !udpnotify)
     {
-        udpnotify = new UDPNotify(udp_port);
+        udpnotify = new UDPNotify(db_udpnotify_port);
         connect(udpnotify,
                 SIGNAL(AddUDPNotifyEvent(
                         const QString&,const UDPNotifyOSDSet*)),
@@ -10234 +10499 @@
 {
     playerLock.lockForWrite();
 
+    //VERBOSE(VB_IMPORTANT, LOC_WARN +
+    //        QString("GetPlayerWriteLock(%1,%2,%3) size(%4)")
+    //        .arg(which).arg(file).arg(location).arg(player.size()));
+
     if ((which >= (int)player.size()))
     {
         VERBOSE(VB_IMPORTANT, LOC_WARN +
@@ -10249 +10518 @@
 {
     playerLock.lockForRead();
 
+    //VERBOSE(VB_IMPORTANT, LOC_WARN +
+    //        QString("GetPlayerReadLock(%1,%2,%3) size(%4)")
+    //        .arg(which).arg(file).arg(location).arg(player.size()));
+
     if ((which >= (int)player.size()))
     {
         VERBOSE(VB_IMPORTANT, LOC_WARN +
@@ -10265 +10538 @@
 {
     playerLock.lockForRead();
 
+    //VERBOSE(VB_IMPORTANT, LOC_WARN +
+    //        QString("GetPlayerReadLock(%1,%2,%3) const size(%4)")
+    //        .arg(which).arg(file).arg(location).arg(player.size()));
+
     if ((which >= (int)player.size()))
     {
         VERBOSE(VB_IMPORTANT, LOC_WARN +
@@ -10312 +10589 @@
 
 void TV::ReturnPlayerLock(PlayerContext *&ctx)
 {
+    //VERBOSE(VB_IMPORTANT, LOC_WARN +
+    //        QString("ReturnPlayerLock() size(%4)")
+    //        .arg(player.size()));
+
     playerLock.unlock();
     ctx = NULL;
 }
 
 void TV::ReturnPlayerLock(const PlayerContext *&ctx) const
 {
+    //VERBOSE(VB_IMPORTANT, LOC_WARN +
+    //        QString("ReturnPlayerLock() const size(%4)")
+    //        .arg(player.size()));
+
     playerLock.unlock();
     ctx = NULL;
 }

libs/libmythtv/videoouttypes.h

@@ -11 +11 @@
     kPIPOff = 0,
     kPIPonTV,
     kPIPStandAlone,
-    kPIPSwap,
     kPBPLeft,
     kPBPRight,
-    kPBPSwap,
-    kPIPToPBP,
-    kPBPToPIP,
-    kPBPToggle
 } PIPState;
 
 typedef enum PIPLocation

libs/libmythtv/videooutbase.cpp

@@ -887 +887 @@
 
     int pipw, piph;
     VideoFrame *pipimage       = pipplayer->GetCurrentFrame(pipw, piph);
-    const bool  pipActive      = false;
+    const bool  pipActive      = pipplayer->IsPIPActive();
     const float pipVideoAspect = pipplayer->GetVideoAspect();
     const QSize pipVideoDim    = pipplayer->GetVideoBufferSize();
     const uint  pipVideoWidth  = pipVideoDim.width();

libs/libmythtv/playercontext.h

@@ -62 +62 @@
     bool StartPIPPlayer(TV *tv, TVState desiredState);
     void PIPTeardown(void);
     bool isPIP(void) const
-        { return (pipState > kPIPOff && pipState < kPBPLeft); }
+        { return (kPIPonTV == pipState) || (kPIPStandAlone == pipState); }
     bool isPBP(void) const
-        { return (pipState > kPIPStandAlone && pipState < kPBPSwap); }
+        { return (kPBPLeft == pipState) || (kPBPRight      == pipState); }
     bool isMainVideo(void) const
-        { return (pipState == kPIPOff || pipState == kPBPLeft); }
+        { return (kPIPOff  == pipState) || (kPBPLeft       == pipState); }
     void DrawARGBFrame(QPainter *p);
     QRect GetStandAlonePIPRect(void);
-    QString PIPLocationToString(void);
-    QString PIPStateToString(void);
     PIPState GetPIPState(void) const { return pipState; }
     void SetNullVideo(bool setting) { useNullVideo = setting; }
     bool UseNullVideo(void) const { return useNullVideo; }
+    bool IsNVPChangingBuffers(void) const { return nvpUnsafe; }
 
-
     void    PushPreviousChannel(void);
     QString PopPreviousChannel(void);
     QString GetPreviousChannel(void) const;
@@ -90 +88 @@
     void LockState(void) const;
     void UnlockState(void) const;
     bool InStateChange(void) const;
-    void ChangeState(TVState newState);
-    void ForceNextStateNone(void);
+    void ChangeState(TVState newState, int line);
+    void ForceNextStateNone(int line);
     TVState DequeueNextState(void);
     TVState GetState(void) const;
     /// This is set if the player encountered some irrecoverable error.
@@ -113 +111 @@
     void SetPlayGroup(const QString &group);
     void SetPseudoLiveTV(const ProgramInfo *pi, PseudoState new_state);
     void SetPIPState(PIPState change) { pipState = change; }
+    void SetNVPChangingBuffers(bool val) { nvpUnsafe = val; }
     void ResizePIPWindow(void);
 
 
   public:
     NuppelVideoPlayer  *nvp;
+    volatile bool       nvpUnsafe;
     RemoteEncoder      *recorder;
     LiveTVChain        *tvchain;
     RingBuffer         *buffer;

libs/libmythtv/videoout_xv.cpp

@@ -3606 +3606 @@
 
     int pipw, piph;
     VideoFrame *pipimage       = pipplayer->GetCurrentFrame(pipw, piph);
-    const bool  pipActive      = false;
+    const bool  pipActive      = pipplayer->IsPIPActive();
     const float pipVideoAspect = pipplayer->GetVideoAspect();
     const QSize pipVideoDim    = pipplayer->GetVideoBufferSize();
     const uint  pipVideoWidth  = pipVideoDim.width();