← Back to branch summary

~ubuntu-branches/ubuntu/lucid/mythtv/lucid

« back to all changes in this revision

Viewing changes to libs/libmythtv/osdtypes.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Dave Walker (Daviey), Jamie Bennett, Mario Limonciello, Dave Walker (Daviey)
  • Date: 2010-03-23 19:32:33 UTC
  • mfrom: (1.1.49 upstream)
  • Revision ID: james.westby@ubuntu.com-20100323193233-5sv9djoxtlmwt3ca
Tags: 0.23.0+fixes23789-0ubuntu1
https://launchpad.net/bugs/537714
https://launchpad.net/bugs/483748
https://launchpad.net/bugs/546552
https://launchpad.net/bugs/544521
[ Jamie Bennett ]
* Fix FTBFS on armel (LP: #537714)

[ Mario Limonciello ]
* mythtv-{common,backend}.{config,templates,postinst}: (LP: #483748)
  - Simplify debconf questions by avoiding showing the generated pw
  - Don't warn about mythtv group.
  - Don't notify about running mythtv-setup.  This is optional (but
    of course encouraged!)
* Set version to include a "+" delimitter.
* Restore libfaad-dev dependency. (LP: #546552)

[ Dave Walker (Daviey) ]
* New snapshot (r23789), based from 0.23-fixes.
* debian/control:
  - mythtv-frontend set to Conflict with mythflix, as it's dropped
    upstream. (LP: #544521)
  - Remove unnecessary and potentially problematic use of Pre-Depends.
  - Set the debug package to Priority extra.
  - Change *-perl Section's from libs to perl
  - add ${shlibs:Depends} for mythtv-common Depends field
  - Minor spelling fix.
  - Fixes the long description for one of the packages, ensuring the
    description doesn't exceed 80 characters.
  - Vcs-* set to -fixes, rather than -trunk.
* debian/rules:
  - Use debconf-updatepo to update translations when required
  - Ensure license files are not included in the binary packages, except 
    for debian/copyright.
  - Fixes the permissions of certain files in the packaging.
* debian/copyright:
  - updated to reflect that mythtv is GPL-2 only.
  - inserted better licence statement and Copyright reference.
* debian/mythtv-*.templates
  - Simplified strings; removed verbosity and improved readability.
* Prevent the maintainer scripts from failing in case any questions 
  can't be displayed.
* Added holding debian/mythtv-frontend.config, mainly to appease lintian.
* debian/mythtv-frontend.menu: Changed section to Applications/Graphics.
* debian/mythtv-backend.postinst: Load debconf libraries.
* debian/source.lintian-overrides: Removes the unecessary override of the 
  binNMU warnings.
* Fix perl binding installation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/libmythtv/osdtypes.cpp
63
63
    m_notimeout = false;
64
64
    m_fadetime = -1;
65
65
    m_maxfade = -1;
66
 
 
 
66
 
67
67
    m_xmove = 0;
68
68
    m_ymove = 0;
69
69
 
141
141
            OSDTypeBox *newbox = new OSDTypeBox(*item);
142
142
            AddType(newbox);
143
143
        }
144
 
        else if (OSDTypePositionRectangle *item = 
 
144
        else if (OSDTypePositionRectangle *item =
145
145
                  dynamic_cast<OSDTypePositionRectangle*>(type))
146
146
        {
147
 
            OSDTypePositionRectangle *newrect = 
 
147
            OSDTypePositionRectangle *newrect =
148
148
                               new OSDTypePositionRectangle(*item);
149
149
            AddType(newrect);
150
150
        }
172
172
    }
173
173
    allTypes->clear();
174
174
}
175
 
 
 
175
 
176
176
void OSDSet::AddType(OSDType *type)
177
177
{
178
178
    typeList[type->Name()] = type;
181
181
}
182
182
 
183
183
void OSDSet::Reinit(int screenwidth, int screenheight, int xoff, int yoff,
184
 
                    int displaywidth, int displayheight, 
 
184
                    int displaywidth, int displayheight,
185
185
                    float wmult, float hmult, int frint)
186
186
{
187
187
    m_frameint = frint;
528
528
        m_displaying = false;
529
529
    }
530
530
 
531
 
    if (currentOSDFunctionalType != osdFunctionalType && 
 
531
    if (currentOSDFunctionalType != osdFunctionalType &&
532
532
        currentOSDFunctionalType != 0)
533
533
    {
534
534
        SendOSDClosed(currentOSDFunctionalType);
546
546
    m_xoff = 0;
547
547
    m_yoff = 0;
548
548
 
549
 
    if (currentOSDFunctionalType != osdFunctionalType && 
 
549
    if (currentOSDFunctionalType != osdFunctionalType &&
550
550
        currentOSDFunctionalType != 0)
551
551
    {
552
552
        SendOSDClosed(currentOSDFunctionalType);
554
554
 
555
555
    currentOSDFunctionalType = osdFunctionalType;
556
556
}
557
 
 
 
557
 
558
558
/*void OSDSet::FadeFor(int time)
559
559
{
560
560
    cerr<<"fadefor("<<time<<")"<<endl;
629
629
    // timeouts and do any animation and/or emit that must be done.
630
630
    if (!m_notimeout && m_displaying)
631
631
    {
632
 
        // Count down pre-fade time 
 
632
        // Count down pre-fade time
633
633
        m_timeleft = max(m_timeleft - m_frameint, 0);
634
634
 
635
635
        // If fading, start counting down fade time
664
664
    return m_showwith.exactMatch(name);
665
665
}
666
666
 
667
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
667
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
668
668
 
669
669
OSDType::OSDType(const QString &name) :
670
670
    m_lock(QMutex::Recursive),
689
689
 
690
690
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
691
691
 
692
 
OSDTypeText::OSDTypeText(const QString &name, TTFFont *font, 
 
692
OSDTypeText::OSDTypeText(const QString &name, TTFFont *font,
693
693
                         const QString &text, QRect displayrect,
694
694
                         float wmult, float hmult) :
695
695
    OSDType(name),
796
796
    for (int i = (int)text.length() - 1; i >= 0; i--)
797
797
    {
798
798
        QChar::Direction text_dir = text[i].direction();
799
 
        if (text_dir != QChar::DirR && 
 
799
        if (text_dir != QChar::DirR &&
800
800
            text_dir != QChar::DirRLE &&
801
801
            text_dir != QChar::DirRLO)
802
802
        {
864
864
 
865
865
    if (log2vis)
866
866
        len = fribidi_remove_bidi_marks(&visual[0], len, NULL, NULL, NULL);
867
 
 
 
867
 
868
868
    output = "";
869
869
    for (size_t i = 0; i < len ; i++)
870
870
        output += QChar(visual[i]);
939
939
    m_displaysize = m_screensize = bias(m_unbiasedsize, wmult, hmult);
940
940
}
941
941
 
942
 
void OSDTypeText::Draw(OSDSurface *surface, int fade, int maxfade, int xoff, 
 
942
void OSDTypeText::Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
943
943
                       int yoff)
944
944
{
945
945
    QMutexLocker locker(&m_lock);
982
982
        for (; it != wordlist.end(); ++it)
983
983
        {
984
984
            QString word = *it;
985
 
            if (word == "%d") 
 
985
            if (word == "%d")
986
986
            {
987
987
                m_parent->SetWantsUpdates(true);
988
988
                int timeleft = (m_parent->GetTimeLeft() + 999999) / 1000000;
990
990
                    timeleft = 99;
991
991
                if (timeleft < 0)
992
992
                    timeleft = 0;
993
 
                
994
 
                word = QString::number(timeleft);    
 
993
 
 
994
                word = QString::number(timeleft);
995
995
            }
996
996
 
997
997
            if (!length && word == "\n")
1002
1002
                (word == "\n"))
1003
1003
            {
1004
1004
                QRect drawrect = m_displaysize;
1005
 
                drawrect.setTop((int)(m_displaysize.top() + m_font->Size() * 
 
1005
                drawrect.setTop((int)(m_displaysize.top() + m_font->Size() *
1006
1006
                                      (lines) * m_linespacing));
1007
1007
                DrawString(surface, drawrect, line, fade, maxfade, xoff, yoff);
1008
1008
                length = 0;
1033
1033
        drawrect.setTop((int)(m_displaysize.top() + m_font->Size() * (lines) *
1034
1034
                              m_linespacing));
1035
1035
        DrawString(surface, drawrect, line, fade, maxfade, xoff, yoff);
1036
 
    }           
 
1036
    }
1037
1037
    else if (m_scroller)
1038
1038
    {
1039
1039
        if (!m_scrollinit)
1061
1061
                m_scrollposx = m_scrollstartx;
1062
1062
                m_displaysize.setWidth(messagewidth);
1063
1063
            }
1064
 
            
 
1064
 
1065
1065
            m_scrollstarty = 0;
1066
1066
            m_scrollendy = 0;
1067
1067
            m_scrollposy = 0;
1078
1078
                m_parent->Hide();
1079
1079
        }
1080
1080
 
1081
 
        DrawString(surface, m_displaysize, m_message, fade, maxfade, 
 
1081
        DrawString(surface, m_displaysize, m_message, fade, maxfade,
1082
1082
                   xoff + m_scrollposx, yoff + m_scrollposy);
1083
1083
    }
1084
1084
    else if (!m_message.contains('['))
1093
1093
    }
1094
1094
}
1095
1095
 
1096
 
void OSDTypeText::DrawHiLiteString(OSDSurface *surface, QRect rect, 
1097
 
                                   const QString &text, int fade, int maxfade, 
 
1096
void OSDTypeText::DrawHiLiteString(OSDSurface *surface, QRect rect,
 
1097
                                   const QString &text, int fade, int maxfade,
1098
1098
                                   int xoff, int yoff, bool double_size)
1099
1099
{
1100
1100
    QMutexLocker locker(&m_lock);
1207
1207
        }
1208
1208
    }
1209
1209
}
1210
 
  
1211
 
void OSDTypeText::DrawString(OSDSurface *surface, QRect rect, 
1212
 
                             const QString &text, int fade, int maxfade, 
 
1210
 
 
1211
void OSDTypeText::DrawString(OSDSurface *surface, QRect rect,
 
1212
                             const QString &text, int fade, int maxfade,
1213
1213
                             int xoff, int yoff, bool doubl)
1214
1214
{
1215
1215
    QMutexLocker locker(&m_lock);
1257
1257
            box.Draw(surface, fade, maxfade, xoff, 0, 200);
1258
1258
        }
1259
1259
    }
1260
 
} 
 
1260
}
1261
1261
 
1262
1262
bool OSDTypeText::MoveCursor(int dir)
1263
1263
{
1308
1308
 
1309
1309
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1310
1310
 
1311
 
OSDTypeImage::OSDTypeImage(const QString &name, const QString &filename, 
1312
 
                           QPoint displaypos, float wmult, float hmult, 
 
1311
OSDTypeImage::OSDTypeImage(const QString &name, const QString &filename,
 
1312
                           QPoint displaypos, float wmult, float hmult,
1313
1313
                           int scalew, int scaleh)
1314
1314
            : OSDType(name)
1315
1315
{
1361
1361
 
1362
1362
        m_ybuffer = m_yuv;
1363
1363
        m_ubuffer = m_yuv + (m_imagesize.width() * m_imagesize.height());
1364
 
        m_vbuffer = m_yuv + (m_imagesize.width() * m_imagesize.height() * 
 
1364
        m_vbuffer = m_yuv + (m_imagesize.width() * m_imagesize.height() *
1365
1365
                             5 / 4);
1366
 
    } 
 
1366
    }
1367
1367
}
1368
1368
 
1369
1369
OSDTypeImage::OSDTypeImage(const QString &name) :
1472
1472
 
1473
1473
        // Get the item from the cache so it's not freed while in use
1474
1474
        OSDImageCacheValue *value = c_cache.Get(ckey, true);
1475
 
  
 
1475
 
1476
1476
        if (value != NULL)
1477
1477
        {
1478
1478
            m_yuv       = value->m_yuv;
1494
1494
            return;
1495
1495
        }
1496
1496
    }
1497
 
  
1498
 
    // Create image 
 
1497
 
 
1498
    // Create image
1499
1499
    QImage tmpimage(filename);
1500
1500
 
1501
1501
    if (tmpimage.width() == 0)
1503
1503
 
1504
1504
    int imwidth = 0, imheight = 0;
1505
1505
 
1506
 
    if (scalew > 0) 
 
1506
    if (scalew > 0)
1507
1507
        imwidth = ((int)(scalew * wmult) / 2) * 2;
1508
1508
    else
1509
1509
        imwidth = ((int)(tmpimage.width() * wmult) / 2) * 2;
1538
1538
        // is reached
1539
1539
        if (m_cacheitem)
1540
1540
            c_cache.Insert(m_cacheitem);
1541
 
  
 
1541
 
1542
1542
        m_cacheitem = new OSDImageCacheValue(
1543
1543
            ckey,
1544
1544
            m_yuv,     m_ybuffer, m_ubuffer,
1545
1545
            m_vbuffer, m_alpha,   m_imagesize);
1546
 
 
 
1546
 
1547
1547
        // save the new cache item to the file cache
1548
1548
        if (!filename.isEmpty())
1549
1549
            c_cache.SaveToDisk(m_cacheitem);
1634
1634
 
1635
1635
    drawheight = (drawheight + ystart > surface->height) ?
1636
1636
        surface->height - ystart - 1 : drawheight;
1637
 
 
 
1637
 
1638
1638
    if ((drawwidth <= 0) || (drawheight <= 0))
1639
1639
        return;
1640
1640
 
1642
1642
    bool needblend = m_onlyusefirst || surface->IntersectsDrawn(destRect);
1643
1643
 
1644
1644
    surface->AddRect(destRect);
1645
 
    
 
1645
 
1646
1646
    int alphamod = 255;
1647
1647
 
1648
1648
    if (maxfade > 0 && fade >= 0)
1663
1663
            for (int x = startcol; x < drawwidth; x++)
1664
1664
            {
1665
1665
                int alpha = *(m_alpha + x + ysrcwidth);
1666
 
  
 
1666
 
1667
1667
                if (alpha == 0)
1668
1668
                    *destalpha = 0;
1669
1669
                else
1715
1715
    if (m_onlyusefirst)
1716
1716
        (surface->blendcolumnfunc) (src, usrc, vsrc, srcalpha, iwidth, dest,
1717
1717
                                    udest, vdest, destalpha, surface->width,
1718
 
                                    drawwidth - startcol, 
 
1718
                                    drawwidth - startcol,
1719
1719
                                    drawheight - startline,
1720
1720
                                    alphamod, 1, surface->rec_lut,
1721
1721
                                    surface->pow_lut);
1722
1722
    else
1723
1723
        (surface->blendregionfunc) (src, usrc, vsrc, srcalpha, iwidth, dest,
1724
1724
                                    udest, vdest, destalpha, surface->width,
1725
 
                                    drawwidth - startcol, 
 
1725
                                    drawwidth - startcol,
1726
1726
                                    drawheight - startline,
1727
1727
                                    alphamod, 1, surface->rec_lut,
1728
1728
                                    surface->pow_lut);
1771
1771
 
1772
1772
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1773
1773
 
1774
 
OSDTypeFillSlider::OSDTypeFillSlider(const QString &name, 
 
1774
OSDTypeFillSlider::OSDTypeFillSlider(const QString &name,
1775
1775
                                     const QString &filename,
1776
 
                                     QRect displayrect, float wmult, 
 
1776
                                     QRect displayrect, float wmult,
1777
1777
                                     float hmult, int scalew, int scaleh)
1778
 
                 : OSDTypeImage(name, filename, displayrect.topLeft(), wmult, 
 
1778
                 : OSDTypeImage(name, filename, displayrect.topLeft(), wmult,
1779
1779
                                hmult, scalew, scaleh)
1780
1780
{
1781
1781
    m_maxval = 1000;
1807
1807
    m_drawwidth = (int)((m_displayrect.width() / 1000.0) * m_curval);
1808
1808
}
1809
1809
 
1810
 
void OSDTypeFillSlider::Draw(OSDSurface *surface, int fade, int maxfade, 
 
1810
void OSDTypeFillSlider::Draw(OSDSurface *surface, int fade, int maxfade,
1811
1811
                             int xoff, int yoff)
1812
1812
{
1813
1813
    if (!m_isvalid)
1836
1836
         m_drawMap[i] = 0;
1837
1837
 
1838
1838
    m_displaypos = displayrect.topLeft();
1839
 
    
 
1839
 
1840
1840
    m_yuv = m_alpha = NULL;
1841
1841
    m_isvalid = false;
1842
1842
 
1879
1879
    m_drawwidth = m_displayrect.width();
1880
1880
 
1881
1881
    delete [] m_drawMap;
1882
 
    
 
1882
 
1883
1883
    m_drawMap = new unsigned char[m_drawwidth + 1];
1884
1884
    for (int i = 0; i < m_drawwidth; i++)
1885
1885
         m_drawMap[i] = 0;
1917
1917
 
1918
1918
    if (start < 0)
1919
1919
        start = 0;
1920
 
    if (start >= m_drawwidth) 
 
1920
    if (start >= m_drawwidth)
1921
1921
        start = m_drawwidth - 1;
1922
1922
    if (end < 0)
1923
1923
        end = 0;
1937
1937
 
1938
1938
void OSDTypeEditSlider::Draw(OSDSurface *surface, int fade, int maxfade,
1939
1939
                             int xoff, int yoff)
1940
 
{           
 
1940
{
1941
1941
    if (!m_isvalid || !m_risvalid)
1942
1942
        return;
1943
 
            
 
1943
 
1944
1944
    unsigned char *dest, *destalpha, *src, *rsrc, *srcalpha, *rsrcalpha;
1945
1945
    unsigned char *udest, *vdest, *usrc, *rusrc, *vsrc, *rvsrc;
1946
 
            
 
1946
 
1947
1947
    int iwidth, riwidth, width;
1948
1948
    iwidth = m_imagesize.width();
1949
1949
    riwidth = m_rimagesize.width();
1952
1952
 
1953
1953
    int ystart = m_displaypos.y();
1954
1954
    int xstart = m_displaypos.x();
1955
 
            
 
1955
 
1956
1956
    xstart += xoff;
1957
1957
    ystart += yoff;
1958
1958
 
1984
1984
 
1985
1985
    QRect destRect = QRect(xstart, ystart, width, height);
1986
1986
    surface->AddRect(destRect);
1987
 
 
1988
 
    int ysrcwidth;              
 
1987
 
 
1988
    int ysrcwidth;
1989
1989
    int rysrcwidth;
1990
1990
    int ydestwidth;
1991
 
   
 
1991
 
1992
1992
    int uvsrcwidth;
1993
1993
    int ruvsrcwidth;
1994
1994
    int uvdestwidth;
1995
 
 
 
1995
 
1996
1996
    int alphamod = 255;
1997
 
    
 
1997
 
1998
1998
    if (maxfade > 0 && fade >= 0)
1999
1999
        alphamod = (int)((((float)(fade) / maxfade) * 256.0) + 0.5);
2000
2000
 
2001
 
    ysrcwidth = startline * iwidth; 
 
2001
    ysrcwidth = startline * iwidth;
2002
2002
    rysrcwidth = startline * riwidth;
2003
2003
    ydestwidth = ystart * surface->width;
2004
2004
 
2080
2080
    if ((height <= 0) || (width <= 0))
2081
2081
        return; // nothing to do...
2082
2082
 
2083
 
    QRect destRect(xstart, ystart, width, height); 
 
2083
    QRect destRect(xstart, ystart, width, height);
2084
2084
    surface->AddRect(destRect);
2085
2085
 
2086
2086
    int alphamod = 255;
2106
2106
        for (int y = ystart; y < yend; y++)
2107
2107
        {
2108
2108
            int ydestwidth = y * surface->width;
2109
 
            
 
2109
 
2110
2110
            memset(surface->y + xstart + ydestwidth, 0, width);
2111
2111
            memset(surface->alpha + xstart + ydestwidth, alpha, width);
2112
2112
        }
2153
2153
{
2154
2154
    if (m_curposition < m_numpositions - 1)
2155
2155
        m_curposition++;
2156
 
    else if (m_curposition == m_numpositions - 1) 
 
2156
    else if (m_curposition == m_numpositions - 1)
2157
2157
        m_curposition = m_offset;
2158
2158
}
2159
2159
 
2163
2163
OSDTypePositionRectangle::OSDTypePositionRectangle(const QString &name)
2164
2164
                        : OSDType(name), OSDTypePositionIndicator()
2165
2165
{
2166
 
}       
2167
 
   
 
2166
}
 
2167
 
2168
2168
OSDTypePositionRectangle::OSDTypePositionRectangle(
2169
 
    const OSDTypePositionRectangle &other) 
 
2169
    const OSDTypePositionRectangle &other)
2170
2170
    : OSDType(other.m_name), OSDTypePositionIndicator(other)
2171
2171
{
2172
2172
    for (int i = 0; i < m_numpositions; i++)
2309
2309
{
2310
2310
    m_wmult = wmult;
2311
2311
    m_hmult = hmult;
2312
 
    
 
2312
 
2313
2313
    OSDTypeImage::Reinit(wmult, hmult);
2314
2314
 
2315
2315
    for (int i = 0; i < m_numpositions; i++)
2398
2398
    displaywidth = dispw;
2399
2399
    displayheight = disph;
2400
2400
    m_wmult = wmult;
2401
 
    m_hmult = hmult;    
 
2401
    m_hmult = hmult;
2402
2402
}
2403
2403
 
2404
 
void OSDTypeCC::AddCCText(const QString &text, int x, int y, int color, 
 
2404
void OSDTypeCC::AddCCText(const QString &text, int x, int y, int color,
2405
2405
                          bool teletextmode)
2406
2406
{
2407
2407
    ccText *cc = new ccText();
2527
2527
    return visible;
2528
2528
}
2529
2529
 
2530
 
void OSDTypeCC::Draw(OSDSurface *surface, int fade, int maxfade, int xoff, 
 
2530
void OSDTypeCC::Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
2531
2531
                     int yoff)
2532
2532
{
2533
2533
    // not used
2535
2535
    maxfade = maxfade;
2536
2536
    xoff = xoff;
2537
2537
    yoff = yoff;
2538
 
 
 
2538
 
2539
2539
    static const QColor clr[8] =
2540
2540
    {
2541
2541
        Qt::white,   Qt::red,     Qt::green, Qt::yellow,
2577
2577
 
2578
2578
            if (m_ccbackground && !cc->teletextmode)
2579
2579
            {
2580
 
                QRect rect = QRect(0, 0, textlength + 4, 
 
2580
                QRect rect = QRect(0, 0, textlength + 4,
2581
2581
                                   (m_font->Size() * 3 / 2) + 3);
2582
2582
                m_box->SetRect(rect, m_wmult, m_hmult);
2583
2583
                m_box->Draw(surface, 0, 0, x - 2, y - 2);
2587
2587
            m_font->setColor(Qt::black, kTTF_Outline);
2588
2588
            m_font->setColor(clr[max(min(0, cc->color), 7)], kTTF_Normal);
2589
2589
 
2590
 
            m_font->DrawString(surface, x, y + 2, cc->text, maxx, maxy, 255); 
 
2590
            m_font->DrawString(surface, x, y + 2, cc->text, maxx, maxy, 255);
2591
2591
        }
2592
2592
    }
2593
2593
}
2603
2603
}
2604
2604
 
2605
2605
OSDType708CC::OSDType708CC(const QString &name, TTFFont *fonts[48],
2606
 
                           int xoff, int yoff, int dispw, int disph) : 
 
2606
                           int xoff, int yoff, int dispw, int disph) :
2607
2607
    OSDType(name)
2608
2608
{
2609
2609
    xoffset = xoff;
2667
2667
 
2668
2668
    // 16:9
2669
2669
    float xrange = 210.0f;
2670
 
    float yrange = 75.0f; 
 
2670
    float yrange = 75.0f;
2671
2671
    // 4:3
2672
2672
    //float xrange = 160.0f;
2673
2673
    //float yrange = 75.0f;