src/bitmapimage.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * bitmapimage.cpp
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007-2008 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #include <config.h>
  15
  16 #include <glib/gstdio.h>
  17 #include <fcntl.h>
  18 #include <errno.h>
  19
  20 #include "application.h"
  21 #include "bitmapimage.h"
  22 #include "deployment.h"
  23 #include "runtime.h"
  24 #include "uri.h"
  25 #include "debug.h"
  26
  27 #ifdef WORDS_BIGENDIAN
  28 #define set_pixel_bgra(pixel,index,b,g,r,a) \
  29         G_STMT_START { \
  30                 ((unsigned char *)(pixel))[index]   = a; \
  31                 ((unsigned char *)(pixel))[index+1] = r; \
  32                 ((unsigned char *)(pixel))[index+2] = g; \
  33                 ((unsigned char *)(pixel))[index+3] = b; \
  34         } G_STMT_END
  35 #define get_pixel_bgr_p(p,b,g,r) \
  36         G_STMT_START { \
  37                 r = *(p);   \
  38                 g = *(p+1); \
  39                 b = *(p+2); \
  40         } G_STMT_END
  41 #else
  42 #define set_pixel_bgra(pixel,index,b,g,r,a) \
  43         G_STMT_START { \
  44                 ((unsigned char *)(pixel))[index]   = b; \
  45                 ((unsigned char *)(pixel))[index+1] = g; \
  46                 ((unsigned char *)(pixel))[index+2] = r; \
  47                 ((unsigned char *)(pixel))[index+3] = a; \
  48         } G_STMT_END
  49 #define get_pixel_bgr_p(p,b,g,r) \
  50         G_STMT_START { \
  51                 b = *(p);   \
  52                 g = *(p+1); \
  53                 r = *(p+2); \
  54         } G_STMT_END
  55 #endif
  56 #define get_pixel_bgra(color, b, g, r, a) \
  57         G_STMT_START { \
  58                 a = *(p+3);     \
  59                 r = *(p+2);     \
  60                 g = *(p+1);     \
  61                 b = *(p+0);     \
  62         } G_STMT_END
  63 #include "alpha-premul-table.inc"
  64
  65 //
  66 // Expands RGB to ARGB allocating new buffer for it.
  67 //
  68 static gpointer
  69 expand_rgb_to_argb (GdkPixbuf *pixbuf)
  70 {
  71         guchar *pb_pixels = gdk_pixbuf_get_pixels (pixbuf);
  72         guchar *p;
  73         int w = gdk_pixbuf_get_width (pixbuf);
  74         int h = gdk_pixbuf_get_height (pixbuf);
  75         int stride = w * 4;
  76         guchar *data = (guchar *) g_malloc (stride * h);
  77         guchar *out;
  78
  79         for (int y = 0; y < h; y ++) {
  80                 p = pb_pixels + y * gdk_pixbuf_get_rowstride (pixbuf);
  81                 out = data + y * (stride);
  82                 for (int x = 0; x < w; x ++) {
  83                         guchar r, g, b;
  84
  85                         get_pixel_bgr_p (p, b, g, r);
  86                         set_pixel_bgra (out, 0, r, g, b, 255);
  87
  88                         p += 3;
  89                         out += 4;
  90                 }
  91         }
  92
  93         return (gpointer) data;
  94 }
  95
  96 //
  97 // Converts RGBA unmultiplied alpha to ARGB pre-multiplied alpha.
  98 //
  99 static gpointer
 100 premultiply_rgba (GdkPixbuf *pixbuf)
 101 {
 102         guchar *pb_pixels = gdk_pixbuf_get_pixels (pixbuf);
 103         guchar *p;
 104         int w = gdk_pixbuf_get_width (pixbuf);
 105         int h = gdk_pixbuf_get_height (pixbuf);
 106         int stride = w * 4;
 107         guchar *data = (guchar *) g_malloc (stride * h);
 108         guchar *out;
 109
 110         for (int y = 0; y < h; y ++) {
 111                 p = pb_pixels + y * gdk_pixbuf_get_rowstride (pixbuf);
 112                 out = data + y * (stride);
 113                 for (int x = 0; x < w; x ++) {
 114                         guchar r, g, b, a;
 115
 116                         get_pixel_bgra (p, b, g, r, a);
 117
 118                         /* pre-multipled alpha */
 119                         if (a == 0) {
 120                                 r = g = b = 0;
 121                         }
 122                         else if (a < 255) {
 123                                 r = pre_multiplied_table [r][a];
 124                                 g = pre_multiplied_table [g][a];
 125                                 b = pre_multiplied_table [b][a];
 126                         }
 127
 128                         /* store it back, swapping red and blue */
 129                         set_pixel_bgra (out, 0, r, g, b, a);
 130
 131                         p += 4;
 132                         out += 4;
 133                 }
 134         }
 135
 136         return (gpointer) data;
 137 }
 138
 139 BitmapImage::BitmapImage ()
 140 {
 141         SetObjectType (Type::BITMAPIMAGE);
 142         downloader = NULL;
 143         loader = NULL;
 144         gerror = NULL;
 145         part_name = NULL;
 146         get_res_aborter = NULL;
 147         policy = MediaPolicy;
 148 }
 149
 150 BitmapImage::~BitmapImage ()
 151 {
 152         if (downloader)
 153                 downloader->unref ();
 154
 155         if (part_name)
 156                 g_free (part_name);
 157
 158         if (get_res_aborter)
 159                 delete get_res_aborter;
 160
 161         CleanupLoader ();
 162 }
 163
 164 void
 165 BitmapImage::Dispose ()
 166 {
 167         Abort ();
 168         BitmapSource::Dispose ();
 169 }
 170
 171 void
 172 BitmapImage::Abort ()
 173 {
 174         if (downloader) {
 175                 CleanupDownloader ();
 176                 downloader->Abort ();
 177                 downloader->unref ();
 178                 downloader = NULL;
 179         }
 180
 181         if (get_res_aborter)
 182                 get_res_aborter->Cancel ();
 183 }
 184
 185 void
 186 BitmapImage::uri_source_changed_callback (EventObject *user_data)
 187 {
 188         BitmapImage *image = (BitmapImage *) user_data;
 189         image->UriSourceChanged ();
 190 }
 191
 192 static void
 193 resource_notify (NotifyType type, gint64 args, gpointer user_data)
 194 {
 195         BitmapImage *media = (BitmapImage *) user_data;
 196
 197         if (type == NotifyProgressChanged)
 198                 media->SetProgress ((double)(args)/100.0);
 199         else if (type == NotifyFailed)
 200                 media->DownloaderFailed ();
 201         else if (type == NotifyCompleted)
 202                 media->DownloaderComplete ();
 203 }
 204
 205 void
 206 BitmapImage::UriSourceChanged ()
 207 {
 208         Surface *surface = Deployment::GetCurrent ()->GetSurface ();
 209         Application *current = Application::GetCurrent ();
 210         Uri *uri = GetUriSource ();
 211
 212         if (surface == NULL) {
 213                 SetBitmapData (NULL);
 214                 return;
 215         }
 216
 217         if (current && uri) {
 218                 if (get_res_aborter)
 219                         delete get_res_aborter;
 220                 get_res_aborter = new Cancellable ();
 221                 if (!current->GetResource (GetResourceBase(), uri, resource_notify, pixbuf_write, policy, get_res_aborter, this))
 222                         DownloaderFailed ();
 223         }
 224 }
 225
 226 void
 227 BitmapImage::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 228 {
 229         if (args->GetProperty ()->GetOwnerType () != Type::BITMAPIMAGE) {
 230                 BitmapSource::OnPropertyChanged (args, error);
 231                 return;
 232         }
 233
 234         if (args->GetId () == BitmapImage::UriSourceProperty) {
 235                 Uri *uri = args->GetNewValue () ? args->GetNewValue ()->AsUri () : NULL;
 236
 237                 Abort ();
 238
 239                 if (Uri::IsNullOrEmpty (uri)) {
 240                         SetBitmapData (NULL);
 241                 } else if (uri->IsInvalidPath ()) {
 242                         if (IsBeingParsed ())
 243                                 MoonError::FillIn (error, MoonError::ARGUMENT_OUT_OF_RANGE, 0, "invalid path found in uri");
 244                         SetBitmapData (NULL);
 245                 } else {
 246                         AddTickCall (uri_source_changed_callback);
 247                 }
 248         } else if (args->GetId () == BitmapImage::ProgressProperty) {
 249                 Emit (DownloadProgressEvent, new DownloadProgressEventArgs (GetProgress ()));
 250         }
 251
 252         NotifyListenersOfPropertyChange (args, error);
 253 }
 254
 255 bool
 256 BitmapImage::ValidateDownloadPolicy ()
 257 {
 258         Surface *surface = Deployment::GetCurrent ()->GetSurface ();
 259         Uri *uri = GetUriSource ();
 260         const char *location;
 261
 262         if (!uri)
 263                 return true;
 264
 265         if (!(location = GetDeployment ()->GetXapLocation ()))
 266                 location = surface ? surface->GetSourceLocation () : NULL;
 267
 268         return Downloader::ValidateDownloadPolicy (location, uri, policy);
 269 }
 270
 271 void
 272 BitmapImage::SetDownloader (Downloader *downloader, Uri *uri, const char *part_name)
 273 {
 274         Abort ();
 275
 276         this->downloader = downloader;
 277         this->part_name = g_strdup (part_name);
 278
 279         downloader->ref();
 280
 281         downloader->AddHandler (Downloader::DownloadProgressChangedEvent, downloader_progress_changed, this);
 282         downloader->AddHandler (Downloader::DownloadFailedEvent, downloader_failed, this);
 283         downloader->AddHandler (Downloader::CompletedEvent, downloader_complete, this);
 284
 285         if (downloader->Completed ()) {
 286                 DownloaderComplete ();
 287         } else {
 288                 if (!downloader->Started () && uri) {
 289                         downloader->Open ("GET", uri, policy);
 290                         downloader->SetStreamFunctions (pixbuf_write, NULL, this);
 291                         downloader->Send ();
 292                 }
 293         }
 294 }
 295
 296 void
 297 BitmapImage::CleanupDownloader ()
 298 {
 299         downloader->RemoveHandler (Downloader::DownloadProgressChangedEvent, downloader_progress_changed, this);
 300         downloader->RemoveHandler (Downloader::DownloadFailedEvent, downloader_failed, this);
 301         downloader->RemoveHandler (Downloader::CompletedEvent, downloader_complete, this);
 302 }
 303
 304 void
 305 BitmapImage::downloader_progress_changed (EventObject *sender, EventArgs *calldata, gpointer closure)
 306 {
 307         BitmapImage *media = (BitmapImage *) closure;
 308
 309         media->DownloaderProgressChanged ();
 310 }
 311
 312 void
 313 BitmapImage::downloader_complete (EventObject *sender, EventArgs *calldata, gpointer closure)
 314 {
 315         BitmapImage *media = (BitmapImage *) closure;
 316
 317         media->DownloaderComplete ();
 318 }
 319
 320 void
 321 BitmapImage::downloader_failed (EventObject *sender, EventArgs *calldata, gpointer closure)
 322 {
 323         BitmapImage *media = (BitmapImage *) closure;
 324
 325         media->DownloaderFailed ();
 326 }
 327
 328 void
 329 BitmapImage::DownloaderProgressChanged ()
 330 {
 331         SetProgress (downloader->GetDownloadProgress ());
 332 }
 333
 334 void
 335 BitmapImage::DownloaderComplete ()
 336 {
 337         MoonError moon_error;
 338
 339         if (downloader)
 340                 CleanupDownloader ();
 341
 342         SetProgress (1.0);
 343
 344         if (downloader && loader == NULL) {
 345                 char *filename = downloader->GetDownloadedFilename (part_name);
 346
 347                 if (filename == NULL) {
 348                         guchar *buffer = (guchar *)downloader->GetBuffer ();
 349
 350                         if (buffer == NULL) {
 351                                 MoonError::FillIn (&moon_error, MoonError::EXCEPTION, 4001, "downloader buffer was NULL");
 352                                 goto failed;
 353                         }
 354
 355                         PixbufWrite (buffer, 0, downloader->GetSize ());
 356                 } else {
 357                         guchar b[4096];
 358                         int offset = 0;
 359                         ssize_t n;
 360                         int fd;
 361
 362                         if ((fd = g_open (filename, O_RDONLY)) == -1) {
 363                                 MoonError::FillIn (&moon_error, MoonError::EXCEPTION, 4001, "failed to open file");
 364                                 goto failed;
 365                         }
 366
 367                         do {
 368                                 do {
 369                                         n = read (fd, b, sizeof (b));
 370                                 } while (n == -1 && errno == EINTR);
 371
 372                                 if (n == -1) break;
 373
 374                                 PixbufWrite (b, offset, n);
 375
 376                                 offset += n;
 377                         } while (n > 0 && !gerror);
 378
 379                         close (fd);
 380
 381                         if (gerror) {
 382                                 MoonError::FillIn (&moon_error, MoonError::EXCEPTION, 4001, gerror->message);
 383                                 goto failed;
 384                         }
 385                 }
 386         }
 387
 388         if (downloader) {
 389                 downloader->unref ();
 390                 downloader = NULL;
 391         }
 392
 393         PixmapComplete ();
 394
 395         return;
 396 failed:
 397         downloader->unref ();
 398         downloader = NULL;
 399
 400         if (loader)
 401                 gdk_pixbuf_loader_close (loader, NULL);
 402         CleanupLoader ();
 403
 404         Emit (ImageFailedEvent, new ImageErrorEventArgs (moon_error));
 405 }
 406
 407
 408 void
 409 BitmapImage::PixmapComplete ()
 410 {
 411         MoonError moon_error;
 412
 413         SetProgress (1.0);
 414
 415         if (!loader) goto failed;
 416
 417         gdk_pixbuf_loader_close (loader, gerror == NULL ? &gerror : NULL);
 418
 419         if (gerror) {
 420                 MoonError::FillIn (&moon_error, MoonError::EXCEPTION, 4001, gerror->message);
 421                 goto failed;
 422         }
 423
 424         {
 425                 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
 426
 427                 if (pixbuf == NULL) {
 428                         MoonError::FillIn (&moon_error, MoonError::EXCEPTION, 4001, "failed to create image data");
 429                         goto failed;
 430                 }
 431
 432                 SetPixelWidth (gdk_pixbuf_get_width (pixbuf));
 433                 SetPixelHeight (gdk_pixbuf_get_height (pixbuf));
 434
 435                 if (gdk_pixbuf_get_n_channels (pixbuf) == 4) {
 436                         SetPixelFormat (PixelFormatPbgra32);
 437                         SetBitmapData (premultiply_rgba (pixbuf));
 438                 } else {
 439                         SetPixelFormat (PixelFormatBgr32);
 440                         SetBitmapData (expand_rgb_to_argb (pixbuf));
 441                 }
 442
 443                 Invalidate ();
 444
 445                 g_object_unref (loader);
 446                 loader = NULL;
 447
 448                 Emit (ImageOpenedEvent, new RoutedEventArgs ());
 449
 450                 return;
 451         }
 452
 453 failed:
 454         CleanupLoader ();
 455
 456         Emit (ImageFailedEvent, new ImageErrorEventArgs (moon_error));
 457 }
 458
 459 void
 460 BitmapImage::DownloaderFailed ()
 461 {
 462         Abort ();
 463         Emit (ImageFailedEvent, new ImageErrorEventArgs (MoonError (MoonError::EXCEPTION, 4001, "downloader failed")));
 464 }
 465
 466 void
 467 BitmapImage::CleanupLoader ()
 468 {
 469         SetPixelWidth (0);
 470         SetPixelHeight (0);
 471
 472         if (loader) {
 473                 g_object_unref (loader);
 474                 loader = NULL;
 475         }
 476         if (gerror) {
 477                 g_error_free (gerror);
 478                 gerror = NULL;
 479         }
 480 }
 481
 482 void
 483 BitmapImage::CreateLoader (unsigned char *buffer)
 484 {
 485         if (!(moonlight_flags & RUNTIME_INIT_ALL_IMAGE_FORMATS)) {
 486                 // 89 50 4E 47 == png magic
 487                 if (buffer[0] == 0x89)
 488                         loader = gdk_pixbuf_loader_new_with_type ("png", NULL);
 489                 // ff d8 ff e0 == jfif magic
 490                 else if (buffer[0] == 0xff)
 491                         loader = gdk_pixbuf_loader_new_with_type ("jpeg", NULL);
 492
 493                 else {
 494                         Abort ();
 495                         Emit (ImageFailedEvent, new ImageErrorEventArgs (MoonError (MoonError::EXCEPTION, 4001, "unsupported image type")));
 496                 }
 497         } else {
 498                 loader = gdk_pixbuf_loader_new ();
 499         }
 500 }
 501
 502 void
 503 BitmapImage::PixbufWrite (gpointer buffer, gint32 offset, gint32 n)
 504 {
 505
 506         if (loader == NULL && offset == 0)
 507                 CreateLoader ((unsigned char *)buffer);
 508
 509         if (loader != NULL && gerror == NULL) {
 510                 gdk_pixbuf_loader_write (GDK_PIXBUF_LOADER (loader), (const guchar *)buffer, n, &gerror);
 511         }
 512 }
 513
 514 void
 515 BitmapImage::pixbuf_write (void *buffer, gint32 offset, gint32 n, gpointer data)
 516 {
 517         BitmapImage *source = (BitmapImage *) data;
 518
 519         source->PixbufWrite ((unsigned char *)buffer, offset, n);
 520 }