khtml/html/HTMLMediaElement.cpp

   1 /*
   2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include <wtf/Platform.h>
  27
  28 #include "HTMLMediaElement.h"
  29 #include "HTMLDocument.h"
  30 #include <misc/htmlhashes.h>
  31 #include <rendering/render_object.h>
  32 #include "MediaError.h"
  33 #include "TimeRanges.h"
  34
  35 const double doubleMax = 999999999.8; // ### numeric_limits<double>::max()
  36 const double doubleInf = 999999999.0; // ### numeric_limits<double>::infinity()
  37
  38 using namespace DOM;
  39
  40 namespace khtml {
  41
  42 HTMLMediaElement::HTMLMediaElement(Document* doc)
  43     : HTMLElement(doc)
  44     , m_defaultPlaybackRate(1.0f)
  45     , m_networkState(EMPTY)
  46     , m_readyState(DATA_UNAVAILABLE)
  47     , m_begun(false)
  48     , m_loadedFirstFrame(false)
  49     , m_autoplaying(true)
  50     , m_currentLoop(0)
  51     , m_volume(0.5f)
  52     , m_muted(false)
  53     , m_paused(true)
  54     , m_seeking(false)
  55     , m_currentTimeDuringSeek(0)
  56     , m_previousProgress(0)
  57     , m_previousProgressTime(doubleMax)
  58     , m_sentStalledEvent(false)
  59     , m_bufferingRate(0)
  60     , m_player(0)
  61 {
  62 }
  63
  64 HTMLMediaElement::~HTMLMediaElement()
  65 {
  66 }
  67
  68 void HTMLMediaElement::attributeChanged(NodeImpl::Id attrId)
  69 {
  70     HTMLElement::attributeChanged(attrId);
  71
  72     if (attrId == ATTR_SRC) {
  73         // 3.14.9.2.
  74         // change to src attribute triggers load()
  75         if (inDocument() && m_networkState == EMPTY)
  76             scheduleLoad();
  77     } if (attrId == ATTR_CONTROLS) {
  78         if (!isVideo() && attached() && (controls() != (renderer() != 0))) {
  79             detach();
  80             attach();
  81         }
  82         if (renderer())
  83             renderer()->updateFromElement();
  84     }
  85 }
  86
  87 void HTMLMediaElement::scheduleLoad()
  88 {
  89     // ###
  90 }
  91
  92 String serializeTimeOffset(float time)
  93 {
  94     QString timeString = QString::number(time);
  95     // FIXME serialize time offset values properly (format not specified yet)
  96     timeString.append("s");
  97     return timeString;
  98 }
  99
 100 float parseTimeOffset(const String& timeString, bool* ok = 0)
 101 {
 102 #if 0
 103     const UChar* characters = timeString.characters();
 104     unsigned length = timeString.length();
 105
 106     if (length && characters[length - 1] == 's')
 107         length--;
 108
 109     // FIXME parse time offset values (format not specified yet)
 110     float val = charactersToFloat(characters, length, ok);
 111     return val;
 112 #else
 113     return timeString.string().toFloat(ok);
 114 #endif
 115 }
 116
 117 float HTMLMediaElement::getTimeOffsetAttribute(NodeImpl::Id name, float valueOnError) const
 118 {
 119     bool ok;
 120     String timeString = getAttribute(name);
 121     float result = parseTimeOffset(timeString, &ok);
 122     if (ok)
 123         return result;
 124     return valueOnError;
 125 }
 126
 127 void HTMLMediaElement::setTimeOffsetAttribute(NodeImpl::Id name, float value)
 128 {
 129     setAttribute(name, serializeTimeOffset(value));
 130 }
 131
 132 PassRefPtr<MediaError> HTMLMediaElement::error() const
 133 {
 134     return m_error;
 135 }
 136
 137 String HTMLMediaElement::src() const
 138 {
 139     return document()->completeURL(getAttribute(ATTR_SRC).string());
 140 }
 141
 142 void HTMLMediaElement::setSrc(const String& url)
 143 {
 144     setAttribute(ATTR_SRC, url);
 145 }
 146
 147 String HTMLMediaElement::currentSrc() const
 148 {
 149     return m_currentSrc;
 150 }
 151
 152 HTMLMediaElement::NetworkState HTMLMediaElement::networkState() const
 153 {
 154     return m_networkState;
 155 }
 156
 157 float HTMLMediaElement::bufferingRate()
 158 {
 159     if (!m_player)
 160         return 0;
 161     return m_bufferingRate;
 162 }
 163
 164 void HTMLMediaElement::load(ExceptionCode&)
 165 {
 166     // ###
 167 }
 168
 169 void HTMLMediaElement::setReadyState(ReadyState state)
 170 {
 171     // 3.14.9.6. The ready states
 172     if (m_readyState == state)
 173         return;
 174
 175     // ###
 176
 177     updatePlayState();
 178 }
 179
 180 HTMLMediaElement::ReadyState HTMLMediaElement::readyState() const
 181 {
 182     return m_readyState;
 183 }
 184
 185 bool HTMLMediaElement::seeking() const
 186 {
 187     return m_seeking;
 188 }
 189
 190 // playback state
 191 float HTMLMediaElement::currentTime() const
 192 {
 193     if (!m_player)
 194         return 0;
 195     if (m_seeking)
 196         return m_currentTimeDuringSeek;
 197     return m_player->currentTime();
 198 }
 199
 200 void HTMLMediaElement::setCurrentTime(float time, ExceptionCode& ec)
 201 {
 202     //    seek(time, ec);
 203 }
 204
 205 float HTMLMediaElement::duration() const
 206 {
 207     return m_player ? m_player->duration() : 0;
 208 }
 209
 210 bool HTMLMediaElement::paused() const
 211 {
 212     return m_paused;
 213 }
 214
 215 float HTMLMediaElement::defaultPlaybackRate() const
 216 {
 217     return m_defaultPlaybackRate;
 218 }
 219
 220 void HTMLMediaElement::setDefaultPlaybackRate(float rate, ExceptionCode& ec)
 221 {
 222     if (rate == 0.0f) {
 223         ec = DOMException::NOT_SUPPORTED_ERR;
 224         return;
 225     }
 226     if (m_defaultPlaybackRate != rate) {
 227         m_defaultPlaybackRate = rate;
 228         // ### dispatchEventAsync(ratechangeEvent);
 229     }
 230 }
 231
 232 float HTMLMediaElement::playbackRate() const
 233 {
 234     return m_player ? m_player->rate() : 0;
 235 }
 236
 237 void HTMLMediaElement::setPlaybackRate(float rate, ExceptionCode& ec)
 238 {
 239     if (rate == 0.0f) {
 240         ec = DOMException::NOT_SUPPORTED_ERR;
 241         return;
 242     }
 243     if (m_player && m_player->rate() != rate) {
 244         m_player->setRate(rate);
 245         // ### dispatchEventAsync(ratechangeEvent);
 246     }
 247 }
 248
 249 bool HTMLMediaElement::ended() const
 250 {
 251     return endedPlayback();
 252 }
 253
 254 bool HTMLMediaElement::autoplay() const
 255 {
 256     return hasAttribute(ATTR_AUTOPLAY);
 257 }
 258
 259 void HTMLMediaElement::setAutoplay(bool b)
 260 {
 261     //   setBooleanAttribute(ATTR_AUTOPLAY, b);
 262 }
 263
 264 void HTMLMediaElement::play(ExceptionCode& ec)
 265 {
 266     // 3.14.9.7. Playing the media resource
 267     if (!m_player || networkState() == EMPTY) {
 268         ec = 0;
 269         load(ec);
 270         if (ec)
 271             return;
 272     }
 273     ExceptionCode unused;
 274     if (endedPlayback()) {
 275         m_currentLoop = 0;
 276         // ### seek(effectiveStart(), unused);
 277     }
 278     setPlaybackRate(defaultPlaybackRate(), unused);
 279
 280     if (m_paused) {
 281         m_paused = false;
 282         // ### dispatchEventAsync(playEvent);
 283     }
 284
 285     m_autoplaying = false;
 286
 287     updatePlayState();
 288 }
 289
 290 void HTMLMediaElement::pause(ExceptionCode& ec)
 291 {
 292     // 3.14.9.7. Playing the media resource
 293     if (!m_player || networkState() == EMPTY) {
 294         ec = 0;
 295         load(ec);
 296         if (ec)
 297             return;
 298     }
 299
 300     if (!m_paused) {
 301         m_paused = true;
 302         // ### dispatchEventAsync(timeupdateEvent);
 303         // ### dispatchEventAsync(pauseEvent);
 304     }
 305
 306     m_autoplaying = false;
 307
 308     updatePlayState();
 309 }
 310
 311 unsigned HTMLMediaElement::playCount() const
 312 {
 313     String val = getAttribute(ATTR_PLAYCOUNT);
 314     int count = val.toInt();
 315     return qMax(count, 1);
 316 }
 317
 318 void HTMLMediaElement::setPlayCount(unsigned count, ExceptionCode& ec)
 319 {
 320     if (!count) {
 321         ec = DOMException::INDEX_SIZE_ERR;
 322         return;
 323     }
 324     setAttribute(ATTR_PLAYCOUNT, QString::number(count));
 325     checkIfSeekNeeded();
 326 }
 327
 328 float HTMLMediaElement::start() const
 329 {
 330     return getTimeOffsetAttribute(ATTR_START, 0);
 331 }
 332
 333 void HTMLMediaElement::setStart(float time)
 334 {
 335     setTimeOffsetAttribute(ATTR_START, time);
 336     checkIfSeekNeeded();
 337 }
 338
 339 float HTMLMediaElement::end() const
 340 {
 341     return getTimeOffsetAttribute(ATTR_END, doubleInf);
 342 }
 343
 344 void HTMLMediaElement::setEnd(float time)
 345 {
 346     setTimeOffsetAttribute(ATTR_END, time);
 347     checkIfSeekNeeded();
 348 }
 349
 350 float HTMLMediaElement::loopStart() const
 351 {
 352     return getTimeOffsetAttribute(ATTR_LOOPSTART, 0);
 353 }
 354
 355 void HTMLMediaElement::setLoopStart(float time)
 356 {
 357     setTimeOffsetAttribute(ATTR_LOOPSTART, time);
 358     checkIfSeekNeeded();
 359 }
 360
 361 float HTMLMediaElement::loopEnd() const
 362 {
 363     return getTimeOffsetAttribute(ATTR_LOOPEND, doubleInf);
 364 }
 365
 366 void HTMLMediaElement::setLoopEnd(float time)
 367 {
 368     setTimeOffsetAttribute(ATTR_LOOPEND, time);
 369     checkIfSeekNeeded();
 370 }
 371
 372 unsigned HTMLMediaElement::currentLoop() const
 373 {
 374     return m_currentLoop;
 375 }
 376
 377 void HTMLMediaElement::setCurrentLoop(unsigned currentLoop)
 378 {
 379     m_currentLoop = currentLoop;
 380 }
 381
 382 bool HTMLMediaElement::controls() const
 383 {
 384     return hasAttribute(ATTR_CONTROLS);
 385 }
 386
 387 void HTMLMediaElement::setControls(bool b)
 388 {
 389     // setBooleanAttribute(ATTR_CONTROLS, b);
 390 }
 391
 392 float HTMLMediaElement::volume() const
 393 {
 394     return m_volume;
 395 }
 396
 397 void HTMLMediaElement::setVolume(float vol, ExceptionCode& ec)
 398 {
 399     if (vol < 0.0f || vol > 1.0f) {
 400         ec = DOMException::INDEX_SIZE_ERR;
 401         return;
 402     }
 403
 404     if (m_volume != vol) {
 405         m_volume = vol;
 406         updateVolume();
 407         // ### dispatchEventAsync(volumechangeEvent);
 408     }
 409 }
 410
 411 bool HTMLMediaElement::muted() const
 412 {
 413     return m_muted;
 414 }
 415
 416 void HTMLMediaElement::setMuted(bool muted)
 417 {
 418     if (m_muted != muted) {
 419         m_muted = muted;
 420         updateVolume();
 421         // ### dispatchEventAsync(volumechangeEvent);
 422     }
 423 }
 424
 425 void HTMLMediaElement::checkIfSeekNeeded()
 426 {
 427     // ###
 428 }
 429
 430 PassRefPtr<TimeRanges> HTMLMediaElement::buffered() const
 431 {
 432     // FIXME real ranges support
 433     if (!m_player || !m_player->maxTimeBuffered())
 434         return new TimeRanges;
 435     return new TimeRanges(0, m_player->maxTimeBuffered());
 436 }
 437
 438 PassRefPtr<TimeRanges> HTMLMediaElement::played() const
 439 {
 440     // FIXME track played
 441     return new TimeRanges;
 442 }
 443
 444 PassRefPtr<TimeRanges> HTMLMediaElement::seekable() const
 445 {
 446     // FIXME real ranges support
 447     if (!m_player || !m_player->maxTimeSeekable())
 448         return new TimeRanges;
 449     return new TimeRanges(0, m_player->maxTimeSeekable());
 450 }
 451
 452 bool HTMLMediaElement::endedPlayback() const
 453 {
 454 #if 0
 455     return networkState() >= LOADED_METADATA && currentTime() >= effectiveEnd() && currentLoop() == playCount() - 1;
 456 #endif
 457     return false;
 458 }
 459
 460 void HTMLMediaElement::updateVolume()
 461 {
 462     if (!m_player)
 463         return;
 464
 465     m_player->setVolume(m_muted ? 0 : m_volume);
 466
 467     if (renderer())
 468         renderer()->updateFromElement();
 469 }
 470
 471 void HTMLMediaElement::updatePlayState()
 472 {
 473     if (!m_player)
 474         return;
 475
 476     // ###
 477 }
 478
 479 }