]> git.vomp.tv Git - vompclient.git/blob - surfacevector.cc
Compile fixes for stretch
[vompclient.git] / surfacevector.cc
1 /*
2     Copyright 2012 Marten Richter
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software
18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20
21 #include "surfacevector.h"
22 #include "bitmap.h"
23 #include "staticartwork.h"
24 #include <wchar.h>
25 #include <stdlib.h>
26 #include <math.h>
27
28 SurfaceVector::SurfaceVector(OsdVector* vosd)
29 {
30
31         osd=vosd;
32         commands.reserve(2048);
33 }
34
35 SurfaceVector::~SurfaceVector()
36 {
37         osd->removeSurface(this);
38         vector<SVGCommand>::iterator itty=commands.begin();
39         while (itty!=commands.end())
40         {
41                 osd->removeStyleRef((*itty).getRef()); // We remove the Style reference, so that osd can free stuff
42                 ImageIndex ii=(*itty).getImageIndex();
43                 if (ii) {
44                         osd->removeImageRef(ii);
45                 }
46                 LoadIndex li=(*itty).getLoadIndex();
47                 if (li) osd->removeLoadIndexRef(li);
48                 itty++;
49         }
50 }
51
52
53 int SurfaceVector::getFontHeight()
54 {
55         return (int)osd->getFontHeight();
56 }
57
58 float SurfaceVector::getCharWidth(wchar_t c)
59 {
60         return osd->getCharWidth(c);
61 }
62
63
64 int SurfaceVector::drawText(const char* text, int x, int y, const DrawStyle& c){
65         return drawText(text, x, y, 0, c);
66 }
67
68 int SurfaceVector::drawText(const char* text, int x, int y, int width, const DrawStyle& c)
69 {
70         float shift=0.;
71         const char *run=text;
72         size_t length=strlen(text);
73
74         
75         command_mutex.Lock();
76         
77         VectorHandle ref=osd->getStyleRef(c);
78         float *charwidtharray=osd->getCharWidthArray();
79         int commands_size=commands.size();
80         int chars=0;
81         commands.resize(commands_size+strlen(text));
82 #ifndef WIN32
83         mbstate_t state;
84         wchar_t tempo;
85         size_t num_bytes = 1;
86         memset((void*)&state,0,sizeof(state));
87         num_bytes=mbrtowc(&tempo, run, length, &state);
88
89         while (num_bytes!=((size_t) -1) && num_bytes!=((size_t) -2) && length>0)
90         {
91                 SVGCommand::PaintGlyph(commands[commands_size+chars],x+shift,y,tempo,ref);
92                 chars++;
93
94                 float cur_shift=charwidtharray[tempo & 0xFF];
95                 if (tempo && 0xFFFFFF00) cur_shift=osd->getCharWidth(tempo);
96                 shift+=cur_shift;
97                 length -= num_bytes;
98                 run += num_bytes;
99                 if (shift>width && width >0) {
100                         command_mutex.Unlock();
101                         return 1;
102                 }
103                 num_bytes=mbrtowc(&tempo, run, length, &state);
104         }
105
106 #else
107         wchar_t* temptext = new wchar_t[length + 1];
108         int real_length = MultiByteToWideChar(CP_UTF8, 0, text, -1,
109                 temptext, length + 1)-1;
110         for (int i = 0; i < real_length; i++) {
111                 SVGCommand::PaintGlyph(commands[commands_size + chars], x + shift, y, temptext[i], ref);
112                 chars++;
113
114                 float cur_shift = charwidtharray[temptext[i] & 0xFF];
115                 if (temptext[i] && 0xFFFFFF00) cur_shift = osd->getCharWidth(temptext[i]);
116                 shift += cur_shift;
117         }
118         delete[] temptext;
119 #endif
120
121         commands.resize(commands_size+chars);
122         command_mutex.Unlock();
123         return 1;
124
125 }
126 int SurfaceVector::drawTextRJ(const char* text, int x, int y, const DrawStyle& c)
127 {
128         float shift=0.;
129         const char *run=text;
130         size_t length=strlen(text);
131
132 #ifndef WIN32
133         mbstate_t state;
134         wchar_t tempo[1];
135         size_t num_bytes = 1;
136         memset((void*)&state,0,sizeof(state));
137         num_bytes=mbrtowc(tempo, run, length, &state);
138         while (num_bytes!=((size_t) -1) && num_bytes!=((size_t) -2) && length>0)
139         {
140                 shift+=osd->getCharWidth(*tempo);
141                 length -= num_bytes;
142                 run += num_bytes;
143                 num_bytes=mbrtowc(tempo, run, length, &state);
144         }
145 #else
146         wchar_t* temptext=new wchar_t[length+1];
147         int real_length=MultiByteToWideChar(CP_UTF8, 0, text, -1,
148                 temptext, length+ 1)-1;
149         for (int i = 0; i < real_length; i++) {
150                 shift += osd->getCharWidth(temptext[i]);
151         }
152         delete[] temptext;
153 #endif
154         return drawText(text, (int)(x-shift), y, c);
155 }
156
157 int SurfaceVector::drawTextCentre(const char* text, int x, int y, const DrawStyle& c)
158 {
159         float shift=0;
160         const char *run=text;
161         size_t length=strlen(text);
162
163 #ifndef WIN32
164         mbstate_t state;
165         wchar_t tempo[1];
166         size_t num_bytes = 1;
167         memset((void*)&state,0,sizeof(state));
168         num_bytes=mbrtowc(tempo, run, length, &state);
169         while (num_bytes!=((size_t) -1) && num_bytes!=((size_t) -2) && length>0)
170         {
171                 shift+=osd->getCharWidth(*tempo);
172                 length -= num_bytes;
173                 run += num_bytes;
174                 num_bytes=mbrtowc(tempo, run, length, &state);
175         }
176 #else 
177         wchar_t* temptext = new wchar_t[length + 1];
178         int real_length = MultiByteToWideChar(CP_UTF8, 0, text, -1,
179                 temptext, length + 1)-1;
180         for (int i = 0; i < real_length; i++) {
181                 shift += osd->getCharWidth(temptext[i]);
182         }
183         delete[] temptext;
184 #endif
185
186         return drawText(text, (int)(x-shift/2.),  y, c);
187 }
188
189 void SurfaceVector::drawJpeg(const char *fileName,int x, int y,int *width, int *height)
190 {
191         StaticArtwork index=sa_MAX; // This is for compatibility only
192         if (strcmp(fileName,"/vdr.jpg")==0) {
193                 index=sa_vdrlogo;
194                 *height=100; // this is faked so that the system does use the old coordinate system
195                 *width=(int)ceil(190.f*osd->getPixelAspect());
196         } else if (strcmp(fileName,"/wallpaperPAL.jpg")==0) {
197                 index=sa_wallpaper;
198                 *width=720; // this is faked so that the system does use the old coordinate system
199                 *height=576;
200         }
201         if (index!=sa_MAX) {
202                 TVMediaInfo info;
203                 info.setStaticArtwork(index);
204                 drawTVMedia(info,x,y,*width,*height,TopLeft);
205         }
206 }
207
208 /*
209 void SurfaceVector::drawJpeg(const char *fileName,int x, int y,int *width, int *height)
210 {
211         command_mutex.Lock();
212         ImageIndex image=osd->getJpegRef(fileName,width,height);
213         commands.push_back(SVGCommand::PaintImage(x,y,*width,*height,image,0));
214         command_mutex.Unlock();
215 }
216 */
217
218 void SurfaceVector::drawTVMedia(TVMediaInfo & tvmedia,float x, float y, float  width, float height, Corner corner)
219 {
220         command_mutex.Lock();
221         ImageIndex image=0;
222         LoadIndex load_index=osd->getTVMediaRef(tvmedia,image);
223         if (width!=0 && height!=0) {
224                 removeCommands(x,y,width,height);
225         }
226         if (image) {
227                 //Log::getInstance()->log("SurfaceVector", Log::DEBUG, "TVMedia Add instru image %d %d", load_index,image);
228                 commands.push_back(SVGCommand::PaintImage(x,y,width,height,image,0,corner));
229         } else {
230
231                 commands.push_back(SVGCommand::PaintImageLoading(load_index,x,y,width,height,0,corner));
232                 //Log::getInstance()->log("SurfaceVector", Log::DEBUG, "TVMedia Add instru image loading %d %d", load_index,image);
233         }
234         command_mutex.Unlock();
235 }
236
237 void SurfaceVector::drawClippingRectangle(float x, float y, float w, float h)
238 {
239         command_mutex.Lock();
240         commands.push_back(SVGCommand::PaintClipping((float)x,(float)y,(float)w,(float)h));
241         command_mutex.Unlock();
242 }
243
244 int SurfaceVector::create(UINT width, UINT height)
245 {
246         sheight=height;
247         swidth=width;
248         return 1;
249 }
250 void SurfaceVector::display()
251 {
252         //nothing this is really mvp specific
253 }
254
255 int SurfaceVector::fillblt(int x, int y, int width, int height, const DrawStyle& c)
256 {
257         command_mutex.Lock();
258         removeCommands(x,y,width,height); // remove commands below the box
259         VectorHandle ref=osd->getStyleRef(c);
260         commands.push_back(SVGCommand::PaintPath(x,y,width,height,PIRectangle,ref));
261         command_mutex.Unlock();
262         return 1;
263
264 }
265 void SurfaceVector::drawHorzLine(int x1, int x2, int y, const DrawStyle& c)
266 {
267         command_mutex.Lock();
268         VectorHandle ref = osd->getStyleRef(c);
269         commands.push_back(SVGCommand::PaintPath(x1,y,x2-x1,1,PIHorzLine,ref));
270         command_mutex.Unlock();
271 }
272
273 void SurfaceVector::drawVertLine(int x, int y1, int y2, const DrawStyle& c){
274         command_mutex.Lock();
275         VectorHandle ref = osd->getStyleRef(c);
276         commands.push_back(SVGCommand::PaintPath(x,y1,1,y2-y1,PIVertLine,ref));
277         command_mutex.Unlock();
278 }
279
280 void SurfaceVector::drawBitmap(int x, int y, const Bitmap& bm,const DisplayRegion & region)
281 {
282         //this is complicated
283         command_mutex.Lock();
284 /*
285         unsigned int * data=(unsigned int*)malloc(sizeof(unsigned int)*bm.getWidth()*bm.getHeight());
286         for (UINT j = 0; j < bm.getHeight(); ++j){
287            for (UINT i = 0; i < bm.getWidth(); ++i)
288            {
289                    data[i+j*bm.getHeight()]=bm.getColour(i,j);
290            }
291     }*/
292         ImageIndex image=osd->getImagePalette(bm.getWidth(),bm.getHeight(),&(bm.rawData()[0]),
293                         (const unsigned int*)&bm.palette.getColourVector()[0]); // data is freed by the OSD
294         //free(data);
295         float tx=x+region.windowx;
296         float ty=y+region.windowy;
297         float th=bm.getHeight();
298         float tw=bm.getWidth();
299
300         float scalex=720.f/((float) (region.framewidth+1));
301         float scaley=576.f/((float) (region.frameheight+1));
302         tx*=scalex;
303         ty*=scaley;
304         tw*=scalex;
305         th*=scaley;
306         SVGCommand temp=SVGCommand::PaintImage(tx,ty,tw,th,image,0);
307         removeCommands(tx,ty,tw,th);
308         commands.push_back(temp);
309         command_mutex.Unlock();
310 }
311
312 void SurfaceVector::drawPoint(int x, int y, DrawStyle& c, bool fastdraw){
313         if (!fastdraw) command_mutex.Lock();
314         VectorHandle ref = osd->getStyleRef(c);
315         commands.push_back(SVGCommand::PaintPath(x,y,1,1,PIPoint,ref));
316         if (!fastdraw)  command_mutex.Unlock();
317 }
318 void SurfaceVector::drawMonoBitmap(UCHAR* base, int dx, int dy, unsigned int height,unsigned int width, DrawStyle& nextColour)
319 {
320         command_mutex.Lock();
321         ImageIndex image=osd->getMonoBitmapRef(base,width,height);
322         VectorHandle ref = osd->getStyleRef(nextColour);
323         removeCommands(dx,dy,width,height);
324         commands.push_back(SVGCommand::PaintImage(dx,dy,height,width,image,ref));
325         command_mutex.Unlock();
326 }
327
328
329 int SurfaceVector::removeCommands(float x,float y,float width,float height)
330 {
331         // we iterate through all old commands in order to remove commands hidden by this rectangle
332         vector<SVGCommand>::iterator itty=commands.begin();
333         vector<SVGCommand>::iterator remstart;
334         bool remove=false;
335         float cx, cy, cw, ch;
336         cx = cy = 0.f;
337         cw = swidth;
338         ch = sheight;
339         bool clipping_erases = false;
340         while (itty!=commands.end())
341         {
342                 if ((clipping_erases // test if clipping helps
343                         || (*itty).Test(x,y,width,height)  )
344                         && (*itty).instr != DrawClipping) {
345                         //Log::getInstance()->log("OSD", Log::DEBUG, "Remove command %d %g %g %g %g %d %d",(*itty).instr,
346                         //(*itty).x,(*itty).y,(*itty).w,(*itty).h,(*itty).reference,(*itty).target.image);
347                         osd->removeStyleRef((*itty).getRef()); // We remove the Style reference, so that osd can free stuff
348                         ImageIndex ii=(*itty).getImageIndex();
349                         if (ii) osd->removeImageRef(ii);
350                         LoadIndex li=(*itty).getLoadIndex();
351                         if (li) osd->removeLoadIndexRef(li);
352                         if (!remove)  {
353                                 remstart=itty;
354                                 remove=true;
355                         }
356                 } else { 
357                         if ((*itty).instr == DrawClipping) {
358                                 if ((*itty).w == 0.f && (*itty).h == 0.f) {
359                                         cx = cy = 0.f;
360                                         cw = swidth;
361                                         ch = sheight;
362
363                                 } else {
364                                         cx = (*itty).x;
365                                         cy = (*itty).y;
366                                         cw = (*itty).w;
367                                         ch = (*itty).h;
368                                 }
369                                 clipping_erases = (cx >= x) && (cy >= y) && ((cx + cw) <= (x + width)) && ((cy + ch) <= (y + height));
370                         }
371                         if (remove) {
372                                 itty=commands.erase(remstart,itty);
373                                 remove=false;
374                         }
375                 }
376                 itty++;
377         }
378         if (remove) {
379                 itty=commands.erase(remstart,itty);
380         }
381         return 1;
382
383 }
384
385 int SurfaceVector::updateToScreen(int sx, int sy, int w, int h, int dx, int dy)
386 {
387         // ok this method really works in a pixel oriented way
388         command_mutex.Lock();
389         osd->updateOrAddSurface(this,dx-sx,dy-sy,swidth,sheight,commands);
390         command_mutex.Unlock();
391         return 1;
392 }
393
394
395 /* This is for systems which need a locking of the drawing surface to speed up drawing */
396 void SurfaceVector::startFastDraw() {
397         command_mutex.Lock();
398 }
399 void SurfaceVector::endFastDraw() {
400         command_mutex.Unlock();
401 }
402
403
404 void SurfaceVector::drawTTChar(int ox, int oy,int x, int y, cTeletextChar c)
405 {
406         command_mutex.Lock();
407         vector<SVGCommand>::iterator itty=commands.begin();
408         while (itty!=commands.end())
409         {
410                 if ((*itty).TTTest(ox,oy,x,y) ) {
411                         itty=commands.erase(itty);
412                         break;
413                 } else {
414                         itty++;
415                 }
416         }
417         commands.push_back(SVGCommand::PaintTTchar(ox,oy,x,y,c.getInternal()));
418         command_mutex.Unlock();
419 }