Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

   1 /*
   2  *  Copyright (C) 2009, 2010 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   3  *
   4  *  This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Lesser General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  *  This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Lesser General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU Lesser General Public
  15  *  License along with this library; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include "config.h"
  20 #include "WebKitWebSourceGStreamer.h"
  21
  22 #if ENABLE(VIDEO) && USE(GSTREAMER)
  23
  24 #include "Document.h"
  25 #include "Frame.h"
  26 #include "GRefPtrGStreamer.h"
  27 #include "GStreamerVersioning.h"
  28 #include "MediaPlayer.h"
  29 #include "NetworkingContext.h"
  30 #include "NotImplemented.h"
  31 #include "ResourceHandleClient.h"
  32 #include "ResourceHandleInternal.h"
  33 #include "ResourceRequest.h"
  34 #include "ResourceResponse.h"
  35
  36 #include <gst/app/gstappsrc.h>
  37 #include <gst/pbutils/missing-plugins.h>
  38
  39 #include <wtf/Noncopyable.h>
  40 #include <wtf/gobject/GOwnPtr.h>
  41 #include <wtf/gobject/GRefPtr.h>
  42 #include <wtf/text/CString.h>
  43
  44 using namespace WebCore;
  45
  46 class StreamingClient : public ResourceHandleClient {
  47     WTF_MAKE_NONCOPYABLE(StreamingClient);
  48     public:
  49         StreamingClient(WebKitWebSrc*);
  50         virtual ~StreamingClient();
  51
  52         virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse&);
  53         virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
  54         virtual void didReceiveData(ResourceHandle*, const char*, int, int);
  55         virtual void didFinishLoading(ResourceHandle*, double /*finishTime*/);
  56         virtual void didFail(ResourceHandle*, const ResourceError&);
  57         virtual void wasBlocked(ResourceHandle*);
  58         virtual void cannotShowURL(ResourceHandle*);
  59
  60     private:
  61         WebKitWebSrc* m_src;
  62 };
  63
  64 #define WEBKIT_WEB_SRC_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_SRC, WebKitWebSrcPrivate))
  65 struct _WebKitWebSrcPrivate {
  66     GstAppSrc* appsrc;
  67     GstPad* srcpad;
  68     gchar* uri;
  69
  70     RefPtr<WebCore::Frame> frame;
  71     WebCore::MediaPlayer* player;
  72
  73     StreamingClient* client;
  74     RefPtr<ResourceHandle> resourceHandle;
  75
  76     guint64 offset;
  77     guint64 size;
  78     gboolean seekable;
  79     gboolean paused;
  80
  81     guint64 requestedOffset;
  82
  83     guint needDataID;
  84     guint enoughDataID;
  85     guint seekID;
  86
  87     // icecast stuff
  88     gboolean iradioMode;
  89     gchar* iradioName;
  90     gchar* iradioGenre;
  91     gchar* iradioUrl;
  92     gchar* iradioTitle;
  93
  94     // TRUE if appsrc's version is >= 0.10.27, see
  95     // https://bugzilla.gnome.org/show_bug.cgi?id=609423
  96     gboolean haveAppSrc27;
  97 };
  98
  99 enum {
 100     PROP_IRADIO_MODE = 1,
 101     PROP_IRADIO_NAME,
 102     PROP_IRADIO_GENRE,
 103     PROP_IRADIO_URL,
 104     PROP_IRADIO_TITLE,
 105     PROP_LOCATION
 106 };
 107
 108 static GstStaticPadTemplate srcTemplate = GST_STATIC_PAD_TEMPLATE("src",
 109                                                                   GST_PAD_SRC,
 110                                                                   GST_PAD_ALWAYS,
 111                                                                   GST_STATIC_CAPS_ANY);
 112
 113 GST_DEBUG_CATEGORY_STATIC(webkit_web_src_debug);
 114 #define GST_CAT_DEFAULT webkit_web_src_debug
 115
 116 static void webKitWebSrcUriHandlerInit(gpointer gIface, gpointer ifaceData);
 117
 118 static void webKitWebSrcFinalize(GObject*);
 119 static void webKitWebSrcSetProperty(GObject*, guint propertyID, const GValue*, GParamSpec*);
 120 static void webKitWebSrcGetProperty(GObject*, guint propertyID, GValue*, GParamSpec*);
 121 static GstStateChangeReturn webKitWebSrcChangeState(GstElement*, GstStateChange);
 122
 123 static gboolean webKitWebSrcQueryWithParent(GstPad*, GstObject*, GstQuery*);
 124 #ifndef GST_API_VERSION_1
 125 static gboolean webKitWebSrcQuery(GstPad*, GstQuery*);
 126 #endif
 127
 128 static void webKitWebSrcNeedDataCb(GstAppSrc*, guint length, gpointer userData);
 129 static void webKitWebSrcEnoughDataCb(GstAppSrc*, gpointer userData);
 130 static gboolean webKitWebSrcSeekDataCb(GstAppSrc*, guint64 offset, gpointer userData);
 131
 132 static void webKitWebSrcStop(WebKitWebSrc*, bool);
 133
 134 static GstAppSrcCallbacks appsrcCallbacks = {
 135     webKitWebSrcNeedDataCb,
 136     webKitWebSrcEnoughDataCb,
 137     webKitWebSrcSeekDataCb,
 138     { 0 }
 139 };
 140
 141 #define webkit_web_src_parent_class parent_class
 142 // We split this out into another macro to avoid a check-webkit-style error.
 143 #define WEBKIT_WEB_SRC_CATEGORY_INIT GST_DEBUG_CATEGORY_INIT(webkit_web_src_debug, "webkitwebsrc", 0, "websrc element");
 144 G_DEFINE_TYPE_WITH_CODE(WebKitWebSrc, webkit_web_src, GST_TYPE_BIN,
 145                          G_IMPLEMENT_INTERFACE(GST_TYPE_URI_HANDLER, webKitWebSrcUriHandlerInit);
 146                          WEBKIT_WEB_SRC_CATEGORY_INIT);
 147
 148 static void webkit_web_src_class_init(WebKitWebSrcClass* klass)
 149 {
 150     GObjectClass* oklass = G_OBJECT_CLASS(klass);
 151     GstElementClass* eklass = GST_ELEMENT_CLASS(klass);
 152
 153     oklass->finalize = webKitWebSrcFinalize;
 154     oklass->set_property = webKitWebSrcSetProperty;
 155     oklass->get_property = webKitWebSrcGetProperty;
 156
 157     gst_element_class_add_pad_template(eklass,
 158                                        gst_static_pad_template_get(&srcTemplate));
 159     setGstElementClassMetadata(eklass, "WebKit Web source element", "Source", "Handles HTTP/HTTPS uris",
 160                                "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 161
 162     // icecast stuff
 163     g_object_class_install_property(oklass,
 164                                     PROP_IRADIO_MODE,
 165                                     g_param_spec_boolean("iradio-mode",
 166                                                          "iradio-mode",
 167                                                          "Enable internet radio mode (extraction of shoutcast/icecast metadata)",
 168                                                          FALSE,
 169                                                          (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 170
 171     g_object_class_install_property(oklass,
 172                                     PROP_IRADIO_NAME,
 173                                     g_param_spec_string("iradio-name",
 174                                                         "iradio-name",
 175                                                         "Name of the stream",
 176                                                         0,
 177                                                         (GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));
 178
 179     g_object_class_install_property(oklass,
 180                                     PROP_IRADIO_GENRE,
 181                                     g_param_spec_string("iradio-genre",
 182                                                         "iradio-genre",
 183                                                         "Genre of the stream",
 184                                                         0,
 185                                                         (GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));
 186
 187     g_object_class_install_property(oklass,
 188                                     PROP_IRADIO_URL,
 189                                     g_param_spec_string("iradio-url",
 190                                                         "iradio-url",
 191                                                         "Homepage URL for radio stream",
 192                                                         0,
 193                                                         (GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));
 194
 195     g_object_class_install_property(oklass,
 196                                     PROP_IRADIO_TITLE,
 197                                     g_param_spec_string("iradio-title",
 198                                                         "iradio-title",
 199                                                         "Name of currently playing song",
 200                                                         0,
 201                                                         (GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));
 202
 203
 204     /* Allows setting the uri using the 'location' property, which is used
 205      * for example by gst_element_make_from_uri() */
 206     g_object_class_install_property(oklass,
 207                                     PROP_LOCATION,
 208                                     g_param_spec_string("location",
 209                                                         "location",
 210                                                         "Location to read from",
 211                                                         0,
 212                                                         (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 213     eklass->change_state = webKitWebSrcChangeState;
 214
 215     g_type_class_add_private(klass, sizeof(WebKitWebSrcPrivate));
 216 }
 217
 218 static void webkit_web_src_init(WebKitWebSrc* src)
 219 {
 220     GRefPtr<GstPadTemplate> padTemplate = adoptGRef(gst_static_pad_template_get(&srcTemplate));
 221     WebKitWebSrcPrivate* priv = WEBKIT_WEB_SRC_GET_PRIVATE(src);
 222
 223     src->priv = priv;
 224
 225     priv->client = new StreamingClient(src);
 226
 227     priv->appsrc = GST_APP_SRC(gst_element_factory_make("appsrc", 0));
 228     if (!priv->appsrc) {
 229         GST_ERROR_OBJECT(src, "Failed to create appsrc");
 230         return;
 231     }
 232
 233     GstElementFactory* factory = GST_ELEMENT_FACTORY(GST_ELEMENT_GET_CLASS(priv->appsrc)->elementfactory);
 234     priv->haveAppSrc27 = gst_plugin_feature_check_version(GST_PLUGIN_FEATURE(factory), 0, 10, 27);
 235
 236     gst_bin_add(GST_BIN(src), GST_ELEMENT(priv->appsrc));
 237
 238
 239     GRefPtr<GstPad> targetPad = adoptGRef(gst_element_get_static_pad(GST_ELEMENT(priv->appsrc), "src"));
 240     priv->srcpad = gst_ghost_pad_new_from_template("src", targetPad.get(), padTemplate.get());
 241
 242     gst_element_add_pad(GST_ELEMENT(src), priv->srcpad);
 243
 244 #ifdef GST_API_VERSION_1
 245     GST_OBJECT_FLAG_SET(priv->srcpad, GST_PAD_FLAG_NEED_PARENT);
 246     gst_pad_set_query_function(priv->srcpad, webKitWebSrcQueryWithParent);
 247 #else
 248     gst_pad_set_query_function(priv->srcpad, webKitWebSrcQuery);
 249 #endif
 250
 251     gst_app_src_set_callbacks(priv->appsrc, &appsrcCallbacks, src, 0);
 252     gst_app_src_set_emit_signals(priv->appsrc, FALSE);
 253     gst_app_src_set_stream_type(priv->appsrc, GST_APP_STREAM_TYPE_SEEKABLE);
 254
 255     // 512k is a abitrary number but we should choose a value
 256     // here to not pause/unpause the SoupMessage too often and
 257     // to make sure there's always some data available for
 258     // GStreamer to handle.
 259     gst_app_src_set_max_bytes(priv->appsrc, 512 * 1024);
 260
 261     // Emit the need-data signal if the queue contains less
 262     // than 20% of data. Without this the need-data signal
 263     // is emitted when the queue is empty, we then dispatch
 264     // the soup message unpausing to the main loop and from
 265     // there unpause the soup message. This already takes
 266     // quite some time and libsoup even needs some more time
 267     // to actually provide data again. If we do all this
 268     // already if the queue is 20% empty, it's much more
 269     // likely that libsoup already provides new data before
 270     // the queue is really empty.
 271     // This might need tweaking for ports not using libsoup.
 272     if (priv->haveAppSrc27)
 273         g_object_set(priv->appsrc, "min-percent", 20, NULL);
 274
 275     webKitWebSrcStop(src, false);
 276 }
 277
 278 static void webKitWebSrcFinalize(GObject* object)
 279 {
 280     WebKitWebSrc* src = WEBKIT_WEB_SRC(object);
 281     WebKitWebSrcPrivate* priv = src->priv;
 282
 283     delete priv->client;
 284
 285     g_free(priv->uri);
 286
 287     GST_CALL_PARENT(G_OBJECT_CLASS, finalize, ((GObject* )(src)));
 288 }
 289
 290 static void webKitWebSrcSetProperty(GObject* object, guint propID, const GValue* value, GParamSpec* pspec)
 291 {
 292     WebKitWebSrc* src = WEBKIT_WEB_SRC(object);
 293     WebKitWebSrcPrivate* priv = src->priv;
 294
 295     switch (propID) {
 296     case PROP_IRADIO_MODE:
 297         priv->iradioMode = g_value_get_boolean(value);
 298         break;
 299     case PROP_LOCATION:
 300 #ifdef GST_API_VERSION_1
 301         gst_uri_handler_set_uri(reinterpret_cast<GstURIHandler*>(src), g_value_get_string(value), 0);
 302 #else
 303         gst_uri_handler_set_uri(reinterpret_cast<GstURIHandler*>(src), g_value_get_string(value));
 304 #endif
 305         break;
 306     default:
 307         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, pspec);
 308         break;
 309     }
 310 }
 311
 312 static void webKitWebSrcGetProperty(GObject* object, guint propID, GValue* value, GParamSpec* pspec)
 313 {
 314     WebKitWebSrc* src = WEBKIT_WEB_SRC(object);
 315     WebKitWebSrcPrivate* priv = src->priv;
 316
 317     switch (propID) {
 318     case PROP_IRADIO_MODE:
 319         g_value_set_boolean(value, priv->iradioMode);
 320         break;
 321     case PROP_IRADIO_NAME:
 322         g_value_set_string(value, priv->iradioName);
 323         break;
 324     case PROP_IRADIO_GENRE:
 325         g_value_set_string(value, priv->iradioGenre);
 326         break;
 327     case PROP_IRADIO_URL:
 328         g_value_set_string(value, priv->iradioUrl);
 329         break;
 330     case PROP_IRADIO_TITLE:
 331         g_value_set_string(value, priv->iradioTitle);
 332         break;
 333     case PROP_LOCATION:
 334         g_value_set_string(value, priv->uri);
 335         break;
 336     default:
 337         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, pspec);
 338         break;
 339     }
 340 }
 341
 342 static void webKitWebSrcStop(WebKitWebSrc* src, bool seeking)
 343 {
 344     WebKitWebSrcPrivate* priv = src->priv;
 345     if (priv->resourceHandle) {
 346         priv->resourceHandle->cancel();
 347         priv->resourceHandle.release();
 348     }
 349     priv->resourceHandle = 0;
 350     if (priv->frame && !seeking)
 351         priv->frame.clear();
 352
 353     priv->player = 0;
 354
 355     GST_OBJECT_LOCK(src);
 356     if (priv->needDataID)
 357         g_source_remove(priv->needDataID);
 358     priv->needDataID = 0;
 359
 360     if (priv->enoughDataID)
 361         g_source_remove(priv->enoughDataID);
 362     priv->enoughDataID = 0;
 363
 364     if (priv->seekID)
 365         g_source_remove(priv->seekID);
 366     priv->seekID = 0;
 367
 368     priv->paused = FALSE;
 369     GST_OBJECT_UNLOCK(src);
 370
 371     g_free(priv->iradioName);
 372     priv->iradioName = 0;
 373
 374     g_free(priv->iradioGenre);
 375     priv->iradioGenre = 0;
 376
 377     g_free(priv->iradioUrl);
 378     priv->iradioUrl = 0;
 379
 380     g_free(priv->iradioTitle);
 381     priv->iradioTitle = 0;
 382
 383     if (priv->appsrc) {
 384         gst_app_src_set_caps(priv->appsrc, 0);
 385         if (!seeking)
 386             gst_app_src_set_size(priv->appsrc, -1);
 387     }
 388
 389     priv->offset = 0;
 390     priv->seekable = FALSE;
 391
 392     if (!seeking) {
 393         priv->size = 0;
 394         priv->requestedOffset = 0;
 395     }
 396
 397     GST_DEBUG_OBJECT(src, "Stopped request");
 398 }
 399
 400 static bool webKitWebSrcStart(WebKitWebSrc* src)
 401 {
 402     WebKitWebSrcPrivate* priv = src->priv;
 403
 404     if (!priv->uri) {
 405         GST_ERROR_OBJECT(src, "No URI provided");
 406         return false;
 407     }
 408
 409     KURL url = KURL(KURL(), priv->uri);
 410
 411     ResourceRequest request(url);
 412     request.setAllowCookies(true);
 413
 414     NetworkingContext* context = 0;
 415     FrameLoader* loader = priv->frame ? priv->frame->loader() : 0;
 416     if (loader) {
 417         loader->addExtraFieldsToSubresourceRequest(request);
 418         context = loader->networkingContext();
 419     }
 420
 421     if (priv->player)
 422         request.setHTTPReferrer(priv->player->referrer());
 423
 424     // Let Apple web servers know we want to access their nice movie trailers.
 425     if (!g_ascii_strcasecmp("movies.apple.com", url.host().utf8().data())
 426         || !g_ascii_strcasecmp("trailers.apple.com", url.host().utf8().data()))
 427         request.setHTTPUserAgent("Quicktime/7.6.6");
 428
 429     if (priv->requestedOffset) {
 430         GOwnPtr<gchar> val;
 431
 432         val.set(g_strdup_printf("bytes=%" G_GUINT64_FORMAT "-", priv->requestedOffset));
 433         request.setHTTPHeaderField("Range", val.get());
 434     }
 435
 436     if (priv->iradioMode)
 437         request.setHTTPHeaderField("icy-metadata", "1");
 438
 439     // Needed to use DLNA streaming servers
 440     request.setHTTPHeaderField("transferMode.dlna", "Streaming");
 441
 442     priv->resourceHandle = ResourceHandle::create(context, request, priv->client, false, false);
 443     if (!priv->resourceHandle) {
 444         GST_ERROR_OBJECT(src, "Failed to create ResourceHandle");
 445         return false;
 446     }
 447     GST_DEBUG_OBJECT(src, "Started request");
 448
 449     return true;
 450 }
 451
 452 static GstStateChangeReturn webKitWebSrcChangeState(GstElement* element, GstStateChange transition)
 453 {
 454     GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 455     WebKitWebSrc* src = WEBKIT_WEB_SRC(element);
 456     WebKitWebSrcPrivate* priv = src->priv;
 457
 458     switch (transition) {
 459     case GST_STATE_CHANGE_NULL_TO_READY:
 460         if (!priv->appsrc) {
 461             gst_element_post_message(element,
 462                                      gst_missing_element_message_new(element, "appsrc"));
 463             GST_ELEMENT_ERROR(src, CORE, MISSING_PLUGIN, (0), ("no appsrc"));
 464             return GST_STATE_CHANGE_FAILURE;
 465         }
 466         break;
 467     default:
 468         break;
 469     }
 470
 471     ret = GST_ELEMENT_CLASS(parent_class)->change_state(element, transition);
 472     if (G_UNLIKELY(ret == GST_STATE_CHANGE_FAILURE)) {
 473         GST_DEBUG_OBJECT(src, "State change failed");
 474         return ret;
 475     }
 476
 477     switch (transition) {
 478     case GST_STATE_CHANGE_READY_TO_PAUSED:
 479         GST_DEBUG_OBJECT(src, "READY->PAUSED");
 480         if (!webKitWebSrcStart(src))
 481             ret = GST_STATE_CHANGE_FAILURE;
 482         break;
 483     case GST_STATE_CHANGE_PAUSED_TO_READY:
 484         GST_DEBUG_OBJECT(src, "PAUSED->READY");
 485         webKitWebSrcStop(src, false);
 486         break;
 487     default:
 488         break;
 489     }
 490
 491     return ret;
 492 }
 493
 494 static gboolean webKitWebSrcQueryWithParent(GstPad* pad, GstObject* parent, GstQuery* query)
 495 {
 496     WebKitWebSrc* webkitSrc = WEBKIT_WEB_SRC(GST_ELEMENT(parent));
 497     gboolean result = FALSE;
 498
 499     switch (GST_QUERY_TYPE(query)) {
 500     case GST_QUERY_DURATION: {
 501         GstFormat format;
 502
 503         gst_query_parse_duration(query, &format, NULL);
 504
 505         GST_DEBUG_OBJECT(webkitSrc, "duration query in format %s", gst_format_get_name(format));
 506         if ((format == GST_FORMAT_BYTES) && (webkitSrc->priv->size > 0)) {
 507             gst_query_set_duration(query, format, webkitSrc->priv->size);
 508             result = TRUE;
 509         }
 510         break;
 511     }
 512     case GST_QUERY_URI: {
 513         gst_query_set_uri(query, webkitSrc->priv->uri);
 514         result = TRUE;
 515         break;
 516     }
 517     default: {
 518         GRefPtr<GstPad> target = adoptGRef(gst_ghost_pad_get_target(GST_GHOST_PAD_CAST(pad)));
 519
 520         // Forward the query to the proxy target pad.
 521         if (target)
 522             result = gst_pad_query(target.get(), query);
 523         break;
 524     }
 525     }
 526
 527     return result;
 528 }
 529
 530 #ifndef GST_API_VERSION_1
 531 static gboolean webKitWebSrcQuery(GstPad* pad, GstQuery* query)
 532 {
 533     GRefPtr<GstElement> src = adoptGRef(gst_pad_get_parent_element(pad));
 534     return webKitWebSrcQueryWithParent(pad, GST_OBJECT(src.get()), query);
 535 }
 536 #endif
 537
 538 // uri handler interface
 539
 540 #ifdef GST_API_VERSION_1
 541 static GstURIType webKitWebSrcUriGetType(GType)
 542 {
 543     return GST_URI_SRC;
 544 }
 545
 546 const gchar* const* webKitWebSrcGetProtocols(GType)
 547 {
 548     static const char* protocols[] = {"http", "https", 0 };
 549     return protocols;
 550 }
 551
 552 static gchar* webKitWebSrcGetUri(GstURIHandler* handler)
 553 {
 554     return g_strdup(WEBKIT_WEB_SRC(handler)->priv->uri);
 555 }
 556
 557 static gboolean webKitWebSrcSetUri(GstURIHandler* handler, const gchar* uri, GError** error)
 558 {
 559     WebKitWebSrc* src = WEBKIT_WEB_SRC(handler);
 560     WebKitWebSrcPrivate* priv = src->priv;
 561
 562     if (GST_STATE(src) >= GST_STATE_PAUSED) {
 563         GST_ERROR_OBJECT(src, "URI can only be set in states < PAUSED");
 564         return FALSE;
 565     }
 566
 567     g_free(priv->uri);
 568     priv->uri = 0;
 569
 570     if (!uri)
 571         return TRUE;
 572
 573     KURL url(KURL(), uri);
 574
 575     if (!url.isValid() || !url.protocolIsInHTTPFamily()) {
 576         g_set_error(error, GST_URI_ERROR, GST_URI_ERROR_BAD_URI, "Invalid URI '%s'", uri);
 577         return FALSE;
 578     }
 579
 580     priv->uri = g_strdup(url.string().utf8().data());
 581     return TRUE;
 582 }
 583
 584 #else
 585 static GstURIType webKitWebSrcUriGetType(void)
 586 {
 587     return GST_URI_SRC;
 588 }
 589
 590 static gchar** webKitWebSrcGetProtocols(void)
 591 {
 592     static gchar* protocols[] = {(gchar*) "http", (gchar*) "https", 0 };
 593     return protocols;
 594 }
 595
 596 static const gchar* webKitWebSrcGetUri(GstURIHandler* handler)
 597 {
 598     return g_strdup(WEBKIT_WEB_SRC(handler)->priv->uri);
 599 }
 600
 601 static gboolean webKitWebSrcSetUri(GstURIHandler* handler, const gchar* uri)
 602 {
 603     WebKitWebSrc* src = WEBKIT_WEB_SRC(handler);
 604     WebKitWebSrcPrivate* priv = src->priv;
 605
 606     if (GST_STATE(src) >= GST_STATE_PAUSED) {
 607         GST_ERROR_OBJECT(src, "URI can only be set in states < PAUSED");
 608         return FALSE;
 609     }
 610
 611     g_free(priv->uri);
 612     priv->uri = 0;
 613
 614     if (!uri)
 615         return TRUE;
 616
 617     KURL url(KURL(), uri);
 618
 619     if (!url.isValid() || !url.protocolIsInHTTPFamily()) {
 620         GST_ERROR_OBJECT(src, "Invalid URI '%s'", uri);
 621         return FALSE;
 622     }
 623
 624     priv->uri = g_strdup(url.string().utf8().data());
 625     return TRUE;
 626 }
 627 #endif
 628
 629 static void webKitWebSrcUriHandlerInit(gpointer gIface, gpointer ifaceData)
 630 {
 631     GstURIHandlerInterface* iface = (GstURIHandlerInterface *) gIface;
 632
 633     iface->get_type = webKitWebSrcUriGetType;
 634     iface->get_protocols = webKitWebSrcGetProtocols;
 635     iface->get_uri = webKitWebSrcGetUri;
 636     iface->set_uri = webKitWebSrcSetUri;
 637 }
 638
 639 // appsrc callbacks
 640
 641 static gboolean webKitWebSrcNeedDataMainCb(WebKitWebSrc* src)
 642 {
 643     WebKitWebSrcPrivate* priv = src->priv;
 644
 645     priv->resourceHandle->setDefersLoading(false);
 646
 647     GST_OBJECT_LOCK(src);
 648     priv->paused = FALSE;
 649     priv->needDataID = 0;
 650     GST_OBJECT_UNLOCK(src);
 651     return FALSE;
 652 }
 653
 654 static void webKitWebSrcNeedDataCb(GstAppSrc* appsrc, guint length, gpointer userData)
 655 {
 656     WebKitWebSrc* src = WEBKIT_WEB_SRC(userData);
 657     WebKitWebSrcPrivate* priv = src->priv;
 658
 659     GST_DEBUG_OBJECT(src, "Need more data: %u", length);
 660
 661     GST_OBJECT_LOCK(src);
 662     if (priv->needDataID || !priv->paused) {
 663         GST_OBJECT_UNLOCK(src);
 664         return;
 665     }
 666
 667     priv->needDataID = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitWebSrcNeedDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
 668     GST_OBJECT_UNLOCK(src);
 669 }
 670
 671 static gboolean webKitWebSrcEnoughDataMainCb(WebKitWebSrc* src)
 672 {
 673     WebKitWebSrcPrivate* priv = src->priv;
 674
 675     priv->resourceHandle->setDefersLoading(true);
 676
 677     GST_OBJECT_LOCK(src);
 678     priv->paused = TRUE;
 679     priv->enoughDataID = 0;
 680     GST_OBJECT_UNLOCK(src);
 681
 682     return FALSE;
 683 }
 684
 685 static void webKitWebSrcEnoughDataCb(GstAppSrc* appsrc, gpointer userData)
 686 {
 687     WebKitWebSrc* src = WEBKIT_WEB_SRC(userData);
 688     WebKitWebSrcPrivate* priv = src->priv;
 689
 690     GST_DEBUG_OBJECT(src, "Have enough data");
 691
 692     GST_OBJECT_LOCK(src);
 693     if (priv->enoughDataID || priv->paused) {
 694         GST_OBJECT_UNLOCK(src);
 695         return;
 696     }
 697
 698     priv->enoughDataID = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitWebSrcEnoughDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
 699     GST_OBJECT_UNLOCK(src);
 700 }
 701
 702 static gboolean webKitWebSrcSeekMainCb(WebKitWebSrc* src)
 703 {
 704     webKitWebSrcStop(src, true);
 705     webKitWebSrcStart(src);
 706
 707     return FALSE;
 708 }
 709
 710 static gboolean webKitWebSrcSeekDataCb(GstAppSrc* appsrc, guint64 offset, gpointer userData)
 711 {
 712     WebKitWebSrc* src = WEBKIT_WEB_SRC(userData);
 713     WebKitWebSrcPrivate* priv = src->priv;
 714
 715     GST_DEBUG_OBJECT(src, "Seeking to offset: %" G_GUINT64_FORMAT, offset);
 716     if (offset == priv->offset)
 717         return TRUE;
 718
 719     if (!priv->seekable)
 720         return FALSE;
 721     if (offset > priv->size)
 722         return FALSE;
 723
 724     GST_DEBUG_OBJECT(src, "Doing range-request seek");
 725     priv->requestedOffset = offset;
 726
 727     GST_OBJECT_LOCK(src);
 728     if (priv->seekID)
 729         g_source_remove(priv->seekID);
 730     priv->seekID = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitWebSrcSeekMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
 731     GST_OBJECT_UNLOCK(src);
 732
 733     return TRUE;
 734 }
 735
 736 void webKitWebSrcSetMediaPlayer(WebKitWebSrc* src, WebCore::MediaPlayer* player)
 737 {
 738     WebKitWebSrcPrivate* priv = src->priv;
 739     WebCore::Frame* frame = 0;
 740
 741     WebCore::Document* document = player->mediaPlayerClient()->mediaPlayerOwningDocument();
 742     if (document)
 743         frame = document->frame();
 744
 745     priv->frame = frame;
 746     priv->player = player;
 747 }
 748
 749 StreamingClient::StreamingClient(WebKitWebSrc* src) : m_src(src)
 750 {
 751
 752 }
 753
 754 StreamingClient::~StreamingClient()
 755 {
 756
 757 }
 758
 759 void StreamingClient::willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse&)
 760 {
 761
 762 }
 763
 764 void StreamingClient::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
 765 {
 766     WebKitWebSrcPrivate* priv = m_src->priv;
 767
 768     GST_DEBUG_OBJECT(m_src, "Received response: %d", response.httpStatusCode());
 769
 770     // If we seeked we need 206 == PARTIAL_CONTENT
 771     if (priv->requestedOffset && response.httpStatusCode() != 206) {
 772         GST_ELEMENT_ERROR(m_src, RESOURCE, READ, (0), (0));
 773         gst_app_src_end_of_stream(priv->appsrc);
 774         webKitWebSrcStop(m_src, false);
 775         return;
 776     }
 777
 778     long long length = response.expectedContentLength();
 779     if (length > 0) {
 780         length += priv->requestedOffset;
 781         gst_app_src_set_size(priv->appsrc, length);
 782         if (!priv->haveAppSrc27) {
 783 #ifdef GST_API_VERSION_1
 784             GstSegment* segment = &GST_BASE_SRC(priv->appsrc)->segment;
 785             segment->duration = length;
 786             segment->format = GST_FORMAT_BYTES;
 787 #else
 788             gst_segment_set_duration(&GST_BASE_SRC(priv->appsrc)->segment, GST_FORMAT_BYTES, length);
 789 #endif
 790             gst_element_post_message(GST_ELEMENT(priv->appsrc),
 791                                      gst_message_new_duration(GST_OBJECT(priv->appsrc),
 792                                                               GST_FORMAT_BYTES, length));
 793         }
 794     }
 795
 796     priv->size = length >= 0 ? length : 0;
 797     priv->seekable = length > 0 && g_ascii_strcasecmp("none", response.httpHeaderField("Accept-Ranges").utf8().data());
 798     // icecast stuff
 799     String value = response.httpHeaderField("icy-metaint");
 800     if (!value.isEmpty()) {
 801         gchar* endptr = 0;
 802         gint64 icyMetaInt = g_ascii_strtoll(value.utf8().data(), &endptr, 10);
 803
 804         if (endptr && *endptr == '\0' && icyMetaInt > 0) {
 805             GRefPtr<GstCaps> caps = adoptGRef(gst_caps_new_simple("application/x-icy", "metadata-interval", G_TYPE_INT, (gint) icyMetaInt, NULL));
 806
 807             gst_app_src_set_caps(priv->appsrc, caps.get());
 808         }
 809     }
 810
 811 #ifdef GST_API_VERSION_1
 812     GstTagList* tags = gst_tag_list_new_empty();
 813 #else
 814     GstTagList* tags = gst_tag_list_new();
 815 #endif
 816     value = response.httpHeaderField("icy-name");
 817     if (!value.isEmpty()) {
 818         g_free(priv->iradioName);
 819         priv->iradioName = g_strdup(value.utf8().data());
 820         g_object_notify(G_OBJECT(m_src), "iradio-name");
 821         gst_tag_list_add(tags, GST_TAG_MERGE_REPLACE, GST_TAG_ORGANIZATION, priv->iradioName, NULL);
 822     }
 823     value = response.httpHeaderField("icy-genre");
 824     if (!value.isEmpty()) {
 825         g_free(priv->iradioGenre);
 826         priv->iradioGenre = g_strdup(value.utf8().data());
 827         g_object_notify(G_OBJECT(m_src), "iradio-genre");
 828         gst_tag_list_add(tags, GST_TAG_MERGE_REPLACE, GST_TAG_GENRE, priv->iradioGenre, NULL);
 829     }
 830     value = response.httpHeaderField("icy-url");
 831     if (!value.isEmpty()) {
 832         g_free(priv->iradioUrl);
 833         priv->iradioUrl = g_strdup(value.utf8().data());
 834         g_object_notify(G_OBJECT(m_src), "iradio-url");
 835         gst_tag_list_add(tags, GST_TAG_MERGE_REPLACE, GST_TAG_LOCATION, priv->iradioUrl, NULL);
 836     }
 837     value = response.httpHeaderField("icy-title");
 838     if (!value.isEmpty()) {
 839         g_free(priv->iradioTitle);
 840         priv->iradioTitle = g_strdup(value.utf8().data());
 841         g_object_notify(G_OBJECT(m_src), "iradio-title");
 842         gst_tag_list_add(tags, GST_TAG_MERGE_REPLACE, GST_TAG_TITLE, priv->iradioTitle, NULL);
 843     }
 844
 845     if (gst_tag_list_is_empty(tags))
 846 #ifdef GST_API_VERSION_1
 847         gst_tag_list_unref(tags);
 848 #else
 849         gst_tag_list_free(tags);
 850 #endif
 851     else
 852 #ifdef GST_API_VERSION_1
 853         gst_pad_push_event(GST_PAD_CAST(m_src->priv->srcpad), gst_event_new_tag("WebKitWebSrc", tags));
 854 #else
 855         gst_element_found_tags_for_pad(GST_ELEMENT(m_src), m_src->priv->srcpad, tags);
 856 #endif
 857 }
 858
 859 void StreamingClient::didReceiveData(ResourceHandle* handle, const char* data, int length, int encodedDataLength)
 860 {
 861     WebKitWebSrcPrivate* priv = m_src->priv;
 862
 863     GST_LOG_OBJECT(m_src, "Have %d bytes of data", length);
 864
 865     if (priv->seekID || handle != priv->resourceHandle) {
 866         GST_DEBUG_OBJECT(m_src, "Seek in progress, ignoring data");
 867         return;
 868     }
 869
 870     GstBuffer* buffer = gst_buffer_new_and_alloc(length);
 871 #ifdef GST_API_VERSION_1
 872     gst_buffer_fill(buffer, 0, data, length);
 873 #else
 874     memcpy(GST_BUFFER_DATA(buffer), data, length);
 875 #endif
 876     GST_BUFFER_OFFSET(buffer) = priv->offset;
 877     priv->offset += length;
 878     GST_BUFFER_OFFSET_END(buffer) = priv->offset;
 879
 880     GstFlowReturn ret = gst_app_src_push_buffer(priv->appsrc, buffer);
 881 #ifdef GST_API_VERSION_1
 882     if (ret != GST_FLOW_OK && ret != GST_FLOW_EOS)
 883 #else
 884     if (ret != GST_FLOW_OK && ret != GST_FLOW_UNEXPECTED)
 885 #endif
 886         GST_ELEMENT_ERROR(m_src, CORE, FAILED, (0), (0));
 887 }
 888
 889 void StreamingClient::didFinishLoading(ResourceHandle*, double)
 890 {
 891     WebKitWebSrcPrivate* priv = m_src->priv;
 892
 893     GST_DEBUG_OBJECT(m_src, "Have EOS");
 894
 895     if (!priv->seekID)
 896         gst_app_src_end_of_stream(m_src->priv->appsrc);
 897 }
 898
 899 void StreamingClient::didFail(ResourceHandle*, const ResourceError& error)
 900 {
 901     GST_ERROR_OBJECT(m_src, "Have failure: %s", error.localizedDescription().utf8().data());
 902     GST_ELEMENT_ERROR(m_src, RESOURCE, FAILED, ("%s", error.localizedDescription().utf8().data()), (0));
 903     gst_app_src_end_of_stream(m_src->priv->appsrc);
 904 }
 905
 906 void StreamingClient::wasBlocked(ResourceHandle*)
 907 {
 908     GST_ERROR_OBJECT(m_src, "Request was blocked");
 909     GST_ELEMENT_ERROR(m_src, RESOURCE, OPEN_READ, ("Access to \"%s\" was blocked", m_src->priv->uri), (0));
 910 }
 911
 912 void StreamingClient::cannotShowURL(ResourceHandle*)
 913 {
 914     GST_ERROR_OBJECT(m_src, "Cannot show URL");
 915     GST_ELEMENT_ERROR(m_src, RESOURCE, OPEN_READ, ("Can't show \"%s\"", m_src->priv->uri), (0));
 916 }
 917
 918 #endif // USE(GSTREAMER)
 919