Ticket #6322: gridedit.trunk.code.5.patch

mythtv/libs/libmyth/mythdialogs.cpp

@@ -1327 +1327 @@
         rect_to_update = this->geometry();
     }
 
-    redrawRect = redrawRect.unite(r);
+    redrawRect = redrawRect.unite(rect_to_update);
 
     update(redrawRect);
 }
@@ -1652 +1652 @@
     return GetUIType<UIBlackHoleType>(this, name);
 }
 
+UIGridEditImageType* MythThemedDialog::getUIGridEditImageType(const QString &name)
+{
+    return GetUIType<UIGridEditImageType>(this, name);
+}
+
+UIGridEditSliderType* MythThemedDialog::getUIGridEditSliderType(const QString &name)
+{
+    return GetUIType<UIGridEditSliderType>(this, name);
+}
+
 UIImageType* MythThemedDialog::getUIImageType(const QString &name)
 {
     return GetUIType<UIImageType>(this, name);

mythtv/libs/libmyth/mythdialogs.h

@@ -26 +26 @@
 class UICheckBoxType;
 class UISelectorType;
 class UIBlackHoleType;
+class UIGridEditImageType;
+class UIGridEditSliderType;
 class UIImageType;
 class UIImageGridType;
 class UIStatusBarType;
@@ -373 +375 @@
     UICheckBoxType *getUICheckBoxType(const QString &name);
     UISelectorType *getUISelectorType(const QString &name);
     UIBlackHoleType *getUIBlackHoleType(const QString &name);
+    UIGridEditImageType *getUIGridEditImageType(const QString &name);
+    UIGridEditSliderType *getUIGridEditSliderType(const QString &name);
     UIImageGridType *getUIImageGridType(const QString &name);
     UIImageType *getUIImageType(const QString &name);
     UIStatusBarType *getUIStatusBarType(const QString &name);

mythtv/libs/libmyth/uitypes.cpp

@@ -4683 +4683 @@
 
 // ********************************************************************
 
+UIGridEditImageType::UIGridEditImageType(const QString &name)
+                     : UIType(name)
+{
+    cutStatus = 0;
+    highlightFrame = false; // Used to highlight frame #0
+    framenumber = -1;
+}
+
+void UIGridEditImageType::calculateScreenArea()
+{
+    QRect r = area;
+    r.translate(m_parent->GetAreaRect().left(),
+                m_parent->GetAreaRect().top());
+    screen_area = r;
+
+    inner_border.setLeft(screen_area.left()+1);
+    inner_border.setRight(screen_area.right()-1);
+    inner_border.setTop(screen_area.top()+1);
+    inner_border.setBottom(screen_area.bottom()-1);
+
+    outer_border = screen_area;
+}
+
+void UIGridEditImageType::Draw(QPainter *p, int drawlayer, int context)
+{
+    if (pmap.isNull())
+    {
+        QColor drawcolor = QColor( 0, 0, 0);
+        p->setBrush(QBrush(Qt::SolidPattern));
+        p->setPen(QPen(drawcolor, 2));
+        p->drawRect(screen_area);
+    }
+    else
+    {
+        p->drawPixmap(screen_area, pmap);
+
+        p->setBrush(QBrush(Qt::NoBrush));
+        // Draw the frame outline
+        // This may be covered by the cut indicator
+        // Or the highlight
+  
+        p->setPen(QPen(colorSet[0], 3));
+        p->drawRect(outer_border);
+
+        if (cutStatus > 0)
+        {
+            p->setPen(QPen(colorSet[cutStatus], 3));
+            p->drawRect(inner_border);
+            p->drawLine(inner_border.topLeft(), inner_border.bottomRight());
+            p->drawLine(inner_border.bottomLeft(), inner_border.topRight());
+        }
+        if (highlightFrame)
+        {
+            // Overlay the image frame with the standard frame color
+            // This is used to highlight small frame #0
+            p->setPen(QPen(highlightColor, 3));
+            p->drawRect(outer_border);
+        }
+    }
+}
+
+void UIGridEditImageType::setPixmap(QPixmap *new_pmap, long long frame, int new_cutStatus)
+{
+    // We can get a null new_pmap at the start or end of the video
+    if (! new_pmap)
+    {
+        clearPixmap();
+        return;
+    }
+
+    if (frame == framenumber)
+    {
+        // No change in pixmap (?)
+        setCutStatus(new_cutStatus);
+        return;
+    }
+
+    pmap = *new_pmap;
+    framenumber = frame;
+
+    if (new_cutStatus >= 0 && new_cutStatus <= 3)
+        cutStatus = new_cutStatus;
+    else
+        cutStatus = 0;
+
+    refresh();
+}
+
+void UIGridEditImageType::clearPixmap(bool dorefresh)
+{
+    if (! pmap.isNull())
+    {
+        pmap = QPixmap();
+
+        cutStatus = 0;
+        framenumber = -1;
+        if (dorefresh)
+            refresh();
+    }
+}
+
+void UIGridEditImageType::setCutStatus(int new_cutStatus)
+{
+    if (new_cutStatus == cutStatus)
+        return;
+
+    if (new_cutStatus >= 0 && new_cutStatus <= 3)
+        cutStatus = new_cutStatus;
+    else
+        cutStatus = 0;
+
+    refresh();
+}
+
+// ********************************************************************
+
+UIGridEditSliderType::UIGridEditSliderType(const QString &name)
+                     : UIType(name)
+{
+    m_drawMap = NULL;
+    m_position=0;
+}
+
+void UIGridEditSliderType::calculateScreenArea()
+{
+    QRect r = area;
+    r.translate(m_parent->GetAreaRect().left(),
+                m_parent->GetAreaRect().top());
+    screen_area = r;
+
+    if (m_drawMap)
+        delete [] m_drawMap;
+
+    m_drawWidth = area.width();
+    m_drawMap = new unsigned char[m_drawWidth];
+    for (int i = 0; i < m_drawWidth; i++)
+        m_drawMap[i] = 0;
+}
+
+void UIGridEditSliderType::ClearAll()
+{
+    for (int i = 0; i < m_drawWidth; i++)
+        m_drawMap[i] = 0;
+    refresh();
+}
+
+void UIGridEditSliderType::SetRange(
+        long long fstart, long long fend, long long fcount)
+{
+    if (fcount <= 0)
+    {
+        VERBOSE(VB_IMPORTANT, QString("Invalid frame count: %1")
+                .arg(fcount));
+        return;
+    }
+    if (fstart < 0)
+    {
+        VERBOSE(VB_IMPORTANT, QString("Invalid starting frame: %1")
+                .arg(fstart));
+        return;
+    }
+    if (fend < 0)
+    {
+        VERBOSE(VB_IMPORTANT, QString("Invalid ending frame: %1")
+                .arg(fend));
+        return;
+    }
+
+    if (fstart > fcount) fstart = fcount;
+    if (fend > fcount) fend = fcount;
+
+    int start = (int)((1.0 * fstart * m_drawWidth) / fcount);
+    int end   = (int)((1.0 * fend   * m_drawWidth) / fcount);
+
+    if (start < 0)
+        start = 0;
+    if (start >= m_drawWidth)
+        start = m_drawWidth - 1;
+    if (end < 0)
+        end = 0;
+    if (end >= m_drawWidth)
+        end = m_drawWidth - 1;
+
+    if (end < start)
+    {
+        int tmp = start;
+        start = end;
+        end = tmp;
+    }
+
+    for (int i = start; i < end; i++)
+        if (m_drawMap[i] < 1)
+            m_drawMap[i] = 1;
+
+    // Mark endpoints
+    m_drawMap[start] = 2;
+    m_drawMap[end]   = 2;
+
+    VERBOSE(VB_GENERAL, QString("Range = %1 - %2 (%3 - %4)")
+            .arg(start).arg(end)
+            .arg(fstart).arg(fend));
+    refresh();
+}
+
+void UIGridEditSliderType::SetPosition(
+        long long fposition, long long fcount)
+{
+    if (fcount <= 0)
+    {
+        VERBOSE(VB_IMPORTANT, QString("Invalid frame count: %1")
+                .arg(fcount));
+        return;
+    }
+
+    if (fposition < 0)
+    {
+        VERBOSE(VB_IMPORTANT, QString("Invalid position frame: %1")
+                .arg(fposition));
+        return;
+    }
+
+    if (fposition > fcount) fposition = fcount;
+
+    int new_position = (int)(1.0 * fposition * m_drawWidth) / fcount;
+
+    if (new_position < 0)
+        new_position = 0;
+    if (new_position >= m_drawWidth)
+       new_position = m_drawWidth - 1;
+
+    if (new_position != m_position)
+    {
+        m_position = new_position;
+        refresh();
+    }
+}
+
+void UIGridEditSliderType::Draw(QPainter *p, int drawlayer, int context)
+{
+    // Draw Background
+    p->setPen(QPen(colorSet[0], 2));
+    p->setBrush(colorSet[0]);
+    p->drawRect(screen_area);
+
+    // Draw bars
+
+//    VERBOSE(VB_GENERAL, QString("Starting"));
+    int i = 0;
+    do {
+        int start = 0;
+        int end = 0;
+
+        while (i < m_drawWidth && m_drawMap[i] == 0) i++;
+        if (i == m_drawWidth) break;
+        start = i;
+
+        i++;
+        
+
+        while (i < m_drawWidth && m_drawMap[i] == 1) i++;
+        end = i;
+        if (end == m_drawWidth) end--;
+
+        // If the next map value is not a normal internal cutpoint
+        // increment i so we handle it properly
+        if (end+1 < m_drawWidth && m_drawMap[end+1] != 1)
+            i++;
+
+        // start == starting point
+        //   end == endingpoint
+        {
+            QRect r = screen_area;
+            r.setLeft(r.left() + start);
+            r.setWidth(end - start);
+
+//            VERBOSE(VB_GENERAL, QString("Cut from (%1, %2) - (%3, %4)")
+//                    .arg(r.left()).arg(r.top())
+//                    .arg(r.right()).arg(r.bottom()));
+
+//            VERBOSE(VB_GENERAL, QString("start = %1, m_position = %2, end = %3")
+//                    .arg(start)
+//                    .arg(m_position)
+//                    .arg(end));
+            
+            if (start <= m_position && m_position <= end)
+            {
+                p->setPen(QPen(colorSet[4], 2));
+                p->setBrush(colorSet[4]);
+            }
+            else
+            {
+                p->setPen(QPen(colorSet[1], 2));
+                p->setBrush(colorSet[1]);
+            }
+            p->drawRect(r);
+
+            p->setPen(QPen(colorSet[2], 2));
+            p->setBrush(colorSet[2]);
+            if (m_drawMap[start] == 2)
+                p->drawLine(r.topLeft(), r.bottomLeft()); 
+            if (m_drawMap[end] == 2)
+                p->drawLine(r.topRight(), r.bottomRight()); 
+
+        }
+    } while (i < m_drawWidth);
+
+    // Draw Current Position Mark
+
+    QPoint ptop(screen_area.left() + m_position, screen_area.top());
+    QPoint pbot(screen_area.left() + m_position, screen_area.bottom());
+
+    p->setPen(QPen(colorSet[3], 2));
+    p->setBrush(colorSet[3]);
+    p->drawLine(ptop, pbot);
+}
+
+// ********************************************************************
+
 UIKeyType::UIKeyType(const QString &name)
          : UIType(name)
 {

mythtv/libs/libmyth/uitypes.h

@@ -1172 +1172 @@
     QRect area;
 };
 
+class MPUBLIC UIGridEditImageType : public UIType
+{
+    Q_OBJECT
+
+  public:
+
+    UIGridEditImageType(const QString &name);
+    void calculateScreenArea();
+    void setArea(QRect an_area)     { area = an_area; };
+
+    void setOutlineColor(QColor c)  { colorSet[0] = c; };
+    void setCutColor(QColor c)      { colorSet[1] = c; };
+    void setCutPointColor(QColor c)
+    {
+         colorSet[2] = c; // Cut before
+         colorSet[3] = c; // Cut after
+    };
+    void setHighlightFrame(bool high) { highlightFrame = high; };
+    void setHighlightColor(QColor c)  { highlightColor = c; };
+
+    virtual void Draw(QPainter *, int, int);
+    void setPixmap(QPixmap *new_pmap, long long frame, int new_cutStatus);
+ 
+    void clearPixmap(bool dorefresh=true);
+    void setCutStatus(int new_cutStatus);
+
+    QRect getOuterBorder() { return outer_border; };
+  protected:
+
+    QRect    area;
+    QRect    inner_border;
+    QRect    outer_border;
+    QPixmap  pmap;
+    long long framenumber; // for consistency checking
+    int      cutStatus;
+    QColor   colorSet[4];
+    bool     highlightFrame;
+    QColor   highlightColor;
+};
+
+class MPUBLIC UIGridEditSliderType : public UIType
+{
+    Q_OBJECT
+
+  public:
+
+    UIGridEditSliderType(const QString &name);
+    void calculateScreenArea();
+    void setArea(QRect an_area)     { area = an_area; };
+
+    void setFillColor(QColor c)     { colorSet[0] = c; };
+    void setCutColor(QColor c)      { colorSet[1] = c; };
+    void setCutPointColor(QColor c) { colorSet[2] = c; };
+    void setPositionColor(QColor c) { colorSet[3] = c; };
+    void setInCutColor(QColor c)    { colorSet[4] = c; };
+
+    void ClearAll();
+    void SetRange(long long fstart, long long fend, long long fcount);
+    void SetPosition(long long fposition, long long fcount);
+
+    virtual void Draw(QPainter *, int, int);
+  protected:
+
+    QRect          area;
+    unsigned char *m_drawMap;
+    int            m_drawWidth;
+    int            m_position;
+
+    QColor         colorSet[5];
+};
+
+
 class MPUBLIC UIKeyType : public UIType
 {
     Q_OBJECT

mythtv/libs/libmyth/xmlparse.cpp

@@ -1363 +1363 @@
             {
                 parseBlackHole(container, info);
             }
+            else if (info.tagName() == "grideditimage")
+            {
+                parseGridEditImage(container, info);
+            }
+            else if (info.tagName() == "grideditslider")
+            {
+                parseGridEditSlider(container, info);
+            }
             else if (info.tagName() == "area")
             {
                 area = parseRect(getFirstText(info));
@@ -3126 +3134 @@
     container->AddType(bh);
 }
 
+
+void XMLParse::parseGridEditImage(LayerSet *container, QDomElement &element)
+{
+    QRect area;
+    QColor outlineColor;
+    QColor cutColor;
+    QColor cutPointColor;
+    QColor highlightColor;
+    bool   haveOutlineColor = false;
+    bool   haveCutColor = false;
+    bool   haveCutPointColor = false;
+    bool   haveHighlightColor = false;
+    bool   highlightFrame = false;
+
+    QString name = element.attribute("name", "");
+    if (name.isNull() || name.isEmpty())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN + "GridEditImage needs a name");
+        return;
+    }
+    QString highlight = element.attribute("highlightframe", "");
+    if (highlight == "true")
+        highlightFrame = true;
+
+    for (QDomNode child = element.firstChild(); !child.isNull();
+         child = child.nextSibling())
+    {
+        QDomElement info = child.toElement();
+        if (!info.isNull())
+        {
+            if (info.tagName() == "area")
+            {
+                area = parseRect(getFirstText(info));
+                normalizeRect(area);
+            }
+            else if (info.tagName() == "outlinecolor")
+            {
+                haveOutlineColor = true;
+                outlineColor = getFirstText(info);
+            }
+            else if (info.tagName() == "cutcolor")
+            {
+                haveCutColor = true;
+                cutColor = getFirstText(info);
+            }
+            else if (info.tagName() == "cutpointcolor")
+            {
+                haveCutPointColor = true;
+                cutPointColor = getFirstText(info);
+            }
+            else if (info.tagName() == "highlightcolor")
+            {
+                haveHighlightColor = true;
+                highlightColor = getFirstText(info);
+            }
+            else
+            {
+                VERBOSE(VB_IMPORTANT, LOC_WARN +
+                        QString("Unknown tag '%1' in grideditimage '%2'")
+                        .arg(info.tagName()).arg(name));
+                return;
+            }
+        }
+    }
+
+    if (!haveOutlineColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'outlinecolor' in grideditimage '%1'")
+                .arg(name));
+        return;
+    }
+
+    if (!haveCutColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'cutcolor' in grideditimage '%1'")
+                .arg(name));
+        return;
+    }
+
+    if (!haveCutPointColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'cutpointcolor' in grideditimage '%1'")
+                .arg(name));
+        return;
+    }
+
+    if (highlightFrame && !haveHighlightColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("highlightframe specified but missing tag 'hightlightcolor' in grideditimage '%1'")
+                .arg(name));
+        return;
+    }
+
+
+    UIGridEditImageType *gei = new UIGridEditImageType(name);
+    gei->SetScreen(wmult, hmult);
+    gei->setArea(area);
+    gei->setOutlineColor(outlineColor);
+    gei->setCutColor(cutColor);
+    gei->setCutPointColor(cutPointColor);
+    gei->setHighlightColor(highlightColor);
+    gei->setHighlightFrame(highlightFrame);
+    gei->SetParent(container);
+    gei->calculateScreenArea();
+    gei->clearPixmap(false);
+    container->AddType(gei);
+}
+
+void XMLParse::parseGridEditSlider(LayerSet *container, QDomElement &element)
+{
+    QRect area;
+    QColor fillColor;
+    QColor cutColor;
+    QColor inCutColor;
+    QColor cutPointColor;
+    QColor positionColor;
+    bool   haveFillColor = false;
+    bool   haveCutColor = false;
+    bool   haveInCutColor = false;
+    bool   haveCutPointColor = false;
+    bool   havePositionColor = false;
+
+    QString name = element.attribute("name", "");
+    if (name.isNull() || name.isEmpty())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN + "GridEditSlider needs a name");
+        return;
+    }
+
+    for (QDomNode child = element.firstChild(); !child.isNull();
+         child = child.nextSibling())
+    {
+        QDomElement info = child.toElement();
+        if (!info.isNull())
+        {
+            if (info.tagName() == "area")
+            {
+                area = parseRect(getFirstText(info));
+                normalizeRect(area);
+            }
+            else if (info.tagName() == "fillcolor")
+            {
+                haveFillColor = true;
+                fillColor = getFirstText(info);
+            }
+            else if (info.tagName() == "cutcolor")
+            {
+                haveCutColor = true;
+                cutColor = getFirstText(info);
+            }
+            else if (info.tagName() == "incutcolor")
+            {
+                haveInCutColor = true;
+                inCutColor = getFirstText(info);
+            }
+            else if (info.tagName() == "cutpointcolor")
+            {
+                haveCutPointColor = true;
+                cutPointColor = getFirstText(info);
+            }
+            else if (info.tagName() == "positioncolor")
+            {
+                havePositionColor = true;
+                positionColor = getFirstText(info);
+            }
+            else
+            {
+                VERBOSE(VB_IMPORTANT, LOC_WARN +
+                        QString("Unknown tag '%1' in grideditslider '%2'")
+                        .arg(info.tagName()).arg(name));
+                return;
+            }
+        }
+    }
+
+    if (!haveFillColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'fillcolor' in grideditslider '%1'")
+                .arg(name));
+        return;
+    }
+
+    if (!haveCutColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'cutcolor' in grideditslider '%1'")
+                .arg(name));
+        return;
+    }
+
+    if (!haveInCutColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'incutcolor' in grideditslider '%1'")
+                .arg(name));
+        return;
+    }
+
+    if (!haveCutPointColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'cutpointcolor' in grideditslider '%1'")
+                .arg(name));
+        return;
+    }
+
+    if (!havePositionColor)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                QString("Missing tag 'positioncolor' in grideditslider '%1'")
+                .arg(name));
+        return;
+    }
+
+    UIGridEditSliderType *ges = new UIGridEditSliderType(name);
+    ges->SetScreen(wmult, hmult);
+    ges->setArea(area);
+    ges->setFillColor(fillColor);
+    ges->setCutColor(cutColor);
+    ges->setInCutColor(inCutColor);
+    ges->setCutPointColor(cutPointColor);
+    ges->setPositionColor(positionColor);
+    ges->SetParent(container);
+    ges->calculateScreenArea();
+    container->AddType(ges);
+}
+
 void XMLParse::parseListBtnArea(LayerSet *container, QDomElement &element)
 {
     int context = -1;

mythtv/libs/libmyth/xmlparse.h

@@ -47 +47 @@
     void parseCheckBox(LayerSet *, QDomElement &);
     void parseSelector(LayerSet *, QDomElement &);
     void parseBlackHole(LayerSet *, QDomElement &);
+    void parseGridEditImage(LayerSet *, QDomElement &);
+    void parseGridEditSlider(LayerSet *, QDomElement &);
     void parseListBtnArea(LayerSet *, QDomElement &);
     void parseListTreeArea(LayerSet *, QDomElement &);
     void parseKeyboard(LayerSet *, QDomElement &);

mythtv/libs/libmythtv/NuppelVideoPlayer.cpp

@@ -55 +55 @@
 #include "mythverbose.h"
 #include "myth_imgconvert.h"
 
+#include "grideditcutpoints.h"
+
 extern "C" {
 #include "vbitext/vbi.h"
 #include "vsync.h"
@@ -166 +168 @@
       decoder_thread_alive(true),   killplayer(false),
       killvideo(false),             livetv(false),
       watchingrecording(false),     editmode(false),
+      hideedits(false),
       resetvideo(false),            using_null_videoout(false),
       no_audio_in(false),           no_audio_out(false),
       transcoding(false),
@@ -175 +178 @@
       bookmarkseek(0),              previewFromBookmark(false),
       // Seek
       fftime(0),                    seekamountpos(4),
-      seekamount(30),               exactseeks(false),
+      allow_pagesize(false),        half_page(0),
+      seekamount(30),               seekamounttext("30 Frames"),
+      exactseeks(false),
       // Playback misc.
       videobuf_retries(0),          framesPlayed(0),
       totalFrames(0),               totalLength(0),
@@ -225 +230 @@
       yuv_need_copy(false),         yuv_desired_size(0,0),
       yuv_scaler(NULL),             yuv_frame_scaled(NULL),
       yuv_scaler_in_size(0,0),      yuv_scaler_out_size(0,0),
+      // Grid Editing
+      grid_edit_image_scaler(NULL), grid_edit_image_small_scaler(NULL),
+      grid_edit_image_buffer_yuv(NULL), grid_edit_image_small_buffer_yuv(NULL),
+      grid_edit_image_buffer_rgb(NULL), grid_edit_image_small_buffer_rgb(NULL),
+      grid_edit_image_buffer_length(0), grid_edit_image_small_buffer_length(0),
+      grid_edit_image_in_size(-1, -1),
+
       // Filters
       videoFiltersForProgram(""),   videoFiltersOverride(""),
       postfilt_width(0),            postfilt_height(0),
@@ -371 +383 @@
         output_jmeter = NULL;
     }
 
+    ClearScreenGrab();
+
     ShutdownYUVResize();
 }
 
@@ -1605 +1619 @@
     return retval;
 }
 
+
+bool NuppelVideoPlayer::GetScreenGrabsOfCurrentFrame(QImage &normal, QImage &small)
+{
+
+    unsigned char *data      = NULL;
+    VideoFrame    *frame     = NULL;
+    AVPicture      orig;
+    AVPicture      scaled;
+    AVPicture      scaled_small;
+    bzero(&orig,         sizeof(AVPicture));
+    bzero(&scaled,       sizeof(AVPicture));
+    bzero(&scaled_small, sizeof(AVPicture));
+
+    int vw, vh;
+    if (!(frame = GetCurrentFrame(vw, vh)))
+    {
+        return false;
+    }
+
+    if (!(data = frame->buf))
+    {
+        ReleaseCurrentFrame(frame);
+        return false;
+    }
+
+    // Check to see if the screen dimensions have changed
+    // Probably shouldn't happen in normal use.
+    if (grid_edit_image_in_size != video_dim)
+        SetupScreenGrab();
+
+    avpicture_fill(&orig, data, PIX_FMT_YUV420P,
+                   video_dim.width(), video_dim.height());
+
+    avpicture_deinterlace(&orig, &orig, PIX_FMT_YUV420P,
+                          video_dim.width(), video_dim.height());
+
+    // Rescale to the normal size
+    avpicture_fill(&scaled, grid_edit_image_buffer_yuv, PIX_FMT_YUV420P,
+                   grid_edit_image_size.width(),
+                   grid_edit_image_size.height());
+
+    img_resample(grid_edit_image_scaler, &scaled, &orig);
+
+    // Don't need the current frame anymore so release it
+    ReleaseCurrentFrame(frame);
+
+    // Rescale to the small size
+    avpicture_fill(&scaled_small, grid_edit_image_small_buffer_yuv, PIX_FMT_YUV420P,
+                   grid_edit_image_small_size.width(),
+                   grid_edit_image_small_size.height());
+
+    img_resample(grid_edit_image_small_scaler, &scaled_small, &scaled);
+
+    // Convert scaled and scaled_small from YUV to RGB
+
+    // scaled first
+    uint w = grid_edit_image_size.width();
+    uint h = grid_edit_image_size.height();
+    unsigned char *yuv_buf = grid_edit_image_buffer_yuv;
+    unsigned char *rgb_buf = grid_edit_image_buffer_rgb;
+    yuv2argb_conv(rgb_buf,
+                  yuv_buf, yuv_buf + (w * h), yuv_buf + (w * h * 5 / 4),
+                  w, h, w * 4, w, w / 2, 0);
+
+    // scaled_small next
+    w = grid_edit_image_small_size.width();
+    h = grid_edit_image_small_size.height();
+    yuv_buf = grid_edit_image_small_buffer_yuv;
+    rgb_buf = grid_edit_image_small_buffer_rgb;
+    yuv2argb_conv(rgb_buf,
+                  yuv_buf, yuv_buf + (w * h), yuv_buf + (w * h * 5 / 4),
+                  w, h, w * 4, w, w / 2, 0);
+
+#ifdef MMX
+#define _RGBSWAP .rgbSwapped()
+#endif
+
+    normal = QImage(grid_edit_image_buffer_rgb,
+                    grid_edit_image_size.width(), grid_edit_image_size.height(),
+                    QImage::Format_RGB32)_RGBSWAP;
+
+    small = QImage(grid_edit_image_small_buffer_rgb,
+                   grid_edit_image_small_size.width(), grid_edit_image_small_size.height(),
+                   QImage::Format_RGB32)_RGBSWAP;
+
+    return true;
+}
+
+void NuppelVideoPlayer::SetScreenGrabSizes(QSize normal, QSize small)
+{
+    grid_edit_image_size = normal;
+    grid_edit_image_small_size = small;
+
+    SetupScreenGrab();
+    VERBOSE(VB_GENERAL, QString("Main Image = (%1, %2) from (%3, %4)")
+                        .arg(grid_edit_image_size.width())
+                        .arg(grid_edit_image_size.height())
+                        .arg(normal.width()).arg(normal.height()));
+    VERBOSE(VB_GENERAL, QString("Small Image = (%1, %2) from (%3, %4)")
+                        .arg(grid_edit_image_small_size.width())
+                        .arg(grid_edit_image_small_size.height())
+                        .arg(small.width()).arg(small.height()));
+
+}
+
+void NuppelVideoPlayer::ClearScreenGrab()
+{
+    if (grid_edit_image_scaler)
+    {
+        img_resample_close(grid_edit_image_scaler);
+        grid_edit_image_scaler = NULL;
+    }
+
+    if (grid_edit_image_small_scaler)
+    {
+        img_resample_close(grid_edit_image_small_scaler);
+        grid_edit_image_small_scaler=NULL;
+    }
+
+    if (grid_edit_image_buffer_yuv)
+    {
+        delete grid_edit_image_buffer_yuv;
+        grid_edit_image_buffer_yuv=NULL;
+    }
+
+    if (grid_edit_image_small_buffer_yuv)
+    {
+        delete grid_edit_image_small_buffer_yuv;
+        grid_edit_image_small_buffer_yuv=NULL;
+    }
+
+    if (grid_edit_image_buffer_rgb)
+    {
+        delete grid_edit_image_buffer_rgb;
+        grid_edit_image_buffer_rgb=NULL;
+    }
+
+    if (grid_edit_image_small_buffer_rgb)
+    {
+        delete grid_edit_image_small_buffer_rgb;
+        grid_edit_image_small_buffer_rgb=NULL;
+    }
+}
+
+void NuppelVideoPlayer::SetupScreenGrab()
+{
+    ClearScreenGrab();
+    grid_edit_image_in_size = video_dim;
+
+    // Normalize the output sizes.
+    // This is necessary to preserve the aspect ratio
+
+    QSize tmpsize = grid_edit_image_size;
+    grid_edit_image_size =  video_dim;
+    grid_edit_image_size.scale(tmpsize, Qt::KeepAspectRatio);
+
+    tmpsize = grid_edit_image_small_size;
+    grid_edit_image_small_size = video_dim;
+    grid_edit_image_small_size.scale(tmpsize, Qt::KeepAspectRatio);
+
+    grid_edit_image_size = QSize(grid_edit_image_size.width() & ~0x7,
+                                 grid_edit_image_size.height() & ~0x7);
+    grid_edit_image_small_size = QSize(grid_edit_image_small_size.width() & ~0x7,
+                                       grid_edit_image_small_size.height() & ~0x7);
+
+    // Do normal first
+    uint sz = grid_edit_image_size.width() * grid_edit_image_size.height();
+    grid_edit_image_buffer_yuv = new unsigned char[(sz * 3 / 2) + 128];
+    grid_edit_image_buffer_rgb = new unsigned char[sz * 4 + 128];
+
+    grid_edit_image_scaler = img_resample_init(
+                grid_edit_image_size.width(), grid_edit_image_size.height(),
+                grid_edit_image_in_size.width(),  grid_edit_image_in_size.height());
+
+    // Then small
+    sz = grid_edit_image_small_size.width() * grid_edit_image_small_size.height();
+    grid_edit_image_small_buffer_yuv = new unsigned char[(sz * 3 / 2) + 128];
+    grid_edit_image_small_buffer_rgb = new unsigned char[sz * 4 + 128];
+
+    // Resize from normal to small
+    grid_edit_image_small_scaler = img_resample_init(
+                grid_edit_image_small_size.width(), grid_edit_image_small_size.height(),
+                grid_edit_image_size.width(),  grid_edit_image_size.height());
+}
+
 void NuppelVideoPlayer::ReleaseCurrentFrame(VideoFrame *frame)
 {
     if (frame)
@@ -4988 +5187 @@
 
     dialogname = "";
 
+    osd->HideAllExcept("editmode");
+
     QMap<QString, QString> infoMap;
     player_ctx->LockPlayingInfo(__FILE__, __LINE__);
     player_ctx->playingInfo->ToMap(infoMap);
@@ -5052 +5253 @@
     player_ctx->UnlockPlayingInfo(__FILE__, __LINE__);
 }
 
+bool NuppelVideoPlayer::EditSeekToFrame(long long targetFrame)
+{
+    bool tmpexactseeks = exactseeks;
+    GetDecoder()->setExactSeeks(true);
+
+//    VERBOSE(VB_GENERAL, QString("Before current frame = %1, going to frame %2")
+//           .arg(GetFramesPlayed())
+//           .arg(targetFrame));
+
+    if (framesPlayed > targetFrame)
+    {
+        // seek back
+        rewindtime = framesPlayed - targetFrame;
+        while (rewindtime != 0)
+            usleep(1000);
+    }
+    else
+    {
+        // seek forward
+        fftime = targetFrame - framesPlayed;
+        while (fftime != 0)
+            usleep(1000);
+
+    }
+//    VERBOSE(VB_GENERAL, QString("After current frame = %1")
+//           .arg(GetFramesPlayed()));
+    GetDecoder()->setExactSeeks(tmpexactseeks);
+    return (targetFrame == framesPlayed);
+}
+
+void NuppelVideoPlayer::EditHandleClearMap()
+{
+    QMap<long long, int>::Iterator it;
+    for (it = deleteMap.begin(); it != deleteMap.end(); ++it)
+        osd->HideEditArrow(it.key(), *it);
+
+    deleteMap.clear();
+    UpdateEditSlider();
+}
+
+void NuppelVideoPlayer::EditHandleInvertMap()
+{
+    QMap<long long, int>::Iterator it;
+    for (it = deleteMap.begin(); it != deleteMap.end(); ++it)
+        ReverseMark(it.key());
+
+    UpdateEditSlider();
+    UpdateTimeDisplay();
+}
+
+void NuppelVideoPlayer::EditHandleLoadCommSkip()
+{
+    if (hascommbreaktable)
+    {
+        commBreakMapLock.lock();
+        QMap<long long, int>::Iterator it;
+        for (it = commBreakMap.begin(); it != commBreakMap.end(); ++it)
+        {
+            if (!deleteMap.contains(it.key()))
+            {
+                if (*it == MARK_COMM_START)
+                    AddMark(it.key(), MARK_CUT_START);
+                else
+                    AddMark(it.key(), MARK_CUT_END);
+            }
+        }
+        commBreakMapLock.unlock();
+        UpdateEditSlider();
+        UpdateTimeDisplay();
+    }
+}
+
 bool NuppelVideoPlayer::DoKeypress(QKeyEvent *e)
 {
     bool handled = false;
@@ -5131 +5404 @@
             UpdateTimeDisplay();
         }
         else if (action == "CLEARMAP")
-        {
-            QMap<long long, int>::Iterator it;
-            for (it = deleteMap.begin(); it != deleteMap.end(); ++it)
-                osd->HideEditArrow(it.key(), *it);
-
-            deleteMap.clear();
-            UpdateEditSlider();
-        }
+            EditHandleClearMap();
         else if (action == "INVERTMAP")
-        {
-            QMap<long long, int>::Iterator it;
-            for (it = deleteMap.begin(); it != deleteMap.end(); ++it)
-                ReverseMark(it.key());
-
-            UpdateEditSlider();
-            UpdateTimeDisplay();
-        }
+            EditHandleInvertMap();
         else if (action == "LOADCOMMSKIP")
-        {
-            if (hascommbreaktable)
-            {
-                commBreakMapLock.lock();
-                QMap<long long, int>::Iterator it;
-                for (it = commBreakMap.begin(); it != commBreakMap.end(); ++it)
-                {
-                    if (!deleteMap.contains(it.key()))
-                    {
-                        if (*it == MARK_COMM_START)
-                            AddMark(it.key(), MARK_CUT_START);
-                        else
-                            AddMark(it.key(), MARK_CUT_END);
-                    }
-                }
-                commBreakMapLock.unlock();
-                UpdateEditSlider();
-                UpdateTimeDisplay();
-            }
-        }
+            EditHandleLoadCommSkip();
         else if (action == "PREVCUT")
         {
             int old_seekamount = seekamount;
@@ -5214 +5454 @@
             UpdateEditSlider();
             UpdateTimeDisplay();
         }
-        else if (action == "ESCAPE" || action == "MENU" ||
-                 action == "TOGGLEEDIT")
+        else if (action == "TOGGLEEDIT" || action == "MENU")
+              m_tv->ShowEditRecordingGrid();
+        else if (action == "ESCAPE")
         {
             DisableEdit();
             retval = false;
@@ -5228 +5469 @@
     return retval;
 }
 
+void NuppelVideoPlayer::ShowEditRecordingGrid(void)
+{
+    // Completely hide the OSD
+    osd->HideAll();
+    hideedits = true;
+
+    GridEditCutpoints::Run(this);
+
+    ClearScreenGrab();
+
+    allow_pagesize = false;
+    hideedits = false;
+
+    // Show OSD
+
+    QMap<QString, QString> infoMap;
+    player_ctx->LockPlayingInfo(__FILE__, __LINE__);
+    player_ctx->playingInfo->ToMap(infoMap);
+    infoMap.detach();
+    player_ctx->UnlockPlayingInfo(__FILE__, __LINE__);
+
+    osd->SetText("editmode", infoMap, -1);
+
+    UpdateEditSlider();
+    UpdateTimeDisplay();
+    if (seekamountpos == 3 || seekamountpos == 4)
+        UpdateSeekAmount(true);
+    else
+        UpdateSeekAmountDisplay();
+
+    QMap<long long, int>::Iterator it;
+    for (it = deleteMap.begin(); it != deleteMap.end(); ++it)
+         AddMark(it.key(), *it);
+}
+
 AspectOverrideMode NuppelVideoPlayer::GetAspectOverride(void) const
 {
     if (videoOutput)
@@ -5304 +5580 @@
 
 void NuppelVideoPlayer::UpdateSeekAmount(bool up)
 {
-    if (seekamountpos > 0 && !up)
-        seekamountpos--;
-    if (seekamountpos < 9 && up)
-        seekamountpos++;
+    if (up)
+    {
+        if (seekamountpos < 11)
+            seekamountpos++;
+        if (allow_pagesize)
+        {
+            if (seekamountpos == 1)
+                seekamountpos = 2;
+        }
+        else
+        {
+            if (seekamountpos == 3 || seekamountpos == 4)
+                seekamountpos = 5;
+        }
+    }
+    else
+    {
+        if (seekamountpos > 0)
+            seekamountpos--;
+        if (allow_pagesize)
+        {
+            if (seekamountpos == 1)
+                seekamountpos =0;
+        }
+        else
+        {
+            if (seekamountpos == 3 || seekamountpos == 4)
+                seekamountpos = 2;
+        }
+    }
 
     QString text = "";
 
     switch (seekamountpos)
     {
-        case 0: text = QObject::tr("cut point"); seekamount = -2; break;
-        case 1: text = QObject::tr("keyframe"); seekamount = -1; break;
-        case 2: text = QObject::tr("1 frame"); seekamount = 1; break;
-        case 3: text = QObject::tr("0.5 seconds"); seekamount = (int)roundf(video_frame_rate / 2); break;
-        case 4: text = QObject::tr("%n second(s)", "", 1); seekamount = (int)roundf(video_frame_rate); break;
-        case 5: text = QObject::tr("%n second(s)", "", 5); seekamount = (int)roundf(video_frame_rate * 5); break;
-        case 6: text = QObject::tr("%n second(s)", "", 20); seekamount = (int)roundf(video_frame_rate * 20); break;
-        case 7: text = QObject::tr("%n minute(s)", "", 1); seekamount = (int)roundf(video_frame_rate * 60); break;
-        case 8: text = QObject::tr("%n minute(s)", "", 5); seekamount = (int)roundf(video_frame_rate * 300); break;
-        case 9: text = QObject::tr("%n minute(s)", "", 10); seekamount = (int)roundf(video_frame_rate * 600); break;
+        case  0: text = QObject::tr("cut point"); seekamount = -2; break;
+
+        // Only for non-edit grid
+        case  1: text = QObject::tr("keyframe"); seekamount = -1; break;
+        // Only for non-edit grid
+
+        case  2: text = QObject::tr("1 frame"); seekamount = 1; break;
+
+        // Case 3 & 4 are for the edit grid only
+        case  3: text = QObject::tr("1/2 Page");    seekamount =  half_page; break;
+        case  4: text = QObject::tr("Full Page");   seekamount =  2*half_page; break;
+        // Case 3 & 4 are for the edit grid only
+    
+        case  5: text = QObject::tr("0.5 seconds"); seekamount = (int)roundf(video_frame_rate / 2); break;
+        case  6: text = QObject::tr("%n second(s)", "", 1); seekamount = (int)roundf(video_frame_rate); break;
+        case  7: text = QObject::tr("%n second(s)", "", 5); seekamount = (int)roundf(video_frame_rate * 5); break;
+        case  8: text = QObject::tr("%n second(s)", "", 20); seekamount = (int)roundf(video_frame_rate * 20); break;
+        case  9: text = QObject::tr("%n minute(s)", "", 1); seekamount = (int)roundf(video_frame_rate * 60); break;
+        case 10: text = QObject::tr("%n minute(s)", "", 5); seekamount = (int)roundf(video_frame_rate * 300); break;
+        case 11: text = QObject::tr("%n minute(s)", "", 10); seekamount = (int)roundf(video_frame_rate * 600); break;
         default: text = QObject::tr("error"); seekamount = (int)roundf(video_frame_rate); break;
     }
 
+    seekamounttext = text;
+    UpdateSeekAmountDisplay();
+}
+
+void NuppelVideoPlayer::UpdateSeekAmountDisplay(void)
+{
     QMap<QString, QString> infoMap;
-    infoMap["seekamount"] = text;
-    osd->SetText("editmode", infoMap, -1);
+    infoMap["seekamount"] = seekamounttext;
+    if (!hideedits)
+        osd->SetText("editmode", infoMap, -1);
 }
 
 void NuppelVideoPlayer::UpdateTimeDisplay(void)
@@ -5358 +5677 @@
     infoMap["timedisplay"] = timestr;
     infoMap["framedisplay"] = framestr;
     infoMap["cutindicator"] = cutmarker;
-    osd->SetText("editmode", infoMap, -1);
+    if (!hideedits)
+        osd->SetText("editmode", infoMap, -1);
 }
 
-void NuppelVideoPlayer::HandleSelect(bool allowSelectNear)
+DeletePointInfo NuppelVideoPlayer::GetDeletePointInfo(long long frame, bool allowSelectNear)
 {
-    bool deletepoint = false;
-    bool cut_after = false;
-    int direction = 0;
+    DeletePointInfo retval;
 
     if(!deleteMap.isEmpty())
     {
         QMap<long long, int>::ConstIterator iter = deleteMap.begin();
 
-        while((iter != deleteMap.end()) && (iter.key() < framesPlayed))
+        while((iter != deleteMap.end()) && (iter.key() < frame))
             ++iter;
 
         if (iter == deleteMap.end())
         {
             --iter;
-            cut_after = !(*iter);
+            retval.cut_after = !(*iter);
         }
-        else if((iter != deleteMap.begin()) && (iter.key() != framesPlayed))
+        else if((iter != deleteMap.begin()) && (iter.key() != frame))
         {
             long long value = iter.key();
-            if((framesPlayed - (--iter).key()) > (value - framesPlayed))
+            if((framesPlayed - (--iter).key()) > (value - frame))
             {
-                cut_after = !(*iter);
+                retval.cut_after = !(*iter);
                 ++iter;
             }
             else
-                cut_after = !(*iter);
+                retval.cut_after = !(*iter);
         }
 
-        direction = (*iter);
-        deleteframe = iter.key();
+        retval.direction = (*iter);
+        retval.deleteframe = iter.key();
 
-        if ((absLongLong(deleteframe - framesPlayed) <
+        if ((absLongLong(retval.deleteframe - frame) <
                    (int)ceil(20 * video_frame_rate)) && !allowSelectNear)
         {
-            deletepoint = true;
+            retval.deletepoint = true;
         }
     }
+    return retval;
+}
 
-    if (deletepoint)
+void NuppelVideoPlayer::HandleSelect(bool allowSelectNear)
+{
+    DeletePointInfo dpi = GetDeletePointInfo(framesPlayed, allowSelectNear);
+    deleteframe = dpi.deleteframe;
+
+    if (dpi.deletepoint)
     {
         QString message = QObject::tr("You are close to an existing cut point. "
                                       "Would you like to:");
@@ -5409 +5734 @@
         QString option2 = QObject::tr("Move this cut point to the current "
                                       "position");
         QString option3 = QObject::tr("Flip directions - delete to the ");
-        if (direction == 0)
+        if (dpi.direction == 0)
             option3 += QObject::tr("right");
         else
             option3 += QObject::tr("left");
@@ -5439 +5764 @@
         options += option1;
         options += option2;
 
-        osd->NewDialogBox(dialogname, message, options, -1, cut_after);
+        osd->NewDialogBox(dialogname, message, options, -1, dpi.cut_after);
     }
 }
 
@@ -5490 +5815 @@
 
 void NuppelVideoPlayer::UpdateEditSlider(void)
 {
-    osd->DoEditSlider(deleteMap, framesPlayed, totalFrames);
+    if (!hideedits)
+        osd->DoEditSlider(deleteMap, framesPlayed, totalFrames);
 }
 
 void NuppelVideoPlayer::AddMark(long long frames, int type)
 {
     deleteMap[frames] = type;
-    osd->ShowEditArrow(frames, totalFrames, type);
+    if (!hideedits)
+        osd->ShowEditArrow(frames, totalFrames, type);
 }
 
 void NuppelVideoPlayer::DeleteMark(long long frames)
 {
-    osd->HideEditArrow(frames, deleteMap[frames]);
+    if (!hideedits)
+        osd->HideEditArrow(frames, deleteMap[frames]);
     deleteMap.remove(frames);
 }
 
 void NuppelVideoPlayer::ReverseMark(long long frames)
 {
-    osd->HideEditArrow(frames, deleteMap[frames]);
+    if (!hideedits)
+        osd->HideEditArrow(frames, deleteMap[frames]);
 
     if (deleteMap[frames] == MARK_CUT_END)
         deleteMap[frames] = MARK_CUT_START;
     else
         deleteMap[frames] = MARK_CUT_END;
 
-    osd->ShowEditArrow(frames, totalFrames, deleteMap[frames]);
+    if (!hideedits)
+        osd->ShowEditArrow(frames, totalFrames, deleteMap[frames]);
+}
+
+long long NuppelVideoPlayer::CalcCutPointSeek(long long baseframe, bool right)
+{
+    QMap<long long, int>::Iterator i = deleteMap.begin();                                      
+    long long framenum = -1;
+    long long seekcount = 0;
+    if (right)                                                                                 
+    {
+        for (; i != deleteMap.end(); ++i)                                                      
+        {
+            if (i.key() > baseframe)                                                        
+            {
+                framenum = i.key();                                                            
+                break;                                                                          
+            }                                                                                  
+        }                                                                                      
+        if (framenum == -1)
+            framenum = totalFrames;
+        seekcount = framenum - baseframe;
+    }
+    else
+    {
+        for (; i != deleteMap.end(); ++i)
+        {
+            if (i.key() >= baseframe)
+                break;
+            framenum = i.key();
+        }
+        if (framenum == -1)
+            framenum = 0;
+        seekcount = baseframe - framenum;
+    }
+    return seekcount;
 }
 
 void NuppelVideoPlayer::HandleArbSeek(bool right)
 {
     if (seekamount == -2)
     {
-        QMap<long long, int>::Iterator i = deleteMap.begin();
-        long long framenum = -1;
+        long long seekcount = CalcCutPointSeek(framesPlayed, right);
         if (right)
         {
-            for (; i != deleteMap.end(); ++i)
-            {
-                if (i.key() > framesPlayed)
-                {
-                    framenum = i.key();
-                    break;
-                }
-            }
-            if (framenum == -1)
-                framenum = totalFrames;
-
-            fftime = framenum - framesPlayed;
+            fftime = seekcount;
             while (fftime > 0)
                 usleep(1000);
         }
         else
         {
-            for (; i != deleteMap.end(); ++i)
-            {
-                if (i.key() >= framesPlayed)
-                    break;
-                framenum = i.key();
-            }
-            if (framenum == -1)
-                framenum = 0;
-
-            rewindtime = framesPlayed - framenum;
+            rewindtime = seekcount;
             while (rewindtime > 0)
                 usleep(1000);
         }
@@ -5582 +5925 @@
     UpdateEditSlider();
 }
 
+int NuppelVideoPlayer::GetCutStatus(long long testframe) const
+{
+    int retval = 0;
+    QMap<long long, int>::const_iterator i;
+    i = deleteMap.find(testframe);
+    if (i == deleteMap.end()) {
+        // testframe is not an explicit cutpoint
+        // See if it is in a deleted area
+        if (IsInDelete(testframe))
+            retval = 1;
+    } else {
+        int direction = *i;
+        if (direction == 0)
+            retval = 2;
+        else
+            retval = 3;
+    }
+
+    return retval;
+}
+
 bool NuppelVideoPlayer::IsInDelete(long long testframe) const
 {
     long long startpos = 0;

mythtv/libs/libmythtv/NuppelVideoPlayer.h

@@ -101 +101 @@
     kDisplayTeletextMenu        = 0x40,
 };
 
+class DeletePointInfo
+{
+    public:
+        DeletePointInfo() :
+            deleteframe(0), deletepoint(false), cut_after(false), direction(0) {}
+
+        long long deleteframe;
+        bool deletepoint;
+        bool cut_after;
+        int direction;
+};
+
+
 class MPUBLIC NuppelVideoPlayer : public CC608Reader, public CC708Reader
 {
     friend class PlayerContext;
+    friend class GridEditCutpoints;
+    friend class TV;
 
   public:
     NuppelVideoPlayer();
@@ -282 +297 @@
     bool EnableEdit(void);
     bool DoKeypress(QKeyEvent *e);
     bool GetEditMode(void) const { return editmode; }
+    bool GetHideEdits(void) const { return hideedits; }
 
     // Decoder stuff..
     VideoFrame *GetNextVideoFrame(bool allow_unsafe = true);
@@ -301 +317 @@
     void ShutdownYUVResize(void);
     void SaveScreenshot(void);
 
+    // Edit stuff
+    bool EditSeekToFrame(long long targetFrame); 
+    void SetScreenGrabSizes(QSize normal, QSize small);
+    bool GetScreenGrabsOfCurrentFrame(QImage & normal, QImage &small); // Get current frame
+
+
+    void       EditHandleClearMap();
+    void       EditHandleInvertMap();
+    void       EditHandleLoadCommSkip();
+
+    void ShowEditRecordingGrid();
+
     // Reinit
     void    ReinitOSD(void);
     void    ReinitVideo(void);
@@ -420 +448 @@
     bool PosMapFromEnc(unsigned long long          start,
                        QMap<long long, long long> &posMap);
 
+    // Stuf for GridEditCutpoints
+    long long CalcCutPointSeek(long long baseframe, bool right);
+    // returns 
+    // 0 - no cut
+    // 1 - is deleted
+    // 2 - cut left
+    // 3 - cut right
+    int  GetCutStatus(long long testframe) const;
+    long long GetSeekAmount() { return seekamount; }
+    QString GetSeekAmountText() { return seekamounttext; }
+
   protected:
     void DisplayPauseFrame(void);
     void DisplayNormalFrame(void);
@@ -502 +541 @@
     void HandleSelect(bool allowSelectNear = false);
     void HandleResponse(void);
 
+    DeletePointInfo GetDeletePointInfo(long long frame, bool allowSelectNear);
+
+    void SetupScreenGrab();
+    void ClearScreenGrab();
+
     void UpdateTimeDisplay(void);
+    int  GetSeekAmountPos() { return seekamountpos; }
     void UpdateSeekAmount(bool up);
+    void SetHalfPageSize(int hp) { allow_pagesize = true; half_page = hp; }
+    void UpdateSeekAmountDisplay(void);
     void UpdateEditSlider(void);
 
     // Private A/V Sync Stuff
@@ -576 +623 @@
     bool     livetv;
     bool     watchingrecording;
     bool     editmode;
+    bool     hideedits;
     bool     resetvideo;
     bool     using_null_videoout;
     bool     no_audio_in;
@@ -596 +644 @@
     long long fftime;
     /// 1..9 == keyframe..10 minutes. 0 == cut point
     int       seekamountpos;
+    ///  Used for Grid Edit logic
+    bool      allow_pagesize;
+    int       half_page;
     /// Seekable frame increment when not using exact seeks.
     /// Usually equal to keyframedist.
     int      seekamount;
+    QString  seekamounttext; // OSD seek units
     /// Iff true we ignore seek amount and try to seek to an
     /// exact frame ignoring key frame restrictions.
     bool     exactseeks;
@@ -737 +789 @@
     QMutex              yuv_lock;
     QWaitCondition      yuv_wait;
 
+    // EditGrid still image capture
+    ImgReSampleContext *grid_edit_image_scaler;
+    ImgReSampleContext *grid_edit_image_small_scaler;
+    unsigned char      *grid_edit_image_buffer_yuv;
+    unsigned char      *grid_edit_image_small_buffer_yuv;
+    unsigned char      *grid_edit_image_buffer_rgb;
+    unsigned char      *grid_edit_image_small_buffer_rgb;
+    int                 grid_edit_image_buffer_length;
+    int                 grid_edit_image_small_buffer_length;
+    QSize               grid_edit_image_in_size;
+    QSize               grid_edit_image_size;
+    QSize               grid_edit_image_small_size;
+
     // Filters
     QMutex   videofiltersLock;
     QString  videoFiltersForProgram;

mythtv/libs/libmythtv/grideditcutpoints.cpp

@@ +1 @@
+#include <math.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+#include <QApplication>
+#include <QPainter>
+#include <QFont>
+#include <QKeyEvent>
+#include <QEvent>
+#include <QPixmap>
+#include <QPaintEvent>
+#include <QCursor>
+#include <QImage>
+#include <QLayout>
+#include <QLabel>
+#include <QDateTime>
+#include <QRect>
+
+#include "mythcontext.h"
+#include "mythdbcon.h"
+#include "grideditcutpoints.h"
+#include "grideditimages.h"
+#include "NuppelVideoPlayer.h"
+
+void GridEditCutpoints::Run(NuppelVideoPlayer *player)
+{
+    VERBOSE(VB_GENERAL, "Starting");
+    gContext->addCurrentLocation("GridEditCutpoints");
+
+    GridEditCutpoints *er = new GridEditCutpoints(gContext->GetMainWindow(),
+                                  player, "editrecording");
+
+    if (er->isValid())
+    {
+        er->Show();
+        er->displayInitialFrame();
+        er->exec();
+    }
+
+    delete er;
+
+    gContext->removeCurrentLocation();
+    VERBOSE(VB_GENERAL, "Ending");
+}
+
+GridEditCutpoints::GridEditCutpoints(MythMainWindow *parent,
+                     NuppelVideoPlayer *player, const char *name)
+         : MythThemedDialog(parent, "grideditcutpoints", "", name)
+{
+    m_player = player;
+    m_images = new GridEditImages(this, player);
+
+    int i;
+    m_gridimagemain = NULL;
+    for (i = m_gridimages.minIndex(); i < m_gridimages.maxIndex(); i++)
+    {
+        m_gridimages[i] = NULL;
+    }
+
+    usedSubVideoCount=0;
+
+    QSize videoSizeMain, videoSizeSmall;
+
+    m_gridimagemain = getUIGridEditImageType("mainvideo");
+    if (m_gridimagemain) 
+        videoSizeMain = m_gridimagemain->getScreenArea().size();
+    else
+    {
+        VERBOSE(VB_IMPORTANT, "FATAL: Couldn't find mainedit:mainvideo");
+        return;
+    }
+
+    // Small version of main frame
+    m_gridimages[0] = getUIGridEditImageType("video0");
+
+    for (i = 1; i < m_gridimages.maxIndex(); i++)
+    {
+        QString p = QString("videop%1").arg(i);
+        QString m = QString("videom%1").arg(i);
+
+        // Minus frame i
+        m_gridimages[-i] = getUIGridEditImageType(m);
+        if (m_gridimages[-i])
+        {
+            QSize tmpVideoSizeSmall = m_gridimages[-i]->getScreenArea().size();
+            if (videoSizeSmall.isValid() && videoSizeSmall != tmpVideoSizeSmall)
+                VERBOSE(VB_IMPORTANT,
+                        QString("Multiple sizes found for edit videos (%1)").arg(m));
+            else
+                videoSizeSmall = tmpVideoSizeSmall;
+            if (i > usedSubVideoCount) usedSubVideoCount=i;
+        }
+
+        m_gridimages[i] = getUIGridEditImageType(p);
+        if (m_gridimages[i])
+        {
+            QSize tmpVideoSizeSmall = m_gridimages[i]->getScreenArea().size();
+            if (videoSizeSmall.isValid() && videoSizeSmall != tmpVideoSizeSmall)
+                VERBOSE(VB_IMPORTANT,
+                        QString("Multiple sizes found for edit videos (%1)").arg(p));
+            else
+                videoSizeSmall = tmpVideoSizeSmall;
+            if (i > usedSubVideoCount) usedSubVideoCount=i;
+        }
+    }
+
+    imageScreenArea = m_gridimages[-usedSubVideoCount]->getOuterBorder();
+    for (i = -usedSubVideoCount; i <= usedSubVideoCount; i++)
+        if (m_gridimages[i])
+            imageScreenArea = imageScreenArea.unite(m_gridimages[i]->getOuterBorder());
+
+    m_images->SetVideoInfo(usedSubVideoCount, videoSizeMain, videoSizeSmall);
+
+    m_player->SetHalfPageSize(usedSubVideoCount);
+    m_slider = getUIGridEditSliderType("positionbar");
+    if (!m_slider)
+        VERBOSE(VB_GENERAL, "Missing positionbar for GridEditCutpoints");
+
+    // Get Status boxes
+    {
+        m_framenum    = getUITextType("framenum");
+        m_time        = getUITextType("time");
+        m_cutind      = getUITextType("cutind");
+        m_jumpstyle   = getUITextType("jumpstyle");
+        m_updatingind = getUITextType("updatingind");
+    }
+
+    VERBOSE(VB_GENERAL, QString("main = (%1, %2) small = (%3, %4)")
+                       .arg(videoSizeMain.width()).arg(videoSizeMain.height())
+                       .arg(videoSizeSmall.width()).arg(videoSizeSmall.height()));
+
+    slowMotionDirection = 1; // start off play forward
+    slowMotionActive = false;
+    readyForNextFrame = false;
+    slowMotionTimer = new QTimer(this);
+    QObject::connect(slowMotionTimer, SIGNAL(timeout()),
+                     this,           SLOT(updateSlowMotion()));
+
+    movingCutpoint = false;
+    // Create blank pixmaps...
+ 
+    updateBackground();
+
+    updateStats();
+
+    setNoErase();
+    gContext->addListener(this);
+    
+    updateForeground();
+}
+
+GridEditCutpoints::~GridEditCutpoints()
+{
+    if (m_images)
+    {
+        delete m_images;
+        m_images = NULL;
+    }
+    gContext->removeListener(this);
+}
+
+void GridEditCutpoints::displayInitialFrame()
+{
+    refreshImages();
+    refreshCutList();
+    updateStats();
+    SetUpdating(false);
+}
+
+void GridEditCutpoints::updateSlowMotion()
+{
+    if (!slowMotionActive)
+        slowMotionTimer->stop();
+    else if (readyForNextFrame && slowMotionDirection != 0)
+    {
+        readyForNextFrame=false;
+
+        if (slowMotionDirection > 0)
+            EditHandleRight();
+        else if (slowMotionDirection < 0)
+            EditHandleLeft();
+    }
+}
+
+
+void GridEditCutpoints::setSlowMotionSpeed()
+{
+    // slowMotionDirection is max FPS
+
+    if (slowMotionDirection != 0)
+    {
+        int smd = slowMotionDirection;
+        if (smd < 0) smd = -smd;
+        int timeout = 1000 / smd;
+
+        slowMotionTimer->start(timeout);
+    }
+    SetUpdating(true, QString("%1 FPS max").arg(slowMotionDirection));
+}
+
+
+void GridEditCutpoints::keyPressEvent(QKeyEvent *e)
+{
+    // keyDown limits keyrepeats to prevent continued scrolling
+    // after key is released. Note: Qt's keycompress should handle
+    // this but will fail with fast key strokes and keyboard repeat
+    // enabled. Keys will not be marked as autorepeat and flood buffer.
+    // setFocusPolicy(QWidget::ClickFocus) in constructor is important 
+    // or keyRelease events will not be received after a refocus.
+    
+    bool handled = false;
+
+    QStringList actions;
+    gContext->GetMainWindow()->TranslateKeyPress("TV Editing", e, actions);
+
+    {
+        for (unsigned int i = 0; i < actions.size() && !handled; i++)
+        {
+            QString action = actions[i];
+            handled = true;
+
+            if (action == "SELECT")
+            {
+                if (slowMotionActive)
+                {
+                    slowMotionActive = false;
+                    slowMotionTimer->stop();
+                }
+                else if (movingCutpoint)
+                {
+                    // Move cutpoint
+                    m_player->DeleteMark(savedCutpoint);
+                    m_player->AddMark(m_images->GetCurrentFrameNumber(), savedCutType);
+                    movingCutpoint = false;
+                    refreshCutList();
+                    refreshImages();
+                }
+                else
+                    handleSelect();
+            }
+            else if (action == "PAUSE") 
+            {
+                if (movingCutpoint)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "Slow Motion Unavailable when moving cutpoint");
+                else if (slowMotionActive)
+                {
+                    slowMotionActive = false;
+                    slowMotionTimer->stop();
+                }
+            }
+            else if (action == "SLOWMO")
+            {
+                if (movingCutpoint)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "Slow Motion Unavailable when moving cutpoint");
+                else
+                {
+                    if (slowMotionActive)
+                    {
+                        slowMotionActive = false;
+                        slowMotionTimer->stop();
+                    }
+                    else
+                    {
+                        slowMotionActive = true;
+                        readyForNextFrame = true;
+                        slowMotionDirection = 1;
+
+                        // force to either 1 frame. 1/2 page or full page motion
+                        int i;
+                        // move to 1 frame if on cutpoint
+                        for (i = 0; m_player->GetSeekAmountPos() < 2 && i < 10; i++)
+                            m_player->UpdateSeekAmount(true);
+
+                        // move to fullpage if higher 
+                        for (i = 0; m_player->GetSeekAmountPos() > 4 && i < 10; i++)
+                            m_player->UpdateSeekAmount(false);
+
+                        setSlowMotionSpeed();
+                    }
+                }
+            }
+            else if (action == "LEFT")
+            {
+                if (slowMotionActive)
+                {
+                    slowMotionDirection--;
+                    setSlowMotionSpeed();
+                }
+                else
+                {
+                    SetUpdating(true);
+                    EditHandleLeft();
+                }
+            }
+            else if (action == "RIGHT" )
+            {
+                if (slowMotionActive)
+                {
+                    slowMotionDirection++;
+                    setSlowMotionSpeed();
+                }
+                else
+                {
+                    SetUpdating(true);
+                    EditHandleRight();
+                }
+            }
+            else if (action == "UP")
+            {
+                m_player->UpdateSeekAmount(true);
+                updateStats();
+            }
+            else if (action == "DOWN")
+            {
+                if ((movingCutpoint || slowMotionActive) && m_player->GetSeekAmountPos() == 2)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "CutPoint skip Unavailable");
+                else
+                {
+                    m_player->UpdateSeekAmount(false);
+                    updateStats();
+                }
+            }
+            else if (action == "CLEARMAP")
+            {
+                if (movingCutpoint || slowMotionActive)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "Clear Cut Map Unavailable");
+                else
+                {
+                    SetUpdating(true);
+                    m_player->EditHandleClearMap();
+                    refreshCutList();
+                    updateStats();
+                }
+            }
+            else if (action == "INVERTMAP")
+            {
+                if (movingCutpoint || slowMotionActive)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "Invert Cut Map Unavailable");
+                else
+                {
+                    SetUpdating(true);
+                    m_player->EditHandleInvertMap();
+                    refreshCutList();
+                    updateStats();
+                }
+            }
+            else if (action == "LOADCOMMSKIP")
+            {
+                if (movingCutpoint || slowMotionActive)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "Load Comm Skip Map Unavailable");
+                else
+                {
+                    SetUpdating(true);
+                    m_player->EditHandleLoadCommSkip();
+                    refreshCutList();
+                    updateStats();
+                }
+            }
+            else if (action == "PREVCUT")
+            {
+                if (movingCutpoint || slowMotionActive)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "Prev Cut Unavailable");
+                else
+                {
+                    SetUpdating(true);
+                    EditHandlePrevCut();
+                }
+            }
+            else if (action == "NEXTCUT")
+            {
+                if (movingCutpoint || slowMotionActive)
+                    MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                                              "Moving Cutpoint",
+                                              "Next Cut Unavailable");
+                else
+                {
+                    SetUpdating(true);
+                    EditHandleNextCut();
+                }
+            }
+            else if (action == "BIGJUMPREW")
+            {
+                SetUpdating(true);
+                EditHandleBigJumpRew();
+            }
+            else if (action == "BIGJUMPFWD")
+            {
+                SetUpdating(true);
+                EditHandleBigJumpFwd();
+            }
+            else if (action == "ESCAPE" && movingCutpoint)
+                movingCutpoint = false;
+            else if (action == "ESCAPE" || action == "TOGGLEEDIT" ||
+                     action == "MENU")
+                escape();
+            else
+                handled = false;
+
+            if (movingCutpoint)
+                SetUpdating(true, "Moving Cutpoint");
+            else if (!slowMotionActive)
+                SetUpdating(false);
+        }
+    }
+
+    if (!handled)
+        MythDialog::keyPressEvent(e);
+}
+
+void GridEditCutpoints::EditHandleLeft(int seektype)
+{
+    long long seekamount = m_player->GetSeekAmount();
+    bool cutpointseek = false;
+
+    if (seektype == -2 || seekamount == -2)
+        cutpointseek = true;
+    else
+    {
+        // seektype == 1 for normal, 10 for bigjump
+        seekamount *= seektype;
+    }
+
+    if (seekamount < 0) // Invalid -- keyframe
+        seekamount = 1;
+
+    m_images->SeekLeft(seekamount, cutpointseek);
+
+    refreshImages();
+    updateStats();
+}
+
+void GridEditCutpoints::EditHandleRight(int seektype)
+{
+    long long seekamount = m_player->GetSeekAmount();
+    bool cutpointseek=false;
+
+    if (seektype == -2 || seekamount == -2)
+        cutpointseek = true;
+    else
+    {
+        // seektype == 1 for normal, 10 for bigjump
+        seekamount *= seektype;
+    }
+
+    if (seekamount < 0) // Invalid -- keyframe
+        seekamount = 1;
+
+    m_images->SeekRight(seekamount, cutpointseek);
+
+    refreshImages();
+     updateStats();
+}
+
+void GridEditCutpoints::handleSelect(void)
+{
+    bool needupdate = false;
+    // add / update cutpoint
+    // -or-
+    // delete / flip / move cutpoint
+
+    // if no cut points on screen 
+    //    "Delete Before"
+    //    "Delete After"
+
+    // if on existing cutpoint
+    //    "Delete cutpoint"
+    //    "Flip directions"
+
+    // FIXME
+    // if a cutpoint exists on the screen but not on the current frame
+    //    "Move to current frame"
+    //    "Add new"
+
+    FrameStats fs = m_images->GetMainFrameStats();
+    DeletePointInfo dpi = m_player->GetDeletePointInfo(fs.frameNumber, true);
+
+    if (fs.cutInd >= 2)
+    {
+        QString title = "";
+        QString message = "Cutpoint exists:";
+        QStringList buttons;
+        buttons.append("Delete cutpoint?");
+        buttons.append("Move cutpoint?");
+        if (fs.cutInd == 2)
+            buttons.append("Flip directions (Cut After)?");
+        else
+            buttons.append("Flip directions (Cut Before)?");
+
+        DialogCode dc = MythPopupBox::ShowButtonPopup(gContext->GetMainWindow(),
+                                                      title, message, buttons, kDialogCodeButton0);
+
+        if (dc != kDialogCodeRejected)
+        {
+            needupdate = true;
+            if (dc == kDialogCodeButton0)
+                // Delete cutpoint
+                m_player->DeleteMark(fs.frameNumber);
+
+            else if (dc == kDialogCodeButton1)
+            {
+                // Move cutpoint
+                savedCutpoint = fs.frameNumber;
+                savedCutType = m_player->deleteMap[fs.frameNumber];
+                movingCutpoint = true;
+                // Ensure we're at least at 1 frame motion
+                int i;
+                for (i = 0; m_player->GetSeekAmountPos() < 2 && i < 10; i++)
+                    m_player->UpdateSeekAmount(true);
+                    
+            }
+            else if (dc == kDialogCodeButton2)
+                // Flip
+                m_player->ReverseMark(fs.frameNumber);
+        }
+    }
+    else
+    {
+        QString title = "";
+        QString message = "Insert New Cutpoint?";
+        QStringList buttons;
+        buttons.append("Delete before this frame");
+        buttons.append("Delete after this frame");
+        DialogCode default_cut = (dpi.cut_after ? kDialogCodeButton1: kDialogCodeButton0);
+        DialogCode dc = MythPopupBox::ShowButtonPopup(gContext->GetMainWindow(),
+                                                      title, message, buttons, default_cut);
+
+        if (dc != kDialogCodeRejected)
+        {
+            needupdate = true;
+            if (dc == kDialogCodeButton0)
+                // Delete left
+                m_player->AddMark(fs.frameNumber, MARK_CUT_END);
+
+            else if (dc == kDialogCodeButton1)
+                // Delete Right
+                m_player->AddMark(fs.frameNumber, MARK_CUT_START);
+        }
+    }
+
+    if (needupdate)
+    {
+        refreshCutList();
+        refreshImages();
+    }
+}
+
+void GridEditCutpoints::refreshImages()
+{
+    m_images->refreshImages(m_gridimagemain, m_gridimages, false);
+    repaint(m_gridimagemain->getOuterBorder());
+    repaint(imageScreenArea);
+}
+
+void GridEditCutpoints::refreshCutList()
+{
+    m_images->refreshCutList(m_gridimagemain, m_gridimages);
+    refreshSlider();
+}
+
+void GridEditCutpoints::refreshSlider()
+{
+    if (!m_slider)
+        return;
+
+    m_slider->ClearAll();
+
+    const int CUT_LEFT = 0;
+    const int CUT_RIGHT = 1;
+
+    long long startpos = 0;
+    long long endpos = 0;
+    
+    int       lastdirection = CUT_LEFT;
+
+    QMap<long long, int> & deleteMap = m_player->deleteMap;
+    QMap<long long, int>::Iterator i = deleteMap.begin();
+    for (; i != deleteMap.end(); ++i)
+    {
+        long long frame = i.key();
+        int direction = *i;
+
+        if (direction == CUT_LEFT)
+        {
+            endpos = frame;
+            m_slider->SetRange(startpos, endpos, m_images->GetMaxFrameNumber());
+
+            startpos = frame;
+            lastdirection = CUT_LEFT;
+        }
+        else if (direction == CUT_RIGHT)
+        {
+            if (lastdirection == CUT_RIGHT)
+            {
+                // continuing within a cutpoint
+                endpos = frame;
+                m_slider->SetRange(startpos, endpos, m_images->GetMaxFrameNumber());
+            }
+
+            startpos = frame;
+            lastdirection = CUT_RIGHT;
+        }
+    }
+
+    if (lastdirection == CUT_RIGHT)
+    {
+        // continuing within a cutpoint
+        endpos = m_images->GetMaxFrameNumber();
+        m_slider->SetRange(startpos, endpos, m_images->GetMaxFrameNumber());
+    }
+}
+
+void GridEditCutpoints::updateStats(bool forcerepaint)
+{
+    int secs, frames, ss, mm, hh;
+
+    FrameStats fs = m_images->GetMainFrameStats();
+
+    secs = (int)(fs.frameNumber / m_player->GetFrameRate());
+    frames = fs.frameNumber - (int)(secs * m_player->GetFrameRate());
+
+    ss = secs;
+    mm = ss / 60;
+    ss %= 60;
+    hh = mm / 60;
+    mm %= 60;
+
+    char timestr[128];
+    sprintf(timestr, "%d:%02d:%02d.%02d", hh, mm, ss, frames);
+
+    char framestr[128];
+    sprintf(framestr, "%lld", fs.frameNumber);
+
+    if (m_time)
+    {
+        m_time->SetText(timestr);
+        if (forcerepaint)
+            repaint(m_time->getScreenArea());
+    }
+    if (m_framenum)
+    {
+        m_framenum->SetText(framestr);
+        if (forcerepaint)
+            repaint(m_framenum->getScreenArea());
+    }
+    if (m_cutind)
+    {
+        switch (fs.cutInd) {
+            case 0: m_cutind->SetText("");           break;
+            case 1: m_cutind->SetText("Cut");        break;
+            case 2: m_cutind->SetText("Cut Before"); break;
+            case 3: m_cutind->SetText("Cut After");  break;
+        }
+        if (forcerepaint)
+            repaint(m_cutind->getScreenArea());
+    }
+
+    // Don't need to force update this
+    if (m_jumpstyle)
+        m_jumpstyle->SetText(m_player->GetSeekAmountText());
+
+    if (m_slider)
+        m_slider->SetPosition(fs.frameNumber, fs.maxFrameNumber);
+
+}
+
+void GridEditCutpoints::escape()
+{
+    // Make sure we're on the right frame when we go back to
+    // Normal edit mode
+    unsetCursor();
+    accept();
+}
+
+void GridEditCutpoints::SetUpdating(bool active, QString text)
+{
+    if (m_updatingind)
+    {
+        //VERBOSE(VB_GENERAL, QString("Updating to %1").arg(active));
+        if (active)
+        {
+            m_updatingind->show();
+            m_updatingind->SetText(text);
+        }
+        else
+            m_updatingind->hide();
+        repaint(m_updatingind->getScreenArea());
+    }
+}
+
+void GridEditCutpoints::cacheFramesAreReady()
+{
+    if (slowMotionActive)
+    {
+        readyForNextFrame=true;
+        if (!slowMotionTimer->isActive())
+            slowMotionTimer->start(0);
+    }
+}
+

mythtv/libs/libmythtv/grideditcutpoints.h

@@ +1 @@
+// -*- Mode: c++ -*-
+#ifndef GRIDEDITCUTPOINTS_H_
+#define GRIDEDITCUTPOINTS_H_
+
+#include <qstring.h>
+
+#include "libmyth/mythwidgets.h"
+#include "uitypes.h"
+
+#include "grideditimages.h"
+
+using namespace std;
+
+class QTimer;
+class NuppelVideoPlayer;
+class GridEditImages;
+
+class MPUBLIC GridEditCutpoints : public MythThemedDialog
+{
+    Q_OBJECT
+
+  public:
+    // Use this function to instantiate an GridEditCutpoints instance.
+    static void Run(NuppelVideoPlayer            *player);
+
+    void refreshImages();
+    void cacheFramesAreReady();
+    bool isValid() { return ((usedSubVideoCount > 0) && (m_gridimagemain != NULL)); };
+
+  protected:
+    GridEditCutpoints(MythMainWindow *parent,
+              NuppelVideoPlayer *player, const char *name = "GridEditCutpoints");
+   ~GridEditCutpoints();
+
+    void displayInitialFrame();
+
+    void handleSelect();
+
+    void updateStats(bool forcerepaint = false);
+
+  protected slots:
+    void escape();
+    void updateSlowMotion();
+
+  private:
+    void keyPressEvent(QKeyEvent *e);
+
+    // seektype == -2 - cutpoint seek
+    // seektype ==  1 - normal seek
+    // seektype == 10 - large seek
+    void EditHandleLeft(int seektype = 1);
+    void EditHandleRight(int seektype = 1);
+    void EditHandlePrevCut()    { EditHandleLeft(-2); };
+    void EditHandleNextCut()    { EditHandleRight(-2); };
+    void EditHandleBigJumpRew() { EditHandleLeft(10); };
+    void EditHandleBigJumpFwd() { EditHandleRight(10); };
+    void setSlowMotionSpeed();
+    void refreshCutList();
+    void refreshSlider();
+
+    void SetUpdating(bool active, QString text = "Updating");
+
+    // Private Data
+
+    NuppelVideoPlayer *m_player;
+    GridEditImages *m_images;
+
+    int   usedSubVideoCount;
+    myArray<UIGridEditImageType*, MAX_SUB_VIDEOS> m_gridimages;
+    // The main Big image
+    UIGridEditImageType* m_gridimagemain;
+
+
+    long long savedCutpoint;
+    int       savedCutType;
+    bool      movingCutpoint;
+
+    UITextType   *m_framenum;
+    UITextType   *m_time;
+    UITextType   *m_cutind;
+    UITextType   *m_jumpstyle;
+    UITextType   *m_updatingind;
+  
+    UIGridEditSliderType  *m_slider;
+    QTimer                *slowMotionTimer;
+    int                    slowMotionDirection;
+    bool                   slowMotionActive;
+    bool                   readyForNextFrame;
+
+    QRect                  imageScreenArea;
+};
+
+#endif

mythtv/libs/libmythtv/grideditimages.cpp

@@ +1 @@
+#include <math.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+#include <QApplication>
+#include <QPainter>
+#include <QFont>
+#include <QKeyEvent>
+#include <QEvent>
+#include <QPixmap>
+#include <QPaintEvent>
+#include <QCursor>
+#include <QImage>
+#include <QLayout>
+#include <QLabel>
+#include <QDateTime>
+#include <QRect>
+
+#include "mythcontext.h"
+#include "mythdbcon.h"
+#include "grideditimages.h"
+#include "grideditcutpoints.h"
+#include "NuppelVideoPlayer.h"
+
+#define FRAME_DEBUG 0
+#define CACHE_DEBUG 0
+
+GridEditImages::GridEditImages(GridEditCutpoints *editor, NuppelVideoPlayer *player)
+{
+    m_editor = editor;
+    m_player = player;
+    usedSubVideoCount = 0;
+
+    lastmovewasright= true;
+
+    int i;
+    for (i = stillFrames.minIndex(); i <= stillFrames.maxIndex(); i++)
+    {
+        stillFrames[i] = NULL;
+        stillFramesBig[i] = NULL;
+        cutFrames[i] = 0;
+    }
+
+    memset(cutFramesCache, 0, sizeof(cutFramesCache));
+    memset(stillFramesCache, 0, sizeof(stillFramesCache));
+    memset(stillFramesBigCache, 0, sizeof(stillFramesBigCache));
+    stillFrameCacheCount = 0;
+    stillFramesCacheBase = 0;
+
+    // Get first frames...
+    stillMainFrameNumber = m_player->GetFramesPlayed();
+    if (stillMainFrameNumber <= 0)
+        stillMainFrameNumber = 1;
+
+    // maxFrameNumber may be overridden if neccessary
+    maxFrameNumber = m_player->GetTotalFrameCount();
+    maxFrameNumberNVP = m_player->GetTotalFrameCount();
+
+    if (stillMainFrameNumber <= 0)
+        stillMainFrameNumber = 1;
+
+    if (stillMainFrameNumber > maxFrameNumber)
+        stillMainFrameNumber = maxFrameNumber;
+
+    getImagesTimer = new QTimer(this);
+    QObject::connect(getImagesTimer, SIGNAL(timeout()),
+                     this,           SLOT(updateAllFrames()));
+
+
+}
+
+GridEditImages::~GridEditImages()
+{
+    emptyCache();
+    clearStillFrames();
+    m_player->EditSeekToFrame(stillMainFrameNumber);
+}
+
+QPixmap *GridEditImages::makeScaledPixmap(const QImage& qim, QSize sz)
+{
+    QPixmap *retval;
+    if (qim.size() == sz)
+    {
+        retval = new QPixmap(sz);
+        QPainter p(retval);
+        p.drawImage(0, 0, qim);
+    }
+    else
+    {
+        retval = new QPixmap(sz);
+        retval->fill(Qt::black);
+        QPainter p(retval);
+
+        int tl_left = 0;
+        int tl_top = 0;
+        if (sz.width() > qim.width())
+            tl_left += (sz.width() - qim.width()) / 2;
+
+        if (sz.height() > qim.height())
+            tl_top += (sz.height() - qim.height()) / 2;
+
+//        VERBOSE(VB_GENERAL, QString("Size mismatch qim(%1, %2) != sz(%3, %4) Shift to (%5, %6)")
+//             .arg(qim.width()).arg(qim.height())
+//             .arg(sz.width()).arg(sz.height())
+//             .arg(tl_left).arg(tl_top));
+
+        p.drawImage(tl_left, tl_top, qim);
+    }
+    return retval;
+}
+
+void GridEditImages::getMainStillFrame()
+{
+    getSpecificFrame(0);
+}
+
+bool GridEditImages::getFrameIndexes(int newlevel)
+{
+    // levels:
+    // 0 - onscreen frames
+    // 1 - precache frames
+    // 2 - fill-out-the buffer frames
+
+    if (newlevel > 2)
+        return false;
+
+    // This gets the upper and lower indexes of the frames we need to get.
+    // Note these indexes maybe negative
+    // Negative frames are before the main frame
+    // Frame #0 is the main frame
+    // Positive frames are after the main frame
+
+    // Basic initialization
+    // Doesn't go to absolute end because it slows down seeking
+    // when you go 1 frame left and right
+    frameIndexLeft       = stillFrames.minIndex() + 4;
+    frameIndexRight      = stillFrames.maxIndex() - 4;
+    getFutureFramesFirst = false;
+
+    if (newlevel == 0) // Current Display only
+    {
+        frameIndexLeft  = -usedSubVideoCount;
+        frameIndexRight =  usedSubVideoCount;
+    }
+    else
+    {
+        getFutureFramesFirst = lastmovewasright;
+
+        if (newlevel == 1) // PreCache only
+        {
+            // preCacheIndexLeft and Right are indexes for the frames to start and end on
+            frameIndexLeft  = preCacheIndexLeft;
+            frameIndexRight = preCacheIndexRight;
+        }
+    }
+
+    // Make sure we don't fall of the front of the file
+    if (stillMainFrameNumber + frameIndexLeft <= 0)
+        frameIndexLeft = -(stillMainFrameNumber-1);
+
+    // ... or the back of the file
+    if (frameIndexRight > (maxFrameNumber - stillMainFrameNumber))
+        frameIndexRight = (maxFrameNumber - stillMainFrameNumber);
+
+#if CACHE_DEBUG
+    VERBOSE(VB_GENERAL, QString("Getting frames from %1 to %2 for level %3")
+            .arg(frameIndexLeft).arg(frameIndexRight).arg(newlevel));
+#endif
+    return true;
+}
+
+bool GridEditImages::getStillFrames(int maxcount)
+{
+    // returns true if no more frames to get
+
+    // This will fill in all the missing frames in the cache
+
+    long long i;
+    if (getFutureFramesFirst && frameIndexLeft < 0)
+    {
+        // If we're filling out the cache and the last move was to the right
+        // grab future frames first before any past frames
+        for (i = 1; i <= frameIndexRight; i++)
+            if (getSpecificFrame(i))
+                if (--maxcount == 0) return false;
+    }
+
+    // grab all appropriate frames
+
+    for (i = frameIndexLeft; i <= frameIndexRight; i++)
+        if (getSpecificFrame(i))
+            if (--maxcount == 0) return false;
+
+    return true;
+}
+
+bool GridEditImages::getSpecificFrame(long long i)
+{
+    // i is the index within the cache of frames
+
+    // If we're outside of the normal boundaries of the buffer,
+    // see if we've precached this frame
+    if (i < stillFrames.minIndex() || i > stillFrames.maxIndex())
+    {
+        // First extra cached frame
+        if (stillFrameCacheCount == 0)
+            stillFramesCacheBase = stillMainFrameNumber + i;
+
+        int tmpi;
+        for (tmpi = 0; tmpi < stillFrameCacheCount; tmpi++)
+        {
+            long long tmpframe = (stillFramesCacheBase + tmpi);
+            if (tmpframe == stillMainFrameNumber + i)
+                return false;
+        }
+
+        // Check for cache overflow
+        if (stillFrameCacheCount >= MAX_SUB_VIDEOS)
+        {
+            VERBOSE(VB_GENERAL, QString("Cached too many videos. Max = %1").arg(MAX_SUB_VIDEOS));
+            return false;
+        }
+
+        tmpi = stillFrameCacheCount++;
+
+#if CACHE_DEBUG
+        VERBOSE(VB_GENERAL, QString("Caching frame %1, (frm# %2, index %3)")
+                            .arg(tmpi).arg(stillMainFrameNumber + i)
+                            .arg(i));
+#endif
+
+        getFrame(i, cutFramesCache[tmpi], stillFramesCache[tmpi], stillFramesBigCache[tmpi]);
+        return true;
+    }
+    else if (!stillFrames[i])
+    {
+        getFrame(i, cutFrames[i], stillFrames[i], stillFramesBig[i]);
+        return true;
+    }
+
+    return false;
+}
+
+void GridEditImages::getFrame(long long i,
+        int &cutFrame,
+        QPixmap * &stillFrame,
+        QPixmap * &stillFrameBig)
+{
+    // get this frame
+    long long targetFrame = stillMainFrameNumber + i;
+
+    if (!m_player->EditSeekToFrame(targetFrame))
+    {
+        VERBOSE(VB_GENERAL, QString("Error seeking to Frame[%1] (frame # %2)")
+                            .arg(i).arg(targetFrame));
+        checkMaxFrameCount();
+
+        stillFrameBig = new QPixmap(videoSizeMain);
+        stillFrameBig->fill(Qt::gray);
+
+        stillFrame = new QPixmap(videoSizeSmall);
+        stillFrame->fill(Qt::gray);
+    }
+    else
+    {
+        cutFrame = m_player->GetCutStatus(targetFrame);
+        QImage normal, small;
+        m_player->GetScreenGrabsOfCurrentFrame(normal, small);
+
+        stillFrameBig = makeScaledPixmap(normal, videoSizeMain);
+        stillFrame    = makeScaledPixmap(small, videoSizeSmall);
+
+#if FRAME_DEBUG
+        VERBOSE(VB_GENERAL, QString("stillFrames[%1] = %2 (%3)")
+                .arg(i)
+                .arg(targetFrame)
+                .arg(cutFrame));
+#endif
+    }
+}
+
+void GridEditImages::SetVideoInfo(int vcount, QSize sizeMain, QSize sizeSmall)
+{
+    usedSubVideoCount = vcount;
+    videoSizeMain = sizeMain;
+    videoSizeSmall = sizeSmall;
+    SetPreCache(1);
+
+    m_player->SetScreenGrabSizes(videoSizeMain, videoSizeSmall);
+
+    // start to grab the current images
+    getMainStillFrame();
+    startFrameCaching();
+}
+
+void GridEditImages::startFrameCaching()
+{
+    frameCacheLevel=0;
+    getFrameIndexes(frameCacheLevel);
+
+    getImagesTimer->start(0);
+}
+
+void GridEditImages::SetPreCache(long long pccount)
+{
+    preCacheIndexLeft  = pccount - usedSubVideoCount;
+    preCacheIndexRight = pccount + usedSubVideoCount;
+}
+
+void GridEditImages::updateAllFrames()
+{
+    // getStillFrames() returns 'true' on the next call after it's gotten all requested frames
+
+    if (getStillFrames(1))
+    {
+        // If we've pre-cached the next screen of frames, tell the editor about it
+        if (frameCacheLevel == 1)
+            m_editor->cacheFramesAreReady();
+
+        frameCacheLevel++;
+        if (getFrameIndexes(frameCacheLevel))
+            getStillFrames(1);
+        else
+            stopFrameCaching();
+    }
+    m_editor->refreshImages();
+}
+
+void GridEditImages::clearStillFrames()
+{
+    int i;
+    for (i = stillFrames.minIndex(); i <= stillFrames.maxIndex(); i++)
+    {
+        if (stillFrames[i])
+        {
+            delete stillFrames[i];
+            stillFrames[i] = NULL;
+        }
+        if (stillFramesBig[i])
+        {
+            delete stillFramesBig[i];
+            stillFramesBig[i] = NULL;
+        }
+        cutFrames[i] = 0;
+    }
+}
+
+bool GridEditImages::shiftStillFramesLeft(long long offset)
+{
+    if (offset > 2 * stillFrames.maxIndex())
+    {
+        // Dump all cached data and re-get it
+        clearStillFrames();
+    }
+    else if (offset < 0)
+    {
+        VERBOSE(VB_IMPORTANT, QString("Offset (%1) < 0").arg(offset));
+        // Dump all cached data and re-get it
+        clearStillFrames();
+        offset = 0;
+    }
+    else if (offset != 0)
+    {
+        // Shift backwards in the stream by offset
+
+        // All frames will actually shift to the right.
+        // frame 'n' will become frame 'n+1'
+        // frame stillFrameMinus[1] will become mainframe
+        // frame stillFramePlus[max] will drop off
+
+        // shove extra frames into the excess space above usedSubVideos
+
+        if (offset >= stillMainFrameNumber)
+            offset = (stillMainFrameNumber-1);
+
+        //    printStillFrameStats("Before SL");
+        int i,j;
+        int minIndex = stillFrames.minIndex();
+        int maxIndex = stillFrames.maxIndex();
+        for (i = 0; i < offset; i++)
+        {
+            
+            if (stillFrames[maxIndex]) 
+            {
+                delete stillFrames[maxIndex];
+                delete stillFramesBig[maxIndex];
+            }
+
+            for (j = maxIndex; j > minIndex; j--) {
+                stillFrames[j]    = stillFrames[j-1];
+                stillFramesBig[j] = stillFramesBig[j-1];
+                cutFrames[j]      = cutFrames[j-1];
+            }
+
+             stillFrames[minIndex]    = NULL;
+             stillFramesBig[minIndex] = NULL;
+             cutFrames[minIndex]      = 0;
+        }
+
+        //   printStillFrameStats("After SL");
+
+    }
+
+    stillMainFrameNumber -= offset;
+    if (stillMainFrameNumber < 1)
+        stillMainFrameNumber = 1;
+
+    emptyCache();
+
+    return (stillFramesBig[0] != NULL);
+}
+
+bool GridEditImages::shiftStillFramesRight(long long offset)
+{
+    //VERBOSE(VB_GENERAL, QString("Offset =  %1").arg(offset));
+    if (offset > 2 * stillFrames.maxIndex())
+    {
+        // Dump all cached data and re-get it
+        clearStillFrames();
+    }
+    else if (offset < 0)
+    {
+        VERBOSE(VB_IMPORTANT, QString("Offset (%1) < 0").arg(offset));
+        // Dump all cached data and re-get it
+        clearStillFrames();
+        offset = 0;
+    }
+    else if (offset != 0)
+    {
+
+        // Shift forwards in the stream by offset
+
+        // All frames will actually shift to the left.
+        // frame 'n' will become frame 'n-1'
+        // frame stillFramePlus[1] will become mainframe
+        // frame stillFrameMinus[max] will drop off
+
+        // shove extra frames into the excess space above usedSubVideos
+
+        if (stillMainFrameNumber + offset > maxFrameNumber)
+        {
+            offset = (maxFrameNumber - stillMainFrameNumber);
+            VERBOSE(VB_GENERAL, QString("new Offset =  %1").arg(offset));
+        }
+        //printStillFrameStats("Before SR");
+
+        int i,j;
+        int minIndex = stillFrames.minIndex();
+        int maxIndex = stillFrames.maxIndex();
+
+        for (i = 0; i < offset; i++)
+        {
+            if (stillFrames[minIndex])
+            {
+                delete stillFrames[minIndex];
+                delete stillFramesBig[minIndex];
+            }
+
+            for (j = minIndex; j < maxIndex; j++) {
+                stillFrames[j]    = stillFrames[j+1];
+                stillFramesBig[j] = stillFramesBig[j+1];
+                cutFrames[j]      = cutFrames[j+1];
+            }
+
+             stillFrames[maxIndex]    = NULL;
+             stillFramesBig[maxIndex] = NULL;
+             cutFrames[maxIndex]      = 0;
+        }
+
+        //printStillFrameStats("After SR");
+
+    }
+    stillMainFrameNumber += offset;
+    if (stillMainFrameNumber > maxFrameNumber )
+        stillMainFrameNumber = maxFrameNumber;
+
+    emptyCache();
+
+    return (stillFramesBig[0] != NULL);
+}
+
+void GridEditImages::emptyCache()
+{
+#if CACHE_DEBUG
+    if (stillFrameCacheCount > 0)
+    {
+        long long minindex = (stillFramesCacheBase - stillMainFrameNumber);
+        long long maxindex = (stillFramesCacheBase+stillFrameCacheCount-1) - stillMainFrameNumber;
+        VERBOSE(VB_GENERAL, QString("emptying %1 frames (%2 - %3) into [%4] - [%5] ")
+                            .arg(stillFrameCacheCount)
+                            .arg(stillFramesCacheBase)
+                            .arg(stillFramesCacheBase+(stillFrameCacheCount-1))
+                            .arg(minindex).arg(maxindex));
+    }
+#endif
+    int i;
+    for (i = 0; i < stillFrameCacheCount; i++)
+    {
+        long long tmpframe = stillFramesCacheBase + i;
+        long long frameIndex = tmpframe - stillMainFrameNumber;
+
+        // frameIndex is the index matching stillFramesCache[i] to stillFrames[frameIndex]
+        // If frameIndex is within the stillFrames range, then use this frame
+        // otherwise delete it
+
+        if (frameIndex >= stillFrames.minIndex() && frameIndex <= stillFrames.maxIndex())
+        {
+            // move cache data into normal arrays.
+            if (stillFrames[frameIndex])
+            {
+                VERBOSE(VB_GENERAL, QString("Frame %1 index %2 already exists")
+                                    .arg(tmpframe).arg(frameIndex));
+                // Can't move it -- the destination exists
+                delete stillFramesCache[i];
+                delete stillFramesBigCache[i];
+            }
+            else
+            {
+                cutFrames[frameIndex] = cutFramesCache[i];
+                stillFrames[frameIndex] = stillFramesCache[i];
+                stillFramesBig[frameIndex] = stillFramesBigCache[i];
+            }
+        }
+        else
+        {
+            delete stillFramesCache[i];
+            delete stillFramesBigCache[i];
+        }
+        cutFramesCache[i]=0;
+        stillFramesCache[i] = NULL;
+        stillFramesBigCache[i] = NULL;
+    }
+    stillFrameCacheCount = 0;
+}
+
+void GridEditImages::printStillFrameStats(QString caption)
+{
+    int i;
+    // Debug info for frame cache
+    QString foundframes= caption + " Found Frames: ";
+
+    for (i = stillFrames.minIndex(); i <= stillFrames.maxIndex(); i++)
+        if (stillFrames[i])
+            foundframes += QString("%1 ").arg(i);
+
+    VERBOSE(VB_GENERAL, foundframes);
+}
+
+void GridEditImages::refreshCutList(UIGridEditImageType* gridimagemain,
+                                    myArray<UIGridEditImageType*, MAX_SUB_VIDEOS> &gridimages)
+{
+    int i;
+    for (i = stillFrames.minIndex(); i <= stillFrames.maxIndex(); i++)
+    {
+        if (stillFrames[i])
+        {
+            cutFrames[i] = m_player->GetCutStatus(stillMainFrameNumber+i);
+            if (gridimages[i])
+                gridimages[i]->setCutStatus(cutFrames[i]);
+        }
+    }
+
+    gridimagemain->setCutStatus(cutFrames[0]);
+}
+
+bool GridEditImages::refreshImages(UIGridEditImageType* gridimagemain,
+                                   myArray<UIGridEditImageType*, MAX_SUB_VIDEOS> &gridimages,
+                                   bool mainFrameOnly)
+{
+//    VERBOSE(VB_GENERAL, "Start");
+    bool alldone = true;
+    if (!stillFramesBig[0])
+        VERBOSE(VB_GENERAL, QString("Null Big Main frame %1").arg(stillMainFrameNumber));
+    gridimagemain->setPixmap(stillFramesBig[0],
+                             stillMainFrameNumber,
+                             cutFrames[0]);
+
+    if (mainFrameOnly && gridimages[0])
+        gridimages[0]->setPixmap(stillFrames[0],
+                                 stillMainFrameNumber,
+                                 cutFrames[0]);
+
+    if (!mainFrameOnly)
+    {
+        int i;
+        for (i = -usedSubVideoCount; i <= usedSubVideoCount; i++)
+        {
+            if (stillFrames[i] == NULL)
+                alldone = false;
+            if (gridimages[i])
+                gridimages[i]->setPixmap(stillFrames[i],
+                                         (stillMainFrameNumber + i),
+                                         cutFrames[i]);
+        }
+    }
+
+//    VERBOSE(VB_GENERAL, "Finish");
+    return alldone;
+}
+
+
+// Back up x frames
+void GridEditImages::SeekLeft(long long seekamount, bool cutpointseek)
+{
+    lastmovewasright = false;
+    stopFrameCaching();
+
+    if (cutpointseek)
+        seekamount = m_player->CalcCutPointSeek(stillMainFrameNumber, false);
+
+    //VERBOSE(VB_GENERAL, QString("SeekLeft %1, cutpoint = %2").arg(seekamount).arg(cutpointseek));
+
+    if (cutpointseek)
+        SetPreCache(-1);
+    else
+        SetPreCache(-seekamount);
+
+    if (!shiftStillFramesLeft(seekamount))
+    {
+        //VERBOSE(VB_GENERAL, QString("shiftStillFramesLeft(%1) == false")
+        //                           .arg(seekamount));
+        // Need to grab the main frame
+
+        getMainStillFrame();
+    }
+
+    startFrameCaching();
+}
+
+void GridEditImages::SeekRight(long long seekamount, bool cutpointseek)
+{
+    lastmovewasright = true;
+    stopFrameCaching();
+
+    if (cutpointseek)
+        seekamount = m_player->CalcCutPointSeek(stillMainFrameNumber, true);
+
+    //VERBOSE(VB_GENERAL, QString("SeekRight %1, cutpoint = %2").arg(seekamount).arg(cutpointseek));
+
+    if (cutpointseek)
+        SetPreCache(1);
+    else
+        SetPreCache(seekamount);
+
+    if (!shiftStillFramesRight(seekamount))
+    {
+        //VERBOSE(VB_GENERAL, QString("shiftStillFramesLeft(%1) == false")
+        //                           .arg(seekamount));
+        // Need to grab the main frame
+
+        getMainStillFrame();
+    }
+
+    startFrameCaching();
+}
+
+void GridEditImages::checkMaxFrameCount()
+{
+    long long tfc = m_player->GetTotalFrameCount();
+    if (tfc != maxFrameNumberNVP)
+    {
+       VERBOSE(VB_GENERAL, QString("Updating: tfc %1, mfn %2, mfnNVP %3")
+            .arg(tfc).arg(maxFrameNumber).arg(maxFrameNumberNVP));
+        // Check to see if things changed
+        maxFrameNumber = tfc;
+        maxFrameNumberNVP = tfc;
+    }
+}
+
+FrameStats GridEditImages::GetMainFrameStats()
+{
+    FrameStats result;
+
+    result.frameNumber = stillMainFrameNumber;
+    result.cutInd  = cutFrames[0];
+    result.maxFrameNumber = maxFrameNumber;
+
+    return result;
+}
+

mythtv/libs/libmythtv/grideditimages.h

@@ +1 @@
+// -*- Mode: c++ -*-
+#ifndef GRIDEDITIMAGES_H_
+#define GRIDEDITIMAGES_H_
+
+#include <qstring.h>
+
+#include "libmyth/mythwidgets.h"
+
+using namespace std;
+
+class QTimer;
+class NuppelVideoPlayer;
+class GridEditCutpoints;
+
+#define MAX_SUB_VIDEOS 25
+
+// Simple class to allow array indexing from -MAX_SUB_VIDEOS to +MAX_SUB_VIDEOS
+template<class T, int COUNT> class myArray
+{
+    public:
+        myArray() { memset(_array, 0, sizeof(_array));};
+
+        T& operator[](int i) { return _array[COUNT+i]; };
+        int minIndex() const { return -COUNT; };
+        int maxIndex() const { return  COUNT; };
+
+    private:
+        T _array[2*COUNT+1];
+};
+
+class FrameStats
+{
+    public:
+        long long frameNumber;
+        int cutInd;
+        long long maxFrameNumber;
+};
+
+class MPUBLIC GridEditImages : public QObject
+{
+    Q_OBJECT
+
+    public:
+        GridEditImages(GridEditCutpoints *er, NuppelVideoPlayer *player);
+        ~GridEditImages();
+
+        void refreshCutList(UIGridEditImageType* gridimagemain,
+                            myArray<UIGridEditImageType*, MAX_SUB_VIDEOS> &gridimages);
+
+        // return true if anything changed
+        bool refreshImages(UIGridEditImageType* gridimagemain,
+                           myArray<UIGridEditImageType*, MAX_SUB_VIDEOS> &gridimages,
+                           bool mainFrameOnly);
+
+        void SeekLeft(long long seekamount, bool cutpointseek = false);
+        void SeekRight(long long seekamount, bool cutpointseek = false);
+
+        FrameStats GetMainFrameStats();
+        long long GetCurrentFrameNumber() const { return stillMainFrameNumber; }
+        long long GetMaxFrameNumber() const { return maxFrameNumber; }
+
+        void SetVideoInfo(int vcount, QSize sizeMain, QSize sizeSmall);
+
+    protected slots:
+        void updateAllFrames();
+
+    private:
+        // Private functions
+        void clearStillFrames();
+        void printStillFrameStats(QString caption);
+        void checkMaxFrameCount();
+
+        // 'newlevel' paramter for getStillFrames():
+        //  0 = get on screen Frames only
+        //  1 = get preCache Frames only
+        //  2 = get any necessary frames
+        //  3 = done
+        bool getFrameIndexes(int newlevel);
+
+        bool getStillFrames(int maxcount = 1000);
+        void getMainStillFrame();
+        bool getSpecificFrame(long long frameindex);
+        void getFrame(long long i, int &cutFrame, QPixmap* &stillFrame, QPixmap* &stillFrameBig);
+        void emptyCache();
+
+        // return true if anything changed
+        bool shiftStillFramesLeft(long long offset);
+        bool shiftStillFramesRight(long long offset);
+        void startFrameCaching();
+        void stopFrameCaching() { getImagesTimer->stop(); };
+
+        QPixmap *makeScaledPixmap(const QImage& qim, QSize sz);
+
+        void SetPreCache(long long pccount);
+
+        // Private data
+        // These frames are in the cutlist
+        // 0 == not cut
+        // 1 == cut
+        // 2 == cutpoint (cut left)
+        // 3 == cutpoint (cut right)
+        myArray<int, MAX_SUB_VIDEOS> cutFrames;
+        myArray<QPixmap *, MAX_SUB_VIDEOS> stillFrames;
+        myArray<QPixmap *, MAX_SUB_VIDEOS> stillFramesBig;
+
+        // pre-caching large seek amounts
+        // (i.e. while seeking +5 seconds, these are places to store the to-be-displayed data)
+
+        int       cutFramesCache[MAX_SUB_VIDEOS];
+        QPixmap  *stillFramesCache[MAX_SUB_VIDEOS];
+        QPixmap  *stillFramesBigCache[MAX_SUB_VIDEOS];
+        int       stillFrameCacheCount;
+        long long stillFramesCacheBase; // Frame # for index[0]
+
+        QSize     videoSizeMain;
+        QSize     videoSizeSmall;
+        int       usedSubVideoCount;
+        long long preCacheIndexLeft;
+        long long preCacheIndexRight;
+        long long frameIndexLeft;
+        long long frameIndexRight;
+        bool      lastmovewasright;
+        bool      getFutureFramesFirst;
+        int       frameCacheLevel;
+
+        long long stillMainFrameNumber; // frame number for big still picture
+        long long currentFrameNumberNVP; // frame number the NVP should be on
+        long long maxFrameNumber;       // max frame number override for NVP
+        long long maxFrameNumberNVP;    // Original NVP number
+
+        GridEditCutpoints *m_editor;
+        NuppelVideoPlayer *m_player;
+
+        QTimer            *getImagesTimer;
+
+};
+
+#endif

mythtv/libs/libmythtv/libmythtv.pro

@@ -363 +363 @@
     # Misc. frontend
     HEADERS += guidegrid.h              infostructs.h
     HEADERS += ttfont.h
+    HEADERS += grideditcutpoints.h      grideditimages.h
     SOURCES += guidegrid.cpp            infostructs.cpp
     SOURCES += ttfont.cpp
+    SOURCES += grideditcutpoints.cpp    grideditimages.cpp
 
     using_mheg {
         # DSMCC stuff

mythtv/libs/libmythtv/tv_play.cpp

@@ -28 +28 @@
 #include "remoteencoder.h"
 #include "remoteutil.h"
 #include "guidegrid.h"
+#include "grideditcutpoints.h"
 //#include "progfind.h"
 #include "NuppelVideoPlayer.h"
 #include "programinfo.h"
@@ -573 +574 @@
     REG_KEY("TV Editing", "BIGJUMPFWD", "Jump forward 10x the normal amount",
             ">,.");
     REG_KEY("TV Editing", "TOGGLEEDIT", "Exit out of Edit Mode", "E");
+    REG_KEY("TV Editing", "SLOWMO", "Slow Motion Play", "Ctrl+P");
+    REG_KEY("TV Editing", "PAUSE", "Pause", "P");
 
     /* Teletext keys */
     REG_KEY("Teletext Menu", "NEXTPAGE",    "Next Page",             "Down");
@@ -3232 +3235 @@
     if (editmode)
     {
         actx->LockDeleteNVP(__FILE__, __LINE__);
+        if (actx->nvp && actx->nvp->GetHideEdits())
+        {
+            actx->UnlockDeleteNVP(__FILE__, __LINE__);
+            return;
+        }
         if (actx->nvp && !actx->nvp->DoKeypress(e))
             editmode = actx->nvp->GetEditMode();
         actx->UnlockDeleteNVP(__FILE__, __LINE__);
@@ -7699 +7707 @@
     qApp->postEvent(myWindow, me);
 }
 
+void TV::ShowEditRecordingGrid()
+{
+     // 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)
+     // on the main thread and avoid a deadlock on Win32
+
+     VERBOSE(VB_GENERAL, "Starting Grid Edit");
+     QString message = QString("START_EDIT");
+     MythEvent* me = new MythEvent(message);
+     qApp->postEvent(myWindow, me);
+}
+
 void TV::ChangeVolume(PlayerContext *ctx, bool up)
 {
     ctx->LockDeleteNVP(__FILE__, __LINE__);
@@ -8346 +8367 @@
         DoEditSchedule(editType);
     }
 
+    if (message.left(10) == "START_EDIT")
+    {
+        const PlayerContext *mctx =
+            GetPlayerReadLock(0, __FILE__, __LINE__);
+        mctx->LockDeleteNVP(__FILE__, __LINE__);
+        if (mctx->nvp)
+            mctx->nvp->ShowEditRecordingGrid();
+
+        mctx->UnlockDeleteNVP(__FILE__, __LINE__);
+        ReturnPlayerLock(mctx);
+    }
+
     if (message.left(14) == "COMMFLAG_START")
     {
         QString evchanid = QString::null;

mythtv/libs/libmythtv/tv_play.h

@@ -199 +199 @@
     void setInPlayList(bool setting) { inPlaylist = setting; }
     void setUnderNetworkControl(bool setting) { underNetworkControl = setting; }
 
+    void ShowEditRecordingGrid();
     void ShowNoRecorderDialog(const PlayerContext*,
                               NoRecorderMsg msgType = kNoRecorders);
     void FinishRecording(int player_idx); ///< Finishes player's recording