src/media.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * media.cpp:
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  */
  12
  13 #include <config.h>
  14
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17 #include <unistd.h>
  18 #include <fcntl.h>
  19 #include <errno.h>
  20 #include <math.h>
  21
  22 #include "writeablebitmap.h"
  23 #include "bitmapimage.h"
  24 #include "uri.h"
  25 #include "runtime.h"
  26 #include "media.h"
  27 #include "error.h"
  28 #include "downloader.h"
  29 #include "geometry.h"
  30 #include "timeline.h"
  31 #include "debug.h"
  32
  33 /*
  34  * MediaBase
  35  */
  36
  37 MediaBase::MediaBase ()
  38 {
  39         SetObjectType (Type::MEDIABASE);
  40
  41         source.downloader = NULL;
  42         source.part_name = NULL;
  43         source.queued = false;
  44         downloader = NULL;
  45         part_name = NULL;
  46         allow_downloads = false;
  47         source_changed = false;
  48 }
  49
  50 MediaBase::~MediaBase ()
  51 {
  52         DownloaderAbort ();
  53 }
  54
  55 void
  56 MediaBase::downloader_complete (EventObject *sender, EventArgs *calldata, gpointer closure)
  57 {
  58         MediaBase *media = (MediaBase *) closure;
  59
  60         media->DownloaderComplete ();
  61 }
  62
  63 void
  64 MediaBase::downloader_failed (EventObject *sender, EventArgs *calldata, gpointer closure)
  65 {
  66         MediaBase *media = (MediaBase *) closure;
  67
  68         media->DownloaderFailed (calldata);
  69 }
  70
  71 void
  72 MediaBase::DownloaderComplete ()
  73 {
  74         // Nothing for MediaBase to do...
  75 }
  76
  77 void
  78 MediaBase::DownloaderFailed (EventArgs *args)
  79 {
  80         // Nothing for MediaBase to do...
  81 }
  82
  83 void
  84 MediaBase::DownloaderAbort ()
  85 {
  86         if (downloader) {
  87                 downloader->RemoveHandler (Downloader::DownloadFailedEvent, downloader_failed, this);
  88                 downloader->RemoveHandler (Downloader::CompletedEvent, downloader_complete, this);
  89                 downloader->SetStreamFunctions (NULL, NULL, NULL);
  90                 downloader->Abort ();
  91                 downloader->unref ();
  92                 g_free (part_name);
  93                 downloader = NULL;
  94                 part_name = NULL;
  95         }
  96 }
  97
  98 void
  99 MediaBase::SetAllowDownloads (bool allow)
 100 {
 101         Surface *surface = GetSurface ();
 102         const char *uri;
 103         Downloader *dl;
 104
 105         if ((allow_downloads && allow) || (!allow_downloads && !allow))
 106                 return;
 107
 108         if (allow && surface && source_changed) {
 109                 source_changed = false;
 110
 111                 if ((uri = GetSource ()) && *uri) {
 112                         if (!(dl = surface->CreateDownloader ())) {
 113                                 // we're shutting down
 114                                 return;
 115                         }
 116
 117                         dl->Open ("GET", uri, GetDownloaderPolicy (uri));
 118                         SetSource (dl, "");
 119                         dl->unref ();
 120                 }
 121         }
 122
 123         allow_downloads = allow;
 124 }
 125
 126 void
 127 MediaBase::OnLoaded ()
 128 {
 129         FrameworkElement::OnLoaded ();
 130         SetAllowDownloads (true);
 131 }
 132
 133 void
 134 MediaBase::SetSourceAsyncCallback ()
 135 {
 136         Downloader *downloader;
 137         char *part_name;
 138
 139         DownloaderAbort ();
 140
 141         downloader = source.downloader;
 142         part_name = source.part_name;
 143
 144         source.queued = false;
 145         source.downloader = NULL;
 146         source.part_name = NULL;
 147
 148         if (GetSurface () == NULL)
 149                 return;
 150
 151         SetSourceInternal (downloader, part_name);
 152
 153         if (downloader)
 154                 downloader->unref ();
 155 }
 156
 157 void
 158 MediaBase::SetSourceInternal (Downloader *downloader, char *PartName)
 159 {
 160         this->downloader = downloader;
 161         part_name = PartName;
 162
 163         if (downloader)
 164                 downloader->ref ();
 165 }
 166
 167 void
 168 MediaBase::set_source_async (EventObject *user_data)
 169 {
 170         MediaBase *media = (MediaBase *) user_data;
 171
 172         media->SetSourceAsyncCallback ();
 173 }
 174
 175 void
 176 MediaBase::SetSource (Downloader *downloader, const char *PartName)
 177 {
 178         source_changed = false;
 179
 180         if (source.queued) {
 181                 if (source.downloader)
 182                         source.downloader->unref ();
 183
 184                 g_free (source.part_name);
 185                 source.downloader = NULL;
 186                 source.part_name = NULL;
 187         }
 188
 189         source.part_name = g_strdup (PartName);
 190         source.downloader = downloader;
 191
 192         if (downloader)
 193                 downloader->ref ();
 194
 195         if (source.downloader && source.downloader->Completed ()) {
 196                 SetSourceInternal (source.downloader, source.part_name);
 197                 source.downloader->unref ();
 198         } else if (!source.queued) {
 199                 AddTickCall (MediaBase::set_source_async);
 200                 source.queued = true;
 201         }
 202 }
 203
 204 void
 205 MediaBase::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 206 {
 207         if (args->GetId () == MediaBase::SourceProperty) {
 208                 const char *uri = args->GetNewValue() ? args->GetNewValue()->AsString () : NULL;
 209                 Surface *surface = GetSurface ();
 210
 211                 if (surface && AllowDownloads ()) {
 212                         if (uri && *uri) {
 213                                 Downloader *dl;
 214                                 if ((dl = surface->CreateDownloader ())) {
 215                                         dl->Open ("GET", uri, GetDownloaderPolicy (uri));
 216                                         SetSource (dl, "");
 217                                         dl->unref ();
 218                                 } else {
 219                                         // we're shutting down
 220                                 }
 221                         } else {
 222                                 SetSource (NULL, NULL);
 223                         }
 224                 } else {
 225                         source_changed = true;
 226                 }
 227         }
 228
 229         if (args->GetProperty ()->GetOwnerType() != Type::MEDIABASE) {
 230                 FrameworkElement::OnPropertyChanged (args, error);
 231                 return;
 232         }
 233
 234         NotifyListenersOfPropertyChange (args, error);
 235 }
 236
 237 //
 238 // Image
 239 //
 240 Image::Image ()
 241 {
 242         SetObjectType (Type::IMAGE);
 243 }
 244
 245 Image::~Image ()
 246 {
 247         BitmapSource *source = (BitmapSource*)GetSource ();
 248
 249         if (source)
 250                 source->RemoveHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);
 251 }
 252
 253 void
 254 Image::download_progress (EventObject *sender, EventArgs *calldata, gpointer closure)
 255 {
 256         Image *media = (Image *) closure;
 257
 258         media->DownloadProgress ();
 259 }
 260
 261 void
 262 Image::image_opened (EventObject *sender, EventArgs *calldata, gpointer closure)
 263 {
 264         Image *media = (Image *) closure;
 265
 266         media->ImageOpened ();
 267 }
 268
 269 void
 270 Image::image_failed (EventObject *sender, EventArgs *calldata, gpointer closure)
 271 {
 272         Image *media = (Image *) closure;
 273
 274         media->ImageFailed ((ImageErrorEventArgs*)calldata);
 275 }
 276
 277 void
 278 Image::source_pixel_data_changed (EventObject *sender, EventArgs *calldata, gpointer closure)
 279 {
 280         Image *media = (Image *) closure;
 281
 282         media->SourcePixelDataChanged ();
 283 }
 284
 285 void
 286 Image::DownloadProgress ()
 287 {
 288         BitmapImage *source = (BitmapImage *) GetSource ();
 289
 290         SetDownloadProgress (source->GetProgress ());
 291         Emit (DownloadProgressChangedEvent);
 292 }
 293
 294 void
 295 Image::ImageOpened ()
 296 {
 297         BitmapSource *source = (BitmapSource*)GetSource ();
 298
 299         if (source->Is (Type::BITMAPIMAGE)) {
 300                 source->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 301                 source->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 302                 source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 303         }
 304
 305         InvalidateArrange ();
 306         InvalidateMeasure ();
 307         UpdateBounds ();
 308         Invalidate ();
 309 }
 310
 311 void
 312 Image::ImageFailed (ImageErrorEventArgs *args)
 313 {
 314         BitmapSource *source = (BitmapSource*) GetSource ();
 315
 316         if (source->Is (Type::BITMAPIMAGE)) {
 317                 source->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 318                 source->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 319                 source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 320         }
 321         source->RemoveHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);
 322
 323
 324         InvalidateArrange ();
 325         InvalidateMeasure ();
 326         UpdateBounds ();
 327         Invalidate ();
 328
 329         args->ref (); // to counter the unref in Emit
 330         Emit (ImageFailedEvent, args);
 331 }
 332
 333 void
 334 Image::SourcePixelDataChanged ()
 335 {
 336         Invalidate();
 337 }
 338
 339 void
 340 Image::SetSourceInternal (Downloader *downloader, char *PartName)
 341 {
 342         BitmapImage *source = (BitmapImage *) GetSource ();
 343
 344         MediaBase::SetSourceInternal (downloader, PartName);
 345
 346         source->AddHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 347         source->AddHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 348         source->AddHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 349
 350         source->SetDownloader (downloader, NULL, PartName);
 351 }
 352
 353 void
 354 Image::SetSource (Downloader *downloader, const char *PartName)
 355 {
 356         MediaBase::SetSource (downloader, PartName);
 357 }
 358
 359 void
 360 Image::Render (cairo_t *cr, Region *region, bool path_only)
 361 {
 362         ImageSource *source = GetSource ();
 363         cairo_pattern_t *pattern = NULL;
 364         cairo_matrix_t matrix;
 365         Rect image;
 366         Rect paint;
 367
 368         if (!source)
 369                 return;
 370
 371         source->Lock ();
 372
 373         cairo_save (cr);
 374
 375         Size specified (GetActualWidth (), GetActualHeight ());
 376         Size stretched = ApplySizeConstraints (specified);
 377
 378         if (GetStretch () != StretchUniformToFill)
 379                 specified = specified.Min(stretched);
 380
 381         paint = Rect (0, 0, specified.width, specified.height);
 382
 383         if (!path_only) {
 384                 image = Rect (0, 0, source->GetPixelWidth (), source->GetPixelHeight ());
 385
 386                 if (GetStretch () == StretchNone)
 387                         paint = paint.Union (image);
 388
 389                 if (image.width == 0.0 && image.height == 0.0)
 390                         return;
 391
 392                 pattern = cairo_pattern_create_for_surface (source->GetSurface (cr));
 393                 image_brush_compute_pattern_matrix (&matrix, paint.width, paint.height,
 394                                                     image.width, image.height,
 395                                                     GetStretch (),
 396                                                     AlignmentXCenter, AlignmentYCenter, NULL, NULL);
 397
 398                 cairo_pattern_set_matrix (pattern, &matrix);
 399                 cairo_set_source (cr, pattern);
 400         }
 401
 402         cairo_set_matrix (cr, &absolute_xform);
 403
 404         if (!path_only)
 405                 RenderLayoutClip (cr);
 406
 407         paint = paint.Intersection (Rect (0,0,stretched.width,stretched.height));
 408         paint.Draw (cr);
 409
 410         if (!path_only)
 411                 cairo_fill (cr);
 412
 413         cairo_restore (cr);
 414
 415         if (pattern)
 416                 cairo_pattern_destroy (pattern);
 417
 418         source->Unlock ();
 419 }
 420
 421 Size
 422 Image::ComputeActualSize ()
 423 {
 424         Size result = MediaBase::ComputeActualSize ();
 425         UIElement *parent = GetVisualParent ();
 426         ImageSource *source = GetSource ();
 427
 428         if (parent && !parent->Is (Type::CANVAS))
 429                 if (LayoutInformation::GetLayoutSlot (this))
 430                         return result;
 431
 432         if (source && source->GetSurface (NULL)) {
 433                 Size available = Size (INFINITY, INFINITY);
 434                 available = ApplySizeConstraints (available);
 435                 result = MeasureOverride (available);
 436                 result = ApplySizeConstraints (result);
 437         }
 438
 439         return result;
 440 }
 441
 442 Size
 443 Image::MeasureOverride (Size availableSize)
 444 {
 445         Size desired = availableSize;
 446         Rect shape_bounds = Rect ();
 447         ImageSource *source = GetSource ();
 448         double sx = 0.0;
 449         double sy = 0.0;
 450
 451         if (source)
 452                 shape_bounds = Rect (0,0,source->GetPixelWidth (),source->GetPixelHeight ());
 453
 454         /* don't stretch to infinite size */
 455         if (isinf (desired.width))
 456                 desired.width = shape_bounds.width;
 457         if (isinf (desired.height))
 458                 desired.height = shape_bounds.height;
 459
 460         /* compute the scaling */
 461         if (shape_bounds.width > 0)
 462                 sx = desired.width / shape_bounds.width;
 463         if (shape_bounds.height > 0)
 464                 sy = desired.height / shape_bounds.height;
 465
 466         /* don't use infinite dimensions as constraints */
 467         if (isinf (availableSize.width))
 468                 sx = sy;
 469         if (isinf (availableSize.height))
 470                 sy = sx;
 471
 472         switch (GetStretch ()) {
 473         case StretchUniform:
 474                 sx = sy = MIN (sx, sy);
 475                 break;
 476         case StretchUniformToFill:
 477                 sx = sy = MAX (sx, sy);
 478                 break;
 479         case StretchFill:
 480                 if (isinf (availableSize.width))
 481                         sx = sy;
 482                 if (isinf (availableSize.height))
 483                         sy = sx;
 484                 break;
 485         case StretchNone:
 486                 sx = sy = 1.0;
 487                 break;
 488         }
 489
 490         desired = Size (shape_bounds.width * sx, shape_bounds.height * sy);
 491
 492         return desired;
 493 }
 494
 495 Size
 496 Image::ArrangeOverride (Size finalSize)
 497 {
 498         Size arranged = finalSize;
 499         Rect shape_bounds = Rect ();
 500         ImageSource *source = GetSource ();
 501         double sx = 1.0;
 502         double sy = 1.0;
 503
 504
 505         if (source)
 506                 shape_bounds = Rect (0, 0, source->GetPixelWidth (), source->GetPixelHeight ());
 507
 508         /* compute the scaling */
 509         if (shape_bounds.width == 0)
 510                 shape_bounds.width = arranged.width;
 511         if (shape_bounds.height == 0)
 512                 shape_bounds.height = arranged.height;
 513
 514         if (shape_bounds.width != arranged.width)
 515                 sx = arranged.width / shape_bounds.width;
 516         if (shape_bounds.height != arranged.height)
 517                 sy = arranged.height / shape_bounds.height;
 518
 519         switch (GetStretch ()) {
 520         case StretchUniform:
 521                 sx = sy = MIN (sx, sy);
 522                 break;
 523         case StretchUniformToFill:
 524                 sx = sy = MAX (sx, sy);
 525                 break;
 526         case StretchNone:
 527                 sx = sy = 1.0;
 528         default:
 529                 break;
 530         }
 531
 532         arranged = Size (shape_bounds.width * sx, shape_bounds.height * sy);
 533
 534         return arranged;
 535 }
 536
 537 Rect
 538 Image::GetCoverageBounds ()
 539 {
 540         Stretch stretch = GetStretch ();
 541         ImageSource *source = GetSource ();
 542
 543         if (!source || source->GetPixelFormat () == PixelFormatPbgra32)
 544                 return Rect ();
 545
 546         if (stretch == StretchFill || stretch == StretchUniformToFill)
 547                 return bounds;
 548
 549         cairo_matrix_t matrix;
 550         Rect image = Rect (0, 0, source->GetPixelWidth (), source->GetPixelHeight ());
 551         Rect paint = Rect (0, 0, GetActualWidth (), GetActualHeight ());
 552
 553         image_brush_compute_pattern_matrix (&matrix,
 554                                             paint.width, paint.height,
 555                                             image.width, image.height, stretch,
 556                                             AlignmentXCenter, AlignmentYCenter, NULL, NULL);
 557
 558         cairo_matrix_invert (&matrix);
 559         cairo_matrix_multiply (&matrix, &matrix, &absolute_xform);
 560
 561         image = image.Transform (&matrix);
 562         image = image.Intersection (bounds);
 563
 564         return image;
 565 }
 566
 567 void
 568 Image::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
 569 {
 570         if (prop && (prop->GetId () == Image::SourceProperty
 571                      || prop->GetId () == MediaBase::SourceProperty)) {
 572                 InvalidateMeasure ();
 573                 Invalidate ();
 574                 return;
 575         }
 576
 577         MediaBase::OnSubPropertyChanged (prop, obj, subobj_args);
 578 }
 579 void
 580 Image::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 581 {
 582         if (args->GetId () == Image::SourceProperty) {
 583                 ImageSource *source = args->GetNewValue () ? args->GetNewValue ()->AsImageSource () : NULL;
 584                 ImageSource *old = args->GetOldValue () ? args->GetOldValue ()->AsImageSource () : NULL;
 585
 586                 if (old && old->Is(Type::BITMAPSOURCE)) {
 587                         old->RemoveHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);
 588                 }
 589                 if (source && source->Is(Type::BITMAPSOURCE)) {
 590                         source->AddHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);
 591                 }
 592
 593                 if (old && old->Is(Type::BITMAPIMAGE)) {
 594                         old->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 595                         old->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 596                         old->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 597                 }
 598                 if (source && source->Is(Type::BITMAPIMAGE)) {
 599                         BitmapImage *bitmap = (BitmapImage *) source;
 600                         Uri *uri = bitmap->GetUriSource ();
 601
 602                         source->AddHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 603                         source->AddHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 604                         source->AddHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 605
 606                         if (bitmap->GetPixelWidth () > 0 && bitmap->GetPixelHeight () > 0) {
 607                                 ImageOpened ();
 608                         }
 609
 610                         // can uri ever be null?
 611                         if (IsBeingParsed () && uri && GetSurface ()) {
 612                                 ImageErrorEventArgs *args = NULL;
 613
 614                                 if (uri->IsInvalidPath ()) {
 615                                         args = new ImageErrorEventArgs (MoonError (MoonError::ARGUMENT_OUT_OF_RANGE, 0, "invalid path found in uri"));
 616                                 } else if (!bitmap->ValidateDownloadPolicy ()) {
 617                                         args = new ImageErrorEventArgs (MoonError (MoonError::ARGUMENT_OUT_OF_RANGE, 0, "Security Policy Violation"));
 618                                 }
 619
 620                                 if (args != NULL) {
 621                                         source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 622                                         GetSurface ()->EmitError (args);
 623                                 }
 624                         }
 625                 }
 626                 InvalidateMeasure ();
 627         }
 628
 629         if (args->GetProperty ()->GetOwnerType() != Type::IMAGE) {
 630                 MediaBase::OnPropertyChanged (args, error);
 631                 return;
 632         }
 633
 634         // we need to notify attachees if our DownloadProgress changed.
 635         NotifyListenersOfPropertyChange (args, error);
 636 }
 637
 638 bool
 639 Image::InsideObject (cairo_t *cr, double x, double y)
 640 {
 641         if (!FrameworkElement::InsideObject (cr, x, y))
 642                 return false;
 643
 644         cairo_save (cr);
 645         cairo_new_path (cr);
 646         cairo_set_matrix (cr, &absolute_xform);
 647
 648         double nx = x;
 649         double ny = y;
 650
 651         TransformPoint (&nx, &ny);
 652
 653         Render (cr, NULL, true);
 654         bool inside = cairo_in_fill (cr, nx, ny);
 655         cairo_restore (cr);
 656
 657         if (inside)
 658                 inside = InsideLayoutClip (x, y);
 659
 660         if (inside)
 661                 inside = InsideClip (cr, x, y);
 662
 663         return inside;
 664 }
 665
 666 Value *
 667 Image::CreateDefaultImageSource (DependencyObject *instance, DependencyProperty *property)
 668 {
 669         return Value::CreateUnrefPtr (new BitmapImage ());
 670 }
 671
 672 //
 673 // MediaAttributeCollection
 674 //
 675
 676 MediaAttribute *
 677 MediaAttributeCollection::GetItemByName (const char *name)
 678 {
 679         MediaAttribute *attr;
 680         const char *value;
 681
 682         for (guint i = 0; i < array->len; i++) {
 683                 attr = ((Value *) array->pdata[i])->AsMediaAttribute ();
 684                 if (!(value = attr->GetName ()))
 685                         continue;
 686
 687                 if (!g_ascii_strcasecmp (value, name))
 688                         return attr;
 689         }
 690
 691         return NULL;
 692 }
 693
 694
 695 //
 696 // TimelineMarkerCollection
 697 //
 698
 699 int
 700 TimelineMarkerCollection::AddWithError (Value *value, MoonError *error)
 701 {
 702         TimelineMarker *marker, *cur;
 703
 704         marker = value->AsTimelineMarker ();
 705
 706         for (guint i = 0; i < array->len; i++) {
 707                 cur = ((Value *) array->pdata[i])->AsTimelineMarker ();
 708                 if (cur->GetTime () >= marker->GetTime ()) {
 709                         DependencyObjectCollection::InsertWithError (i, value, error);
 710                         return i;
 711                 }
 712         }
 713
 714         return DependencyObjectCollection::InsertWithError (array->len, value, error) ? array->len - 1 : -1;
 715 }
 716
 717 bool
 718 TimelineMarkerCollection::InsertWithError (int index, Value *value, MoonError *error)
 719 {
 720         return AddWithError (value, error) != -1;
 721 }
 722
 723
 724 //
 725 // MarkerReachedEventArgs
 726 //
 727
 728 MarkerReachedEventArgs::MarkerReachedEventArgs (TimelineMarker *marker)
 729 {
 730         SetObjectType (Type::MARKERREACHEDEVENTARGS);
 731         this->marker = marker;
 732         marker->ref ();
 733 }
 734
 735 MarkerReachedEventArgs::~MarkerReachedEventArgs ()
 736 {
 737         marker->unref ();
 738 }