]> git.saurik.com Git - wxWidgets.git/blob - src/dfb/bitmap.cpp
document On{Open,Save}Document()
[wxWidgets.git] / src / dfb / bitmap.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/dfb/bitmap.cpp
3 // Purpose: wxBitmap implementation
4 // Author: Vaclav Slavik
5 // Created: 2006-08-04
6 // RCS-ID: $Id$
7 // Copyright: (c) 2006 REA Elektronik GmbH
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // For compilers that support precompilation, includes "wx.h".
12 #include "wx/wxprec.h"
13
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #ifndef WX_PRECOMP
19 #include "wx/app.h"
20 #include "wx/log.h"
21 #endif
22
23 #include "wx/bitmap.h"
24 #include "wx/colour.h"
25 #include "wx/image.h"
26 #include "wx/rawbmp.h"
27
28 #include "wx/dfb/private.h"
29
30 //-----------------------------------------------------------------------------
31 // helpers
32 //-----------------------------------------------------------------------------
33
34 // NB: Most of this conversion code is needed because of differences between
35 // wxImage and wxDFB's wxBitmap representations:
36 // (1) wxImage uses RGB order, while DirectFB uses BGR
37 // (2) wxImage has alpha channel in a separate plane, while DirectFB puts
38 // all components into single BGRA plane
39
40 // pitch = stride = # of bytes between the start of N-th line and (N+1)-th line
41 // {Src,Dst}PixSize = # of bytes used to represent one pixel
42 template<int SrcPixSize, int DstPixSize>
43 static void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
44 const unsigned char *src,
45 unsigned src_pitch,
46 unsigned char *dst,
47 unsigned dst_pitch)
48 {
49 unsigned src_advance = src_pitch - SrcPixSize * w;
50 unsigned dst_advance = dst_pitch - DstPixSize * w;
51 for ( unsigned y = 0; y < h; y++, src += src_advance, dst += dst_advance )
52 {
53 for ( unsigned x = 0; x < w; x++, src += SrcPixSize, dst += DstPixSize )
54 {
55 // copy with RGB -> BGR translation:
56 dst[0] = src[2];
57 dst[1] = src[1];
58 dst[2] = src[0];
59 }
60 }
61 }
62
63 static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
64 wxImage& image)
65 {
66 wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
67 wxCHECK_RET( locked.ptr, "failed to lock surface" );
68
69 const unsigned width = image.GetWidth();
70 const unsigned height = image.GetHeight();
71 const DFBSurfacePixelFormat format = surface->GetPixelFormat();
72
73 // copy RGB data from the surface:
74 switch ( format )
75 {
76 case DSPF_RGB24:
77 CopyPixelsAndSwapRGB<3,3>
78 (
79 width, height,
80 (unsigned char*)locked.ptr, locked.pitch,
81 image.GetData(), width * 3
82 );
83 break;
84
85 case DSPF_RGB32:
86 case DSPF_ARGB:
87 CopyPixelsAndSwapRGB<4,3>
88 (
89 width, height,
90 (unsigned char*)locked.ptr, locked.pitch,
91 image.GetData(), width * 3
92 );
93 break;
94
95 default:
96 wxFAIL_MSG( "unexpected pixel format" );
97 return;
98 }
99
100 // extract alpha channel if the bitmap has it:
101 if ( format == DSPF_ARGB )
102 {
103 // create alpha plane:
104 image.SetAlpha();
105
106 // and copy alpha data to it:
107 const unsigned advance = locked.pitch - 4 * width;
108 unsigned char *alpha = image.GetAlpha();
109 // NB: "+3" is to get pointer to alpha component
110 const unsigned char *src = ((unsigned char*)locked.ptr) + 3;
111
112 for ( unsigned y = 0; y < height; y++, src += advance )
113 for ( unsigned x = 0; x < width; x++, src += 4 )
114 *(alpha++) = *src;
115 }
116 }
117
118 static void CopyImageToSurface(const wxImage& image,
119 const wxIDirectFBSurfacePtr& surface)
120 {
121 wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
122 wxCHECK_RET( locked.ptr, "failed to lock surface" );
123
124 const unsigned width = image.GetWidth();
125 const unsigned height = image.GetHeight();
126 const DFBSurfacePixelFormat format = surface->GetPixelFormat();
127
128 // copy RGB data to the surface:
129 switch ( format )
130 {
131 case DSPF_RGB24:
132 CopyPixelsAndSwapRGB<3,3>
133 (
134 width, height,
135 image.GetData(), width * 3,
136 (unsigned char*)locked.ptr, locked.pitch
137 );
138 break;
139
140 case DSPF_RGB32:
141 case DSPF_ARGB:
142 CopyPixelsAndSwapRGB<3,4>
143 (
144 width, height,
145 image.GetData(), width * 3,
146 (unsigned char*)locked.ptr, locked.pitch
147 );
148 break;
149
150 default:
151 wxFAIL_MSG( "unexpected pixel format" );
152 return;
153 }
154
155 // if the image has alpha channel, merge it in:
156 if ( format == DSPF_ARGB )
157 {
158 wxCHECK_RET( image.HasAlpha(), "logic error - ARGB, but no alpha" );
159
160 const unsigned advance = locked.pitch - 4 * width;
161 const unsigned char *alpha = image.GetAlpha();
162 // NB: "+3" is to get pointer to alpha component
163 unsigned char *dest = ((unsigned char*)locked.ptr) + 3;
164
165 for ( unsigned y = 0; y < height; y++, dest += advance )
166 for ( unsigned x = 0; x < width; x++, dest += 4 )
167 *dest = *(alpha++);
168 }
169 }
170
171 static wxIDirectFBSurfacePtr
172 CreateSurfaceWithFormat(int w, int h, DFBSurfacePixelFormat format)
173 {
174 DFBSurfaceDescription desc;
175 desc.flags = (DFBSurfaceDescriptionFlags)
176 (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
177 desc.caps = DSCAPS_NONE;
178 desc.width = w;
179 desc.height = h;
180
181 if ( format != DSPF_UNKNOWN )
182 {
183 desc.flags = (DFBSurfaceDescriptionFlags)(
184 desc.flags | DSDESC_PIXELFORMAT);
185 desc.pixelformat = format;
186 }
187
188 return wxIDirectFB::Get()->CreateSurface(&desc);
189 }
190
191 // Creates a surface that will use wxImage's pixel data (RGB only)
192 static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
193 {
194 wxCHECK_MSG( image.Ok(), NULL, "invalid image" );
195 // FIXME_DFB: implement alpha handling by merging alpha buffer with RGB
196 // into a temporary RGBA surface
197 wxCHECK_MSG( !image.HasAlpha(), NULL, "alpha channel not supported" );
198
199 // NB: wxImage uses RGB order of bytes while DirectFB uses BGR, so we
200 // cannot use preallocated surface that shares data with wxImage, we
201 // have to copy the data to temporary surface instead
202 return CreateSurfaceWithFormat(image.GetWidth(), image.GetHeight(),
203 DSPF_RGB24);
204 }
205
206 static bool ConvertSurfaceToFormat(wxIDirectFBSurfacePtr& surface,
207 DFBSurfacePixelFormat format)
208 {
209 if ( surface->GetPixelFormat() == format )
210 return true;
211
212 int w, h;
213 surface->GetSize(&w, &h);
214 wxIDirectFBSurfacePtr s = CreateSurfaceWithFormat(w, h, format);
215 if ( !s )
216 return false;
217
218 if ( !s->SetBlittingFlags(DSBLIT_NOFX) )
219 return false;
220 if ( !s->Blit(surface->GetRaw(), NULL, 0, 0) )
221 return false;
222
223 surface = s;
224 return true;
225 }
226
227 static DFBSurfacePixelFormat DepthToFormat(int depth)
228 {
229 switch ( depth )
230 {
231 case 24:
232 return DSPF_RGB24;
233 case 32:
234 // NB: we treat depth=32 as requesting ARGB for consistency with
235 // other ports
236 return DSPF_ARGB;
237 default:
238 wxFAIL_MSG( "unsupported depth requested" );
239 // fall through
240 case -1:
241 return DSPF_UNKNOWN;
242 }
243 }
244
245 //-----------------------------------------------------------------------------
246 // wxBitmapRefData
247 //-----------------------------------------------------------------------------
248
249 class wxBitmapRefData: public wxGDIRefData
250 {
251 public:
252 wxBitmapRefData()
253 {
254 m_mask = NULL;
255 #if wxUSE_PALETTE
256 m_palette = NULL;
257 #endif
258 }
259
260 wxBitmapRefData(const wxBitmapRefData& data)
261 {
262 m_surface = data.m_surface ? data.m_surface->Clone() : NULL;
263
264 m_mask = data.m_mask ? new wxMask(*data.m_mask) : NULL;
265 #if wxUSE_PALETTE
266 m_palette = data.m_palette ? new wxPalette(*data.m_palette) : NULL;
267 #endif
268 }
269
270 virtual ~wxBitmapRefData()
271 {
272 delete m_mask;
273 #if wxUSE_PALETTE
274 delete m_palette;
275 #endif
276 }
277
278 virtual bool IsOk() const { return m_surface; }
279
280 wxIDirectFBSurfacePtr m_surface;
281 wxMask *m_mask;
282 #if wxUSE_PALETTE
283 wxPalette *m_palette;
284 #endif
285 };
286
287 #define M_BITMAP ((wxBitmapRefData *)m_refData)
288
289 //-----------------------------------------------------------------------------
290 // wxBitmap
291 //-----------------------------------------------------------------------------
292
293 IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
294 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
295
296 wxBitmap::wxBitmap(int width, int height, int depth)
297 {
298 Create(width, height, depth);
299 }
300
301 bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
302 {
303 UnRef();
304
305 wxCHECK_MSG( surface, false, "invalid surface" );
306
307 m_refData = new wxBitmapRefData();
308 M_BITMAP->m_surface = surface;
309 return true;
310 }
311
312 bool wxBitmap::Create(int width, int height, int depth)
313 {
314 return CreateWithFormat(width, height, DepthToFormat(depth));
315 }
316
317 bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)
318 {
319 UnRef();
320
321 wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
322
323 return Create(CreateSurfaceWithFormat(width, height,
324 DFBSurfacePixelFormat(dfbFormat)));
325 }
326
327 #if wxUSE_IMAGE
328 wxBitmap::wxBitmap(const wxImage& imageOrig, int depth)
329 {
330 wxCHECK_RET( imageOrig.Ok(), wxT("invalid image") );
331
332 wxImage image(imageOrig);
333
334 // convert mask to alpha channel, because wxMask isn't implemented yet
335 // FIXME: don't do this, implement proper wxMask support
336 if ( image.HasMask() )
337 image.InitAlpha();
338
339 DFBSurfacePixelFormat format = DepthToFormat(depth);
340 if ( format == DSPF_UNKNOWN && image.HasAlpha() )
341 format = DSPF_ARGB;
342
343 // create surface in screen's format (unless we need alpha channel,
344 // in which case use ARGB):
345 if ( !CreateWithFormat(image.GetWidth(), image.GetHeight(), format) )
346 return;
347
348 // then copy the image to it:
349 wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;
350
351 switch ( dst->GetPixelFormat() )
352 {
353 case DSPF_RGB24:
354 case DSPF_RGB32:
355 case DSPF_ARGB:
356 CopyImageToSurface(image, dst);
357 break;
358
359 default:
360 {
361 // wxBitmap uses different pixel format, so we have to use a
362 // temporary surface and blit to the bitmap via it:
363 wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image));
364 CopyImageToSurface(image, src);
365
366 if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
367 return;
368 if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
369 return;
370 }
371 }
372 }
373
374 wxImage wxBitmap::ConvertToImage() const
375 {
376 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
377
378 wxImage img(GetWidth(), GetHeight());
379 wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
380
381 switch ( src->GetPixelFormat() )
382 {
383 case DSPF_RGB24:
384 case DSPF_RGB32:
385 case DSPF_ARGB:
386 CopySurfaceToImage(src, img);
387 break;
388 default:
389 {
390 // wxBitmap uses different pixel format, so we have to use a
391 // temporary surface and blit to the bitmap via it:
392 wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));
393
394 if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
395 return wxNullImage;
396 if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
397 return wxNullImage;
398
399 CopySurfaceToImage(dst, img);
400 }
401 }
402
403 // FIXME: implement mask setting in the image
404 wxASSERT_MSG( GetMask() == NULL, "bitmap masks are ignored for now" );
405
406 return img;
407 }
408 #endif // wxUSE_IMAGE
409
410 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
411 {
412 wxCHECK_MSG( Ok(), NULL, "invalid bitmap" );
413
414 AllocExclusive();
415
416 DFBSurfacePixelFormat format;
417 if ( bpp == 32 )
418 format = DSPF_ARGB;
419 else
420 format = DSPF_RGB24;
421
422 // convert the bitmap into format compatible with requested raw access;
423 // note that we don't bother converting the bitmap back in UngetRawData(),
424 // as unpacked formats (RGB24, RGB32) are the common case and converting
425 // between them while blitting is fast enough (FIXME?)
426 if ( !ConvertSurfaceToFormat(M_BITMAP->m_surface, format) )
427 return NULL;
428
429 void *bits = NULL;
430 if ( !M_BITMAP->m_surface->Lock
431 (
432 (DFBSurfaceLockFlags)(DSLF_READ | DSLF_WRITE),
433 &bits,
434 &data.m_stride
435 ) )
436 return NULL;
437
438 M_BITMAP->m_surface->GetSize(&data.m_width, &data.m_height);
439
440 return bits;
441 }
442
443 void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
444 {
445 M_BITMAP->m_surface->Unlock();
446 }
447
448 bool wxBitmap::HasAlpha() const
449 {
450 wxCHECK_MSG( Ok(), false, "invalid bitmap" );
451
452 return M_BITMAP->m_surface->GetPixelFormat() == DSPF_ARGB;
453 }
454
455 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
456 {
457 LoadFile(filename, type);
458 }
459
460 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
461 {
462 wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
463
464 wxFAIL_MSG( "not implemented" );
465 }
466
467 int wxBitmap::GetHeight() const
468 {
469 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
470
471 int h = -1;
472 M_BITMAP->m_surface->GetSize(NULL, &h);
473 return h;
474 }
475
476 int wxBitmap::GetWidth() const
477 {
478 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
479
480 int w = -1;
481 M_BITMAP->m_surface->GetSize(&w, NULL);
482 return w;
483 }
484
485 int wxBitmap::GetDepth() const
486 {
487 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
488
489 return M_BITMAP->m_surface->GetDepth();
490 }
491
492 wxMask *wxBitmap::GetMask() const
493 {
494 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
495
496 return M_BITMAP->m_mask;
497 }
498
499 void wxBitmap::SetMask(wxMask *mask)
500 {
501 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
502
503 AllocExclusive();
504 delete M_BITMAP->m_mask;
505 M_BITMAP->m_mask = mask;
506 }
507
508 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
509 {
510 *this = *((wxBitmap*)(&icon));
511 return true;
512 }
513
514 wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
515 {
516 wxCHECK_MSG( Ok() &&
517 rect.x >= 0 && rect.y >= 0 &&
518 rect.x+rect.width <= GetWidth() &&
519 rect.y+rect.height <= GetHeight(),
520 wxNullBitmap,
521 wxT("invalid bitmap or bitmap region") );
522
523 // NB: DirectFB subsurfaces share the same pixels buffer, so we must
524 // clone the obtained subsurface
525 DFBRectangle r = { rect.x, rect.y, rect.width, rect.height };
526 return wxBitmap(M_BITMAP->m_surface->GetSubSurface(&r)->Clone());
527 }
528
529 #warning "to common code"
530 bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
531 {
532 UnRef();
533
534 wxBitmapHandler *handler = FindHandler(type);
535
536 if ( handler == NULL )
537 {
538 wxImage image;
539 if ( !image.LoadFile(name, type) || !image.Ok() )
540 {
541 wxLogError(_("No bitmap handler for type %d defined."), type);
542 return false;
543 }
544 else
545 {
546 *this = wxBitmap(image);
547 return true;
548 }
549 }
550
551 m_refData = new wxBitmapRefData();
552
553 return handler->LoadFile(this, name, type, -1, -1);
554 }
555
556 #warning "to common code"
557 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
558 {
559 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
560
561 wxBitmapHandler *handler = FindHandler(type);
562
563 if ( handler == NULL )
564 {
565 wxImage image = ConvertToImage();
566 #if wxUSE_PALETTE
567 if ( palette )
568 image.SetPalette(*palette);
569 #endif // wxUSE_PALETTE
570
571 if ( image.Ok() )
572 return image.SaveFile(filename, type);
573 else
574 {
575 wxLogError(_("No bitmap handler for type %d defined."), type);
576 return false;
577 }
578 }
579
580 return handler->SaveFile(this, filename, type, palette);
581 }
582
583 #if wxUSE_PALETTE
584 wxPalette *wxBitmap::GetPalette() const
585 {
586 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
587
588 return M_BITMAP->m_palette;
589 }
590
591 void wxBitmap::SetPalette(const wxPalette& palette)
592 {
593 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
594 wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
595
596 AllocExclusive();
597 delete M_BITMAP->m_palette;
598 M_BITMAP->m_palette = NULL;
599
600 if ( !palette.Ok() ) return;
601
602 M_BITMAP->m_palette = new wxPalette(palette);
603 }
604 #endif // wxUSE_PALETTE
605
606 void wxBitmap::SetHeight(int height)
607 {
608 AllocExclusive();
609
610 wxFAIL_MSG( "SetHeight not implemented" );
611 }
612
613 void wxBitmap::SetWidth(int width)
614 {
615 AllocExclusive();
616
617 wxFAIL_MSG( "SetWidth not implemented" );
618 }
619
620 void wxBitmap::SetDepth(int depth)
621 {
622 DFBSurfacePixelFormat format = DepthToFormat(depth);
623 if ( M_BITMAP->m_surface->GetPixelFormat() == format )
624 return;
625
626 AllocExclusive();
627
628 int w, h;
629 M_BITMAP->m_surface->GetSize(&w, &h);
630 wxIDirectFBSurfacePtr s = CreateSurfaceWithFormat(w, h, format);
631 if ( !s )
632 return;
633 if ( !s->SetBlittingFlags(DSBLIT_NOFX) )
634 return;
635 if ( !s->Blit(M_BITMAP->m_surface->GetRaw(), NULL, 0, 0) )
636 return;
637
638 M_BITMAP->m_surface = s;
639 }
640
641 wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
642 {
643 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
644
645 return M_BITMAP->m_surface;
646 }
647
648 wxGDIRefData *wxBitmap::CreateGDIRefData() const
649 {
650 return new wxBitmapRefData;
651 }
652
653 wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
654 {
655 return new wxBitmapRefData(*(wxBitmapRefData *)data);
656 }
657
658
659 /*static*/
660 void wxBitmap::InitStandardHandlers()
661 {
662 // not wxBitmap handlers, we rely on wxImage
663 }