Ticket #101: xvmcosd-cleanedup-v1.patch

File xvmcosd-cleanedup-v1.patch, 66.9 KB (added by danielk, 15 years ago)

Ivors patch w/some cleanup

  • themes/themes.pro

     
    99!macx:QMAKE_COPY_DIR = sh ./cpsvndir
    1010
    1111themes.path = $${PREFIX}/share/mythtv/themes/
    12 themes.files = blue defaultosd blueosd oldosd default G.A.N.T. classic DVR
     12themes.files = blue default G.A.N.T. classic DVR
     13themes.files += defaultosd blueosd oldosd xvmcosd
    1314
    1415fonts.path = $${PREFIX}/share/mythtv
    1516fonts.files = FreeSans.ttf FreeMono.ttf
  • libs/libmythtv/NuppelVideoPlayer.cpp

     
    19031903                      visible.width(), visible.height());
    19041904
    19051905        if (kCodec_NORMAL_END < GetDecoder()->GetVideoCodecID() &&
    1906             kCodec_SPECIAL_END > GetDecoder()->GetVideoCodecID() &&
     1906            kCodec_STD_XVMC_END > GetDecoder()->GetVideoCodecID() &&
    19071907            (600 < video_height))
    19081908        {           
    19091909            osd->DisableFade();
  • libs/libmythtv/osd.h

     
    123123
    124124    void DisableFade(void);
    125125
     126    bool HasPalette(void)         const { return hasPalette; }
     127
     128// TODO using a QValueList here is NOT threadsafe -- dtk
     129    QValueList<QColor> GetPalette(void) const
     130        { return surfPalette; }
     131
    126132 private:
    127133    void SetDefaults();
    128134    TTFFont *LoadFont(QString name, int size);
     
    149155    void parsePositionRects(OSDSet *container, QDomElement &element);
    150156    void parsePositionImage(OSDSet *container, QDomElement &element);
    151157    void parseListTree(OSDSet *container, QDomElement &element);
     158    void parsePalette(QDomElement &element);
    152159
    153160    int vid_width;
    154161    int vid_height;
     
    184191
    185192    OSDListTreeType *runningTreeMenu;
    186193    QString treeMenuContainer;
     194
     195    // variables to support restricted color palette
     196    bool               hasPalette;
     197    QString            surftype;
     198    QValueList<QColor> surfPalette;
     199
    187200};
    188201   
    189202#endif
  • libs/libmythtv/osdtypes.cpp

     
    1414
    1515#include "mythcontext.h"
    1616
     17#include <sys/time.h>
     18
     19#ifdef TIMING
     20#include "timer.h"
     21#endif
     22
     23QValueList<QColor> OSDTypeImage::s_palette;
     24
    1725OSDSet::OSDSet(const QString &name, bool cache, int screenwidth,
    1826               int screenheight, float wmult, float hmult, int frint)
    1927      : QObject()
     
    367375
    368376void OSDSet::Draw(OSDSurface *surface, bool actuallydraw)
    369377{
     378#ifdef TIMING
     379Timer t("OSDSet::Draw");
     380#endif
     381
    370382    if (actuallydraw)
    371383    {
    372384        vector<OSDType *>::iterator i = allTypes->begin();
     
    443455
    444456OSDTypeText::OSDTypeText(const QString &name, TTFFont *font,
    445457                         const QString &text, QRect displayrect)
    446            : OSDType(name)
     458           : OSDType(name), m_raster(0)
    447459{
    448460    m_message = text;
    449461    m_default_msg = text;
     
    463475    m_scrollinit = false;
    464476
    465477    m_linespacing = 1.5;
     478
     479    m_message.replace(QRegExp("%BR%"), "\n");
     480    m_message.replace(QRegExp("\n")," \n ");
    466481}
    467482
    468483OSDTypeText::OSDTypeText(const OSDTypeText &other)
    469            : OSDType(other.m_name)
     484           : OSDType(other.m_name), m_raster(0)
    470485{
    471486    m_displaysize = other.m_displaysize;
    472487    m_screensize = other.m_screensize;
     
    486501
    487502OSDTypeText::~OSDTypeText()
    488503{
     504    if (m_raster)
     505    {
     506       TTFFont::destroy_font_raster(m_raster);
     507       m_raster=0;
     508    }
    489509}
    490510
    491511void OSDTypeText::SetAltFont(TTFFont *font)
     
    495515
    496516void OSDTypeText::SetText(const QString &text)
    497517{
     518    if (m_raster)
     519    {
     520       TTFFont::destroy_font_raster(m_raster);
     521       m_raster=0;
     522    }
     523
    498524    m_message = text;
    499525    m_scrollinit = false;
     526
     527   m_message.replace(QRegExp("%BR%"), "\n");
     528   m_message.replace(QRegExp("\n"), " \n ");
    500529}
    501530
    502531void OSDTypeText::SetDefaultText(const QString &text)
    503532{
     533    if (m_raster)
     534    {
     535       TTFFont::destroy_font_raster(m_raster);
     536       m_raster=0;
     537    }
     538
    504539    m_message = text;
    505540    m_default_msg = text;
    506541    m_scrollinit = false;
     542
     543    m_message.replace(QRegExp("%BR%"), "\n");
     544    m_message.replace(QRegExp("\n"), " \n ");
    507545}
    508546
    509547void OSDTypeText::Reinit(float wchange, float hchange)
    510548{
     549    if (m_raster)
     550    {
     551       TTFFont::destroy_font_raster(m_raster);
     552       m_raster=0;
     553    }
     554
    511555    int width = (int)(m_screensize.width() * wchange);
    512556    int height = (int)(m_screensize.height() * hchange);
    513557    int x = (int)(m_screensize.x() * wchange);
     
    519563void OSDTypeText::Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
    520564                       int yoff)
    521565{
     566#ifdef TIMING
     567    Timer t("OSDTypeText::Draw");
     568#endif
    522569    int textlength = 0;
    523570
    524571    if (m_message == QString::null)
     
    530577    if (m_scroller)
    531578        m_parent->SetDrawEveryFrame(true);
    532579
    533     m_font->CalcWidth(m_message, &textlength);
     580//    m_font->CalcWidth(m_message, &textlength);
    534581
    535582    int maxlength = m_displaysize.width();
    536583
    537584    if (m_multiline)
    538585    {
    539         QString tmp_msg = m_message;
    540         tmp_msg.replace(QRegExp("%BR%"), "\n");
    541         tmp_msg.replace(QRegExp("\n")," \n ");
     586//        QString tmp_msg = m_message;
     587//        tmp_msg.replace(QRegExp("%BR%"), "\n");
     588//        tmp_msg.replace(QRegExp("\n"), " \n ");
    542589
    543         QStringList wordlist = QStringList::split(" ", tmp_msg);
     590        QStringList wordlist = QStringList::split(" ", m_message);
    544591        int length = 0;
    545592        int lines = 0;
    546593
     
    658705                             const QString &text, int fade, int maxfade,
    659706                             int xoff, int yoff)
    660707{
     708#ifdef TIMING
     709    Timer t("OSDTypeText::DrawString");
     710#endif
     711
    661712    if (m_centered || m_right)
    662713    {
    663714        int textlength = 0;
     
    713764    m_isvalid = false;
    714765    m_imagesize = QRect(0, 0, 0, 0);
    715766
     767    m_i44 = NULL;
     768
    716769    m_scalew = scalew;
    717770    m_scaleh = scaleh;
    718771
     
    734787    m_scaleh = other.m_scaleh;
    735788
    736789    m_alpha = m_yuv = NULL;
     790    m_i44 = NULL;
     791
    737792    if (m_isvalid)
    738793    {
    739794        int size = m_imagesize.width() * m_imagesize.height() * 3 / 2;
     
    749804        m_ubuffer = m_yuv + (m_imagesize.width() * m_imagesize.height());
    750805        m_vbuffer = m_yuv + (m_imagesize.width() * m_imagesize.height() *
    751806                             5 / 4);
    752     }
     807
     808//I44
     809        m_i44 = new unsigned char[size];
     810        memcpy(m_i44, other.m_i44, size);
     811    }
    753812}
    754813
    755814OSDTypeImage::OSDTypeImage(const QString &name)
     
    767826    m_vbuffer = NULL;
    768827    m_isvalid = false;
    769828    m_filename = "";
     829
     830    m_i44 = NULL;
    770831}
    771832
    772833OSDTypeImage::OSDTypeImage(void)
     
    785846    m_vbuffer = NULL;
    786847    m_isvalid = false;
    787848    m_filename = "";
     849
     850    m_i44 = NULL;
    788851}
    789852
    790853OSDTypeImage::~OSDTypeImage()
     
    793856        delete [] m_yuv;
    794857    if (m_alpha)
    795858        delete [] m_alpha;
     859    if (m_i44)
     860        delete [] m_i44;
    796861}
    797862
    798863void OSDTypeImage::SetName(const QString &name)
     
    811876    LoadImage(m_filename, wmult, hmult, m_scalew, m_scaleh);
    812877}
    813878
    814 void OSDTypeImage::LoadImage(const QString &filename, float wmult, float hmult,
     879void rgb32_to_i44(unsigned char*i44, unsigned char*rgb, int width, int height, int srcwidth, const QValueList<QColor> &palette )
     880{
     881    int wrap, wrap4, x, y;
     882    unsigned char *p;
     883    unsigned char ch, r, g, b;
     884
     885printf("rgb32_to_i44 called, image size: %dx%d\n", width, height);
     886
     887    p = rgb;
     888
     889    for (y=0; y<height; y++)
     890    {
     891        unsigned char *pstart=p;
     892
     893        for (x=0; x<width; x++)
     894        {
     895            ch = (p[3] >> 4) & 0x0f; //trunc alpha
     896            r=p[2]; g=p[1]; b=p[0];
     897
     898            //Find nearest palette colour
     899            long d1, d2=( 256*256 )*3; //black is white
     900            int i, j;
     901            for ( i=0;i<palette.count(); i++ )
     902            {
     903                d1 = ( palette[i].red()-r ) * ( palette[i].red()-r ) +
     904                     ( palette[i].green()-g ) * ( palette[i].green()-g ) +
     905                     ( palette[i].blue()-b ) * ( palette[i].blue()-b );
     906
     907                if ( d1==0 ) { //perfect match
     908                    j=i;
     909                    break;
     910                }
     911                if ( d1 < d2 ) { //nearer match
     912                    d2 = d1;
     913                    j=i;
     914                }
     915            }
     916
     917            ch |= ( j<<4 );
     918
     919            *(i44+x+y*width) = ch;
     920
     921            p+=4;
     922        }
     923
     924        p=pstart+srcwidth*4;
     925
     926    }
     927}
     928
     929void OSDTypeImage::LoadImage(const QString &filename,
     930                             float wmult, float hmult,
    815931                             int scalew, int scaleh)
    816932{
    817933    if (m_isvalid)
     
    820936            delete [] m_yuv;
    821937        if (m_alpha)
    822938            delete [] m_alpha;
     939        if (m_i44)
     940            delete [] m_i44;
    823941
    824942        m_isvalid = false;
    825943        m_yuv = NULL;
    826944        m_alpha = NULL;
     945        m_i44 = NULL;
    827946    }
    828947
    829948    if (filename.length() < 2)
     
    862981
    863982    m_alpha = new unsigned char[imwidth * imheight];
    864983
    865     rgb32_to_yuv420p(m_ybuffer, m_ubuffer, m_vbuffer, m_alpha, tmp2.bits(),
     984    m_i44 = new unsigned char[imwidth*imheight];
     985
     986    rgb32_to_yuv420p(m_ybuffer, m_ubuffer, m_vbuffer, m_alpha, tmp2.bits(),
    866987                     imwidth, imheight, tmp2.width());
    867988
     989    rgb32_to_i44(m_i44, tmp2.bits(), imwidth, imheight, tmp2.width(),
     990                 GetPalette());
     991
    868992    m_imagesize = QRect(0, 0, imwidth, imheight);
    869993}
    870994
     
    8771001        if (m_alpha)
    8781002            delete [] m_alpha;
    8791003
     1004        if (m_i44)
     1005            delete[] m_i44;
     1006
    8801007        m_isvalid = false;
    8811008        m_yuv = NULL;
    8821009        m_alpha = NULL;
     1010        m_i44 = NULL;
    8831011    }
    8841012
    8851013    m_isvalid = true;
     
    8941022
    8951023    m_alpha = new unsigned char[imwidth * imheight];
    8961024
    897     rgb32_to_yuv420p(m_ybuffer, m_ubuffer, m_vbuffer, m_alpha, img.bits(),
     1025    m_i44 = new unsigned char[imwidth*imheight];
     1026
     1027    rgb32_to_yuv420p(m_ybuffer, m_ubuffer, m_vbuffer, m_alpha, img.bits(),
    8981028                     img.width(), img.height(), img.bytesPerLine() / 4);
    8991029
     1030    rgb32_to_i44(m_i44, img.bits(), imwidth, imheight, img.width(),
     1031                 GetPalette());
    9001032    m_imagesize = QRect(0, 0, imwidth, imheight);
    9011033}
    9021034
    903 void OSDTypeImage::Draw(OSDSurface *surface, int fade, int maxfade,
    904                         int xoff, int yoff)
     1035void OSDTypeImage::Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff)
    9051036{
     1037#ifdef TIMING
     1038Timer t("OSDTypeImage::Draw");
     1039#endif
     1040
     1041    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1042        Draw((YUVSurface*)surface, fade, maxfade, xoff, yoff);
     1043    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1044        Draw((I44Surface*)surface, fade, maxfade, xoff, yoff);
     1045}
     1046
     1047void OSDTypeImage::Draw(I44Surface *surface, int fade, int maxfade, int xoff,
     1048                        int yoff)
     1049{
    9061050    if (!m_isvalid)
    9071051        return;
    9081052
     1053    unsigned char *dest, *destalpha, *src, *srcalpha;
     1054    unsigned char *udest, *vdest, *usrc, *vsrc;
     1055    int alpha, iwidth, width;
     1056
     1057    iwidth = width = m_imagesize.width();
     1058    int height = m_imagesize.height();
     1059
     1060    if (m_drawwidth >= 0)
     1061        width = m_drawwidth;
     1062
     1063    int ystart = m_displaypos.y();
     1064    int xstart = m_displaypos.x();
     1065
     1066    xstart += xoff;
     1067    ystart += yoff;
     1068
     1069    ystart = (ystart / 2) * 2;
     1070    xstart = ((xstart + 1) / 2) * 2;
     1071
     1072    int startline = 0;
     1073    int startcol = 0;
     1074
     1075    if (ystart < 0)
     1076    {
     1077        startline = 0 - ystart;
     1078        ystart = 0;
     1079    }
     1080
     1081    if (xstart < 0)
     1082    {
     1083        startcol = 0 - xstart;
     1084        xstart = 0;
     1085    }
     1086
     1087    if (height + ystart > surface->height)
     1088        height = surface->height - ystart - 1;
     1089    if (width + xstart > surface->width)
     1090        width = surface->width - xstart - 1;
     1091
     1092    if (width == 0 || height == 0)
     1093{
     1094printf("zeros\n");
     1095        return;
     1096}
     1097
     1098
     1099    QRect destRect = QRect(xstart, ystart, width, height);
     1100    bool needblend = false;
     1101
     1102    if (m_onlyusefirst || surface->IntersectsDrawn(destRect))
     1103        needblend = true;
     1104    surface->AddRect(destRect);
     1105
     1106    int ysrcwidth;
     1107    int ydestwidth;
     1108
     1109    int uvsrcwidth;
     1110    int uvdestwidth;
     1111
     1112    int alphamod = 0xf;
     1113
     1114
     1115    if (maxfade > 0 && fade >= 0)
     1116        alphamod = (int)((((float)(fade) / maxfade) * 16.0) + 0.5);
     1117
     1118unsigned char almap[256];
     1119    {
     1120for (int i=0; i<256; i++)
     1121{
     1122almap[i] = ( i & 0xf0)|((((i & 0xf) * alphamod)>>4)&0xf);
     1123}
     1124}
     1125        unsigned char *dst;
     1126
     1127        src = m_i44;
     1128        dst = surface->i44buffer + xstart + (ystart)*surface->width;
     1129
     1130        unsigned long *ldst = (unsigned long*)dst;
     1131
     1132{
     1133        for (int y = startline; y < height; y++)
     1134        {
     1135            unsigned long *lsrc = (unsigned long*)(src+(y*iwidth));
     1136            for (int x = startcol/4; x < width/4; x++)
     1137            {
     1138                unsigned long sch = lsrc[x];
     1139                unsigned long dsh =
     1140                            almap[sch>>24]<<24 |
     1141                            almap[sch>>16 & 0xff] << 16 |
     1142                            almap[sch>>8 & 0xff] << 8 |
     1143                            almap[sch&0xff];
     1144
     1145                ldst[x] = (ldst[x] & 0x0f0f0f0f) | dsh;
     1146
     1147/* unsigned char ch = (alphamod & 0xf0) | (*(m_ubuffer+(x/2)+ysrcwidth) & 0x0f) ;
     1148                *(surface->i44buffer + x +xstart+ ydestwidth) = ch;
     1149*/
     1150            }
     1151            ldst+=surface->width/4;
     1152        }
     1153}
     1154        return;
     1155
     1156}
     1157void OSDTypeImage::Draw(YUVSurface *surface, int fade, int maxfade, int xoff,
     1158                        int yoff)
     1159{
     1160    if (!m_isvalid)
     1161        return;
     1162
    9091163    int xstart = ((m_displaypos.x() + xoff + 1) / 2) * 2;
    9101164    int ystart = ((m_displaypos.y() + yoff)     / 2) * 2;
    9111165
     
    9331187
    9341188    drawheight = (drawheight + ystart > surface->height) ?
    9351189        surface->height - ystart - 1 : drawheight;
    936  
     1190
    9371191    if ((drawwidth <= 0) || (drawheight <= 0))
    9381192        return;
    9391193
     
    9411195    bool needblend = m_onlyusefirst || surface->IntersectsDrawn(destRect);
    9421196
    9431197    surface->AddRect(destRect);
    944    
     1198
    9451199    int alphamod = 255;
    9461200
    9471201    if (maxfade > 0 && fade >= 0)
     
    9541208            int ysrcwidth = y * iwidth;
    9551209            int ydestwidth = (y + ystart - startline) * surface->width;
    9561210
    957             memcpy(surface->y + xstart + ydestwidth,
     1211            memcpy(surface->y + xstart + ydestwidth, 
    9581212                   m_ybuffer + startcol + ysrcwidth, drawwidth);
    9591213
    9601214            unsigned char *destalpha = surface->alpha + xstart + ydestwidth;
     
    9621216            for (int x = startcol; x < drawwidth; x++)
    9631217            {
    9641218                int alpha = *(m_alpha + x + ysrcwidth);
    965  
     1219
    9661220                if (alpha == 0)
    9671221                    *destalpha = 0;
    9681222                else
     
    9851239            int uvsrcwidth = y * iwidth;
    9861240            int uvdestwidth = (y + ystart - startline) * (surface->width / 2);
    9871241
    988             memcpy(surface->u + xstart + uvdestwidth,
     1242            memcpy(surface->u + xstart + uvdestwidth, 
    9891243                   m_ubuffer + startcol + uvsrcwidth, drawwidth);
    990             memcpy(surface->v + xstart + uvdestwidth,
     1244            memcpy(surface->v + xstart + uvdestwidth, 
    9911245                   m_vbuffer + startcol + uvsrcwidth, drawwidth);
    9921246        }
    9931247
     
    10121266    unsigned char *destalpha = surface->alpha + xstart     + ydestwidth;
    10131267
    10141268    if (m_onlyusefirst)
    1015         (surface->blendcolumnfunc) (src, usrc, vsrc, srcalpha, iwidth, dest,
    1016                                     udest, vdest, destalpha, surface->width,
     1269        (surface->blendcolumnfunc) (src, usrc, vsrc, srcalpha, iwidth, dest, 
     1270                                    udest, vdest, destalpha, surface->width, 
    10171271                                    drawwidth - startcol,
    1018                                     drawheight - startline,
    1019                                     alphamod, 1, surface->rec_lut,
     1272                                    drawheight - startline, 
     1273                                    alphamod, 1, surface->rec_lut, 
    10201274                                    surface->pow_lut);
    10211275    else
    1022         (surface->blendregionfunc) (src, usrc, vsrc, srcalpha, iwidth, dest,
    1023                                     udest, vdest, destalpha, surface->width,
     1276        (surface->blendregionfunc) (src, usrc, vsrc, srcalpha, iwidth, dest, 
     1277                                    udest, vdest, destalpha, surface->width, 
    10241278                                    drawwidth - startcol,
    1025                                     drawheight - startline,
    1026                                     alphamod, 1, surface->rec_lut,
     1279                                    drawheight - startline, 
     1280                                    alphamod, 1, surface->rec_lut, 
    10271281                                    surface->pow_lut);
    10281282}
    10291283
    10301284//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    10311285
    1032 OSDTypePosSlider::OSDTypePosSlider(const QString &name,
    1033                                    const QString &filename,
    1034                                    QRect displayrect, float wmult,
     1286OSDTypePosSlider::OSDTypePosSlider(const QString &name, 
     1287                                   const QString &filename, 
     1288                                   QRect displayrect, float wmult, 
    10351289                                   float hmult, int scalew, int scaleh)
    1036                : OSDTypeImage(name, filename, displayrect.topLeft(), wmult,
     1290               : OSDTypeImage(name, filename, displayrect.topLeft(), wmult, 
    10371291                              hmult, scalew, scaleh)
    10381292{
    10391293    m_maxval = 1000;
     
    10451299{
    10461300}
    10471301
    1048 void OSDTypePosSlider::Reinit(float wchange, float hchange, float wmult,
     1302void OSDTypePosSlider::Reinit(float wchange, float hchange, float wmult, 
    10491303                              float hmult)
    10501304{
    10511305    int width = (int)(m_displayrect.width() * wchange);
     
    10771331//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    10781332
    10791333OSDTypeFillSlider::OSDTypeFillSlider(const QString &name,
    1080                                      const QString &filename,
     1334                                     const QString &filename, 
    10811335                                     QRect displayrect, float wmult,
    10821336                                     float hmult, int scalew, int scaleh)
    10831337                 : OSDTypeImage(name, filename, displayrect.topLeft(), wmult,
     
    10941348{
    10951349}
    10961350
    1097 void OSDTypeFillSlider::Reinit(float wchange, float hchange, float wmult,
     1351void OSDTypeFillSlider::Reinit(float wchange, float hchange, float wmult, 
    10981352                               float hmult)
    10991353{
    11001354    int width = (int)(m_displayrect.width() * wchange);
     
    11291383
    11301384//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    11311385
    1132 OSDTypeEditSlider::OSDTypeEditSlider(const QString &name,
    1133                                      const QString &bluefilename,
    1134                                      const QString &redfilename,
    1135                                      QRect displayrect, float wmult,
     1386OSDTypeEditSlider::OSDTypeEditSlider(const QString &name, 
     1387                                     const QString &bluefilename, 
     1388                                     const QString &redfilename, 
     1389                                     QRect displayrect, float wmult, 
    11361390                                     float hmult, int scalew, int scaleh)
    11371391                 : OSDTypeImage(name)
    11381392{
     
    11461400         m_drawMap[i] = 0;
    11471401
    11481402    m_displaypos = displayrect.topLeft();
    1149    
     1403
    11501404    m_yuv = m_alpha = NULL;
    11511405    m_isvalid = false;
    11521406
     
    11871441        delete [] m_ralpha;
    11881442}
    11891443
    1190 void OSDTypeEditSlider::Reinit(float wchange, float hchange, float wmult,
     1444void OSDTypeEditSlider::Reinit(float wchange, float hchange, float wmult, 
    11911445                               float hmult)
    11921446{
    11931447    int width = (int)(m_displayrect.width() * wchange);
     
    11991453    m_drawwidth = m_displayrect.width();
    12001454
    12011455    delete [] m_drawMap;
    1202    
     1456
    12031457    m_drawMap = new unsigned char[m_drawwidth + 1];
    12041458    for (int i = 0; i < m_drawwidth; i++)
    12051459         m_drawMap[i] = 0;
     
    12421496
    12431497    if (start < 0)
    12441498        start = 0;
    1245     if (start >= m_drawwidth) 
     1499    if (start >= m_drawwidth)
    12461500        start = m_drawwidth - 1;
    12471501    if (end < 0)
    12481502        end = 0;
     
    12601514        m_drawMap[i] = 1;
    12611515}
    12621516
    1263 void OSDTypeEditSlider::Draw(OSDSurface *surface, int fade, int maxfade,
     1517void OSDTypeEditSlider::Draw(OSDSurface *surface, int fade, int maxfade, 
    12641518                             int xoff, int yoff)
    1265 {           
     1519{
     1520    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1521        Draw((YUVSurface*)surface, fade, maxfade, xoff, yoff);
     1522//    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1523//        Draw((I44Surface*)surface, fade, maxfade, xoff, yoff);
     1524}
     1525void OSDTypeEditSlider::Draw(YUVSurface *surface, int fade, int maxfade,
     1526                             int xoff, int yoff)
     1527{
    12661528    if (!m_isvalid || !m_risvalid)
    12671529        return;
    1268            
     1530
    12691531    unsigned char *dest, *destalpha, *src, *rsrc, *srcalpha, *rsrcalpha;
    12701532    unsigned char *udest, *vdest, *usrc, *rusrc, *vsrc, *rvsrc;
    1271            
     1533
    12721534    int iwidth, riwidth, width;
    12731535    iwidth = m_imagesize.width();
    12741536    riwidth = m_rimagesize.width();
     
    12771539
    12781540    int ystart = m_displaypos.y();
    12791541    int xstart = m_displaypos.x();
    1280            
     1542
    12811543    xstart += xoff;
    12821544    ystart += yoff;
    12831545
     
    13091571
    13101572    QRect destRect = QRect(xstart, ystart, width, height);
    13111573    surface->AddRect(destRect);
    1312  
    1313     int ysrcwidth;             
     1574
     1575    int ysrcwidth;
    13141576    int rysrcwidth;
    13151577    int ydestwidth;
    1316    
     1578
    13171579    int uvsrcwidth;
    13181580    int ruvsrcwidth;
    13191581    int uvdestwidth;
    1320  
     1582
    13211583    int alphamod = 255;
    1322    
     1584
    13231585    if (maxfade > 0 && fade >= 0)
    13241586        alphamod = (int)((((float)(fade) / maxfade) * 256.0) + 0.5);
    13251587
    1326     ysrcwidth = startline * iwidth; 
     1588    ysrcwidth = startline * iwidth;
    13271589    rysrcwidth = startline * riwidth;
    13281590    ydestwidth = ystart * surface->width;
    13291591
     
    13461608    vdest = surface->v + xstart / 2 + uvdestwidth;
    13471609    vsrc = m_vbuffer + uvsrcwidth;
    13481610    rvsrc = m_rvbuffer + ruvsrcwidth;
    1349     (surface->blendcolumn2func) (rsrc, rusrc, rvsrc, rsrcalpha, riwidth, src,
    1350                                  usrc, vsrc, srcalpha, iwidth,
    1351                                  m_drawMap + startcol, dest, udest, vdest,
    1352                                  destalpha, surface->width, width - startcol,
    1353                                  height - startline, alphamod, 1,
     1611    (surface->blendcolumn2func) (rsrc, rusrc, rvsrc, rsrcalpha, riwidth, src, 
     1612                                 usrc, vsrc, srcalpha, iwidth, 
     1613                                 m_drawMap + startcol, dest, udest, vdest, 
     1614                                 destalpha, surface->width, width - startcol, 
     1615                                 height - startline, alphamod, 1, 
    13541616                                 surface->rec_lut, surface->pow_lut);
    13551617}
    13561618
    13571619//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    13581620
    1359 OSDTypeBox::OSDTypeBox(const QString &name, QRect displayrect) 
     1621OSDTypeBox::OSDTypeBox(const QString &name, QRect displayrect)
    13601622          : OSDType(name)
    13611623{
    13621624    size = displayrect;
     
    13851647void OSDTypeBox::Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
    13861648                      int yoff)
    13871649{
     1650#ifdef TIMING
     1651Timer t("OSDTypeBox::Draw");
     1652#endif
     1653
     1654    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1655        Draw((YUVSurface*)surface, fade, maxfade, xoff, yoff);
     1656    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1657        Draw((I44Surface*)surface, fade, maxfade, xoff, yoff);
     1658}
     1659
     1660void OSDTypeBox::Draw(I44Surface *surface, int fade, int maxfade, int xoff,
     1661                      int yoff)
     1662{
    13881663    unsigned char *dest, *destalpha;
    13891664    unsigned char alpha = 192;
     1665    unsigned char targ;
    13901666
    13911667    QRect disprect = size;
    13921668    disprect.moveBy(xoff, yoff);
     
    14071683
    14081684    int height = yend - ystart + 1, width = xend - xstart + 1;
    14091685
     1686    QRect destRect = QRect(xstart, ystart, width, height);
     1687    bool needblend = false;
     1688
     1689    if (surface->IntersectsDrawn(destRect))
     1690        needblend = true;
     1691    surface->AddRect(destRect);
     1692
     1693    int alphamod = 255;
     1694    if (maxfade > 0 && fade >= 0)
     1695        alphamod = (int)((((float)(fade) / maxfade) * 16.0) + 0.5);
     1696
     1697    int ydestwidth;
     1698
     1699    alpha = ((alpha * alphamod) + 0x8);
     1700
     1701    targ = 0 | (alpha & 0xf); //black
     1702//targ=0xf3;
     1703
     1704    for (int y = ystart; y < yend; y++)
     1705    {
     1706        ydestwidth = y * surface->width;
     1707        memset(surface->i44buffer + xstart + ydestwidth, targ , width);
     1708    }
     1709}
     1710
     1711void OSDTypeBox::Draw(YUVSurface *surface, int fade, int maxfade, int xoff,
     1712                      int yoff)
     1713{
     1714    unsigned char *dest, *destalpha;
     1715    unsigned char alpha = 192;
     1716
     1717    QRect disprect = size;
     1718    disprect.moveBy(xoff, yoff);
     1719
     1720    int ystart = disprect.top();
     1721    int yend = disprect.bottom();
     1722    int xstart = disprect.left();
     1723    int xend = disprect.right();
     1724
     1725    if (xstart < 0)
     1726        xstart = 0;
     1727    if (xend > surface->width)
     1728        xend = surface->width;
     1729    if (ystart < 0)
     1730        ystart = 0;
     1731    if (yend > surface->height)
     1732        yend = surface->height;
     1733
     1734    int height = yend - ystart + 1, width = xend - xstart + 1;
     1735
    14101736    QRect destRect = QRect(xstart, ystart, width, height);
    14111737    bool needblend = false;
    14121738
     
    15331859void OSDTypePositionRectangle::Draw(OSDSurface *surface, int fade, int maxfade,
    15341860                                    int xoff, int yoff)
    15351861{
     1862#ifdef TIMING
     1863Timer t("OSDTypePositionRectangle::Draw");
     1864#endif
     1865
     1866    if (surface->SurfaceType()==OSDSurface::SURF_YUV)
     1867        Draw((YUVSurface*)surface, fade, maxfade, xoff, yoff);
     1868    else if (surface->SurfaceType()==OSDSurface::SURF_I44)
     1869        Draw((I44Surface*)surface, fade, maxfade, xoff, yoff);
     1870}
     1871
     1872void OSDTypePositionRectangle::Draw(YUVSurface *surface, int fade, int maxfade,
     1873                                    int xoff, int yoff)
     1874{
    15361875    fade = fade;
    15371876    maxfade = maxfade;
    15381877    xoff = xoff;
     
    16111950    }
    16121951}
    16131952
     1953
     1954void OSDTypePositionRectangle::Draw(I44Surface *surface, int fade, int maxfade,
     1955                                    int xoff, int yoff)
     1956{
     1957    fade = fade;
     1958    maxfade = maxfade;
     1959    xoff = xoff;
     1960    yoff = yoff;
     1961
     1962    if (m_curposition < 0 || m_curposition >= m_numpositions)
     1963        return;
     1964
     1965    QRect rect = positions[m_curposition];
     1966
     1967    unsigned char *src;
     1968    int ystart = rect.top();
     1969    int yend = rect.bottom();
     1970    int xstart = rect.left();
     1971    int xend = rect.right();
     1972
     1973    int height = yend - ystart + 1, width = xend - xstart + 1;
     1974
     1975    QRect destRect = QRect(xstart, ystart, width, height);
     1976    surface->AddRect(destRect);
     1977
     1978
     1979    for (int y = ystart; y < yend; y++)
     1980    {
     1981        if (y < 0 || y >= surface->height)
     1982            continue;
     1983
     1984        for (int x = xstart; x < xstart + 2; x++)
     1985        {
     1986            if (x < 0 || x >= surface->width)
     1987                continue;
     1988
     1989            src = surface->i44buffer + x + y * surface->width;
     1990            *src = 0xaa; //white
     1991        }
     1992
     1993        for (int x = xend - 2; x < xend; x++)
     1994        {
     1995            if (x < 0 || x >= surface->width)
     1996                continue;
     1997
     1998            src = surface->i44buffer + x + y * surface->width;
     1999            *src = 0xaa; //white
     2000        }
     2001    }
     2002
     2003    for (int x = xstart; x < xend; x++)
     2004    {
     2005        if (x < 0 || x >= surface->width)
     2006            continue;
     2007
     2008        for (int y = ystart; y < ystart + 2; y++)
     2009        {
     2010            if (y < 0 || y >= surface->height)
     2011                continue;
     2012
     2013            src = surface->i44buffer + x + y * surface->width;
     2014            *src = 0xaa;
     2015        }
     2016        for (int y = yend - 2; y < yend; y++)
     2017        {
     2018            if (y < 0 || y >= surface->height)
     2019                continue;
     2020
     2021            src = surface->i44buffer + x + y * surface->width;
     2022            *src = 0xaa;
     2023        }
     2024    }
     2025}
     2026
    16142027//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    16152028
    16162029OSDTypePositionImage::OSDTypePositionImage(const QString &name)
  • libs/libmythtv/videooutbase.cpp

     
    11721172    if (!osd)
    11731173        return -1;
    11741174
    1175     OSDSurface *surface = osd->Display();
    1176     if (!surface)
     1175    OSDSurface *osdsurf = osd->Display();
     1176    if (!osdsurf)
    11771177        return -1;
    11781178
    11791179    bool changed = (-1 == revision) ?
    1180         surface->Changed() : (surface->GetRevision()!=revision);
     1180        osdsurf->Changed() : (osdsurf->GetRevision()!=revision);
    11811181
     1182    if (osdsurf->SurfaceType() == OSDSurface::SURF_YUV)
     1183    {
     1184        YUVSurface *surface = (YUVSurface*)osdsurf;
     1185
    11821186    switch (frame->codec)
    11831187    {
    11841188        case FMT_YV12:
     
    12131217        default:
    12141218            break;
    12151219    }
     1220    }
     1221    else if (osdsurf->SurfaceType() == OSDSurface::SURF_I44)
     1222    {
     1223        I44Surface* surface=(I44Surface*)osdsurf;
     1224
     1225        if (changed)
     1226            surface->BlendToI44( frame->buf, false, stride, XJ_height);
     1227    }
     1228
    12161229    return (changed) ? 1 : 0;
    12171230}
    12181231
  • 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
     
    214218    bool m_scrollinit;
    215219
    216220    float m_linespacing;
     221
     222    Raster_Map *m_raster;
    217223};
    218224   
    219225class OSDTypeImage : public OSDType
     
    247253
    248254    virtual void Draw(OSDSurface *surface, int fade, int maxfade, int xoff,
    249255                      int yoff);
     256    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff,
     257                      int yoff);
     258    void Draw(I44Surface *surface, int fade, int maxfade, int xoff,
     259              int yoff);
    250260
     261// TODO this should not be static -- dtk
     262    static void SetPalette(const QValueList<QColor> &palette)
     263        { s_palette = palette; }
     264// TODO this should not be static -- dtk
     265// TODO QValueList here is unsafe, QValueList is not threadsafe -- dtk
     266    static QValueList<QColor> GetPalette(void) { return s_palette; }
     267
    251268  protected:
    252269    QRect m_imagesize;
    253270    QPoint m_displaypos;
     
    263280
    264281    unsigned char *m_alpha;
    265282
     283    unsigned char *m_i44;
     284
    266285    int m_scalew, m_scaleh;
     286    float m_wmult, m_hmult;
    267287
    268288    int m_drawwidth;
    269289    bool m_onlyusefirst;
     290
     291// Cant think of a clean way to get this to all the osdtypes that need it.
     292// TODO this should not be static -- dtk
     293// TODO QValueList is not threadsafe -- dtk
     294    static QValueList<QColor> s_palette;
    270295};
    271296
    272297class OSDTypePosSlider : public OSDTypeImage
     
    333358    void SetRange(int start, int end);
    334359
    335360    void Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff);
     361    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff, int yoff);
     362    void Draw(I44Surface *surface, int fade, int maxfade, int xoff, int yoff);
    336363
    337364  private:
    338365    QRect m_displayrect;
     
    365392    void SetRect(QRect newrect) { size = newrect; }
    366393
    367394    void Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff);
     395    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff, int yoff);
     396    void Draw(I44Surface *surface, int fade, int maxfade, int xoff, int yoff);
    368397
    369398  private:
    370399    QRect size;
     
    405434    void Reinit(float wchange, float hchange);
    406435
    407436    void Draw(OSDSurface *surface, int fade, int maxfade, int xoff, int yoff);
     437    void Draw(YUVSurface *surface, int fade, int maxfade, int xoff, int yoff);
     438    void Draw(I44Surface *surface, int fade, int maxfade, int xoff, int yoff);
    408439
    409440  private:
    410441    vector<QRect> positions;
  • libs/libmythtv/videoout_xv.cpp

     
    26222622    XvMCOSD* xvmc_osd = GetAvailableOSD();
    26232623    if (osd && xvmc_osd->IsValid())
    26242624    {
     2625        if (osd->HasPalette() && !xvmc_osd->CustomPalette())
     2626        {
     2627            VERBOSE(VB_PLAYBACK, LOC + "Setting XvMC OSD palette");
     2628            xvmc_osd->SetPalette(osd->GetPalette());
     2629        }
     2630
    26252631        VideoFrame *osdframe = NULL;
    26262632        int ret = DisplayOSD(xvmc_osd->OSDFrame(), osd, -1,
    26272633                             xvmc_osd->GetRevision());
     
    33593365    Reinit(next);
    33603366
    33613367    // then blend the OSD onto it
    3362     unsigned char *buf = (unsigned char*) shm_infos[next].shmaddr;
    3363     osdsurf->BlendToARGB(buf, img[next]->bytes_per_line, vf[next].height,
    3364                          false/*blend_to_black*/, 16);
     3368    YUVSurface *yuvsurf = dynamic_cast<YUVSurface*>(osdsurf);
     3369    if (yuvsurf)
     3370    {
     3371        unsigned char *buf = (unsigned char*) shm_infos[next].shmaddr;
     3372        yuvsurf->BlendToARGB(buf, img[next]->bytes_per_line, vf[next].height,
     3373                             false/*blend_to_black*/, 16);
     3374    }
    33653375
    33663376    // then set it as the current OSD image
    33673377    revision = osdsurf->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;
     
    131132    osd_subpict_alloc = true;
    132133}
    133134
     135void XvMCOSD::SetPalette(const QValueList<QColor> &palette)
     136{
     137    int i;
     138    custompalette = true;
     139    int entries = palette.count();
     140
     141    VERBOSE(VB_PLAYBACK, QString("SetPalette entries %1").arg(entries));
     142
     143    if (entries > osd_subpict.num_palette_entries)
     144        entries = osd_subpict.num_palette_entries;
     145    int seb = osd_subpict.entry_bytes;
     146
     147    for (i=0; i<entries; i++)
     148    {
     149        int r = palette[i].red();
     150        int g = palette[i].green();
     151        int b = palette[i].blue();
     152       
     153        int Y = (int)((0.257*r)+(0.504*g)+(0.098*b)+16);
     154        int U = (int)(-(0.148*r)-(0.291*g)+(0.439*b)+128);
     155        int V = (int)((0.439*r)-(0.368*g)-(0.071*b)+128);
     156                       
     157        VERBOSE(VB_PLAYBACK,
     158                QString("Colour: Y=%1 U=%1 V=%1" ).arg(Y).arg(U).arg(V));
     159
     160        for (int j = 0; j < seb; j++)
     161        {
     162            switch (osd_subpict.component_order[j])
     163            {
     164                case 'U': osd_palette[i * seb + j] = U; break;
     165                case 'V': osd_palette[i * seb + j] = V; break;
     166                case 'Y':
     167                    default:  osd_palette[i * seb + j] = Y; break;
     168            }
     169        }
     170    }
     171   
     172    X11S(XvMCSetSubpicturePalette(XJ_disp, &osd_subpict, osd_palette));
     173}
     174
    134175void XvMCOSD::DeleteBuffer()
    135176{
    136177    if (!osd_subpict_alloc)
  • libs/libmythtv/osdsurface.cpp

     
    1111
    1212#endif
    1313
    14 OSDSurface::OSDSurface(int w, int h)
     14OSDSurface::OSDSurface(int w, int h) :
     15    width(std::max(w,0)), height(std::max(h,0)), size(width * height)
    1516{
     17    Clear();
     18}
     19
     20OSDSurface::~OSDSurface()
     21{
     22}
     23
     24void OSDSurface::Clear(void)
     25{
     26    usedRegions = QRegion();
     27}
     28
     29void OSDSurface::ClearUsed(void)
     30{
     31}
     32
     33bool OSDSurface::IntersectsDrawn(QRect &newrect)
     34{
     35    QMemArray<QRect> rects = usedRegions.rects();
     36    QMemArray<QRect>::Iterator it = rects.begin();
     37
     38    for (; it != rects.end(); ++it)
     39    {
     40        if (newrect.intersects(*it))
     41            return true;
     42    }
     43
     44    return false;
     45}
     46
     47void OSDSurface::AddRect(QRect &newrect)
     48{
     49    usedRegions = usedRegions.unite(newrect);
     50}
     51
     52YUVSurface::YUVSurface(int w, int h) :
     53    OSDSurface(w, h)
     54{
    1655    yuvbuffer = new unsigned char[w * (h + 2) * 3 / 2];
    1756    y = yuvbuffer;
    1857    u = yuvbuffer + w * h;
    1958    v = u + w * h / 4;
    2059    alpha = new unsigned char[w * (h + 2)];
    2160
    22     width = w;
    23     height = h;
    24 
    25     size = width * height;
    26 
    2761    for (int i = 0; i < 256; i++)
    2862    {
    2963        for (int j = 0; j < 256; j++)
     
    72106    revision = 0;
    73107}
    74108
    75 OSDSurface::~OSDSurface()
     109YUVSurface::~YUVSurface()
    76110{
    77111    delete [] yuvbuffer;
    78112    delete [] alpha;
    79113}
    80114
    81 void OSDSurface::Clear(void)
     115void YUVSurface::Clear(void)
    82116{
    83117    memset(y, 0, size);
    84118    memset(u, 127, size / 4);
    85119    memset(v, 127, size / 4);
    86120    memset(alpha, 0, size);
    87     usedRegions = QRegion();
     121   
     122    OSDSurface::Clear();
    88123}
    89124
    90 void OSDSurface::ClearUsed(void)
     125void YUVSurface::ClearUsed(void)
    91126{
    92127    QMemArray<QRect> rects = usedRegions.rects();
    93128    QMemArray<QRect>::Iterator it = rects.begin();
     
    127162    }
    128163
    129164    usedRegions = QRegion();
     165   
     166    OSDSurface::Clear();
    130167}
    131168
    132 bool OSDSurface::IntersectsDrawn(QRect &newrect)
    133 {
    134     QMemArray<QRect> rects = usedRegions.rects();
    135     QMemArray<QRect>::Iterator it = rects.begin();
    136     for (; it != rects.end(); ++it)
    137         if (newrect.intersects(*it))
    138             return true;
    139     return false;
    140 }
    141169
    142 void OSDSurface::AddRect(QRect &newrect)
    143 {
    144     usedRegions = usedRegions.unite(newrect);
    145 }
    146 
    147170///////////////////////////////////////////////////////////////////////////
    148171// Helper functions
    149172///////////////////////////////////////////////////////////////////////////
     
    251274}
    252275#endif
    253276
    254 blendtoyv12_8_fun blendtoyv12_8_init(const OSDSurface *surface)
     277blendtoyv12_8_fun blendtoyv12_8_init(const YUVSurface *surface)
    255278{
    256279    (void)surface;
    257280#ifdef MMX
     
    261284    return blendalpha8_c;
    262285}
    263286
    264 static inline void blendtoargb_8_c(const OSDSurface *surf, unsigned char *src,
     287static inline void blendtoargb_8_c(const YUVSurface *surf, unsigned char *src,
    265288                                   unsigned char *usrc, unsigned char *vsrc,
    266289                                   unsigned char *alpha, unsigned char *dest)
    267290{
     
    283306
    284307#ifdef MMX
    285308#define movntq(src, dest) movq_r2m(src, dest);
    286 static inline void blendtoargb_8_mmx(const OSDSurface * /*surf*/, unsigned char *src,
     309static inline void blendtoargb_8_mmx(const YUVSurface * /*surf*/,
     310                                     unsigned char *src,
    287311                                     unsigned char *usrc, unsigned char *vsrc,
    288312                                     unsigned char *alpha, unsigned char *dest)
    289313{
     
    378402}
    379403#endif
    380404
    381 blendtoargb_8_fun blendtoargb_8_init(const OSDSurface *surface)
     405blendtoargb_8_fun blendtoargb_8_init(const YUVSurface *surface)
    382406{
    383407    (void)surface;
    384408#ifdef MMX
     
    494518}
    495519#endif
    496520
    497 dithertoia44_8_fun dithertoia44_8_init(const OSDSurface* /*surface*/)
     521dithertoia44_8_fun dithertoia44_8_init(const YUVSurface* /*surface*/)
    498522{
    499523#ifdef MMX
    500524// mmx version seems to be about the same speed, no reason to use it.
     
    543567    delete context;
    544568}
    545569
    546 /** \fn OSDSurface::BlendToYV12(unsigned char *) const
    547  *  \brief Alpha blends OSDSurface to yuv buffer of the same size.
     570/** \fn YUVSurface::BlendToYV12(unsigned char *) const
     571 *  \brief Alpha blends YUVSurface to yuv buffer of the same size.
    548572 *  \param yuvptr Pointer to YUV buffer to blend OSD to.
    549573 */
    550 void OSDSurface::BlendToYV12(unsigned char *yuvptr) const
     574void YUVSurface::BlendToYV12(unsigned char *yuvptr) const
    551575{
    552     const OSDSurface *surface = this;
     576    const YUVSurface *surface = this;
    553577    blendtoyv12_8_fun blender = blendtoyv12_8_init(surface);
    554578
    555579    unsigned char *uptrdest = yuvptr + surface->width * surface->height;
     
    668692    }
    669693}
    670694
    671 /** \fn OSDSurface::BlendToARGB(unsigned char *,uint,uint,bool) const
    672  *  \brief Alpha blends OSDSurface to ARGB buffer.
     695/** \fn YUVSurface::BlendToARGB(unsigned char *,uint,uint,bool) const
     696 *  \brief Alpha blends YUVSurface to ARGB buffer.
    673697 *
    674698 *  \todo Currently blend_to_black is implemented as a post process
    675699 *        on the whole frame, it would make sense to make this more
     
    680704 *  \param blend_to_black Uses Alpha to blend buffer to black
    681705 *  \param threshold      Alpha threshold above which to perform blending
    682706 */
    683 void OSDSurface::BlendToARGB(unsigned char *argbptr, uint stride,
     707void YUVSurface::BlendToARGB(unsigned char *argbptr, uint stride,
    684708                             uint outheight, bool blend_to_black,
    685709                             uint threshold) const
    686710{
    687     const OSDSurface *surface = this;
     711    const YUVSurface *surface = this;
    688712    blendtoargb_8_fun blender = blendtoargb_8_init(surface);
    689713    const unsigned char *cm = surface->cm;
    690714
     
    756780        BlendToBlack(argbptr, stride>>2, outheight);
    757781}
    758782
    759 /** \fn OSDSurface::DitherToI44(unsigned char*,bool,uint,uint) const
    760  *  \brief Copies and converts OSDSurface to either a greyscale
     783/** \fn YUVSurface::DitherToI44(unsigned char*,bool,uint,uint) const
     784 *  \brief Copies and converts YUVSurface to either a greyscale
    761785 *         IA44 or AI44 buffer.
    762786 *  \sa DitherToIA44(unsigned char*,uint,uint) const,
    763787 *      DitherToAI44(unsigned char*,uint,uint) const.
     
    767791 *  \param stride Length of each line in output buffer in bytes
    768792 *  \param outheight Number of lines in output buffer
    769793 */
    770 void OSDSurface::DitherToI44(unsigned char *outbuf, bool ifirst,
     794void YUVSurface::DitherToI44(unsigned char *outbuf, bool ifirst,
    771795                             uint stride, uint outheight) const
    772796{
    773     const OSDSurface *surface = this;
     797    const YUVSurface *surface = this;
    774798    int ashift = ifirst ? 0 : 4;
    775799    int amask = ifirst ? 0x0f : 0xf0;
    776800
     
    855879    delete_dithertoia44_8_context(dcontext);
    856880}
    857881
    858 /** \fn OSDSurface::DitherToIA44(unsigned char*,uint,uint) const
    859  *  \brief Copies and converts OSDSurface to a greyscale IA44 buffer.
     882/** \fn YUVSurface::DitherToIA44(unsigned char*,uint,uint) const
     883 *  \brief Copies and converts YUVSurface to a greyscale IA44 buffer.
    860884 *
    861885 *  \param outbuf Output buffer
    862886 *  \param stride Length of each line in output buffer in bytes
     
    864888 *  \sa DitherToI44(unsigned char*,bool,uint,uint) const,
    865889 *      DitherToAI44(unsigned char*,uint,uint) const.
    866890 */
    867 void OSDSurface::DitherToIA44(unsigned char* outbuf,
     891void YUVSurface::DitherToIA44(unsigned char* outbuf,
    868892                              uint stride, uint outheight) const
    869893{
    870894    DitherToI44(outbuf, false, stride, outheight);
    871895}
    872896
    873 /** \fn OSDSurface::DitherToAI44(unsigned char*,bool,uint,uint) const
    874  *  \brief Copies and converts OSDSurface to a greyscale AI44 buffer.
     897/** \fn YUVSurface::DitherToAI44(unsigned char*,bool,uint,uint) const
     898 *  \brief Copies and converts YUVSurface to a greyscale AI44 buffer.
    875899 *
    876900 *  \param outbuf Output buffer
    877901 *  \param stride Length of each line in output buffer in bytes
     
    879903 *  \sa DitherToI44(unsigned char*,bool,uint,uint) const,
    880904 *      DitherToIA44(unsigned char*,uint,uint) const.
    881905 */
    882 void OSDSurface::DitherToAI44(unsigned char* outbuf,
     906void YUVSurface::DitherToAI44(unsigned char* outbuf,
    883907                              uint stride, uint outheight) const
    884908{
    885909    DitherToI44(outbuf, true, stride, outheight);
    886910}
     911
     912I44Surface::I44Surface(int w, int h) :
     913    OSDSurface(w,h)
     914{
     915    i44buffer = new unsigned char [size];
     916    Clear();
     917}
     918
     919I44Surface::~I44Surface()
     920{
     921    delete [] i44buffer;
     922}
     923
     924void I44Surface::Clear(void)
     925{
     926    bzero(i44buffer, size);
     927    OSDSurface::Clear();
     928}
     929
     930void I44Surface::ClearUsed(void)
     931{
     932    bzero(i44buffer, size);
     933    OSDSurface::Clear();
     934}
     935
     936void I44Surface::BlendToI44(unsigned char *i44ptr, bool /*ifirst*/,
     937                            uint /*stride*/, uint /*height*/) const
     938{
     939    memcpy(i44ptr, i44buffer, size);
     940}
  • 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#if 0
    3946struct Raster_Map
    4047{
    4148    int width;
     
    4451    int size;
    4552    unsigned char *bitmap;
    4653};
     54#endif
    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   rmap->cols = (m_mono) ? (rmap->width+7) >> 3 : rmap->width;
     119   rmap->size = rmap->rows * rmap->cols;
    108120   if (rmap->size <= 0)
    109121   {
    110122        delete rmap;
     
    202214void TTFFont::render_text(Raster_Map *rmap, Raster_Map *rchr,
    203215                          const QString &text, int *xorblah, int *yor)
    204216{
     217#ifdef TIMING
     218    Timer t("render_text");
     219#endif
     220
    205221   FT_F26Dot6 x, y, xmin, ymin, xmax, ymax;
    206222   FT_BBox bbox;
    207223   unsigned int i, ioff, iread;
     
    248264           origin.x = 0;
    249265           origin.y = 0;
    250266
    251            FT_Glyph_To_Bitmap(&glyphs[j], ft_render_mode_normal, &origin, 1);
     267           FT_Render_Mode rmode;
     268           rmode = m_mono ? ft_render_mode_mono : ft_render_mode_normal;
     269           FT_Glyph_To_Bitmap(&glyphs[j], rmode, &origin, 1);
    252270           bmap = (FT_BitmapGlyph)(glyphs[j]);
    253271
    254272           glyphs_cached[j] = duplicate_raster(bmap);
     
    311329       if (ymax >= rmap->rows)
    312330           ymax = rmap->rows - 1;
    313331
     332       int x_ioff = 0, x_iread=0;
     333
    314334       if (xmin < 0)
    315335       {
    316            iread -= xmin;
     336           x_iread = -xmin;
    317337           xmin = 0;
    318338       }
    319339       else
    320            ioff += xmin;
     340           x_ioff = xmin;
    321341
    322342       if (xmax >= rmap->width)
    323343           xmax = rmap->width - 1;
     
    327347       _read = (char *)rtmp->bitmap + iread;
    328348       _off = (char *)rmap->bitmap + ioff;
    329349
     350       int len = xmax - xmin;
     351       int bytes = len >> 3;
     352
     353       int x_off = x_ioff;
     354
     355       unsigned char last=0, next=0;
     356       unsigned char lmask,nmask=255;
     357
     358       int bit_off = x_off&7;
     359
     360       nmask = nmask >> bit_off;
     361       lmask = 255 ^ nmask;
     362
    330363       for (y = ymin; y <= ymax; y++)
    331364       {
    332365           read = _read;
    333366           off = _off;
    334367
    335            for (x = xmin; x <= xmax; x++)
     368           if (m_mono)
    336369           {
    337                *off = *read;
    338                off++;
    339                read++;
     370               off += (x_off>>3);
     371
     372               int i;
     373               last = *off;
     374               for (i=0; i<=bytes; i++)
     375               {
     376                   __asm__ __volatile__ (
     377                       "movb %b1, %b0; rorb %b2,%b0"
     378                       : "=a"(next):"g"(*read++),"c"(bit_off));
     379               
     380                   *off++ = (last & lmask)|(next & nmask);
     381
     382                   last=next;
     383               }
     384               if (bit_off)
     385                   *off |= last & lmask;
     386
     387// i 16, j 't' xmin 180, xmax 186, x_iread 0, x_ioff 180 iread 34 ioff 594
     388// i 17, j 'c' xmin 188, xmax 197, x_iread 0, x_ioff 188 iread 24 ioff 594
     389// i 18, j 'h' xmin 201, xmax 210, x_iread 0, x_ioff 201 iread 34 ioff 594
    340390           }
     391           else
     392           {
     393               read += x_iread;
     394               off += x_ioff;
     395
     396               for (x = xmin; x <= xmax; x++)
     397               {
     398                   *off = *read;
     399                   off++;
     400                   read++;
     401               }
     402           }
    341403           _read -= rtmp->cols;
    342404           _off -= rmap->cols;
    343405       }
     
    349411    }
    350412}
    351413
    352 void TTFFont::merge_text(OSDSurface *surface, Raster_Map * rmap, int offset_x,
     414void TTFFont::merge_text(I44Surface *surface, Raster_Map * rmap, int offset_x,
    353415                         int offset_y, int xstart, int ystart, int width,
    354416                         int height, int alphamod, kTTF_Color k)
    355417{
     418#ifdef TIMING
     419    Timer t("merge_text i44");
     420#endif
     421
     422    unsigned char *asrc, *adst;
     423    if (xstart < 0)
     424    {
     425        width += xstart;
     426        offset_x -= xstart;
     427        xstart = 0;
     428    }
     429
     430    if (ystart < 0)
     431    {
     432        height += ystart;
     433        offset_y -= ystart;
     434        ystart = 0;
     435    }
     436
     437    if (height + ystart > surface->height)
     438        height = surface->height - ystart;
     439
     440    if (width + xstart > surface->width)
     441        width = surface->width - xstart;
     442
     443    QRect drawRect(xstart, ystart, width, height);
     444    surface->AddRect(drawRect);
     445
     446    int x, y;
     447
     448    asrc = rmap->bitmap;
     449    adst = surface->i44buffer;
     450
     451    asrc += rmap->cols*offset_y+(offset_x>>3);
     452    adst += xstart+ystart*surface->width;
     453
     454    unsigned long col;
     455    switch(k)
     456    {
     457        case kTTF_Normal:
     458                 col = (m_color_normal&0xf)<<4;
     459            break;
     460        case kTTF_Outline:
     461                 col = (m_color_outline&0xf)<<4;
     462            break;
     463        case kTTF_Shadow:
     464                 col = (m_color_shadow&0xf)<<4;
     465            break;
     466    }
     467
     468    if (alphamod>255)
     469        alphamod = 255;
     470    col |= alphamod>>4;
     471
     472    for (y = 0; y<height;y++)
     473    {
     474        char ch;
     475        int j = 0;
     476
     477        for (x = 0; x<width;x++)
     478        {
     479            if ((x&7) == 0)
     480            {
     481                ch = asrc[j++];
     482            }
     483            else
     484            {
     485                ch = ch<<1;
     486            }
     487
     488            if (ch & 0x80)
     489                adst[x] = col;// | 0x0f;
     490        }
     491        asrc += rmap->cols;
     492        adst += surface->width;
     493    }
     494}
     495
     496void TTFFont::merge_text(YUVSurface *surface, Raster_Map * rmap, int offset_x,
     497                         int offset_y, int xstart, int ystart, int width,
     498                         int height, int alphamod, kTTF_Color k)
     499{
    356500    unsigned char * asrc, * ydst, * udst, * vdst, * adst;
    357501    uint8_t color_y = 0, color_u = 0, color_v = 0;
    358502
     
    411555                               surface->pow_lut);
    412556}
    413557
    414 void TTFFont::DrawString(OSDSurface *surface, int x, int y,
    415                          const QString &text, int maxx, int maxy,
    416                          int alphamod)
     558Raster_Map* TTFFont::Prerender(const QString &text)
    417559{
    418    int                  width, height, w, h, inx, iny, clipx, clipy;
    419    Raster_Map          *rmap, *rtmp;
    420    char                 is_pixmap = 0;
     560#ifdef TIMING
     561    Timer t("Prerender");
     562#endif
     563   int inx, iny, w, h;
     564   Raster_Map   *rmap, *rtmp;
     565   char         is_pixmap = 0;
    421566
    422567   if (text.length() < 1)
    423         return;
     568        return 0;
    424569
    425570   inx = 0;
    426571   iny = 0;
     
    429574   if (w <= 0 || h <= 0)
    430575   {
    431576       destroy_font_raster(rtmp);
    432        return;
     577       return 0;
    433578   }
    434579   rmap = create_font_raster(w, h);
    435580
     
    437582
    438583   is_pixmap = 1;
    439584
     585    rmap->m_w = w;
     586    rmap->m_h = h;
     587    rmap->m_inx = inx;
     588    rmap->m_iny = iny;
     589
     590return rmap;
     591}
     592
     593void TTFFont::DrawString(OSDSurface *surface, int x, int y,
     594                         const QString &text, int maxx, int maxy,
     595                         int alphamod )
     596{
     597#ifdef TIMING
     598    Timer t("DrawString");
     599#endif
     600    Raster_Map          *rmap;
     601
     602    int width, height, w, h, inx, iny, clipx, clipy;
     603
     604    if (rasters.contains(text))
     605    {
     606        rmap = rasters[text];
     607    }
     608    else
     609    {
     610        rmap = Prerender(text);
     611        rasters[text] = rmap;
     612    }
     613
     614    if (!rmap)
     615        return;
     616
     617    w = rmap->m_w;
     618    h = rmap->m_h;
     619    inx = rmap->m_inx;
     620    iny = rmap->m_iny;
     621   
    440622   y += loadedfontsize;
    441623   
    442624   width = maxx;
     
    470652     }
    471653   if ((width <= 0) || (height <= 0))
    472654     {
    473         destroy_font_raster(rmap);
    474         destroy_font_raster(rtmp);
    475         return;
     655         return;
    476656     }
    477657
    478658   if (m_shadowxoff > 0 || m_shadowyoff > 0)
    479659   {
    480        merge_text(surface, rmap, clipx, clipy, x + m_shadowxoff,
    481                   y + m_shadowyoff, width, height, alphamod, kTTF_Shadow);
     660       if (surface->SurfaceType() == OSDSurface::SURF_YUV)
     661       {
     662           merge_text((YUVSurface*)surface, rmap, clipx, clipy,
     663                      x + m_shadowxoff, y + m_shadowyoff,
     664                      width, height, alphamod, kTTF_Shadow);
     665       }
     666       else if (surface->SurfaceType() == OSDSurface::SURF_I44)
     667       {
     668           merge_text((I44Surface*)surface, rmap, clipx, clipy,
     669                      x + m_shadowxoff, y + m_shadowyoff,
     670                      width, height, alphamod, kTTF_Shadow);
     671       }
    482672   }
    483673
    484674   if (m_outline)
    485675   {
    486        merge_text(surface, rmap, clipx, clipy, x - 1, y - 1, width, height,
    487                   alphamod, kTTF_Outline);
    488        merge_text(surface, rmap, clipx, clipy, x + 1, y - 1, width, height,
    489                   alphamod, kTTF_Outline);
    490        merge_text(surface, rmap, clipx, clipy, x - 1, y + 1, width, height,
    491                   alphamod, kTTF_Outline);
    492        merge_text(surface, rmap, clipx, clipy, x + 1, y + 1, width, height,
    493                   alphamod, kTTF_Outline);
     676       if (surface->SurfaceType() == OSDSurface::SURF_YUV)
     677       {
     678           merge_text((YUVSurface*)surface, rmap, clipx, clipy,
     679                      x - 1, y - 1, width, height,
     680                      alphamod, kTTF_Outline);
     681           merge_text((YUVSurface*)surface, rmap, clipx, clipy,
     682                      x + 1, y - 1, width, height,
     683                      alphamod, kTTF_Outline);
     684           merge_text((YUVSurface*)surface, rmap, clipx, clipy,
     685                      x - 1, y + 1, width, height,
     686                      alphamod, kTTF_Outline);
     687           merge_text((YUVSurface*)surface, rmap, clipx, clipy,
     688                      x + 1, y + 1, width, height,
     689                      alphamod, kTTF_Outline);
     690       }
     691       else if (surface->SurfaceType() == OSDSurface::SURF_I44)
     692       {
     693           merge_text((I44Surface*)surface, rmap, clipx, clipy,
     694                      x - 1, y - 1, width, height,
     695                      alphamod, kTTF_Outline);
     696           merge_text((I44Surface*)surface, rmap, clipx, clipy,
     697                      x + 1, y - 1, width, height,
     698                      alphamod, kTTF_Outline);
     699           merge_text((I44Surface*)surface, rmap, clipx, clipy,
     700                      x - 1, y + 1, width, height,
     701                      alphamod, kTTF_Outline);
     702           merge_text((I44Surface*)surface, rmap, clipx, clipy,
     703                      x + 1, y + 1, width, height,
     704                      alphamod, kTTF_Outline);
     705
     706       }
    494707   }
    495708
    496    merge_text(surface, rmap, clipx, clipy, x, y, width, height, alphamod);
    497 
    498    destroy_font_raster(rmap);
    499    destroy_font_raster(rtmp);
     709   if (surface->SurfaceType() == OSDSurface::SURF_YUV)
     710   {
     711       merge_text((YUVSurface*)surface, rmap, clipx, clipy,
     712                  x, y, width, height, alphamod);
     713   }
     714   else if (surface->SurfaceType() == OSDSurface::SURF_I44)
     715   {
     716       merge_text((I44Surface*)surface, rmap, clipx, clipy,
     717                  x, y, width, height, alphamod);
     718   }
    500719}
    501720
    502721TTFFont::~TTFFont()
    503722{
    504    if (!valid)
    505        return;
     723    QMap<QString,Raster_Map*>::Iterator it;
     724    for (it = rasters.begin(); it != rasters.end(); ++it)
     725        destroy_font_raster(*it);
    506726
    507    KillFace();
     727    if (!valid)
     728        return;
     729
     730    KillFace();
    508731}
    509732
    510733void TTFFont::KillFace(void)
     
    526749}
    527750
    528751TTFFont::TTFFont(char *file, int size, int video_width, int video_height,
    529                  float hmult)
     752                 float hmult, bool mono)
    530753{
    531754   FT_Error            error;
    532755
     
    534757   m_size = size;
    535758   spacewidth = 0;
    536759
     760   m_mono = mono;
    537761   m_outline = false;
    538762   m_shadowxoff = 0;
    539763   m_shadowyoff = 0;
    540764
    541765   m_color_normal_y = 255;
     766   m_color_normal = 255;
    542767   m_color_normal_u = m_color_normal_v = 128;
    543768
    544769   m_color_outline_y = 0x40;
     770   m_color_outline = 0x40;
    545771   m_color_outline_u = m_color_outline_v = 128;
    546772
    547773   m_color_shadow_y = 0x20;
     774   m_color_shadow = 0x20;
    548775   m_color_shadow_u = m_color_shadow_v = 128;
    549776
    550777   if (!have_library)
  • libs/libmythtv/osd.cpp

     
    2929
    3030OSD::OSD(int width, int height, int frint,
    3131         int dispx, int dispy, int dispw, int disph)
    32    : QObject()
     32   : QObject(NULL, "osd")
    3333{
     34    hasPalette = false;
    3435    changed = false;
    3536    vid_width = width;
    3637    vid_height = height;
     
    7576
    7677    SetDefaults();
    7778
    78     drawSurface = new OSDSurface(width, height);
     79    if (surftype == "I44")
     80        drawSurface = new I44Surface(width, height);
     81    else //default to normal YUV
     82        drawSurface = new YUVSurface(width, height);
    7983}
    8084
    8185OSD::~OSD(void)
     
    245249    }
    246250
    247251    delete drawSurface;
    248     drawSurface = new OSDSurface(width, height);
    249252
     253    if (surftype == "I44")
     254        drawSurface = new I44Surface(width, height);
     255    else //default to normal YUV
     256        drawSurface = new YUVSurface(width, height);
     257
    250258    osdlock.unlock();
    251259}
    252260
     
    274282TTFFont *OSD::LoadFont(QString name, int size)
    275283{
    276284    QString fullname = MythContext::GetConfDir() + "/" + name;
     285    bool mono = (surftype == "I44");
    277286    TTFFont *font = new TTFFont((char *)fullname.ascii(), size, vid_width,
    278                                 vid_height, hmult);
     287                                vid_height, hmult, mono);
    279288
    280289    if (font->isValid())
    281290        return font;
     
    284293    fullname = gContext->GetShareDir() + name;
    285294
    286295    font = new TTFFont((char *)fullname.ascii(), size, vid_width,
    287                        vid_height, hmult);
     296                       vid_height, hmult, mono);
    288297
    289298    if (font->isValid())
    290299        return font;
     
    294303    {
    295304        fullname = themepath + "/" + name;
    296305        font = new TTFFont((char *)fullname.ascii(), size, vid_width,
    297                            vid_height, hmult);
     306                           vid_height, hmult, mono);
    298307        if (font->isValid())
    299308            return font;
    300309    }
     
    303312
    304313    fullname = name;
    305314    font = new TTFFont((char *)fullname.ascii(), size, vid_width, vid_height,
    306                        hmult);
     315                       hmult, mono);
    307316
    308317    if (font->isValid())
    309318        return font;
     
    327336    return "";
    328337}
    329338
     339void OSD::parsePalette(QDomElement &element)
     340{
     341    hasPalette = true;
     342
     343    for (QDomNode child = element.firstChild(); !child.isNull();
     344         child = child.nextSibling())
     345    {
     346        QDomElement node = child.toElement();
     347
     348        if (node.isNull())
     349            continue;
     350
     351        if (node.tagName() != "rgb")
     352        {
     353            VERBOSE(VB_IMPORTANT, QString("Unknown tag '%1' in colour node")
     354                    .arg(node.tagName()));
     355            continue;
     356        }
     357
     358        int r, g, b;
     359        QString text = getFirstText(node);
     360        if (sscanf(text.data(), "%d,%d,%d", &r, &g, &b) != 3)
     361        {
     362            VERBOSE(VB_IMPORTANT, QString("Badly formed rgb node '%1'")
     363                    .arg(text.data()));
     364            continue;
     365        }
     366
     367        // Success! Add new color to the palette.
     368        surfPalette.append(QColor(r,g,b));
     369    }
     370}
     371
    330372void OSD::parseFont(QDomElement &element)
    331373{
    332374    QString name;
     
    11961238            {
    11971239                parseContainer(e);
    11981240            }
     1241            else if (e.tagName() == "surface")
     1242            {
     1243                surftype = getFirstText(e);
     1244            }
     1245            else if (e.tagName() == "palette")
     1246            {
     1247                parsePalette(e);
     1248                OSDTypeImage::SetPalette(surfPalette);
     1249            }
    11991250            else
    12001251            {
    12011252                VERBOSE(VB_IMPORTANT, "Unknown element: " << e.tagName());
  • 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,
     
    4591    void DitherToIA44(unsigned char* outbuf, uint stride, uint height) const;
    4692    void DitherToAI44(unsigned char* outbuf, uint stride, uint height) const;
    4793
    48     int revision;
    49 
    5094    unsigned char *yuvbuffer;
    5195
    5296    // just pointers into yuvbuffer
     
    56100
    57101    unsigned char *alpha;
    58102
    59     int width;
    60     int height;
    61     int size;
    62 
    63     QRegion usedRegions;
    64 
    65103#ifdef MMX
    66104    short int rec_lut[256];
    67105#else
     
    75113    blendcolor_ptr blendcolorfunc;
    76114    blendconst_ptr blendconstfunc;
    77115
    78     bool changed;
    79 
    80116    bool usemmx;
    81117
    82118    unsigned char cropTbl[256 + 2 * MAX_NEG_CROP];
     
    86122typedef void (*blendtoyv12_8_fun)(unsigned char *src, unsigned char *dest,
    87123                                  unsigned char *alpha, bool uvplane);
    88124
    89 blendtoyv12_8_fun blendtoyv12_8_init(const OSDSurface *surface);
     125blendtoyv12_8_fun blendtoyv12_8_init(const YUVSurface *surface);
    90126
    91 typedef void (*blendtoargb_8_fun)(const OSDSurface *surf, unsigned char *src,
     127typedef void (*blendtoargb_8_fun)(const YUVSurface *surf, unsigned char *src,
    92128                                  unsigned char *usrc, unsigned char *vsrc,
    93129                                  unsigned char *alpha, unsigned char *dest);
    94130
    95 blendtoargb_8_fun blendtoargb_8_init(const OSDSurface *surface);
     131blendtoargb_8_fun blendtoargb_8_init(const YUVSurface *surface);
    96132           
    97133
    98134struct dither8_context;
     
    102138                                   const unsigned char *dmp, int xpos,
    103139                                   dither8_context *context);
    104140
    105 dithertoia44_8_fun dithertoia44_8_init(const OSDSurface *surface);
     141dithertoia44_8_fun dithertoia44_8_init(const YUVSurface *surface);
    106142dither8_context *init_dithertoia44_8_context(bool first);
    107143void delete_dithertoia44_8_context(dither8_context *context);
    108144
  • libs/libmythtv/ttfont.h

     
    1717
    1818struct Raster_Map;
    1919class OSDSurface;
     20class YUVSurface;
     21class I44Surface;
    2022
    2123enum kTTF_Color {
    2224    kTTF_Normal = 0,
     
    2426    kTTF_Shadow,
    2527};
    2628
     29struct Raster_Map
     30{
     31    int width;
     32    int rows;
     33    int cols;
     34    int size;
     35    unsigned char *bitmap;
     36    int m_w;
     37    int m_h;
     38    int m_inx;
     39    int m_iny;
     40};
     41
    2742class TTFFont
    2843{
    2944  public:
    3045     TTFFont(char *file, int size, int video_width, int video_height,
    31              float hmult);
     46             float hmult, bool mono);
    3247    ~TTFFont();
    3348
    3449     // Actually greyscale, keep for compat.
     
    4156
    4257     bool isValid(void) { return valid; }
    4358
     59     Raster_Map* Prerender(const QString &text );
    4460     void DrawString(OSDSurface *surface, int x, int y, const QString &text,
    4561                     int maxx, int maxy, int alphamod = 255);
    4662     void CalcWidth(const QString &text, int *width_return);
     
    5066
    5167     void Reinit(int width, int height, float hmult);
    5268
     69     static void destroy_font_raster(Raster_Map *rmap);
     70
    5371  private:
    5472     void KillFace(void);
    5573     void Init(void);
     
    5775     Raster_Map *create_font_raster(int width, int height);
    5876     Raster_Map *duplicate_raster(FT_BitmapGlyph bmap);
    5977     void clear_raster(Raster_Map *rmap);
    60      void destroy_font_raster(Raster_Map *rmap);
    6178     Raster_Map *calc_size(int *width, int *height, const QString &text);
    6279     void render_text(Raster_Map *rmap, Raster_Map *rchr, const QString &text,
    63                       int *xorblah, int *yor);
    64      void merge_text(OSDSurface *surface, Raster_Map *rmap, int offset_x,
     80                      int *xorblah, int *yor );
     81     void merge_text(YUVSurface *surface, Raster_Map *rmap, int offset_x,
    6582                     int offset_y, int xstart, int ystart, int width,
    6683                     int height, int alphamod, kTTF_Color k = kTTF_Normal);
     84     void merge_text(I44Surface *surface, Raster_Map *rmap, int offset_x,
     85                     int offset_y, int xstart, int ystart, int width,
     86                     int height, int alphamod, kTTF_Color k = kTTF_Normal);
    6787     bool cache_glyph(unsigned short c);
    6888
    6989     bool         valid;
     
    88108     uint8_t m_color_normal_y;
    89109     uint8_t m_color_normal_u;
    90110     uint8_t m_color_normal_v;
     111     uint8_t m_color_normal;
    91112
    92113     uint8_t m_color_outline_y;
    93114     uint8_t m_color_outline_u;
    94115     uint8_t m_color_outline_v;
     116     uint8_t m_color_outline;
    95117
    96118     uint8_t m_color_shadow_y;
    97119     uint8_t m_color_shadow_u;
    98120     uint8_t m_color_shadow_v;
     121     uint8_t m_color_shadow;
    99122
    100123     QString m_file;
    101124
    102125     int loadedfontsize;
    103126     float m_hmult;
     127   
     128    bool m_mono;
     129
     130    QMap<QString, Raster_Map *> rasters;
     131
    104132};
    105133
    106134#endif