Ticket #101: xvmcosd-6.diff

File xvmcosd-6.diff, 57.1 KB (added by Ivor Hewitt <ivor@…>, 16 years ago)
  • libs/libmythtv/NuppelVideoPlayer.cpp

     
    18781878                      dispx, dispy, dispw, disph);
    18791879
    18801880        if (kCodec_NORMAL_END < decoder->GetVideoCodecID() &&
    1881             kCodec_SPECIAL_END > decoder->GetVideoCodecID() &&
     1881            kCodec_STD_XVMC_END > decoder->GetVideoCodecID() &&
    18821882            (600 < video_height))
    18831883        {           
    18841884            osd->DisableFade();
  • libs/libmythtv/osd.h

     
    121121                                  OSDGenericTree *treeToShow);
    122122
    123123    void DisableFade(void);
     124    bool HasPalette() { return hasPalette; }
     125    const QValueList<QColor>& Palette() { return surfPalette; }
    124126
    125127 private:
    126128    void SetDefaults();
     
    149151    void parsePositionImage(OSDSet *container, QDomElement &element);
    150152    void parseListTree(OSDSet *container, QDomElement &element);
    151153
     154    void parsePalette(QDomElement &element);
     155       
    152156    int vid_width;
    153157    int vid_height;
    154158    int frameint;
     
    178182    OSDTypeImage *editarrowright;
    179183    QRect editarrowRect;
    180184
     185    QString surftype;
     186    QValueList<QColor> surfPalette;
     187    bool hasPalette;
     188   
    181189    OSDSurface *drawSurface;
    182190    bool changed;
    183191
  • libs/libmythtv/osdtypes.cpp

     
    1414
    1515#include "mythcontext.h"
    1616
     17#include <sys/time.h>
     18
     19#ifdef TIMING
     20#include "timer.h"
     21
     22int Timer::indent = 0;
     23Timer::Timer(const QString &title)
     24{
     25    name = title;
     26    gettimeofday(&start,NULL);
     27
     28    int i;
     29    for (i=0;i<indent;i++)
     30        cout << "  ";
     31    indent ++;
     32    cout << name << " timing.." << endl;
     33}
     34
     35Timer::~Timer()
     36{
     37    struct timeval dur;
     38    gettimeofday(&end,NULL);
     39
     40    timersub(&end, &start, &dur);
     41
     42    indent--;
     43    int i;
     44    for (i=0;i<indent;i++)
     45        cout << "  ";
     46 
     47    cout << name << " time " << dur.tv_usec << endl;
     48}
     49
     50void Timer::check(const QString &tag)
     51{
     52    struct timeval dur,now;
     53    gettimeofday(&now,NULL);
     54
     55    timersub(&now, &start, &dur);
     56
     57    int i;
     58    for (i=0;i<indent;i++)
     59        cout << "  ";
     60    cout << tag << " time " << dur.tv_usec << endl;
     61}
     62#endif
     63
    1764OSDSet::OSDSet(const QString &name, bool cache, int screenwidth,
    1865               int screenheight, float wmult, float hmult, int frint)
    1966      : QObject()
     
    361408
    362409void OSDSet::Draw(OSDSurface *surface, bool actuallydraw)
    363410{
     411#ifdef TIMING
     412Timer t("OSDSet::Draw");
     413#endif
     414
    364415    if (actuallydraw)
    365416    {
    366417        vector<OSDType *>::iterator i = allTypes->begin();
     
    437488
    438489OSDTypeText::OSDTypeText(const QString &name, TTFFont *font,
    439490                         const QString &text, QRect displayrect)
    440            : OSDType(name)
     491           : OSDType(name),m_raster(0)
    441492{
    442493    m_message = text;
    443494    m_default_msg = text;
     
    457508    m_scrollinit = false;
    458509
    459510    m_linespacing = 1.5;
     511
     512m_message.replace(QRegExp("%BR%"), "\n");
     513m_message.replace(QRegExp("\n")," \n ");
     514
    460515}
    461516
    462517OSDTypeText::OSDTypeText(const OSDTypeText &other)
    463            : OSDType(other.m_name)
     518           : OSDType(other.m_name),m_raster(0)
    464519{
    465520    m_displaysize = other.m_displaysize;
    466521    m_screensize = other.m_screensize;
     
    480535
    481536OSDTypeText::~OSDTypeText()
    482537{
     538    if (m_raster)
     539    {
     540       TTFFont::destroy_font_raster(m_raster);
     541       m_raster=0;
     542    }     
    483543}
    484544
    485545void OSDTypeText::SetAltFont(TTFFont *font)
     
    489549
    490550void OSDTypeText::SetText(const QString &text)
    491551{
     552    if (m_raster)
     553    {
     554       TTFFont::destroy_font_raster(m_raster);
     555       m_raster=0;
     556    }
     557
    492558    m_message = text;
    493559    m_scrollinit = false;
     560
     561m_message.replace(QRegExp("%BR%"), "\n");
     562m_message.replace(QRegExp("\n")," \n ");
    494563}
    495564
    496565void OSDTypeText::SetDefaultText(const QString &text)
    497566{
     567    if (m_raster)
     568    {
     569       TTFFont::destroy_font_raster(m_raster);
     570       m_raster=0;
     571    }
     572
    498573    m_message = text;
    499574    m_default_msg = text;
    500575    m_scrollinit = false;
     576
     577m_message.replace(QRegExp("%BR%"), "\n");
     578m_message.replace(QRegExp("\n")," \n ");
    501579}
    502580
    503581void OSDTypeText::Reinit(float wchange, float hchange)
    504582{
     583    if (m_raster)
     584    {
     585       TTFFont::destroy_font_raster(m_raster);
     586       m_raster=0;
     587    }
     588
    505589    int width = (int)(m_screensize.width() * wchange);
    506590    int height = (int)(m_screensize.height() * hchange);
    507591    int x = (int)(m_screensize.x() * wchange);
     
    513597void OSDTypeText::Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
    514598                       int yoff)
    515599{
     600#ifdef TIMING
     601Timer t("OSDTypeText::Draw");
     602#endif
    516603    int textlength = 0;
    517604
    518605    if (m_message == QString::null)
     
    524611    if (m_scroller)
    525612        m_parent->SetDrawEveryFrame(true);
    526613
    527     m_font->CalcWidth(m_message, &textlength);
     614//    m_font->CalcWidth(m_message, &textlength);
    528615
    529616    int maxlength = m_displaysize.width();
    530617
    531618    if (m_multiline)
    532619    {
    533         QString tmp_msg = m_message;
    534         tmp_msg.replace(QRegExp("%BR%"), "\n");
    535         tmp_msg.replace(QRegExp("\n")," \n ");
     620//        QString tmp_msg = m_message;
     621//        tmp_msg.replace(QRegExp("%BR%"), "\n");
     622//        tmp_msg.replace(QRegExp("\n")," \n ");
    536623
    537         QStringList wordlist = QStringList::split(" ", tmp_msg);
     624        QStringList wordlist = QStringList::split(" ", m_message);
    538625        int length = 0;
    539626        int lines = 0;
    540627
     
    652739                             const QString &text, int fade, int maxfade,
    653740                             int xoff, int yoff)
    654741{
     742#ifdef TIMING
     743Timer t("OSDTypeText::DrawString");
     744#endif
     745 
    655746    if (m_centered || m_right)
    656747    {
    657748        int textlength = 0;
     
    707798    m_isvalid = false;
    708799    m_imagesize = QRect(0, 0, 0, 0);
    709800
     801    m_i44 = NULL;
     802
    710803    m_scalew = scalew;
    711804    m_scaleh = scaleh;
    712805
     
    728821    m_scaleh = other.m_scaleh;
    729822
    730823    m_alpha = m_yuv = NULL;
     824    m_i44 = NULL;
     825
    731826    if (m_isvalid)
    732827    {
    733828        int size = m_imagesize.width() * m_imagesize.height() * 3 / 2;
     
    743838        m_ubuffer = m_yuv + (m_imagesize.width() * m_imagesize.height());
    744839        m_vbuffer = m_yuv + (m_imagesize.width() * m_imagesize.height() *
    745840                             5 / 4);
    746     }
     841
     842//I44
     843        m_i44 = new unsigned char[size];
     844        memcpy(m_i44, other.m_i44, size);
     845    }
    747846}
    748847
    749848OSDTypeImage::OSDTypeImage(const QString &name)
     
    761860    m_vbuffer = NULL;
    762861    m_isvalid = false;
    763862    m_filename = "";
     863
     864    m_i44 = NULL;
    764865}
    765866
    766867OSDTypeImage::OSDTypeImage(void)
     
    779880    m_vbuffer = NULL;
    780881    m_isvalid = false;
    781882    m_filename = "";
     883
     884    m_i44 = NULL;
    782885}
    783886
    784887OSDTypeImage::~OSDTypeImage()
     
    787890        delete [] m_yuv;
    788891    if (m_alpha)
    789892        delete [] m_alpha;
     893
     894    if (m_i44)
     895        delete [] m_i44;
    790896}
    791897
    792898void OSDTypeImage::SetName(const QString &name)
     
    805911    LoadImage(m_filename, wmult, hmult, m_scalew, m_scaleh);
    806912}
    807913
     914void rgb32_to_i44(unsigned char*i44, unsigned char*rgb, int width, int height, int srcwidth)
     915{
     916    int wrap, wrap4, x, y;
     917    unsigned char *p;
     918    unsigned char ch,r,g,b;
     919   
     920printf("rgb32_to_i44\n");
     921 
     922    p = rgb;
     923
     924    for (y=0; y<height; y++)
     925    {
     926        unsigned char *pstart=p;
     927       
     928        for (x=0; x<width; x++)
     929        {
     930
     931// 0 0 0 0 . . . .  // alpha
     932// . . . . 0 x x x  // greys
     933// . . . . 1 0 0 0  //
     934// . . . . 1 0 0 1  // red
     935// . . . . 1 0 1 0  // green
     936// . . . . 1 0 1 1  // yellow
     937// . . . . 1 1 0 0  // blue
     938// . . . . 1 1 0 1  // magen
     939// . . . . 1 1 1 0  // cyan
     940// . . . . 1 1 1 1  //
     941
     942            ch = (p[3] >> 4) & 0x0f; //trunc alpha
     943            r=p[2]; g=p[1]; b=p[0];
     944
     945            if ((r == g) && (g == b)) //lets have 8 greys
     946            {
     947                ch |= ((r>>1) & 0x70);
     948//                ch |= 0x0b;
     949            }
     950            else // ok now try and grab colours
     951            { // trivial func for now.
     952                ch |= 0x80;
     953              if (r>128) ch |= 0x10;
     954              if (g>128) ch |= 0x20;
     955              if (b>128) ch |= 0x40;
     956            }
     957
     958            *(i44+x+y*width) = ch;
     959
     960            p+=4;
     961        }
     962
     963        p=pstart+srcwidth*4;
     964
     965    }
     966}
     967
    808968void OSDTypeImage::LoadImage(const QString &filename, float wmult, float hmult,
    809969                             int scalew, int scaleh)
    810970{
     
    815975        if (m_alpha)
    816976            delete [] m_alpha;
    817977
     978        if (m_i44)
     979            delete [] m_i44;
     980
    818981        m_isvalid = false;
    819982        m_yuv = NULL;
    820983        m_alpha = NULL;
     984
     985        m_i44 = NULL;
    821986    }
    822987
    823988    if (filename.length() < 2)
     
    8561021
    8571022    m_alpha = new unsigned char[imwidth * imheight];
    8581023
     1024    m_i44 = new unsigned char[imwidth*imheight];
     1025
     1026printf("yuv convert\n");
     1027
    8591028    rgb32_to_yuv420p(m_ybuffer, m_ubuffer, m_vbuffer, m_alpha, tmp2.bits(),
    8601029                     imwidth, imheight, tmp2.width());
    8611030
     1031    rgb32_to_i44(m_i44, tmp2.bits(), imwidth, imheight, tmp2.width());
     1032
    8621033    m_imagesize = QRect(0, 0, imwidth, imheight);
    8631034}
    8641035
     
    8711042        if (m_alpha)
    8721043            delete [] m_alpha;
    8731044
     1045        if (m_i44)
     1046            delete[] m_i44;
     1047
    8741048        m_isvalid = false;
    8751049        m_yuv = NULL;
    8761050        m_alpha = NULL;
     1051        m_i44 = NULL;
    8771052    }
    8781053
    8791054    m_isvalid = true;
     
    8881063
    8891064    m_alpha = new unsigned char[imwidth * imheight];
    8901065
     1066    m_i44 = new unsigned char[imwidth*imheight];
     1067
    8911068    rgb32_to_yuv420p(m_ybuffer, m_ubuffer, m_vbuffer, m_alpha, img.bits(),
    8921069                     imwidth, imheight, img.width());
    8931070
     1071    rgb32_to_i44(m_i44, img.bits(), imwidth, imheight, img.width());
    8941072    m_imagesize = QRect(0, 0, imwidth, imheight);
    8951073}
    8961074
    897 void OSDTypeImage::Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
     1075void OSDTypeImage::Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff)
     1076{
     1077#ifdef TIMING
     1078Timer t("OSDTypeImage::Draw");
     1079#endif
     1080
     1081    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1082        Draw((YUVSurface*)surface,fade,maxfade,xoff,yoff);
     1083    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1084        Draw((I44Surface*)surface,fade,maxfade,xoff,yoff);
     1085}
     1086
     1087void OSDTypeImage::Draw(I44Surface *surface, int fade, int maxfade, int xoff,
    8981088                        int yoff)
    8991089{
    9001090    if (!m_isvalid)
     
    9021092
    9031093    unsigned char *dest, *destalpha, *src, *srcalpha;
    9041094    unsigned char *udest, *vdest, *usrc, *vsrc;
     1095    int alpha, iwidth, width;
     1096
     1097    iwidth = width = m_imagesize.width();
     1098    int height = m_imagesize.height();
     1099
     1100    if (m_drawwidth >= 0)
     1101        width = m_drawwidth;
     1102
     1103    int ystart = m_displaypos.y();
     1104    int xstart = m_displaypos.x();
     1105
     1106    xstart += xoff;
     1107    ystart += yoff;
     1108
     1109    ystart = (ystart / 2) * 2;
     1110    xstart = ((xstart + 1) / 2) * 2;
     1111
     1112    int startline = 0;
     1113    int startcol = 0;
     1114
     1115    if (ystart < 0)
     1116    {
     1117        startline = 0 - ystart;
     1118        ystart = 0;
     1119    }
     1120
     1121    if (xstart < 0)
     1122    {
     1123        startcol = 0 - xstart;
     1124        xstart = 0;
     1125    }
     1126
     1127    if (height + ystart > surface->height)
     1128        height = surface->height - ystart - 1;
     1129    if (width + xstart > surface->width)
     1130        width = surface->width - xstart - 1;
     1131
     1132    if (width == 0 || height == 0)
     1133{
     1134printf("zeros\n");
     1135        return;
     1136}
     1137
     1138
     1139    QRect destRect = QRect(xstart, ystart, width, height);
     1140    bool needblend = false;
     1141
     1142    if (m_onlyusefirst || surface->IntersectsDrawn(destRect))
     1143        needblend = true;
     1144    surface->AddRect(destRect);
     1145
     1146    int ysrcwidth;
     1147    int ydestwidth;
     1148
     1149    int uvsrcwidth;
     1150    int uvdestwidth;
     1151
     1152    int alphamod = 0xf;
     1153
     1154
     1155    if (maxfade > 0 && fade >= 0)
     1156        alphamod = (int)((((float)(fade) / maxfade) * 16.0) + 0.5);
     1157
     1158unsigned char almap[256];
     1159    {
     1160for (int i=0; i<256; i++)
     1161{
     1162almap[i] = ( i & 0xf0)|((((i & 0xf) * alphamod)>>4)&0xf);
     1163}
     1164}
     1165        unsigned char *dst;
     1166
     1167        src = m_i44;
     1168        dst = surface->i44buffer + xstart + (ystart)*surface->width;
     1169
     1170        unsigned long *ldst = (unsigned long*)dst;
     1171
     1172{
     1173        for (int y = startline; y < height; y++)
     1174        {
     1175            unsigned long *lsrc = (unsigned long*)(src+(y*iwidth));
     1176            for (int x = startcol/4; x < width/4; x++)
     1177            {
     1178                unsigned long sch = lsrc[x];
     1179                unsigned long dsh =
     1180                            almap[sch>>24]<<24 |
     1181                            almap[sch>>16 & 0xff] << 16 |
     1182                            almap[sch>>8 & 0xff] << 8 |
     1183                            almap[sch&0xff];
     1184
     1185                ldst[x] = (ldst[x] & 0x0f0f0f0f) | dsh;
     1186
     1187/* unsigned char ch = (alphamod & 0xf0) | (*(m_ubuffer+(x/2)+ysrcwidth) & 0x0f) ;
     1188                *(surface->i44buffer + x +xstart+ ydestwidth) = ch;
     1189*/
     1190            }
     1191            ldst+=surface->width/4;
     1192        }
     1193}
     1194        return;
     1195
     1196}
     1197void OSDTypeImage::Draw(YUVSurface *surface, int fade, int maxfade, int xoff,
     1198                        int yoff)
     1199{
     1200    if (!m_isvalid)
     1201        return;
     1202
     1203    unsigned char *dest, *destalpha, *src, *srcalpha;
     1204    unsigned char *udest, *vdest, *usrc, *vsrc;
    9051205    int alpha, iwidth, drawwidth;
    9061206
    9071207    iwidth = drawwidth = m_imagesize.width();
     
    12821582
    12831583void OSDTypeEditSlider::Draw(OSDSurface *surface, int fade, int maxfade,
    12841584                             int xoff, int yoff)
     1585{
     1586    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1587        Draw((YUVSurface*)surface,fade,maxfade,xoff,yoff);
     1588//    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1589//        Draw((I44Surface*)surface,fade,maxfade,xoff,yoff);
     1590}
     1591void OSDTypeEditSlider::Draw(YUVSurface *surface, int fade, int maxfade,
     1592                             int xoff, int yoff)
    12851593{           
    12861594    if (!m_isvalid || !m_risvalid)
    12871595        return;
     
    14051713void OSDTypeBox::Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
    14061714                      int yoff)
    14071715{
     1716#ifdef TIMING
     1717Timer t("OSDTypeBox::Draw");
     1718#endif
     1719
     1720    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1721        Draw((YUVSurface*)surface,fade,maxfade,xoff,yoff);
     1722    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1723        Draw((I44Surface*)surface,fade,maxfade,xoff,yoff);
     1724}
     1725
     1726void OSDTypeBox::Draw(I44Surface *surface, int fade, int maxfade, int xoff,
     1727                      int yoff)
     1728{
    14081729    unsigned char *dest, *destalpha;
    14091730    unsigned char alpha = 192;
     1731    unsigned char targ;
    14101732
    14111733    QRect disprect = size;
    14121734    disprect.moveBy(xoff, yoff);
     
    14271749
    14281750    int height = yend - ystart + 1, width = xend - xstart + 1;
    14291751
     1752    QRect destRect = QRect(xstart, ystart, width, height);
     1753    bool needblend = false;
     1754
     1755    if (surface->IntersectsDrawn(destRect))
     1756        needblend = true;
     1757    surface->AddRect(destRect);
     1758
     1759    int alphamod = 255;
     1760    if (maxfade > 0 && fade >= 0)
     1761        alphamod = (int)((((float)(fade) / maxfade) * 16.0) + 0.5);
     1762
     1763    int ydestwidth;
     1764
     1765    alpha = ((alpha * alphamod) + 0x8);
     1766
     1767    targ = 0 | (alpha & 0xf); //black
     1768//targ=0xf3;
     1769
     1770    for (int y = ystart; y < yend; y++)
     1771    {
     1772        ydestwidth = y * surface->width;
     1773        memset(surface->i44buffer + xstart + ydestwidth, targ , width);
     1774    }
     1775}
     1776
     1777void OSDTypeBox::Draw(YUVSurface *surface, int fade, int maxfade, int xoff,
     1778                      int yoff)
     1779{
     1780    unsigned char *dest, *destalpha;
     1781    unsigned char alpha = 192;
     1782
     1783    QRect disprect = size;
     1784    disprect.moveBy(xoff, yoff);
     1785
     1786    int ystart = disprect.top();
     1787    int yend = disprect.bottom();
     1788    int xstart = disprect.left();
     1789    int xend = disprect.right();
     1790
     1791    if (xstart < 0)
     1792        xstart = 0;
     1793    if (xend > surface->width)
     1794        xend = surface->width;
     1795    if (ystart < 0)
     1796        ystart = 0;
     1797    if (yend > surface->height)
     1798        yend = surface->height;
     1799
     1800    int height = yend - ystart + 1, width = xend - xstart + 1;
     1801
    14301802    QRect destRect = QRect(xstart, ystart, width, height);
    14311803    bool needblend = false;
    14321804
     
    15491921    positions.push_back(rect);
    15501922    m_numpositions++;
    15511923}
    1552 
    15531924void OSDTypePositionRectangle::Draw(OSDSurface *surface, int fade, int maxfade,
    15541925                                    int xoff, int yoff)
    15551926{
     1927#ifdef TIMING
     1928Timer t("OSDTypePositionRectangle::Draw");
     1929#endif
     1930
     1931    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1932        Draw((YUVSurface*)surface,fade,maxfade,xoff,yoff);
     1933    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1934        Draw((I44Surface*)surface,fade,maxfade,xoff,yoff);
     1935}
     1936
     1937void OSDTypePositionRectangle::Draw(YUVSurface *surface, int fade, int maxfade,
     1938                                    int xoff, int yoff)
     1939{
    15561940    fade = fade;
    15571941    maxfade = maxfade;
    15581942    xoff = xoff;
     
    16222006    }
    16232007}
    16242008
     2009
     2010void OSDTypePositionRectangle::Draw(I44Surface *surface, int fade, int maxfade,
     2011                                    int xoff, int yoff)
     2012{
     2013    fade = fade;
     2014    maxfade = maxfade;
     2015    xoff = xoff;
     2016    yoff = yoff;
     2017
     2018    if (m_curposition < 0 || m_curposition >= m_numpositions)
     2019        return;
     2020
     2021    QRect rect = positions[m_curposition];
     2022
     2023    unsigned char *src;
     2024    int ystart = rect.top();
     2025    int yend = rect.bottom();
     2026    int xstart = rect.left();
     2027    int xend = rect.right();
     2028
     2029    int height = yend - ystart + 1, width = xend - xstart + 1;
     2030
     2031    QRect destRect = QRect(xstart, ystart, width, height);
     2032    surface->AddRect(destRect);
     2033
     2034   
     2035    for (int y = ystart; y < yend; y++)
     2036    {
     2037        if (y < 0 || y >= surface->height)
     2038            continue;
     2039
     2040        for (int x = xstart; x < xstart + 2; x++)
     2041        {
     2042            if (x < 0 || x >= surface->width)
     2043                continue;
     2044
     2045            src = surface->i44buffer + x + y * surface->width;
     2046            *src = 0xaa; //white
     2047        }
     2048
     2049        for (int x = xend - 2; x < xend; x++)
     2050        {
     2051            if (x < 0 || x >= surface->width)
     2052                continue;
     2053
     2054            src = surface->i44buffer + x + y * surface->width;
     2055            *src = 0xaa; //white
     2056        }
     2057    }
     2058
     2059    for (int x = xstart; x < xend; x++)
     2060    {
     2061        if (x < 0 || x >= surface->width)
     2062            continue;
     2063
     2064        for (int y = ystart; y < ystart + 2; y++)
     2065        {
     2066            if (y < 0 || y >= surface->height)
     2067                continue;
     2068
     2069            src = surface->i44buffer + x + y * surface->width;
     2070            *src = 0xaa;
     2071        }
     2072        for (int y = yend - 2; y < yend; y++)
     2073        {
     2074            if (y < 0 || y >= surface->height)
     2075                continue;
     2076
     2077            src = surface->i44buffer + x + y * surface->width;
     2078            *src = 0xaa;
     2079        }
     2080    }
     2081}
     2082
    16252083//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    16262084
    16272085OSDTypePositionImage::OSDTypePositionImage(const QString &name)
  • libs/libmythtv/videooutbase.cpp

     
    11051105    if (!osd)
    11061106        return -1;
    11071107
    1108     OSDSurface *surface = osd->Display();
    1109     if (!surface)
     1108    OSDSurface *osdsurf = osd->Display();
     1109    if (!osdsurf)
    11101110        return -1;
    11111111
    11121112    bool changed = (-1 == revision) ?
    1113         surface->Changed() : (surface->GetRevision()!=revision);
     1113        osdsurf->Changed() : (osdsurf->GetRevision()!=revision);
    11141114
     1115    if (osdsurf->SurfaceType() == OSDSurface::SURF_YUV)
     1116    {
     1117        YUVSurface *surface = (YUVSurface*)osdsurf;
     1118
    11151119    switch (frame->codec)
    11161120    {
    11171121        case FMT_YV12:
     
    11461150        default:
    11471151            break;
    11481152    }
     1153    }
     1154    else if (osdsurf->SurfaceType() == OSDSurface::SURF_I44)
     1155    {
     1156        I44Surface* surface=(I44Surface*)osdsurf;
     1157
     1158        if (changed)
     1159            surface->BlendToI44( frame->buf, false, stride, XJ_height);
     1160    }
     1161
    11491162    return (changed) ? 1 : 0;
    11501163}
    11511164
  • libs/libmythtv/osdtypes.h

     
    1414class TTFFont;
    1515class OSDType;
    1616class OSDSurface;
     17class YUVSurface;
     18class I44Surface;
    1719class TV;
    1820
     21struct Raster_Map;
     22
    1923class OSDSet : public QObject
    2024{
    2125    Q_OBJECT
     
    212216    bool m_scrollinit;
    213217
    214218    float m_linespacing;
     219
     220    Raster_Map *m_raster;
    215221};
    216222   
    217223class OSDTypeImage : public OSDType
     
    245251
    246252    virtual void Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
    247253                      int yoff);
     254    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff,
     255                      int yoff);
     256    void Draw(I44Surface *surface, int fade, int maxfade, int xoff,
     257              int yoff);
    248258
    249259  protected:
    250260    QRect m_imagesize;
     
    261271
    262272    unsigned char *m_alpha;
    263273
     274    unsigned char *m_i44;
     275
    264276    int m_scalew, m_scaleh;
     277    float m_wmult, m_hmult;
    265278
    266279    int m_drawwidth;
    267280    bool m_onlyusefirst;
     
    331344    void SetRange(int start, int end);
    332345
    333346    void Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff);
     347    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff, int yoff);
     348    void Draw(I44Surface *surface, int fade, int maxfade, int xoff, int yoff);
    334349
    335350  private:
    336351    QRect m_displayrect;
     
    363378    void SetRect(QRect newrect) { size = newrect; }
    364379
    365380    void Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff);
     381    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff, int yoff);
     382    void Draw(I44Surface *surface, int fade, int maxfade, int xoff, int yoff);
    366383
    367384  private:
    368385    QRect size;
     
    403420    void Reinit(float wchange, float hchange);
    404421
    405422    void Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff);
     423    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff, int yoff);
     424    void Draw(I44Surface *surface, int fade, int maxfade, int xoff, int yoff);
    406425
    407426  private:
    408427    vector<QRect> positions;
  • libs/libmythtv/videoout_xv.cpp

     
    24152415    XvMCOSD* xvmc_osd = GetAvailableOSD();
    24162416    if (osd && xvmc_osd->IsValid())
    24172417    {
     2418        if (osd->HasPalette() &&
     2419            !xvmc_osd->CustomPalette())
     2420        {
     2421            VERBOSE(VB_IMPORTANT, "Setting palette");
     2422            xvmc_osd->SetPalette(osd->Palette());
     2423        }
     2424
    24182425        VideoFrame *osdframe = NULL;
    24192426        int ret = DisplayOSD(xvmc_osd->OSDFrame(), osd, -1,
    24202427                             xvmc_osd->GetRevision());
  • libs/libmythtv/osdxvmc.h

     
    2828    void DeleteBuffer();
    2929    void CompositeOSD(VideoFrame* frame, VideoFrame* osdframe=NULL);
    3030
     31    void SetPalette( const QValueList<QColor> &palette );
     32    bool CustomPalette() { return custompalette; }
     33
    3134    VideoFrame *OSDFrame()
    3235    {
    3336        tmpframe.codec =
     
    5558    int                  osd_subpict_clear_color;
    5659    bool                 osd_subpict_alloc;
    5760
     61    bool                 custompalette;
    5862    VideoFrame           tmpframe;
    5963    int                  revision;
    6064};
  • libs/libmythtv/osdxvmc.cpp

     
    2525    : XJ_disp(disp), XJ_width(0), XJ_height(0),
    2626      xv_port(port), osd_palette(NULL), osd_xv_image(NULL),
    2727      osd_subpict_mode(NO_SUBPICTURE), osd_subpict_clear_color(0),
    28       osd_subpict_alloc(false)
     28      osd_subpict_alloc(false),
     29      custompalette(false)
    2930{
    3031    // subpicture init
    3132    int num = 0;
     
    5051
    5152void XvMCOSD::CreateBuffer(XvMCContext &xvmc_ctx, int width, int height)
    5253{
     54    VERBOSE(VB_IMPORTANT, "XvMCOSD::CreateBuffer");
     55
    5356    if (NO_SUBPICTURE == osd_subpict_mode)
    5457    {
    5558        VERBOSE(VB_IMPORTANT, "XvMCOSD::CreateBuffer() failed because "
     
    131134    osd_subpict_alloc = true;
    132135}
    133136
     137void XvMCOSD::SetPalette( const QValueList<QColor> &palette )
     138{
     139    int i;
     140    custompalette=true;
     141    int entries = palette.count();
     142
     143    VERBOSE(VB_PLAYBACK, QString("SetPalette entries %1").arg(entries));
     144
     145    if (entries > osd_subpict.num_palette_entries)
     146        entries = osd_subpict.num_palette_entries;
     147    int seb = osd_subpict.entry_bytes;
     148
     149    for (i=0; i<entries; i++)
     150    {
     151        int r=palette[i].red();
     152        int g=palette[i].green();
     153        int b=palette[i].blue();
     154       
     155        int Y = (int)((0.257*r)+(0.504*g)+(0.098*b)+16);
     156        int U = (int)(-(0.148*r)-(0.291*g)+(0.439*b)+128);
     157        int V = (int)((0.439*r)-(0.368*g)-(0.071*b)+128);
     158                       
     159        VERBOSE(VB_PLAYBACK,
     160                QString("Colour: Y=%1 U=%1 V=%1" ).arg(Y).arg(U).arg(V));
     161
     162        for (int j = 0; j < seb; j++)
     163        {
     164            switch (osd_subpict.component_order[j])
     165            {
     166                case 'U': osd_palette[i * seb + j] = U; break;
     167                case 'V': osd_palette[i * seb + j] = V; break;
     168                case 'Y':
     169                    default:  osd_palette[i * seb + j] = Y; break;
     170            }
     171        }
     172    }
     173   
     174    X11S(XvMCSetSubpicturePalette(XJ_disp, &osd_subpict, osd_palette));
     175}
     176
    134177void XvMCOSD::DeleteBuffer()
    135178{
    136179    if (!osd_subpict_alloc)
  • libs/libmythtv/osdsurface.cpp

     
    150150
    151151OSDSurface::OSDSurface(int w, int h)
    152152{
     153    width = w;
     154    height = h;
     155
     156    size = width * height;
     157
     158    Clear();
     159}
     160
     161OSDSurface::~OSDSurface()
     162{
     163}
     164
     165void OSDSurface::Clear(void)
     166{
     167    usedRegions = QRegion();
     168}
     169
     170void OSDSurface::ClearUsed(void)
     171{
     172}
     173
     174bool OSDSurface::IntersectsDrawn(QRect &newrect)
     175{
     176    QMemArray<QRect> rects = usedRegions.rects();
     177    QMemArray<QRect>::Iterator it = rects.begin();
     178    for (; it != rects.end(); ++it)
     179        if (newrect.intersects(*it))
     180            return true;
     181    return false;
     182}
     183
     184void OSDSurface::AddRect(QRect &newrect)
     185{
     186    usedRegions = usedRegions.unite(newrect);
     187}
     188
     189YUVSurface::YUVSurface(int w, int h) : OSDSurface(w,h)
     190{
    153191    yuvbuffer = new unsigned char[w * h * 3 / 2];
    154192    y = yuvbuffer;
    155193    u = yuvbuffer + w * h;
    156194    v = u + w * h / 4;
    157195    alpha = new unsigned char[w * h];
    158196
    159     width = w;
    160     height = h;
    161 
    162     size = width * height;
    163 
    164197    for (int i = 0; i < 256; i++)
    165198    {
    166199        for (int j = 0; j < 256; j++)
     
    209242    revision = 0;
    210243}
    211244
    212 OSDSurface::~OSDSurface()
     245YUVSurface::~YUVSurface()
    213246{
    214247    delete [] yuvbuffer;
    215248    delete [] alpha;
    216249}
    217250
    218 void OSDSurface::Clear(void)
     251void YUVSurface::Clear(void)
    219252{
    220253    memset(y, 0, size);
    221254    memset(u, 127, size / 4);
    222255    memset(v, 127, size / 4);
    223256    memset(alpha, 0, size);
    224     usedRegions = QRegion();
     257   
     258    OSDSurface::Clear();
    225259}
    226260
    227 void OSDSurface::ClearUsed(void)
     261void YUVSurface::ClearUsed(void)
    228262{
    229263    QMemArray<QRect> rects = usedRegions.rects();
    230264    QMemArray<QRect>::Iterator it = rects.begin();
     
    259293    }
    260294
    261295    usedRegions = QRegion();
     296   
     297    OSDSurface::Clear();
    262298}
    263299
    264 bool OSDSurface::IntersectsDrawn(QRect &newrect)
    265 {
    266     QMemArray<QRect> rects = usedRegions.rects();
    267     QMemArray<QRect>::Iterator it = rects.begin();
    268     for (; it != rects.end(); ++it)
    269         if (newrect.intersects(*it))
    270             return true;
    271     return false;
    272 }
    273300
    274 void OSDSurface::AddRect(QRect &newrect)
    275 {
    276     usedRegions = usedRegions.unite(newrect);
    277 }
    278 
    279301///////////////////////////////////////////////////////////////////////////
    280302// Helper functions
    281303///////////////////////////////////////////////////////////////////////////
     
    383405}
    384406#endif
    385407
    386 blendtoyv12_8_fun blendtoyv12_8_init(const OSDSurface *surface)
     408blendtoyv12_8_fun blendtoyv12_8_init(const YUVSurface *surface)
    387409{
    388410    (void)surface;
    389411#ifdef MMX
     
    393415    return blendalpha8_c;
    394416}
    395417
    396 static inline void blendtoargb_8_c(const OSDSurface *surf, unsigned char *src,
     418static inline void blendtoargb_8_c(const YUVSurface *surf, unsigned char *src,
    397419                                   unsigned char *usrc, unsigned char *vsrc,
    398420                                   unsigned char *alpha, unsigned char *dest)
    399421{
     
    415437
    416438#ifdef MMX
    417439#define movntq(src, dest) movq_r2m(src, dest);
    418 static inline void blendtoargb_8_mmx(const OSDSurface * /*surf*/, unsigned char *src,
     440static inline void blendtoargb_8_mmx(YUVSurface * /*surf*/, unsigned char *src,
    419441                                     unsigned char *usrc, unsigned char *vsrc,
    420442                                     unsigned char *alpha, unsigned char *dest)
    421443{
     
    510532}
    511533#endif
    512534
    513 blendtoargb_8_fun blendtoargb_8_init(const OSDSurface *surface)
     535blendtoargb_8_fun blendtoargb_8_init(const YUVSurface *surface)
    514536{
    515537    (void)surface;
    516538#ifdef MMX
     
    626648}
    627649#endif
    628650
    629 dithertoia44_8_fun dithertoia44_8_init(const OSDSurface* /*surface*/)
     651dithertoia44_8_fun dithertoia44_8_init(const YUVSurface* /*surface*/)
    630652{
    631653#ifdef MMX
    632654// mmx version seems to be about the same speed, no reason to use it.
     
    675697    delete context;
    676698}
    677699
    678 /** \fn OSDSurface::BlendToYV12(unsigned char *) const
    679  *  \brief Alpha blends OSDSurface to yuv buffer of the same size.
     700/** \fn YUVSurface::BlendToYV12(unsigned char *) const
     701 *  \brief Alpha blends YUVSurface to yuv buffer of the same size.
    680702 *  \param yuvptr Pointer to YUV buffer to blend OSD to.
    681703 */
    682 void OSDSurface::BlendToYV12(unsigned char *yuvptr) const
     704void YUVSurface::BlendToYV12(unsigned char *yuvptr) const
    683705{
    684     const OSDSurface *surface = this;
     706    const YUVSurface *surface = this;
    685707    blendtoyv12_8_fun blender = blendtoyv12_8_init(surface);
    686708
    687709    unsigned char *uptrdest = yuvptr + surface->width * surface->height;
     
    790812    }
    791813}
    792814
    793 /** \fn OSDSurface::BlendToARGB(unsigned char *,uint,uint,bool) const
    794  *  \brief Alpha blends OSDSurface to ARGB buffer.
     815/** \fn YUVSurface::BlendToARGB(unsigned char *,uint,uint,bool) const
     816 *  \brief Alpha blends YUVSurface to ARGB buffer.
    795817 *
    796818 *  \todo Currently blend_to_black is implemented as a post process
    797819 *        on the whole frame, it would make sense to make this more
     
    801823 *  \param height         Number of lines in output buffer
    802824 *  \param blend_to_black Uses Alpha to blend buffer to black
    803825 */
    804 void OSDSurface::BlendToARGB(unsigned char *argbptr, uint stride, uint height,
     826void YUVSurface::BlendToARGB(unsigned char *argbptr, uint stride, uint height,
    805827                             bool blend_to_black) const
    806828{
    807     const OSDSurface *surface = this;
     829    const YUVSurface *surface = this;
    808830    blendtoargb_8_fun blender = blendtoargb_8_init(surface);
    809831    const unsigned char *cm = surface->cm;
    810832
     
    876898        BlendToBlack(argbptr, stride>>2, height);
    877899}
    878900
    879 /** \fn OSDSurface::DitherToI44(unsigned char*,bool,uint,uint) const
    880  *  \brief Copies and converts OSDSurface to either a greyscale
     901/** \fn YUVSurface::DitherToI44(unsigned char*,bool,uint,uint) const
     902 *  \brief Copies and converts YUVSurface to either a greyscale
    881903 *         IA44 or AI44 buffer.
    882904 *  \sa DitherToIA44(unsigned char*,uint,uint) const,
    883905 *      DitherToAI44(unsigned char*,uint,uint) const.
     
    887909 *  \param stride Length of each line in output buffer in bytes
    888910 *  \param height Number of lines in output buffer
    889911 */
    890 void OSDSurface::DitherToI44(unsigned char *outbuf, bool ifirst,
     912void YUVSurface::DitherToI44(unsigned char *outbuf, bool ifirst,
    891913                             uint stride, uint height) const
    892914{
    893     const OSDSurface *surface = this;
     915    const YUVSurface *surface = this;
    894916    int ashift = ifirst ? 0 : 4;
    895917    int amask = ifirst ? 0x0f : 0xf0;
    896918
     
    970992    delete_dithertoia44_8_context(dcontext);
    971993}
    972994
    973 /** \fn OSDSurface::DitherToIA44(unsigned char*,uint,uint) const
    974  *  \brief Copies and converts OSDSurface to a greyscale IA44 buffer.
     995/** \fn YUVSurface::DitherToIA44(unsigned char*,uint,uint) const
     996 *  \brief Copies and converts YUVSurface to a greyscale IA44 buffer.
    975997 *
    976998 *  \param outbuf Output buffer
    977999 *  \param stride Length of each line in output buffer in bytes
     
    9791001 *  \sa DitherToI44(unsigned char*,bool,uint,uint) const,
    9801002 *      DitherToAI44(unsigned char*,uint,uint) const.
    9811003 */
    982 void OSDSurface::DitherToIA44(unsigned char* outbuf,
     1004void YUVSurface::DitherToIA44(unsigned char* outbuf,
    9831005                              uint stride, uint height) const
    9841006{
    9851007    DitherToI44(outbuf, false, stride, height);
    9861008}
    9871009
    988 /** \fn OSDSurface::DitherToAI44(unsigned char*,bool,uint,uint) const
    989  *  \brief Copies and converts OSDSurface to a greyscale AI44 buffer.
     1010/** \fn YUVSurface::DitherToAI44(unsigned char*,bool,uint,uint) const
     1011 *  \brief Copies and converts YUVSurface to a greyscale AI44 buffer.
    9901012 *
    9911013 *  \param outbuf Output buffer
    9921014 *  \param stride Length of each line in output buffer in bytes
     
    9941016 *  \sa DitherToI44(unsigned char*,bool,uint,uint) const,
    9951017 *      DitherToIA44(unsigned char*,uint,uint) const.
    9961018 */
    997 void OSDSurface::DitherToAI44(unsigned char* outbuf,
     1019void YUVSurface::DitherToAI44(unsigned char* outbuf,
    9981020                              uint stride, uint height) const
    9991021{
    10001022    DitherToI44(outbuf, true, stride, height);
    10011023}
     1024
     1025
     1026I44Surface::I44Surface(int w, int h): OSDSurface(w,h)
     1027{
     1028printf("I44Surface - %d, %d\n",w,h);
     1029    i44buffer = new unsigned char [w*h];
     1030    Clear();
     1031}
     1032
     1033I44Surface::~I44Surface()
     1034{
     1035    delete [] i44buffer;
     1036}
     1037
     1038void I44Surface::Clear(void)
     1039{
     1040    memset(i44buffer, 0, size);
     1041   
     1042    OSDSurface::Clear();
     1043}
     1044
     1045void I44Surface::ClearUsed(void)
     1046{
     1047    memset(i44buffer, 0, size);
     1048    OSDSurface::Clear();
     1049}
     1050
     1051void I44Surface::BlendToI44( unsigned char *i44ptr, bool ifirst, uint stride, uint height) const
     1052{
     1053printf("BlendToI44 %d\n", size);
     1054    memcpy(i44ptr, i44buffer, size);//stride * XJ_height);
     1055}
  • libs/libmythtv/ttfont.cpp

     
    3131#include "osdtypes.h"
    3232#include "osdsurface.h"
    3333
     34#include <sys/time.h>
     35
     36#ifdef TIMING
     37#include "timer.h"
     38#endif
     39
    3440static int          have_library = 0;
    3541static FT_Library   the_library;
    3642
    3743#define FT_VALID(handle) ((handle) && (handle)->clazz != NULL)
    3844
     45/*
    3946struct Raster_Map
    4047{
    4148    int width;
     
    4451    int size;
    4552    unsigned char *bitmap;
    4653};
     54*/
    4755
    4856void TTFFont::setColor(int color)
    4957{
    5058    color %= 256;
     59    m_color_normal = color;
    5160    m_color_normal_y = color;
    5261    m_color_normal_u = m_color_normal_v = 128;
    5362
     
    8089            m_color_normal_y = (uint8_t)(y);
    8190            m_color_normal_u = (uint8_t)(127 + u);
    8291            m_color_normal_v = (uint8_t)(127 + v);
     92            m_color_normal = k;
    8393            break;
    8494
    8595        case kTTF_Outline:
    8696            m_color_outline_y = (uint8_t)(y);
    8797            m_color_outline_u = (uint8_t)(127 + u);
    8898            m_color_outline_v = (uint8_t)(127 + v);
     99            m_color_outline = k;
    89100            break;
    90101
    91102        case kTTF_Shadow:
    92103            m_color_shadow_y = (uint8_t)(y);
    93104            m_color_shadow_u = (uint8_t)(127 + u);
    94105            m_color_shadow_v = (uint8_t)(127 + v);
     106            m_color_shadow = k;
    95107            break;
    96108    }
    97109}
     
    103115   rmap = new Raster_Map;
    104116   rmap->width = (width + 3) & -4;
    105117   rmap->rows = height;
    106    rmap->cols = rmap->width;
    107    rmap->size = rmap->rows * rmap->width;
     118   
     119   if (m_mono)
     120    rmap->cols = (rmap->width+7) >> 3;
     121   else
     122    rmap->cols = rmap->width;
     123
     124   rmap->size = rmap->rows * rmap->cols;
    108125   if (rmap->size <= 0)
    109126   {
    110127        delete rmap;
     
    202219void TTFFont::render_text(Raster_Map *rmap, Raster_Map *rchr,
    203220                          const QString &text, int *xorblah, int *yor)
    204221{
     222#ifdef TIMING
     223    Timer t("render_text");
     224#endif
     225
    205226   FT_F26Dot6 x, y, xmin, ymin, xmax, ymax;
    206227   FT_BBox bbox;
    207228   unsigned int i, ioff, iread;
     
    248269           origin.x = 0;
    249270           origin.y = 0;
    250271
    251            FT_Glyph_To_Bitmap(&glyphs[j], ft_render_mode_normal, &origin, 1);
     272           FT_Glyph_To_Bitmap(&glyphs[j], m_mono ? ft_render_mode_mono : ft_render_mode_normal, &origin, 1);
    252273           bmap = (FT_BitmapGlyph)(glyphs[j]);
    253274
    254275           glyphs_cached[j] = duplicate_raster(bmap);
     
    311332       if (ymax >= rmap->rows)
    312333           ymax = rmap->rows - 1;
    313334
     335int x_ioff = 0, x_iread=0;
     336
    314337       if (xmin < 0)
    315338       {
    316            iread -= xmin;
     339           // iread -= xmin;
     340            x_iread = -xmin;
    317341           xmin = 0;
    318342       }
    319343       else
    320            ioff += xmin;
     344        {
     345            x_ioff = xmin;
     346          // ioff += xmin;
     347        }   
    321348
    322349       if (xmax >= rmap->width)
    323350           xmax = rmap->width - 1;
     
    327354       _read = (char *)rtmp->bitmap + iread;
    328355       _off = (char *)rmap->bitmap + ioff;
    329356
     357//printf("rows %d ymin %d cols %d\n", rmap->rows, ymin, rmap->cols);
     358
     359//printf(" i %d, j '%c' xmin %d, xmax %d, x_iread %d, x_ioff %d iread %d ioff %d\n",
     360//        i, j,xmin, xmax, x_iread, x_ioff, iread, ioff);
     361 
     362            int len = xmax - xmin;
     363            int bytes = len >> 3;
     364            int rem = len & 7;
     365
     366            int x_read = x_iread;
     367            int x_off = x_ioff;
     368
     369            unsigned char last=0, next=0;
     370            unsigned char lmask,nmask=255;
     371
     372            int bit_off = x_off&7;
     373
     374            nmask = nmask >> bit_off;
     375            lmask = 255 ^ nmask;
     376
     377//            printf(" nmask %02x, lmask %02x, bit_off %d, len %d, bytes %d, rem %d\n",
     378//                    nmask, lmask, bit_off, len, bytes, rem);
     379
    330380       for (y = ymin; y <= ymax; y++)
    331381       {
    332382           read = _read;
    333383           off = _off;
    334384
    335            for (x = xmin; x <= xmax; x++)
     385           if (m_mono)
    336386           {
    337                *off = *read;
    338                off++;
    339                read++;
     387
     388            off += (x_off>>3);
     389
     390            int i;
     391            last = *off;
     392            for (i=0; i<=bytes; i++)
     393            {
     394                __asm__ __volatile__ ("movb %b1, %b0; rorb %b2,%b0"
     395                    : "=a"(next):"g"(*read++),"c"(bit_off));
     396               
     397                *off++ = (last & lmask)|(next & nmask);
     398
     399                last=next;
     400            }
     401           if (bit_off)
     402            *off |= last & lmask;
     403
     404/*
     405       for (x = xmin; x <= xmax; x++)
     406       {
     407
     408        int r = x_iread + (x-xmin);
     409        int w = x_ioff + (x-xmin);               
     410
     411        bool bit = read[r>>3] & mask[r&7];
     412       
     413        if (bit)
     414            off[w>>3] |= mask[w&7];
     415       }
     416*/
     417
     418// i 16, j 't' xmin 180, xmax 186, x_iread 0, x_ioff 180 iread 34 ioff 594
     419// i 17, j 'c' xmin 188, xmax 197, x_iread 0, x_ioff 188 iread 24 ioff 594
     420// i 18, j 'h' xmin 201, xmax 210, x_iread 0, x_ioff 201 iread 34 ioff 594
    340421           }
     422           else
     423           {
     424               read += x_iread;
     425               off += x_ioff;
     426               
     427               for (x = xmin; x <= xmax; x++)
     428               {
     429                   *off = *read;
     430                   off++;
     431                   read++;
     432               }
     433           }
    341434           _read -= rtmp->cols;
    342435           _off -= rmap->cols;
    343436       }
     
    349442    }
    350443}
    351444
    352 void TTFFont::merge_text(OSDSurface *surface, Raster_Map * rmap, int offset_x,
     445void TTFFont::merge_text(I44Surface *surface, Raster_Map * rmap, int offset_x,
    353446                         int offset_y, int xstart, int ystart, int width,
    354447                         int height, int alphamod, kTTF_Color k)
    355448{
     449#ifdef TIMING
     450    Timer t("merge_text i44");
     451#endif
     452
    356453    unsigned char * asrc, * ydst, * udst, * vdst, * adst;
    357454    uint8_t color_y = 0, color_u = 0, color_v = 0;
     455    if (xstart < 0)
     456    {
     457        width += xstart;
     458        offset_x -= xstart;
     459        xstart = 0;
     460    }
    358461
     462    if (ystart < 0)
     463    {
     464        height += ystart;
     465        offset_y -= ystart;
     466        ystart = 0;
     467    }
     468
     469    if (height + ystart > surface->height)
     470        height = surface->height - ystart;
     471
     472    if (width + xstart > surface->width)
     473        width = surface->width - xstart;
     474
     475    QRect drawRect(xstart, ystart, width, height);
     476    surface->AddRect(drawRect);
     477
     478int b,x,y;
     479char ch;
     480
     481 asrc=rmap->bitmap;
     482 adst=surface->i44buffer;
     483
     484 asrc += rmap->cols*offset_y+(offset_x>>3);
     485 adst += xstart+ystart*surface->width;
     486
     487unsigned long* ldst=(unsigned long*)adst;
     488
     489unsigned char chmap[16];
     490
     491unsigned long col;
     492    switch(k)
     493    {
     494        case kTTF_Normal:
     495                 col=(m_color_normal&0xf)<<4;
     496            break;
     497        case kTTF_Outline:
     498                 col=(m_color_outline&0xf)<<4;
     499            break;
     500        case kTTF_Shadow:
     501                 col=(m_color_shadow&0xf)<<4;
     502            break;
     503    }
     504
     505    if (alphamod>255)
     506        alphamod=255;
     507    col |= alphamod>>4;
     508
     509    for (y=0; y<height;y++)
     510    {
     511        char ch;
     512        int j=0;
     513
     514        for (x=0; x<width;x++)
     515        {
     516            if ((x&7) == 0)
     517            {
     518                ch = asrc[j++];
     519            }
     520            else
     521            {
     522                ch = ch<<1;
     523            }
     524
     525            if (ch & 0x80)
     526                adst[x] = col;// | 0x0f;
     527        }
     528        asrc += rmap->cols;
     529        adst += surface->width;
     530    }
     531}
     532
     533void TTFFont::merge_text(YUVSurface *surface, Raster_Map * rmap, int offset_x,
     534                         int offset_y, int xstart, int ystart, int width,
     535                         int height, int alphamod, kTTF_Color k)
     536{
     537    unsigned char * asrc, * ydst, * udst, * vdst, * adst;
     538    uint8_t color_y = 0, color_u = 0, color_v = 0;
     539
    359540    if (xstart < 0)
    360541    {
    361542        width += xstart;
     
    411592                               surface->pow_lut);
    412593}
    413594
    414 void TTFFont::DrawString(OSDSurface *surface, int x, int y,
    415                          const QString &text, int maxx, int maxy,
    416                          int alphamod)
     595Raster_Map* TTFFont::Prerender(const QString &text)
    417596{
    418    int                  width, height, w, h, inx, iny, clipx, clipy;
    419    Raster_Map          *rmap, *rtmp;
    420    char                 is_pixmap = 0;
     597#ifdef TIMING
     598    Timer t("Prerender");
     599#endif
     600   int inx, iny, w, h;
     601   Raster_Map   *rmap, *rtmp;
     602   char         is_pixmap = 0;
    421603
    422604   if (text.length() < 1)
    423         return;
     605        return 0;
    424606
    425607   inx = 0;
    426608   iny = 0;
     
    429611   if (w <= 0 || h <= 0)
    430612   {
    431613       destroy_font_raster(rtmp);
    432        return;
     614       return 0;
    433615   }
    434616   rmap = create_font_raster(w, h);
    435617
     
    437619
    438620   is_pixmap = 1;
    439621
     622    rmap->m_w = w;
     623    rmap->m_h = h;
     624    rmap->m_inx = inx;
     625    rmap->m_iny = iny;
     626
     627return rmap;
     628}
     629
     630void TTFFont::DrawString(OSDSurface *surface, int x, int y,
     631                         const QString &text, int maxx, int maxy,
     632                         int alphamod )
     633{
     634#ifdef TIMING
     635    Timer t("DrawString");
     636#endif
     637 Raster_Map          *rmap;
     638
     639   int                  width, height, w, h, inx, iny, clipx, clipy;
     640
     641    if (rasters.contains(text))
     642    {
     643        rmap = rasters[text];
     644    }
     645    else
     646    {
     647        rmap = Prerender(text);
     648        rasters[text] = rmap;
     649    }
     650
     651    if (!rmap)
     652        return;
     653
     654        w = rmap->m_w;
     655        h = rmap->m_h;
     656        inx = rmap->m_inx;
     657        iny = rmap->m_iny;
     658   
    440659   y += loadedfontsize;
    441660   
    442661   width = maxx;
     
    470689     }
    471690   if ((width <= 0) || (height <= 0))
    472691     {
    473         destroy_font_raster(rmap);
    474         destroy_font_raster(rtmp);
    475         return;
     692 return;
    476693     }
    477694
    478695   if (m_shadowxoff > 0 || m_shadowyoff > 0)
    479696   {
    480        merge_text(surface, rmap, clipx, clipy, x + m_shadowxoff,
     697    if (surface->SurfaceType() == OSDSurface::SURF_YUV)
     698    {
     699       merge_text((YUVSurface*)surface, rmap, clipx, clipy, x + m_shadowxoff,
    481700                  y + m_shadowyoff, width, height, alphamod, kTTF_Shadow);
     701    }
     702    else if (surface->SurfaceType() == OSDSurface::SURF_I44)
     703    {
     704       merge_text((I44Surface*)surface, rmap, clipx, clipy, x + m_shadowxoff,
     705                  y + m_shadowyoff, width, height, alphamod, kTTF_Shadow);
     706    }
    482707   }
    483708
    484709   if (m_outline)
    485710   {
    486        merge_text(surface, rmap, clipx, clipy, x - 1, y - 1, width, height,
     711    if (surface->SurfaceType() == OSDSurface::SURF_YUV)
     712    {
     713       merge_text((YUVSurface*)surface, rmap, clipx, clipy, x - 1, y - 1, width, height,
    487714                  alphamod, kTTF_Outline);
    488        merge_text(surface, rmap, clipx, clipy, x + 1, y - 1, width, height,
     715       merge_text((YUVSurface*)surface, rmap, clipx, clipy, x + 1, y - 1, width, height,
    489716                  alphamod, kTTF_Outline);
    490        merge_text(surface, rmap, clipx, clipy, x - 1, y + 1, width, height,
     717       merge_text((YUVSurface*)surface, rmap, clipx, clipy, x - 1, y + 1, width, height,
    491718                  alphamod, kTTF_Outline);
    492        merge_text(surface, rmap, clipx, clipy, x + 1, y + 1, width, height,
     719       merge_text((YUVSurface*)surface, rmap, clipx, clipy, x + 1, y + 1, width, height,
    493720                  alphamod, kTTF_Outline);
     721                  }
     722    else if (surface->SurfaceType() == OSDSurface::SURF_I44)
     723    {
     724       merge_text((I44Surface*)surface, rmap, clipx, clipy, x - 1, y - 1, width, height,
     725                  alphamod, kTTF_Outline);
     726       merge_text((I44Surface*)surface, rmap, clipx, clipy, x + 1, y - 1, width, height,
     727                  alphamod, kTTF_Outline);
     728       merge_text((I44Surface*)surface, rmap, clipx, clipy, x - 1, y + 1, width, height,
     729                  alphamod, kTTF_Outline);
     730       merge_text((I44Surface*)surface, rmap, clipx, clipy, x + 1, y + 1, width, height,
     731                  alphamod, kTTF_Outline);
     732
     733    }
     734
    494735   }
    495736
    496    merge_text(surface, rmap, clipx, clipy, x, y, width, height, alphamod);
    497 
    498    destroy_font_raster(rmap);
    499    destroy_font_raster(rtmp);
     737       if (surface->SurfaceType() == OSDSurface::SURF_YUV)
     738    {
     739   merge_text((YUVSurface*)surface, rmap, clipx, clipy, x, y, width, height, alphamod);
     740   }
     741else if (surface->SurfaceType() == OSDSurface::SURF_I44)
     742    {
     743   merge_text((I44Surface*)surface, rmap, clipx, clipy, x, y, width, height, alphamod);
     744   }
    500745}
    501746
    502747TTFFont::~TTFFont()
    503748{
     749    QMap<QString,Raster_Map*>::Iterator it;
     750    for (it=rasters.begin(); it!= rasters.end(); ++it)
     751    {
     752        destroy_font_raster(*it);
     753    }
     754
    504755   if (!valid)
    505756       return;
    506757
     
    526777}
    527778
    528779TTFFont::TTFFont(char *file, int size, int video_width, int video_height,
    529                  float hmult)
     780                 float hmult, bool mono)
    530781{
     782
    531783   FT_Error            error;
    532784
    533785   valid = false;
    534786   m_size = size;
    535787   spacewidth = 0;
    536788
     789   m_mono = mono;
     790
    537791   m_outline = false;
    538792   m_shadowxoff = 0;
    539793   m_shadowyoff = 0;
    540794
    541795   m_color_normal_y = 255;
     796   m_color_normal = 255;
    542797   m_color_normal_u = m_color_normal_v = 128;
    543798
    544799   m_color_outline_y = 0x40;
     800   m_color_outline = 0x40;
    545801   m_color_outline_u = m_color_outline_v = 128;
    546802
    547803   m_color_shadow_y = 0x20;
     804   m_color_shadow = 0x20;
    548805   m_color_shadow_u = m_color_shadow_v = 128;
    549806
    550807   if (!have_library)
     
    597854
    598855void TTFFont::Init(void)
    599856{
     857
    600858   FT_Error error;
    601859   FT_CharMap char_map;
    602860   int xdpi = 96, ydpi = 96;
     
    663921
    664922void TTFFont::CalcWidth(const QString &text, int *width_return)
    665923{
     924
    666925   unsigned int i, pw;
    667926
    668927   pw = 0;
  • libs/libmythtv/osd.cpp

     
    3030         int dispx, int dispy, int dispw, int disph)
    3131   : QObject()
    3232{
     33    hasPalette=false;
    3334    changed = false;
    3435    vid_width = width;
    3536    vid_height = height;
     
    7475
    7576    SetDefaults();
    7677
    77     drawSurface = new OSDSurface(width, height);
     78
     79    if (surftype == "I44")
     80    {
     81        drawSurface = new I44Surface(width,height);
     82    }
     83    else //default to normal YUV
     84    {
     85        drawSurface = new YUVSurface(width, height);
     86    }
    7887}
    7988
    8089OSD::~OSD(void)
     
    234243    }
    235244
    236245    delete drawSurface;
    237     drawSurface = new OSDSurface(width, height);
     246   
     247    if (surftype == "I44")
     248    {
     249        drawSurface = new I44Surface(width,height);
     250    }
     251    else //default to normal YUV
     252    {
     253        drawSurface = new YUVSurface(width, height);
     254    }
    238255
    239256    osdlock.unlock();
    240257}
     
    263280TTFFont *OSD::LoadFont(QString name, int size)
    264281{
    265282    QString fullname = MythContext::GetConfDir() + "/" + name;
     283
     284    bool mono = (surftype == "I44") ? true:false;
     285
     286    printf("Load font %s\n", mono?"mono":"nonmono");
     287
    266288    TTFFont *font = new TTFFont((char *)fullname.ascii(), size, vid_width,
    267                                 vid_height, hmult);
     289                                vid_height, hmult,mono);
    268290
    269291    if (font->isValid())
    270292        return font;
     
    273295    fullname = gContext->GetShareDir() + name;
    274296
    275297    font = new TTFFont((char *)fullname.ascii(), size, vid_width,
    276                        vid_height, hmult);
     298                       vid_height, hmult,mono);
    277299
    278300    if (font->isValid())
    279301        return font;
     
    283305    {
    284306        fullname = themepath + "/" + name;
    285307        font = new TTFFont((char *)fullname.ascii(), size, vid_width,
    286                            vid_height, hmult);
     308                           vid_height, hmult,mono);
    287309        if (font->isValid())
    288310            return font;
    289311    }
     
    292314
    293315    fullname = name;
    294316    font = new TTFFont((char *)fullname.ascii(), size, vid_width, vid_height,
    295                        hmult);
     317                       hmult,mono);
    296318
    297319    if (font->isValid())
    298320        return font;
     
    316338    return "";
    317339}
    318340
     341void OSD::parsePalette(QDomElement &element)
     342{
     343    int index=0;
     344    hasPalette = true;
     345
     346    for (QDomNode child = element.firstChild(); !child.isNull(); child = child.nextSibling())
     347    {
     348        QDomElement node = child.toElement();
     349        if (!node.isNull())
     350        {
     351            if (node.tagName() == "rgb")
     352            {
     353                int r,g,b;
     354                QString text = getFirstText(node);
     355
     356                if (sscanf(text.data(), "%d,%d,%d", &r, &g, &b) == 3)
     357                {
     358                    surfPalette.append(QColor(r,g,b));
     359                }
     360            }
     361            else
     362            {
     363                cerr << "Unknown tag " << node.tagName() << " in colour\n";
     364                continue;
     365            }
     366            index ++;
     367        }
     368    }
     369}
     370
    319371void OSD::parseFont(QDomElement &element)
    320372{
    321373    QString name;
     
    11661218            {
    11671219                parseContainer(e);
    11681220            }
     1221            else if (e.tagName() == "surface")
     1222            {
     1223                surftype = getFirstText(e);
     1224            }
     1225            else if (e.tagName() == "palette")
     1226            {
     1227                parsePalette(e);
     1228            }
     1229
    11691230            else
    11701231            {
    11711232                cerr << "Unknown element: " << e.tagName() << endl;
  • libs/libmythtv/osdsurface.h

     
    1818class OSDSurface
    1919{
    2020  public:
     21    enum SURFTYPE{
     22    SURF_YUV,
     23    SURF_I44
     24    };
     25
    2126    OSDSurface(int w, int h);
    22    ~OSDSurface();
     27    virtual ~OSDSurface();
    2328
    24     void Clear(void);
    25     void ClearUsed(void);
     29    virtual void Clear(void);
     30    virtual void ClearUsed(void);
    2631
    2732    bool IntersectsDrawn(QRect &newrect);
    2833    void AddRect(QRect &newrect);
     
    3540            ++revision;
    3641    }
    3742    int GetRevision() { return revision; }
     43    int revision;
    3844
     45    virtual SURFTYPE SurfaceType() = 0;
     46
     47    int width;
     48    int height;
     49    int size;
     50
     51    QRegion usedRegions;
     52    bool changed;
     53};
     54
     55class I44Surface : public OSDSurface
     56{
     57public:       
     58    I44Surface(int w, int h);
     59    ~I44Surface();
     60
     61    virtual void Clear(void);
     62    virtual void ClearUsed(void);
     63   
     64    SURFTYPE SurfaceType() { return SURF_I44; }
     65   
     66    unsigned char *i44buffer;
     67
     68    void BlendToI44(unsigned char* outbuf, bool ifirst, uint stride, uint height) const;
     69private:
     70};
     71
     72
     73class YUVSurface : public OSDSurface
     74{
     75  public:
     76    YUVSurface(int w, int h);
     77   ~YUVSurface();
     78   
     79    SURFTYPE SurfaceType() { return SURF_YUV; }
     80
     81    virtual void Clear(void);
     82    virtual void ClearUsed(void);
     83
     84
    3985    void BlendToYV12(unsigned char *yuvptr) const;
    4086    void BlendToARGB(unsigned char *argbptr,
    4187                     uint stride, uint height, bool blendtoblack=false) const;
     
    4490    void DitherToIA44(unsigned char* outbuf, uint stride, uint height) const;
    4591    void DitherToAI44(unsigned char* outbuf, uint stride, uint height) const;
    4692
    47     int revision;
    48 
    4993    unsigned char *yuvbuffer;
    5094
    5195    // just pointers into yuvbuffer
     
    5599
    56100    unsigned char *alpha;
    57101
    58     int width;
    59     int height;
    60     int size;
    61 
    62     QRegion usedRegions;
    63 
    64102#ifdef MMX
    65103    short int rec_lut[256];
    66104#else
     
    74112    blendcolor_ptr blendcolorfunc;
    75113    blendconst_ptr blendconstfunc;
    76114
    77     bool changed;
    78 
    79115    bool usemmx;
    80116
    81117    unsigned char cropTbl[256 + 2 * MAX_NEG_CROP];
     
    85121typedef void (*blendtoyv12_8_fun)(unsigned char *src, unsigned char *dest,
    86122                                  unsigned char *alpha, bool uvplane);
    87123
    88 blendtoyv12_8_fun blendtoyv12_8_init(const OSDSurface *surface);
     124blendtoyv12_8_fun blendtoyv12_8_init(const YUVSurface *surface);
    89125
    90 typedef void (*blendtoargb_8_fun)(const OSDSurface *surf, unsigned char *src,
     126typedef void (*blendtoargb_8_fun)(const YUVSurface *surf, unsigned char *src,
    91127                                  unsigned char *usrc, unsigned char *vsrc,
    92128                                  unsigned char *alpha, unsigned char *dest);
    93129
    94 blendtoargb_8_fun blendtoargb_8_init(const OSDSurface *surface);
     130blendtoargb_8_fun blendtoargb_8_init(const YUVSurface *surface);
    95131           
    96132
    97133struct dither8_context;
     
    101137                                   const unsigned char *dmp, int xpos,
    102138                                   dither8_context *context);
    103139
    104 dithertoia44_8_fun dithertoia44_8_init(const OSDSurface *surface);
     140dithertoia44_8_fun dithertoia44_8_init(const YUVSurface *surface);
    105141dither8_context *init_dithertoia44_8_context(bool first);
    106142void delete_dithertoia44_8_context(dither8_context *context);
    107143
  • libs/libmythtv/ttfont.h

     
    1212
    1313struct Raster_Map;
    1414class OSDSurface;
     15class YUVSurface;
     16class I44Surface;
    1517
    1618enum kTTF_Color {
    1719    kTTF_Normal = 0,
     
    1921    kTTF_Shadow,
    2022};
    2123
     24struct Raster_Map
     25{
     26    int width;
     27    int rows;
     28    int cols;
     29    int size;
     30    unsigned char *bitmap;
     31    int m_w;
     32    int m_h;
     33    int m_inx;
     34    int m_iny;
     35};
     36
    2237class TTFFont
    2338{
    2439  public:
    2540     TTFFont(char *file, int size, int video_width, int video_height,
    26              float hmult);
     41             float hmult, bool mono);
    2742    ~TTFFont();
    2843
    2944     // Actually greyscale, keep for compat.
     
    3651
    3752     bool isValid(void) { return valid; }
    3853
     54     Raster_Map* Prerender(const QString &text );
    3955     void DrawString(OSDSurface *surface, int x, int y, const QString &text,
    4056                     int maxx, int maxy, int alphamod = 255);
    4157     void CalcWidth(const QString &text, int *width_return);
     
    4561
    4662     void Reinit(int width, int height, float hmult);
    4763
     64     static void destroy_font_raster(Raster_Map *rmap);
     65
    4866  private:
    4967     void KillFace(void);
    5068     void Init(void);
     
    5270     Raster_Map *create_font_raster(int width, int height);
    5371     Raster_Map *duplicate_raster(FT_BitmapGlyph bmap);
    5472     void clear_raster(Raster_Map *rmap);
    55      void destroy_font_raster(Raster_Map *rmap);
    5673     Raster_Map *calc_size(int *width, int *height, const QString &text);
    5774     void render_text(Raster_Map *rmap, Raster_Map *rchr, const QString &text,
    58                       int *xorblah, int *yor);
    59      void merge_text(OSDSurface *surface, Raster_Map *rmap, int offset_x,
     75                      int *xorblah, int *yor );
     76     void merge_text(YUVSurface *surface, Raster_Map *rmap, int offset_x,
    6077                     int offset_y, int xstart, int ystart, int width,
    6178                     int height, int alphamod, kTTF_Color k = kTTF_Normal);
     79     void merge_text(I44Surface *surface, Raster_Map *rmap, int offset_x,
     80                     int offset_y, int xstart, int ystart, int width,
     81                     int height, int alphamod, kTTF_Color k = kTTF_Normal);
    6282     bool cache_glyph(unsigned short c);
    6383
    6484     bool         valid;
     
    83103     uint8_t m_color_normal_y;
    84104     uint8_t m_color_normal_u;
    85105     uint8_t m_color_normal_v;
     106     uint8_t m_color_normal;
    86107
    87108     uint8_t m_color_outline_y;
    88109     uint8_t m_color_outline_u;
    89110     uint8_t m_color_outline_v;
     111     uint8_t m_color_outline;
    90112
    91113     uint8_t m_color_shadow_y;
    92114     uint8_t m_color_shadow_u;
    93115     uint8_t m_color_shadow_v;
     116     uint8_t m_color_shadow;
    94117
    95118     QString m_file;
    96119
    97120     int loadedfontsize;
    98121     float m_hmult;
     122   
     123    bool m_mono;
     124
     125    QMap<QString, Raster_Map *> rasters;
     126
    99127};
    100128
    101129#endif