Index: libs/libmythtv/NuppelVideoPlayer.cpp
===================================================================
--- libs/libmythtv/NuppelVideoPlayer.cpp	(revision 13468)
+++ libs/libmythtv/NuppelVideoPlayer.cpp	(working copy)
@@ -4602,13 +4602,20 @@
     return retval;
 }
 
-int NuppelVideoPlayer::GetLetterbox(void) const
+int NuppelVideoPlayer::GetAspectOverride(void) const
 {
     if (videoOutput)
-        return videoOutput->GetLetterbox();
+        return videoOutput->GetAspectOverride();
     return false;
 }
 
+int NuppelVideoPlayer::GetAdjustFill(void) const
+{
+    if (videoOutput)
+        return videoOutput->GetAdjustFill();
+    return false;
+}
+
 void NuppelVideoPlayer::SetForcedAspectRatio(int mpeg2_aspect_value, int letterbox_permission)
 {
     (void)letterbox_permission;
@@ -4629,15 +4636,24 @@
     }
 }
 
-void NuppelVideoPlayer::ToggleLetterbox(int letterboxMode)
+void NuppelVideoPlayer::ToggleAspectOverride(int aspectMode)
 {
     if (videoOutput)
     {
-        videoOutput->ToggleLetterbox(letterboxMode);
+        videoOutput->ToggleAspectOverride(aspectMode);
         ReinitOSD();
     }
 }
 
+void NuppelVideoPlayer::ToggleAdjustFill(int adjustfillMode)
+{
+    if (videoOutput)
+    {
+        videoOutput->ToggleAdjustFill(adjustfillMode);
+        ReinitOSD();
+    }
+}
+
 void NuppelVideoPlayer::Zoom(int direction)
 {
     if (videoOutput)
Index: libs/libmythtv/videoout_quartz.cpp
===================================================================
--- libs/libmythtv/videoout_quartz.cpp	(revision 13468)
+++ libs/libmythtv/videoout_quartz.cpp	(working copy)
@@ -344,21 +344,21 @@
     double hscale, vscale;
     switch (parentData->srcMode)
     {
-        case kLetterbox_4_3_Zoom:
+        case kAdjustFill_Full:
             // height only fills 3/4 of image, zoom up
-            hscale = vscale = h * 1.0 / (sh * 0.75);
-            break;
-        case kLetterbox_16_9_Zoom:
-            // width only fills 3/4 of image, zoom up
+            // (16:9 movie in 4:3 letterbox format on 16:9 screen)
             hscale = vscale = w * 1.0 / (sw * 0.75);
             break;
-        case kLetterbox_16_9_Stretch:
+        case kAdjustFill_Half:
+            // height only fills 3/4 of image, zoom up
+            // (4:3 movie on 16:9 screen - 14:9 zoom is a good compromise)
+            hscale = vscale = w * 7.0 / (sw * 6);
+            break;
+        case kAdjustFill_Stretch:
             // like 16 x 9 standard, but with a horizontal stretch applied
             hscale = vscale = fmin(h * 1.0 / sh, w * 1.0 / sw);
             hscale *= 4.0 / 3.0;
             break;
-        case kLetterbox_4_3:
-        case kLetterbox_16_9:
         default:
             // standard, fill viewport with scaled image
             hscale = vscale = fmin(h * 1.0 / sh, w * 1.0 / sw);
Index: libs/libmythtv/tv_play.h
===================================================================
--- libs/libmythtv/tv_play.h	(revision 13468)
+++ libs/libmythtv/tv_play.h	(working copy)
@@ -234,7 +234,8 @@
 
     void ChangeVolume(bool up);
     void ToggleMute(void);
-    void ToggleLetterbox(int letterboxMode = -1);
+    void ToggleAspectOverride(int aspectMode = -1);
+    void ToggleAdjustFill(int adjustfillMode = -1);
 
     bool FillMenuTracks(OSDGenericTree*, uint type);
     void ChangeTrack(uint type, int dir);
Index: libs/libmythtv/NuppelVideoPlayer.h
===================================================================
--- libs/libmythtv/NuppelVideoPlayer.h	(revision 13468)
+++ libs/libmythtv/NuppelVideoPlayer.h	(working copy)
@@ -170,7 +170,8 @@
     void SetVideoResize(const QRect &videoRect);
 
     // Toggle Sets
-    void ToggleLetterbox(int letterboxMode = -1);
+    void ToggleAspectOverride(int aspectMode = -1);
+    void ToggleAdjustFill(int adjustfillMode = -1);
 
     // Gets
     int     GetVideoWidth(void) const         { return video_width; }
@@ -179,7 +180,8 @@
     float   GetFrameRate(void) const          { return video_frame_rate; }
 
     int     GetSecondsBehind(void) const;
-    int     GetLetterbox(void) const;
+    int     GetAspectOverride(void) const;
+    int     GetAdjustFill(void) const;
     int     GetFFRewSkip(void) const          { return ffrew_skip; }
     float   GetAudioStretchFactor(void) const { return audio_stretchfactor; }
     float   GetNextPlaySpeed(void) const      { return next_play_speed; }
Index: libs/libmythtv/tv_play.cpp
===================================================================
--- libs/libmythtv/tv_play.cpp	(revision 13468)
+++ libs/libmythtv/tv_play.cpp	(working copy)
@@ -2295,7 +2295,7 @@
                 ToggleRecord();
             else if (action == "VOLUMEDOWN" || action == "VOLUMEUP" ||
                      action == "STRETCHINC" || action == "STRETCHDEC" ||
-                     action == "MUTE" || action == "TOGGLEASPECT")
+                     action == "MUTE" || action == "TOGGLEASPECT" || action == "TOGGLEFILL" )
             {
                 passThru = 1;
                 handled = false;
@@ -2890,7 +2890,9 @@
         else if (action == "STRETCHDEC")
             ChangeTimeStretch(-1);
         else if (action == "TOGGLEASPECT")
-            ToggleLetterbox();
+            ToggleAspectOverride();
+        else if (action == "TOGGLEFILL")
+            ToggleAdjustFill();
         else if (action == "MENU")
             ShowOSDTreeMenu();
         else 
@@ -5434,20 +5436,16 @@
     wantsToQuit = true;
 }
 
-void TV::ToggleLetterbox(int letterboxMode)
+void TV::ToggleAspectOverride(int aspectMode)
 {
-    nvp->ToggleLetterbox(letterboxMode);
-    int letterbox = nvp->GetLetterbox();
+    nvp->ToggleAspectOverride(aspectMode);
+    int aspectoverride = nvp->GetAspectOverride();
     QString text;
 
-    switch (letterbox)
+    switch (aspectoverride)
     {
-        case kLetterbox_4_3:          text = tr("4:3"); break;
-        case kLetterbox_16_9:         text = tr("16:9"); break;
-        case kLetterbox_4_3_Zoom:     text = tr("4:3 Zoom"); break;
-        case kLetterbox_16_9_Zoom:    text = tr("16:9 Zoom"); break;
-        case kLetterbox_16_9_Stretch: text = tr("16:9 Stretch"); break;
-        case kLetterbox_Fill:         text = tr("Fill"); break;
+        case kAspect_4_3:             text = tr("4:3"); break;
+        case kAspect_16_9:            text = tr("16:9"); break;
         default:                      text = tr("Off"); break;
     }
 
@@ -5455,6 +5453,24 @@
         GetOSD()->SetSettingsText(text, 3);
 }
 
+void TV::ToggleAdjustFill(int adjustfillMode)
+{
+    nvp->ToggleAdjustFill(adjustfillMode);
+    int adjustfill = nvp->GetAdjustFill();
+    QString text;
+
+    switch (adjustfill)
+    {
+        case kAdjustFill_Half:        text = tr("Half Zoom"); break;
+        case kAdjustFill_Full:        text = tr("Full Zoom"); break;
+        case kAdjustFill_Stretch:     text = tr("Zoom & Stretch"); break;
+        default:                      text = tr("Off"); break;
+    }
+
+    if (GetOSD() && !browsemode && !GetOSD()->IsRunningTreeMenu())
+        GetOSD()->SetSettingsText(text, 3);
+}
+
 void TV::EPGChannelUpdate(uint chanid, QString channum)
 {
     if (chanid && !channum.isEmpty())
@@ -6488,8 +6504,12 @@
     }
     else if (action.left(12) == "TOGGLEASPECT")
     {
-        ToggleLetterbox(action.right(1).toInt());
+        ToggleAspectOverride(action.right(1).toInt());
     }
+    else if (action.left(10) == "TOGGLEFILL")
+    {
+        ToggleAdjustFill(action.right(1).toInt());
+    }
     else if (action == "GUIDE")
         EditSchedule(kScheduleProgramGuide);
     else if (action == "FINDER")
@@ -6728,38 +6748,42 @@
         FillMenuTracks(treeMenu, kTrackTypeTeletextCaptions);
     }
 
-    int letterbox = nvp->GetLetterbox();
+    int aspectoverride = nvp->GetAspectOverride();
     item = new OSDGenericTree(treeMenu, tr("Change Aspect Ratio"));
     subitem = new OSDGenericTree(item, tr("Off"), "TOGGLEASPECT" +
-                                 QString("%1").arg(kLetterbox_Off),
-                                 ((letterbox <= kLetterbox_Off) ||
-                                  (letterbox >= kLetterbox_END)) ? 1 : 0,
+                                 QString("%1").arg(kAspect_Off),
+                                 ((aspectoverride <= kAspect_Off) ||
+                                  (aspectoverride >= kAspect_END)) ? 1 : 0,
                                  NULL, "ASPECTGROUP");
     subitem = new OSDGenericTree(item, tr("4:3"), "TOGGLEASPECT" +
-                                 QString("%1").arg(kLetterbox_4_3),
-                                 (letterbox == kLetterbox_4_3) ? 1 : 0,
+                                 QString("%1").arg(kAspect_4_3),
+                                 (aspectoverride == kAspect_4_3) ? 1 : 0,
                                  NULL, "ASPECTGROUP");
     subitem = new OSDGenericTree(item, tr("16:9"), "TOGGLEASPECT" +
-                                 QString("%1").arg(kLetterbox_16_9),
-                                 (letterbox == kLetterbox_16_9) ? 1 : 0,
+                                 QString("%1").arg(kAspect_16_9),
+                                 (aspectoverride == kAspect_16_9) ? 1 : 0,
                                  NULL, "ASPECTGROUP");
-    subitem = new OSDGenericTree(item, tr("4:3 Zoom"), "TOGGLEASPECT" +
-                                 QString("%1").arg(kLetterbox_4_3_Zoom),
-                                 (letterbox == kLetterbox_4_3_Zoom) ? 1 : 0,
-                                 NULL, "ASPECTGROUP");
-    subitem = new OSDGenericTree(item, tr("16:9 Zoom"), "TOGGLEASPECT" +
-                                 QString("%1").arg(kLetterbox_16_9_Zoom),
-                                 (letterbox == kLetterbox_16_9_Zoom) ? 1 : 0,
-                                 NULL, "ASPECTGROUP");
-    subitem = new OSDGenericTree(item, tr("16:9 Stretch"), "TOGGLEASPECT" +
-                                 QString("%1").arg(kLetterbox_16_9_Stretch),
-                                 (letterbox == kLetterbox_16_9_Stretch) ? 1 : 0,
-                                 NULL, "ASPECTGROUP");
-    subitem = new OSDGenericTree(item, tr("Fill"), "TOGGLEASPECT" +
-                                 QString("%1").arg(kLetterbox_Fill),
-                                 (letterbox == kLetterbox_Fill) ? 1 : 0,
-                                 NULL, "ASPECTGROUP");
 
+    int adjustfill = nvp->GetAdjustFill();
+    item = new OSDGenericTree(treeMenu, tr("Adjust Fill"));
+    subitem = new OSDGenericTree(item, tr("Off"), "TOGGLEFILL" +
+                                 QString("%1").arg(kAdjustFill_Off),
+                                 ((adjustfill <= kAdjustFill_Off) ||
+                                  (adjustfill >= kAdjustFill_END)) ? 1 : 0,
+                                 NULL, "ADJUSTFILLGROUP");
+    subitem = new OSDGenericTree(item, tr("Half"), "TOGGLEFILL" +
+                                 QString("%1").arg(kAdjustFill_Half),
+                                 (adjustfill == kAdjustFill_Half) ? 1 : 0,
+                                 NULL, "ADJUSTFILLGROUP");
+    subitem = new OSDGenericTree(item, tr("Full"), "TOGGLEFILL" +
+                                 QString("%1").arg(kAdjustFill_Full),
+                                 (adjustfill == kAdjustFill_Full) ? 1 : 0,
+                                 NULL, "ADJUSTFILLGROUP");
+    subitem = new OSDGenericTree(item, tr("Stretch"), "TOGGLEFILL" +
+                                 QString("%1").arg(kAdjustFill_Stretch),
+                                 (adjustfill == kAdjustFill_Stretch) ? 1 : 0,
+                                 NULL, "ADJUSTFILLGROUP");
+
     if (db_use_picture_attr)
     {
         item = new OSDGenericTree(treeMenu, tr("Adjust Picture"));
Index: libs/libmythtv/videooutbase.cpp
===================================================================
--- libs/libmythtv/videooutbase.cpp	(revision 13468)
+++ libs/libmythtv/videooutbase.cpp	(working copy)
@@ -151,7 +151,8 @@
     db_display_dim(0,0),                db_move(0,0),
     db_scale_horiz(0.0f),               db_scale_vert(0.0f),
     db_pip_location(0),                 db_pip_size(26),
-    db_letterbox(kLetterbox_Off),       db_deint_filtername(QString::null),
+    db_aspectoverride(kAspect_Off),     db_adjustfill(kAdjustFill_Off),
+    db_deint_filtername(QString::null),
 
     // Manual Zoom
     mz_scale(0),                        mz_move(0,0),
@@ -163,8 +164,11 @@
     video_dim(640,480),                 video_aspect(1.3333f),
 
     // Aspect override
-    letterboxed_video_aspect(1.3333f),  letterbox(kLetterbox_Off),
+    overriden_video_aspect(1.3333f),    aspectoverride(kAspect_Off),
 
+    // Adjust Fill
+    adjustfill(kAdjustFill_Off),
+
     // Screen settings
     video_rect(0,0,0,0),                display_video_rect(0,0,0,0),
     display_visible_rect(0,0,0,0),      tmp_display_visible_rect(0,0,0,0),
@@ -211,7 +215,8 @@
     db_pict_attr[kPictureAttribute_Hue] =
         gContext->GetNumSetting("PlaybackHue",         0);
 
-    db_letterbox       = gContext->GetNumSetting("AspectOverride",     0);
+    db_aspectoverride  = gContext->GetNumSetting("AspectOverride",     0);
+    db_adjustfill      = gContext->GetNumSetting("AdjustFill",         0);
     db_deint_filtername= gContext->GetSetting("DeinterlaceFilter",
                                               "linearblend");
 }
@@ -255,7 +260,8 @@
     video_dim            = QSize(width, height);
     video_rect           = QRect(QPoint(winx, winy), fix_1080i(video_dim));
 
-    letterbox  = db_letterbox;
+    aspectoverride  = db_aspectoverride;
+    adjustfill      = db_adjustfill;
 
     VideoAspectRatioChanged(aspect); // apply aspect ratio and letterbox mode
 
@@ -376,25 +382,23 @@
 /**
  * \fn VideoOutput::SetVideoAspectRatio(float aspect)
  * \brief Sets VideoOutput::video_aspect to aspect, and sets 
- *        VideoOutput::letterboxed_video_aspect the letterbox type, unless
- *        the letterbox type is kLetterbox_Fill.
+ *        VideoOutput::overriden_video_aspect if aspectoverride
+ *        is set to either 4:3 or 16:9.
  * 
  * \param aspect video aspect ratio to use
  */
 void VideoOutput::SetVideoAspectRatio(float aspect)
 {
-    letterboxed_video_aspect = video_aspect = aspect;
-    
+    overriden_video_aspect = video_aspect = aspect;
+
     // Override video's aspect if configured to do so
-    if ((kLetterbox_4_3      == letterbox) ||
-        (kLetterbox_4_3_Zoom == letterbox))
+    if (kAspect_4_3 == aspectoverride)
     {
-        letterboxed_video_aspect = 4.0f / 3.0f;
+        overriden_video_aspect = 4.0f / 3.0f;
     }
-    else if ((kLetterbox_16_9      == letterbox) ||
-             (kLetterbox_16_9_Zoom == letterbox))
+    else if (kAspect_16_9 == aspectoverride)
     {
-        letterboxed_video_aspect = 16.0f / 9.0f;
+        overriden_video_aspect = 16.0f / 9.0f;
     }
 }
 
@@ -548,12 +552,12 @@
     float dispPixelAdj = (GetDisplayAspect() * display_visible_rect.height()) / display_visible_rect.width();
     // now adjust for scaling of the video on the aspect ratio
     float vs = ((float)vb.width())/vb.height();
-    visible_aspect = 1.3333f * (vs/letterboxed_video_aspect) * dispPixelAdj;
+    visible_aspect = 1.3333f * (vs/overriden_video_aspect) * dispPixelAdj;
 
     // now adjust for scaling of the video on the size
     font_scaling = 1.0f/sqrtf(2.0/(sq(visible_aspect / 1.3333f) + 1.0f));
     // now adjust for aspect ratio effect on font size (should be in osd.cpp?)
-    font_scaling *= sqrtf(letterboxed_video_aspect/1.3333f);
+    font_scaling *= sqrtf(overriden_video_aspect/1.3333f);
     return vb;
 }
 
@@ -717,16 +721,16 @@
 void VideoOutput::ApplyLetterboxing(void)
 {
     float disp_aspect = fix_aspect(GetDisplayAspect());
-    float aspect_diff = disp_aspect - letterboxed_video_aspect;
+    float aspect_diff = disp_aspect - overriden_video_aspect;
     bool  aspects_match = abs(aspect_diff / disp_aspect) <= 0.1f;
-    bool  nomatch_with_fill = !aspects_match && (letterbox == kLetterbox_Fill);
+    bool  nomatch_with_fill = !aspects_match && (adjustfill == kAdjustFill_Stretch);
     bool  nomatch_without_fill = (!aspects_match) && !nomatch_with_fill;
 
     // Adjust for video/display aspect ratio mismatch
-    if (nomatch_with_fill && (disp_aspect > letterboxed_video_aspect))
+    if (nomatch_with_fill && (disp_aspect > overriden_video_aspect))
     {
         float pixNeeded =
-            ((disp_aspect / letterboxed_video_aspect) *
+            ((disp_aspect / overriden_video_aspect) *
              (float)display_video_rect.height()) + 0.5f;
 
         display_video_rect.moveTop(
@@ -737,7 +741,7 @@
     else if (nomatch_with_fill)
     {
         float pixNeeded =
-            ((letterboxed_video_aspect / disp_aspect) * 
+            ((overriden_video_aspect / disp_aspect) * 
              (float)display_video_rect.width()) + 0.5f;
 
         display_video_rect.moveLeft(
@@ -746,10 +750,10 @@
 
         display_video_rect.setWidth((int)pixNeeded);
     }
-    else if (nomatch_without_fill && (disp_aspect > letterboxed_video_aspect))
+    else if (nomatch_without_fill && (disp_aspect > overriden_video_aspect))
     {
         float pixNeeded =
-            ((letterboxed_video_aspect / disp_aspect) *
+            ((overriden_video_aspect / disp_aspect) *
              (float)display_video_rect.width()) + 0.5f;
 
         display_video_rect.moveLeft(
@@ -761,7 +765,7 @@
     else if (nomatch_without_fill)
     {
         float pixNeeded =
-            ((disp_aspect / letterboxed_video_aspect) *
+            ((disp_aspect / overriden_video_aspect) *
              (float)display_video_rect.height()) + 0.5f;
 
         display_video_rect.moveTop(
@@ -772,8 +776,7 @@
     }
 
     // Process letterbox zoom modes
-    if ((letterbox == kLetterbox_4_3_Zoom) ||
-        (letterbox == kLetterbox_16_9_Zoom))
+    if (adjustfill == kAdjustFill_Full)
     {
         // Zoom mode -- Expand by 4/3 and overscan.
         // 1/6 of original is 1/8 of new
@@ -783,8 +786,22 @@
             display_video_rect.width()  * 4 / 3,
             display_video_rect.height() * 4 / 3);
     }
-    else if (letterbox == kLetterbox_16_9_Stretch)
+    else if (adjustfill == kAdjustFill_Half)
     {
+        // Zoom mode -- Expand by 7/6 and overscan.
+        // Intended for eliminating the top bars on 14:9 material.
+        // Also good compromise for 4:3 material on 16:9 screen.
+        // Expanding by 7/6, so remove 1/6 of original from overscan;
+        // take half from each side, so remove 1/12.
+        display_video_rect = QRect(
+            display_video_rect.left() - (display_video_rect.width()  / 12),
+            display_video_rect.top()  - (display_video_rect.height() / 12),
+            display_video_rect.width()  * 7 / 6,
+            display_video_rect.height() * 7 / 6);
+    }
+
+    else if (adjustfill == kAdjustFill_Stretch)
+    {
         // Stretch mode -- intended to be used to eliminate side
         //                 bars on 4:3 material encoded to 16:9.
         // 1/6 of original is 1/8 of new
@@ -852,9 +869,10 @@
     printf("Vscan(%f, %f)\n", db_scale_vert, db_scale_vert);
     printf("DisplayAspect: %f\n", GetDisplayAspect());
     printf("VideoAspect(%f)\n", video_aspect);
-    printf("letterboxed_video_aspect(%f)\n", letterboxed_video_aspect);
+    printf("overriden_video_aspect(%f)\n", overriden_video_aspect);
     printf("CDisplayAspect: %f\n", fix_aspect(GetDisplayAspect()));
-    printf("Letterbox: %d\n", letterbox);
+    printf("AspectOverride: %d\n", aspectoverride);
+    printf("AdjustFill: %d\n", adjustfill);
 #endif
 
     VERBOSE(VB_PLAYBACK,
@@ -869,7 +887,7 @@
                     "height: %4, aspect: %5")
             .arg(video_rect.left()).arg(video_rect.top())
             .arg(video_rect.width()).arg(video_rect.height())
-            .arg(letterboxed_video_aspect));
+            .arg(overriden_video_aspect));
 
 }
 
@@ -881,7 +899,7 @@
  * then we letterbox settings, and finally we apply manual
  * scale & move properties for "Zoom Mode".
  *
- * \sa Zoom(int), ToggleLetterbox(int)
+ * \sa Zoom(int), ToggleAdjustFill(int)
  */
 void VideoOutput::MoveResize(void)
 {
@@ -904,7 +922,7 @@
  * \fn VideoOutput::Zoom(int)
  * \brief Sets up zooming into to different parts of the video, the zoom
  *        is actually applied in MoveResize().
- * \sa ToggleLetterbox(int), GetLetterbox()
+ * \sa ToggleAdjustFill(int)
  */
 void VideoOutput::Zoom(int direction)
 {
@@ -938,27 +956,49 @@
 }
 
 /**
- * \fn VideoOutput::ToggleLetterbox(int)
- * \brief Sets up letterboxing for various standard video frame and
- *        monitor dimensions, then calls VideoAspectRatioChanged(float)
+ * \fn VideoOutput::ToggleAspectOverride(int)
+ * \brief Enforce different aspect ration than detected,
+ *        then calls VideoAspectRatioChanged(float)
  *        to apply them.
- * \sa Zoom(int), 
+ * \sa Zoom(int), ToggleAdjustFill(int)
  */
-void VideoOutput::ToggleLetterbox(int letterboxMode)
+void VideoOutput::ToggleAspectOverride(int aspectMode)
 {
-    if (letterboxMode == kLetterbox_Toggle)
+    if (aspectMode == kAspect_Toggle)
     {
-        if (++letterbox >= kLetterbox_END)
-            letterbox = kLetterbox_Off;
+        if (++aspectoverride >= kAspect_END)
+            aspectoverride = kAspect_Off;
     }
     else
     {
-        letterbox = letterboxMode;
+        aspectoverride = aspectMode;
     }
 
     VideoAspectRatioChanged(video_aspect);
 }
 
+/**
+ * \fn VideoOutput::ToggleAdjustFill(int)
+ * \brief Sets up letterboxing for various standard video frame and
+ *        monitor dimensions, then calls MoveResize()
+ *        to apply them.
+ * \sa Zoom(int), ToggleAspectOverride(int)
+ */
+void VideoOutput::ToggleAdjustFill(int adjustfillMode)
+{
+    if (adjustfillMode == kAdjustFill_Toggle)
+    {
+        if (++adjustfill >= kAdjustFill_END)
+            adjustfill = kAdjustFill_Off;
+    }
+    else
+    {
+        adjustfill = adjustfillMode;
+    }
+
+    MoveResize();
+}
+
 int VideoOutput::ChangePictureAttribute(int attributeType, bool direction)
 {
     int curVal = GetPictureAttribute(attributeType);
@@ -1109,7 +1149,7 @@
     int letterXadj = 0;
     int letterYadj = 0;
     float letterAdj = 1.0f;
-    if (letterbox != kLetterbox_Off)
+    if (aspectoverride != kAspect_Off)
     {
         letterXadj = max(-display_video_rect.left(), 0);
         float xadj = (float) video_rect.width() / display_visible_rect.width();
@@ -1119,7 +1159,7 @@
         letterYadj = max(-display_video_rect.top(), 0);
         letterYadj = (int) (letterYadj * yadj);
 
-        letterAdj  = video_aspect / letterboxed_video_aspect;
+        letterAdj  = video_aspect / overriden_video_aspect;
     }
 
     // adjust for non-square pixels on screen
Index: libs/libmythtv/videooutbase.h
===================================================================
--- libs/libmythtv/videooutbase.h	(revision 13468)
+++ libs/libmythtv/videooutbase.h	(working copy)
@@ -89,19 +89,25 @@
     kZoomRight
 };
 
-enum LetterboxModes
+enum AdjustFillModes
 {
-    kLetterbox_Toggle = -1,
-    kLetterbox_Off = 0,
-    kLetterbox_4_3,
-    kLetterbox_16_9,
-    kLetterbox_4_3_Zoom,
-    kLetterbox_16_9_Zoom,
-    kLetterbox_16_9_Stretch,
-    kLetterbox_Fill,
-    kLetterbox_END
+    kAdjustFill_Toggle = -1,
+    kAdjustFill_Off = 0,
+    kAdjustFill_Half,
+    kAdjustFill_Full,
+    kAdjustFill_Stretch,
+    kAdjustFill_END
 };
 
+enum AspectOverrideModes
+{
+    kAspect_Toggle = -1,
+    kAspect_Off = 0,
+    kAspect_4_3,
+    kAspect_16_9,
+    kAspect_END
+};
+
 enum FrameScanType
 {
     kScan_Ignore      = -1,
@@ -200,11 +206,16 @@
     /// \brief Returns current display aspect ratio.
     virtual float GetDisplayAspect(void) const { return display_aspect; }
 
-    /// \brief Returns current letterboxing mode
-    /// \sa ToggleLetterbox(int)
-    int GetLetterbox(void) { return letterbox; }
-    void ToggleLetterbox(int letterboxMode = kLetterbox_Toggle);
+    /// \brief Returns current aspect override mode
+    /// \sa ToggleAspectOverride(int)
+    int GetAspectOverride(void) { return aspectoverride; }
+    void ToggleAspectOverride(int aspectOverrideMode = kAspect_Toggle);
 
+    /// \brief Returns current adjust fill mode
+    /// \sa ToggleAdjustFill(int)
+    int GetAdjustFill(void) { return adjustfill; }
+    void ToggleAdjustFill(int adjustFillMode = kAdjustFill_Toggle);
+
     // pass in null to use the pause frame, if it exists.
     virtual void ProcessFrame(VideoFrame *frame, OSD *osd,
                               FilterChain *filterList,
@@ -343,7 +354,8 @@
     int     db_pip_location;
     int     db_pip_size;      ///< percentage of full window to use for PiP
     QMap<int,int> db_pict_attr; ///< Picture settings
-    int     db_letterbox;
+    int     db_aspectoverride;
+    int     db_adjustfill;
     QString db_deint_filtername;
 
     // Manual Zoom
@@ -359,10 +371,12 @@
     float   video_aspect;     ///< Physical aspect ratio of video
 
     /// Normally this is the same as videoAspect, but may not be
-    /// if the user has toggled to a different "letterbox" mode.
-    float   letterboxed_video_aspect;
-    /// LetterboxMode to use to modify letterboxed_video_aspect
-    int     letterbox;
+    /// if the user has toggled the aspect override mode.
+    float   overriden_video_aspect;
+    /// AspectOverrideMode to use to modify overriden_video_aspect
+    int     aspectoverride;
+    /// Zoom mode
+    int     adjustfill;
 
     /// Pixel rectangle in video frame to display
     QRect   video_rect;
Index: programs/mythfrontend/globalsettings.cpp
===================================================================
--- programs/mythfrontend/globalsettings.cpp	(revision 13470)
+++ programs/mythfrontend/globalsettings.cpp	(working copy)
@@ -1500,18 +1500,23 @@
     gc->addSelection(QObject::tr("Off"), "0");
     gc->addSelection(QObject::tr("4/3"), "1");
     gc->addSelection(QObject::tr("16/9"), "2");
-    gc->addSelection(QObject::tr("4/3 Zoom"), "3");
-    gc->addSelection(QObject::tr("16/9 Zoom"), "4");
-    gc->addSelection(QObject::tr("16/9 Stretch"), "5");
-    gc->addSelection(QObject::tr("Fill"), "6");
     gc->setHelpText(QObject::tr("This will override any aspect ratio in the "
                     "recorded stream, the same as pressing the W Key during "
-                    "playback. Fill will \"fill\" the screen with the image "
-                    "clipping as required. Fill is useful when using 4:3 "
-                    "interlaced TV's for display."));
+                    "playback."));
     return gc;
 }
 
+static HostComboBox *AdjustFill()
+{
+    HostComboBox *gc = new HostComboBox("AdjustFill");
+    gc->setLabel(QObject::tr("Zoom"));
+    gc->addSelection(QObject::tr("Off"), "0");
+    gc->addSelection(QObject::tr("Half"), "1");
+    gc->addSelection(QObject::tr("Full"), "2");
+    gc->addSelection(QObject::tr("Stretch"), "3");
+    return gc;
+}
+
 // Theme settings
 
 static HostSpinBox *GuiWidth()
@@ -3506,6 +3511,7 @@
     general->addChild(UseVideoTimebase());
     general->addChild(DecodeExtraAudio());
     general->addChild(AspectOverride());
+    // general->addChild(AdjustFill());
     general->addChild(PIPLocation());
     addChild(general);
 
