Changeset 142005 in webkit


Ignore:
Timestamp:
Feb 6, 2013 10:15:30 AM (11 years ago)
Author:
commit-queue@webkit.org
Message:

[GStreamer] MediaPlayer's code is not easily reusable by other GStreamer-based players
​https://bugs.webkit.org/show_bug.cgi?id=100261

.:

Patch by Jonathon Jongsma <​jonathon.jongsma@collabora.com> on 2013-02-06
Reviewed by Philippe Normand

  • configure.ac: removed farstream requirement for now since it's

not actually used yet and makes it more difficult to build and test

Source/WebCore:

Refactor the media player implementation so that more of the
internal functionality can be shared between the current media
backend and the mediastream player backend. Common code is
broken out into a MediaPlayerPrivateGStreamerBase class, and
both MediaPlayerPrivateGStreamer and
StreamMediaPlayerPrivateGStreamer inherit from this base class.

Patch by Jonathon Jongsma <​jonathon.jongsma@collabora.com> on 2013-02-06
Reviewed by Philippe Normand

No new tests since functionality is covered by existing media tests

  • GNUmakefile.list.am:
  • PlatformEfl.cmake:
  • Target.pri:
  • platform/graphics/gstreamer/FullscreenVideoControllerGStreamer.cpp:

(WebCore::FullscreenVideoControllerGStreamer::create):
(WebCore::FullscreenVideoControllerGStreamer::FullscreenVideoControllerGStreamer):

  • platform/graphics/gstreamer/FullscreenVideoControllerGStreamer.h:

(WebCore):
(FullscreenVideoControllerGStreamer):

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:

(WebCore::MediaPlayerPrivateGStreamer::MediaPlayerPrivateGStreamer):
(WebCore::MediaPlayerPrivateGStreamer::~MediaPlayerPrivateGStreamer):

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:

(MediaPlayerPrivateGStreamer):
(WebCore::MediaPlayerPrivateGStreamer::isLiveStream):

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp: Added.

(WebCore):
(WebCore::greatestCommonDivisor):
(WebCore::mediaPlayerPrivateVolumeChangedCallback):
(WebCore::mediaPlayerPrivateVolumeChangeTimeoutCallback):
(WebCore::mediaPlayerPrivateMuteChangedCallback):
(WebCore::mediaPlayerPrivateMuteChangeTimeoutCallback):
(WebCore::mediaPlayerPrivateRepaintCallback):
(WebCore::MediaPlayerPrivateGStreamerBase::MediaPlayerPrivateGStreamerBase):
(WebCore::MediaPlayerPrivateGStreamerBase::~MediaPlayerPrivateGStreamerBase):
(WebCore::MediaPlayerPrivateGStreamerBase::naturalSize):
(WebCore::MediaPlayerPrivateGStreamerBase::setVolume):
(WebCore::MediaPlayerPrivateGStreamerBase::volume):
(WebCore::MediaPlayerPrivateGStreamerBase::notifyPlayerOfVolumeChange):
(WebCore::MediaPlayerPrivateGStreamerBase::volumeChanged):
(WebCore::MediaPlayerPrivateGStreamerBase::networkState):
(WebCore::MediaPlayerPrivateGStreamerBase::readyState):
(WebCore::MediaPlayerPrivateGStreamerBase::sizeChanged):
(WebCore::MediaPlayerPrivateGStreamerBase::setMuted):
(WebCore::MediaPlayerPrivateGStreamerBase::muted):
(WebCore::MediaPlayerPrivateGStreamerBase::notifyPlayerOfMute):
(WebCore::MediaPlayerPrivateGStreamerBase::muteChanged):
(WebCore::MediaPlayerPrivateGStreamerBase::triggerRepaint):
(WebCore::MediaPlayerPrivateGStreamerBase::setSize):
(WebCore::MediaPlayerPrivateGStreamerBase::paint):
(WebCore::MediaPlayerPrivateGStreamerBase::enterFullscreen):
(WebCore::MediaPlayerPrivateGStreamerBase::exitFullscreen):
(WebCore::MediaPlayerPrivateGStreamerBase::supportsFullscreen):
(WebCore::MediaPlayerPrivateGStreamerBase::platformMedia):
(WebCore::MediaPlayerPrivateGStreamerBase::movieLoadType):
(WebCore::MediaPlayerPrivateGStreamerBase::createVideoSink):
(WebCore::MediaPlayerPrivateGStreamerBase::setStreamVolumeElement):
(WebCore::MediaPlayerPrivateGStreamerBase::decodedFrameCount):
(WebCore::MediaPlayerPrivateGStreamerBase::droppedFrameCount):
(WebCore::MediaPlayerPrivateGStreamerBase::audioDecodedByteCount):
(WebCore::MediaPlayerPrivateGStreamerBase::videoDecodedByteCount):

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h: Added.

(WebCore):
(MediaPlayerPrivateGStreamerBase):
(WebCore::MediaPlayerPrivateGStreamerBase::supportsMuting):
(WebCore::MediaPlayerPrivateGStreamerBase::setVisible):
(WebCore::MediaPlayerPrivateGStreamerBase::hasSingleSecurityOrigin):
(WebCore::MediaPlayerPrivateGStreamerBase::maxTimeLoaded):
(WebCore::MediaPlayerPrivateGStreamerBase::canEnterFullscreen):
(WebCore::MediaPlayerPrivateGStreamerBase::mediaPlayer):
(WebCore::MediaPlayerPrivateGStreamerBase::audioSink):

  • platform/graphics/gtk/FullscreenVideoControllerGtk.cpp:

(WebCore::FullscreenVideoControllerGtk::FullscreenVideoControllerGtk):

  • platform/graphics/gtk/FullscreenVideoControllerGtk.h:

(FullscreenVideoControllerGtk):

Location:
trunk
Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/ChangeLog

    r141985 r142005  
     12013-02-06  Jonathon Jongsma  <jonathon.jongsma@collabora.com>
     2
     3        [GStreamer] MediaPlayer's code is not easily reusable by other GStreamer-based players
     4        https://bugs.webkit.org/show_bug.cgi?id=100261
     5
     6        Reviewed by Philippe Normand
     7
     8        * configure.ac: removed farstream requirement for now since it's
     9        not actually used yet and makes it more difficult to build and test
     10
    1112013-02-06  Mike West  <mkwst@chromium.org>
    212

  • trunk/Source/WebCore/ChangeLog

    r142004 r142005  
     12013-02-06  Jonathon Jongsma  <jonathon.jongsma@collabora.com>
     2
     3        [GStreamer] MediaPlayer's code is not easily reusable by other GStreamer-based players
     4        https://bugs.webkit.org/show_bug.cgi?id=100261
     5
     6        Refactor the media player implementation so that more of the
     7        internal functionality can be shared between the current media
     8        backend and the mediastream player backend.  Common code is
     9        broken out into a MediaPlayerPrivateGStreamerBase class, and
     10        both MediaPlayerPrivateGStreamer and
     11        StreamMediaPlayerPrivateGStreamer inherit from this base class.
     12
     13        Reviewed by Philippe Normand
     14
     15        No new tests since functionality is covered by existing media tests
     16
     17        * GNUmakefile.list.am:
     18        * PlatformEfl.cmake:
     19        * Target.pri:
     20        * platform/graphics/gstreamer/FullscreenVideoControllerGStreamer.cpp:
     21        (WebCore::FullscreenVideoControllerGStreamer::create):
     22        (WebCore::FullscreenVideoControllerGStreamer::FullscreenVideoControllerGStreamer):
     23        * platform/graphics/gstreamer/FullscreenVideoControllerGStreamer.h:
     24        (WebCore):
     25        (FullscreenVideoControllerGStreamer):
     26        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
     27        (WebCore::MediaPlayerPrivateGStreamer::MediaPlayerPrivateGStreamer):
     28        (WebCore::MediaPlayerPrivateGStreamer::~MediaPlayerPrivateGStreamer):
     29        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
     30        (MediaPlayerPrivateGStreamer):
     31        (WebCore::MediaPlayerPrivateGStreamer::isLiveStream):
     32        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp: Added.
     33        (WebCore):
     34        (WebCore::greatestCommonDivisor):
     35        (WebCore::mediaPlayerPrivateVolumeChangedCallback):
     36        (WebCore::mediaPlayerPrivateVolumeChangeTimeoutCallback):
     37        (WebCore::mediaPlayerPrivateMuteChangedCallback):
     38        (WebCore::mediaPlayerPrivateMuteChangeTimeoutCallback):
     39        (WebCore::mediaPlayerPrivateRepaintCallback):
     40        (WebCore::MediaPlayerPrivateGStreamerBase::MediaPlayerPrivateGStreamerBase):
     41        (WebCore::MediaPlayerPrivateGStreamerBase::~MediaPlayerPrivateGStreamerBase):
     42        (WebCore::MediaPlayerPrivateGStreamerBase::naturalSize):
     43        (WebCore::MediaPlayerPrivateGStreamerBase::setVolume):
     44        (WebCore::MediaPlayerPrivateGStreamerBase::volume):
     45        (WebCore::MediaPlayerPrivateGStreamerBase::notifyPlayerOfVolumeChange):
     46        (WebCore::MediaPlayerPrivateGStreamerBase::volumeChanged):
     47        (WebCore::MediaPlayerPrivateGStreamerBase::networkState):
     48        (WebCore::MediaPlayerPrivateGStreamerBase::readyState):
     49        (WebCore::MediaPlayerPrivateGStreamerBase::sizeChanged):
     50        (WebCore::MediaPlayerPrivateGStreamerBase::setMuted):
     51        (WebCore::MediaPlayerPrivateGStreamerBase::muted):
     52        (WebCore::MediaPlayerPrivateGStreamerBase::notifyPlayerOfMute):
     53        (WebCore::MediaPlayerPrivateGStreamerBase::muteChanged):
     54        (WebCore::MediaPlayerPrivateGStreamerBase::triggerRepaint):
     55        (WebCore::MediaPlayerPrivateGStreamerBase::setSize):
     56        (WebCore::MediaPlayerPrivateGStreamerBase::paint):
     57        (WebCore::MediaPlayerPrivateGStreamerBase::enterFullscreen):
     58        (WebCore::MediaPlayerPrivateGStreamerBase::exitFullscreen):
     59        (WebCore::MediaPlayerPrivateGStreamerBase::supportsFullscreen):
     60        (WebCore::MediaPlayerPrivateGStreamerBase::platformMedia):
     61        (WebCore::MediaPlayerPrivateGStreamerBase::movieLoadType):
     62        (WebCore::MediaPlayerPrivateGStreamerBase::createVideoSink):
     63        (WebCore::MediaPlayerPrivateGStreamerBase::setStreamVolumeElement):
     64        (WebCore::MediaPlayerPrivateGStreamerBase::decodedFrameCount):
     65        (WebCore::MediaPlayerPrivateGStreamerBase::droppedFrameCount):
     66        (WebCore::MediaPlayerPrivateGStreamerBase::audioDecodedByteCount):
     67        (WebCore::MediaPlayerPrivateGStreamerBase::videoDecodedByteCount):
     68        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h: Added.
     69        (WebCore):
     70        (MediaPlayerPrivateGStreamerBase):
     71        (WebCore::MediaPlayerPrivateGStreamerBase::supportsMuting):
     72        (WebCore::MediaPlayerPrivateGStreamerBase::setVisible):
     73        (WebCore::MediaPlayerPrivateGStreamerBase::hasSingleSecurityOrigin):
     74        (WebCore::MediaPlayerPrivateGStreamerBase::maxTimeLoaded):
     75        (WebCore::MediaPlayerPrivateGStreamerBase::canEnterFullscreen):
     76        (WebCore::MediaPlayerPrivateGStreamerBase::mediaPlayer):
     77        (WebCore::MediaPlayerPrivateGStreamerBase::audioSink):
     78        * platform/graphics/gtk/FullscreenVideoControllerGtk.cpp:
     79        (WebCore::FullscreenVideoControllerGtk::FullscreenVideoControllerGtk):
     80        * platform/graphics/gtk/FullscreenVideoControllerGtk.h:
     81        (FullscreenVideoControllerGtk):
     82
    1832013-02-06  Tony Gentilcore  <tonyg@chromium.org>
    284

  • trunk/Source/WebCore/GNUmakefile.list.am

    r141984 r142005  
    60936093        Source/WebCore/platform/graphics/gstreamer/ImageGStreamerCairo.cpp \
    60946094        Source/WebCore/platform/graphics/gstreamer/ImageGStreamer.h \
     6095        Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp \
     6096        Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h \
    60956097        Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp \
    60966098        Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h \

  • trunk/Source/WebCore/PlatformEfl.cmake

    r141749 r142005  
    122122    platform/graphics/gstreamer/GStreamerVersioning.cpp
    123123    platform/graphics/gstreamer/ImageGStreamerCairo.cpp
     124    platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
    124125    platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
    125126    platform/graphics/gstreamer/PlatformVideoWindowEfl.cpp

  • trunk/Source/WebCore/Target.pri

    r141973 r142005  
    33523352        HEADERS += \
    33533353            platform/graphics/gstreamer/GStreamerGWorld.h \
     3354            platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h \
    33543355            platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h \
    33553356            platform/graphics/gstreamer/VideoSinkGStreamer.h \
    … …  
    33603361        SOURCES += \
    33613362            platform/graphics/gstreamer/GStreamerGWorld.cpp \
     3363            platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp \
    33623364            platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp \
    33633365            platform/graphics/gstreamer/VideoSinkGStreamer.cpp \

  • trunk/Source/WebCore/platform/graphics/gstreamer/FullscreenVideoControllerGStreamer.cpp

    r141566 r142005  
    3030#include "GStreamerGWorld.h"
    3131#include "MediaPlayer.h"
    32 #include "MediaPlayerPrivateGStreamer.h"
     32#include "MediaPlayerPrivateGStreamerBase.h"
    3333#include <gst/gst.h>
    3434#include <wtf/text/CString.h>
    … …  
    4949}
    5050
    51 PassOwnPtr<FullscreenVideoControllerGStreamer> FullscreenVideoControllerGStreamer::create(MediaPlayerPrivateGStreamer* player)
     51PassOwnPtr<FullscreenVideoControllerGStreamer> FullscreenVideoControllerGStreamer::create(MediaPlayerPrivateGStreamerBase* player)
    5252{
    5353#if PLATFORM(GTK)
    … …  
    5858}
    5959
    60 FullscreenVideoControllerGStreamer::FullscreenVideoControllerGStreamer(MediaPlayerPrivateGStreamer* player)
     60FullscreenVideoControllerGStreamer::FullscreenVideoControllerGStreamer(MediaPlayerPrivateGStreamerBase* player)
    6161    : m_player(player)
    6262    , m_client(player->mediaPlayer()->mediaPlayerClient())

  • trunk/Source/WebCore/platform/graphics/gstreamer/FullscreenVideoControllerGStreamer.h

    r141566 r142005  
    3030
    3131class GStreamerGWorld;
    32 class MediaPlayerPrivateGStreamer;
     32class MediaPlayerPrivateGStreamerBase;
    3333class MediaPlayerClient;
    3434
    … …  
    3636    WTF_MAKE_NONCOPYABLE(FullscreenVideoControllerGStreamer);
    3737public:
    38     static PassOwnPtr<FullscreenVideoControllerGStreamer> create(MediaPlayerPrivateGStreamer* player);
    39     FullscreenVideoControllerGStreamer(MediaPlayerPrivateGStreamer*);
     38    static PassOwnPtr<FullscreenVideoControllerGStreamer> create(MediaPlayerPrivateGStreamerBase*);
     39    FullscreenVideoControllerGStreamer(MediaPlayerPrivateGStreamerBase*);
    4040    virtual ~FullscreenVideoControllerGStreamer();
    4141
    … …  
    5757    String timeToString(float time);
    5858
    59     MediaPlayerPrivateGStreamer* m_player;
     59    MediaPlayerPrivateGStreamerBase* m_player;
    6060    MediaPlayerClient* m_client;
    6161    GStreamerGWorld* m_gstreamerGWorld;

  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp

    r141697 r142005  
    2727#if ENABLE(VIDEO) && USE(GSTREAMER)
    2828
    29 #include "ColorSpace.h"
    30 #include "Document.h"
    31 #include "Frame.h"
    32 #include "FrameView.h"
    33 #include "FullscreenVideoControllerGStreamer.h"
    34 #include "GStreamerGWorld.h"
    3529#include "GStreamerUtilities.h"
    3630#include "GStreamerVersioning.h"
    37 #include "GraphicsContext.h"
    38 #include "GraphicsTypes.h"
    39 #include "ImageGStreamer.h"
    40 #include "ImageOrientation.h"
    41 #include "IntRect.h"
    4231#include "KURL.h"
    4332#include "Logging.h"
    4433#include "MIMETypeRegistry.h"
    4534#include "MediaPlayer.h"
    46 #include "NotImplemented.h"
    4735#include "SecurityOrigin.h"
    4836#include "TimeRanges.h"
    49 #include "VideoSinkGStreamer.h"
    5037#include "WebKitWebSourceGStreamer.h"
    5138#include <gst/gst.h>
    52 #include <gst/video/video.h>
    5339#include <limits>
    54 #include <math.h>
    5540#include <wtf/gobject/GOwnPtr.h>
    5641#include <wtf/text/CString.h>
    57 
    58 #ifdef GST_API_VERSION_1
    59 #include <gst/audio/streamvolume.h>
    60 #else
    61 #include <gst/interfaces/streamvolume.h>
    62 #endif
    6342
    6443// GstPlayFlags flags from playbin2. It is the policy of GStreamer to
    … …  
    9776namespace WebCore {
    9877
    99 static int greatestCommonDivisor(int a, int b)
    100 {
    101     while (b) {
    102         int temp = a;
    103         a = b;
    104         b = temp % b;
    105     }
    106 
    107     return ABS(a);
    108 }
    109 
    11078static gboolean mediaPlayerPrivateMessageCallback(GstBus*, GstMessage* message, MediaPlayerPrivateGStreamer* player)
    11179{
    … …  
    11684{
    11785    player->sourceChanged();
    118 }
    119 
    120 static void mediaPlayerPrivateVolumeChangedCallback(GObject*, GParamSpec*, MediaPlayerPrivateGStreamer* player)
    121 {
    122     // This is called when playbin receives the notify::volume signal.
    123     player->volumeChanged();
    124 }
    125 
    126 static gboolean mediaPlayerPrivateVolumeChangeTimeoutCallback(MediaPlayerPrivateGStreamer* player)
    127 {
    128     // This is the callback of the timeout source created in ::volumeChanged.
    129     player->notifyPlayerOfVolumeChange();
    130     return FALSE;
    131 }
    132 
    133 static void mediaPlayerPrivateMuteChangedCallback(GObject*, GParamSpec*, MediaPlayerPrivateGStreamer* player)
    134 {
    135     // This is called when playbin receives the notify::mute signal.
    136     player->muteChanged();
    137 }
    138 
    139 static gboolean mediaPlayerPrivateMuteChangeTimeoutCallback(MediaPlayerPrivateGStreamer* player)
    140 {
    141     // This is the callback of the timeout source created in ::muteChanged.
    142     player->notifyPlayerOfMute();
    143     return FALSE;
    14486}
    14587
    … …  
    171113    player->notifyPlayerOfVideo();
    172114    return FALSE;
    173 }
    174 
    175 static void mediaPlayerPrivateRepaintCallback(WebKitVideoSink*, GstBuffer *buffer, MediaPlayerPrivateGStreamer* playerPrivate)
    176 {
    177     playerPrivate->triggerRepaint(buffer);
    178115}
    179116
    … …  
    213150
    214151MediaPlayerPrivateGStreamer::MediaPlayerPrivateGStreamer(MediaPlayer* player)
    215     : m_player(player)
    216     , m_webkitVideoSink(0)
    217     , m_fpsSink(0)
     152    : MediaPlayerPrivateGStreamerBase(player)
    218153    , m_source(0)
    219154    , m_seekTime(0)
    … …  
    221156    , m_endTime(numeric_limits<float>::infinity())
    222157    , m_isEndReached(false)
    223     , m_networkState(MediaPlayer::Empty)
    224     , m_readyState(MediaPlayer::HaveNothing)
    225158    , m_isStreaming(false)
    226     , m_size(IntSize())
    227     , m_buffer(0)
    228159    , m_mediaLocations(0)
    229160    , m_mediaLocationCurrentIndex(0)
    … …  
    243174    , m_mediaDurationKnown(true)
    244175    , m_maxTimeLoadedAtLastDidLoadingProgress(0)
    245     , m_volumeTimerHandler(0)
    246     , m_muteTimerHandler(0)
    247176    , m_hasVideo(false)
    248177    , m_hasAudio(false)
    … …  
    261190        m_fillTimer.stop();
    262191
    263     if (m_buffer)
    264         gst_buffer_unref(m_buffer);
    265     m_buffer = 0;
    266 
    267192    if (m_mediaLocations) {
    268193        gst_structure_free(m_mediaLocations);
    269194        m_mediaLocations = 0;
    270195    }
    271 
    272 #if USE(NATIVE_FULLSCREEN_VIDEO)
    273     if (m_fullscreenVideoController)
    274         exitFullscreen();
    275 
    276     if (m_videoSinkBin) {
    277         gst_object_unref(m_videoSinkBin);
    278         m_videoSinkBin = 0;
    279     }
    280 #endif
    281196
    282197    if (m_playBin) {
    … …  
    286201        gst_bus_remove_signal_watch(bus.get());
    287202
     203        g_signal_handlers_disconnect_by_func(m_playBin.get(), reinterpret_cast<gpointer>(mediaPlayerPrivateSourceChangedCallback), this);
     204        g_signal_handlers_disconnect_by_func(m_playBin.get(), reinterpret_cast<gpointer>(mediaPlayerPrivateVideoChangedCallback), this);
     205        g_signal_handlers_disconnect_by_func(m_playBin.get(), reinterpret_cast<gpointer>(mediaPlayerPrivateAudioChangedCallback), this);
     206
    288207        gst_element_set_state(m_playBin.get(), GST_STATE_NULL);
    289         m_playBin = 0;
    290     }
    291 
    292     m_player = 0;
    293 
    294     if (m_muteTimerHandler)
    295         g_source_remove(m_muteTimerHandler);
    296 
    297     if (m_volumeTimerHandler)
    298         g_source_remove(m_volumeTimerHandler);
     208        m_playBin.clear();
     209    }
     210
     211    GRefPtr<GstPad> videoSinkPad = adoptGRef(gst_element_get_static_pad(m_webkitVideoSink.get(), "sink"));
     212    g_signal_handlers_disconnect_by_func(videoSinkPad.get(), reinterpret_cast<gpointer>(mediaPlayerPrivateVideoSinkCapsChangedCallback), this);
    299213
    300214    if (m_videoTimerHandler)
    … …  
    573487}
    574488
    575 // Returns the size of the video
    576 IntSize MediaPlayerPrivateGStreamer::naturalSize() const
    577 {
    578     if (!hasVideo())
    579         return IntSize();
    580 
    581     if (!m_videoSize.isEmpty())
    582         return m_videoSize;
    583 
    584     GRefPtr<GstCaps> caps = webkitGstGetPadCaps(m_videoSinkPad.get());
    585     if (!caps)
    586         return IntSize();
    587 
    588 
    589     // TODO: handle possible clean aperture data. See
    590     // https://bugzilla.gnome.org/show_bug.cgi?id=596571
    591     // TODO: handle possible transformation matrix. See
    592     // https://bugzilla.gnome.org/show_bug.cgi?id=596326
    593 
    594     // Get the video PAR and original size, if this fails the
    595     // video-sink has likely not yet negotiated its caps.
    596     int pixelAspectRatioNumerator, pixelAspectRatioDenominator, stride;
    597     IntSize originalSize;
    598     GstVideoFormat format;
    599     if (!getVideoSizeAndFormatFromCaps(caps.get(), originalSize, format, pixelAspectRatioNumerator, pixelAspectRatioDenominator, stride))
    600         return IntSize();
    601 
    602     LOG_MEDIA_MESSAGE("Original video size: %dx%d", originalSize.width(), originalSize.height());
    603     LOG_MEDIA_MESSAGE("Pixel aspect ratio: %d/%d", pixelAspectRatioNumerator, pixelAspectRatioDenominator);
    604 
    605     // Calculate DAR based on PAR and video size.
    606     int displayWidth = originalSize.width() * pixelAspectRatioNumerator;
    607     int displayHeight = originalSize.height() * pixelAspectRatioDenominator;
    608 
    609     // Divide display width and height by their GCD to avoid possible overflows.
    610     int displayAspectRatioGCD = greatestCommonDivisor(displayWidth, displayHeight);
    611     displayWidth /= displayAspectRatioGCD;
    612     displayHeight /= displayAspectRatioGCD;
    613 
    614     // Apply DAR to original video size. This is the same behavior as in xvimagesink's setcaps function.
    615     guint64 width = 0, height = 0;
    616     if (!(originalSize.height() % displayHeight)) {
    617         LOG_MEDIA_MESSAGE("Keeping video original height");
    618         width = gst_util_uint64_scale_int(originalSize.height(), displayWidth, displayHeight);
    619         height = static_cast<guint64>(originalSize.height());
    620     } else if (!(originalSize.width() % displayWidth)) {
    621         LOG_MEDIA_MESSAGE("Keeping video original width");
    622         height = gst_util_uint64_scale_int(originalSize.width(), displayHeight, displayWidth);
    623         width = static_cast<guint64>(originalSize.width());
    624     } else {
    625         LOG_MEDIA_MESSAGE("Approximating while keeping original video height");
    626         width = gst_util_uint64_scale_int(originalSize.height(), displayWidth, displayHeight);
    627         height = static_cast<guint64>(originalSize.height());
    628     }
    629 
    630     LOG_MEDIA_MESSAGE("Natural size: %" G_GUINT64_FORMAT "x%" G_GUINT64_FORMAT, width, height);
    631     m_videoSize = IntSize(static_cast<int>(width), static_cast<int>(height));
    632     return m_videoSize;
    633 }
    634 
    635489void MediaPlayerPrivateGStreamer::videoChanged()
    636490{
    … …  
    671525    m_hasAudio = audioTracks > 0;
    672526    m_player->mediaPlayerClient()->mediaPlayerEngineUpdated(m_player);
    673 }
    674 
    675 void MediaPlayerPrivateGStreamer::setVolume(float volume)
    676 {
    677     if (!m_playBin)
    678         return;
    679 
    680     gst_stream_volume_set_volume(GST_STREAM_VOLUME(m_playBin.get()), GST_STREAM_VOLUME_FORMAT_CUBIC,
    681                                  static_cast<double>(volume));
    682 }
    683 
    684 float MediaPlayerPrivateGStreamer::volume() const
    685 {
    686     if (!m_playBin)
    687         return 0;
    688 
    689     return gst_stream_volume_get_volume(GST_STREAM_VOLUME(m_playBin.get()), GST_STREAM_VOLUME_FORMAT_CUBIC);
    690 }
    691 
    692 void MediaPlayerPrivateGStreamer::notifyPlayerOfVolumeChange()
    693 {
    694     m_volumeTimerHandler = 0;
    695 
    696     if (!m_player || !m_playBin)
    697         return;
    698     double volume;
    699     volume = gst_stream_volume_get_volume(GST_STREAM_VOLUME(m_playBin.get()), GST_STREAM_VOLUME_FORMAT_CUBIC);
    700     // get_volume() can return values superior to 1.0 if the user
    701     // applies software user gain via third party application (GNOME
    702     // volume control for instance).
    703     volume = CLAMP(volume, 0.0, 1.0);
    704     m_player->volumeChanged(static_cast<float>(volume));
    705 }
    706 
    707 void MediaPlayerPrivateGStreamer::volumeChanged()
    708 {
    709     if (m_volumeTimerHandler)
    710         g_source_remove(m_volumeTimerHandler);
    711     m_volumeTimerHandler = g_timeout_add(0, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateVolumeChangeTimeoutCallback), this);
    712527}
    713528
    … …  
    774589{
    775590    m_preservesPitch = preservesPitch;
    776 }
    777 
    778 MediaPlayer::NetworkState MediaPlayerPrivateGStreamer::networkState() const
    779 {
    780     return m_networkState;
    781 }
    782 
    783 MediaPlayer::ReadyState MediaPlayerPrivateGStreamer::readyState() const
    784 {
    785     return m_readyState;
    786591}
    787592
    … …  
    1115920}
    1116921
    1117 unsigned MediaPlayerPrivateGStreamer::decodedFrameCount() const
    1118 {
    1119     guint64 decodedFrames = 0;
    1120     if (m_fpsSink)
    1121         g_object_get(m_fpsSink, "frames-rendered", &decodedFrames, NULL);
    1122     return static_cast<unsigned>(decodedFrames);
    1123 }
    1124 
    1125 unsigned MediaPlayerPrivateGStreamer::droppedFrameCount() const
    1126 {
    1127     guint64 framesDropped = 0;
    1128     if (m_fpsSink)
    1129         g_object_get(m_fpsSink, "frames-dropped", &framesDropped, NULL);
    1130     return static_cast<unsigned>(framesDropped);
    1131 }
    1132 
    1133 unsigned MediaPlayerPrivateGStreamer::audioDecodedByteCount() const
    1134 {
    1135     GstQuery* query = gst_query_new_position(GST_FORMAT_BYTES);
    1136     gint64 position = 0;
    1137 
    1138     if (m_webkitAudioSink && gst_element_query(m_webkitAudioSink.get(), query))
    1139         gst_query_parse_position(query, 0, &position);
    1140 
    1141     gst_query_unref(query);
    1142     return static_cast<unsigned>(position);
    1143 }
    1144 
    1145 unsigned MediaPlayerPrivateGStreamer::videoDecodedByteCount() const
    1146 {
    1147     GstQuery* query = gst_query_new_position(GST_FORMAT_BYTES);
    1148     gint64 position = 0;
    1149 
    1150     if (gst_element_query(m_webkitVideoSink, query))
    1151         gst_query_parse_position(query, 0, &position);
    1152 
    1153     gst_query_unref(query);
    1154     return static_cast<unsigned>(position);
    1155 }
    1156 
    1157922void MediaPlayerPrivateGStreamer::updateAudioSink()
    1158923{
    … …  
    1167932}
    1168933
     934GstElement* MediaPlayerPrivateGStreamer::audioSink() const
     935{
     936    return m_webkitAudioSink.get();
     937}
    1169938
    1170939void MediaPlayerPrivateGStreamer::sourceChanged()
    … …  
    14731242}
    14741243
    1475 void MediaPlayerPrivateGStreamer::sizeChanged()
    1476 {
    1477     notImplemented();
    1478 }
    1479 
    14801244void MediaPlayerPrivateGStreamer::timeChanged()
    14811245{
    … …  
    15521316}
    15531317
    1554 bool MediaPlayerPrivateGStreamer::supportsMuting() const
    1555 {
    1556     return true;
    1557 }
    1558 
    1559 void MediaPlayerPrivateGStreamer::setMuted(bool muted)
    1560 {
    1561     if (!m_playBin)
    1562         return;
    1563 
    1564     g_object_set(m_playBin.get(), "mute", muted, NULL);
    1565 }
    1566 
    1567 bool MediaPlayerPrivateGStreamer::muted() const
    1568 {
    1569     if (!m_playBin)
    1570         return false;
    1571 
    1572     bool muted;
    1573     g_object_get(m_playBin.get(), "mute", &muted, NULL);
    1574     return muted;
    1575 }
    1576 
    1577 void MediaPlayerPrivateGStreamer::notifyPlayerOfMute()
    1578 {
    1579     m_muteTimerHandler = 0;
    1580 
    1581     if (!m_player || !m_playBin)
    1582         return;
    1583 
    1584     gboolean muted;
    1585     g_object_get(m_playBin.get(), "mute", &muted, NULL);
    1586     m_player->muteChanged(static_cast<bool>(muted));
    1587 }
    1588 
    1589 void MediaPlayerPrivateGStreamer::muteChanged()
    1590 {
    1591     if (m_muteTimerHandler)
    1592         g_source_remove(m_muteTimerHandler);
    1593     m_muteTimerHandler = g_timeout_add(0, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateMuteChangeTimeoutCallback), this);
    1594 }
    1595 
    15961318void MediaPlayerPrivateGStreamer::loadingFailed(MediaPlayer::NetworkState error)
    15971319{
    … …  
    16051327        m_player->readyStateChanged();
    16061328    }
    1607 }
    1608 
    1609 void MediaPlayerPrivateGStreamer::setSize(const IntSize& size)
    1610 {
    1611     m_size = size;
    1612 }
    1613 
    1614 void MediaPlayerPrivateGStreamer::setVisible(bool)
    1615 {
    1616 }
    1617 
    1618 
    1619 void MediaPlayerPrivateGStreamer::triggerRepaint(GstBuffer* buffer)
    1620 {
    1621     g_return_if_fail(GST_IS_BUFFER(buffer));
    1622     gst_buffer_replace(&m_buffer, buffer);
    1623     m_player->repaint();
    1624 }
    1625 
    1626 void MediaPlayerPrivateGStreamer::paint(GraphicsContext* context, const IntRect& rect)
    1627 {
    1628     if (context->paintingDisabled())
    1629         return;
    1630 
    1631     if (!m_player->visible())
    1632         return;
    1633 
    1634     if (!m_buffer)
    1635         return;
    1636 
    1637     GRefPtr<GstCaps> caps = webkitGstGetPadCaps(m_videoSinkPad.get());
    1638     if (!caps)
    1639         return;
    1640 
    1641     RefPtr<ImageGStreamer> gstImage = ImageGStreamer::createImage(m_buffer, caps.get());
    1642     if (!gstImage)
    1643         return;
    1644 
    1645     context->drawImage(reinterpret_cast<Image*>(gstImage->image().get()), ColorSpaceSRGB,
    1646                        rect, gstImage->rect(), CompositeCopy, DoNotRespectImageOrientation, false);
    16471329}
    16481330
    … …  
    17681450}
    17691451
    1770 bool MediaPlayerPrivateGStreamer::hasSingleSecurityOrigin() const
    1771 {
    1772     return true;
    1773 }
    1774 
    1775 #if USE(NATIVE_FULLSCREEN_VIDEO)
    1776 void MediaPlayerPrivateGStreamer::enterFullscreen()
    1777 {
    1778     ASSERT(!m_fullscreenVideoController);
    1779     m_fullscreenVideoController = FullscreenVideoControllerGStreamer::create(this);
    1780     if (m_fullscreenVideoController)
    1781         m_fullscreenVideoController->enterFullscreen();
    1782 }
    1783 
    1784 void MediaPlayerPrivateGStreamer::exitFullscreen()
    1785 {
    1786     if (!m_fullscreenVideoController)
    1787         return;
    1788     m_fullscreenVideoController->exitFullscreen();
    1789     m_fullscreenVideoController.release();
    1790 }
    1791 #endif
    1792 
    1793 bool MediaPlayerPrivateGStreamer::supportsFullscreen() const
    1794 {
    1795 #if PLATFORM(MAC) && !PLATFORM(IOS) && __MAC_OS_X_VERSION_MIN_REQUIRED == 1050
    1796     // See <rdar://problem/7389945>
    1797     return false;
    1798 #else
    1799     return true;
    1800 #endif
    1801 }
    1802 
    1803 PlatformMedia MediaPlayerPrivateGStreamer::platformMedia() const
    1804 {
    1805 #if USE(NATIVE_FULLSCREEN_VIDEO)
    1806     PlatformMedia p;
    1807     p.type = PlatformMedia::GStreamerGWorldType;
    1808     p.media.gstreamerGWorld = m_gstGWorld.get();
    1809     return p;
    1810 #else
    1811     return NoPlatformMedia;
    1812 #endif
    1813 }
    1814 
    1815 MediaPlayer::MovieLoadType MediaPlayerPrivateGStreamer::movieLoadType() const
    1816 {
    1817     if (m_readyState == MediaPlayer::HaveNothing)
    1818         return MediaPlayer::Unknown;
    1819 
    1820     if (isLiveStream())
    1821         return MediaPlayer::LiveStream;
    1822 
    1823     return MediaPlayer::Download;
    1824 }
    1825 
    18261452void MediaPlayerPrivateGStreamer::setDownloadBuffering()
    18271453{
    … …  
    18951521    // we should not adopt.
    18961522    m_playBin = gst_element_factory_make(gPlaybinName, "play");
     1523    setStreamVolumeElement(GST_STREAM_VOLUME(m_playBin.get()));
    18971524
    18981525    GRefPtr<GstBus> bus = webkitGstPipelineGetBus(GST_PIPELINE(m_playBin.get()));
    … …  
    19021529    g_object_set(m_playBin.get(), "mute", m_player->muted(), NULL);
    19031530
    1904     g_signal_connect(m_playBin.get(), "notify::volume", G_CALLBACK(mediaPlayerPrivateVolumeChangedCallback), this);
    19051531    g_signal_connect(m_playBin.get(), "notify::source", G_CALLBACK(mediaPlayerPrivateSourceChangedCallback), this);
    1906     g_signal_connect(m_playBin.get(), "notify::mute", G_CALLBACK(mediaPlayerPrivateMuteChangedCallback), this);
    19071532    g_signal_connect(m_playBin.get(), "video-changed", G_CALLBACK(mediaPlayerPrivateVideoChangedCallback), this);
    19081533    g_signal_connect(m_playBin.get(), "audio-changed", G_CALLBACK(mediaPlayerPrivateAudioChangedCallback), this);
    19091534
    1910 #if USE(NATIVE_FULLSCREEN_VIDEO)
    1911     m_gstGWorld = GStreamerGWorld::createGWorld(m_playBin.get());
    1912     m_webkitVideoSink = webkitVideoSinkNew(m_gstGWorld.get());
    1913 #else
    1914     m_webkitVideoSink = webkitVideoSinkNew();
    1915 #endif
    1916     m_videoSinkPad = adoptGRef(gst_element_get_static_pad(m_webkitVideoSink, "sink"));
    1917 
    1918     g_signal_connect(m_webkitVideoSink, "repaint-requested", G_CALLBACK(mediaPlayerPrivateRepaintCallback), this);
    1919 
    1920 
    1921 #if USE(NATIVE_FULLSCREEN_VIDEO)
    1922     // Build a new video sink consisting of a bin containing a tee
    1923     // (meant to distribute data to multiple video sinks) and our
    1924     // internal video sink. For fullscreen we create an autovideosink
    1925     // and initially block the data flow towards it and configure it
    1926 
    1927     m_videoSinkBin = gst_bin_new("video-sink");
    1928 
    1929     // Take ownership.
    1930     gst_object_ref_sink(m_videoSinkBin);
    1931 
    1932     GstElement* videoTee = gst_element_factory_make("tee", "videoTee");
    1933     GstElement* queue = gst_element_factory_make("queue", 0);
    1934 
    1935 #ifdef GST_API_VERSION_1
    1936     GRefPtr<GstPad> sinkPad = adoptGRef(gst_element_get_static_pad(videoTee, "sink"));
    1937     GST_OBJECT_FLAG_SET(GST_OBJECT(sinkPad.get()), GST_PAD_FLAG_PROXY_ALLOCATION);
    1938 #endif
    1939 
    1940     gst_bin_add_many(GST_BIN(m_videoSinkBin), videoTee, queue, NULL);
    1941 
    1942     // Link a new src pad from tee to queue1.
    1943     gst_element_link_pads_full(videoTee, 0, queue, "sink", GST_PAD_LINK_CHECK_NOTHING);
    1944 #endif
    1945 
    1946     GstElement* actualVideoSink = 0;
    1947     m_fpsSink = gst_element_factory_make("fpsdisplaysink", "sink");
    1948     if (m_fpsSink) {
    1949         // The verbose property has been added in -bad 0.10.22. Making
    1950         // this whole code depend on it because we don't want
    1951         // fpsdiplaysink to spit data on stdout.
    1952         GstElementFactory* factory = GST_ELEMENT_FACTORY(GST_ELEMENT_GET_CLASS(m_fpsSink)->elementfactory);
    1953         if (gst_plugin_feature_check_version(GST_PLUGIN_FEATURE(factory), 0, 10, 22)) {
    1954             g_object_set(m_fpsSink, "silent", TRUE , NULL);
    1955 
    1956             // Turn off text overlay unless logging is enabled.
    1957 #if LOG_DISABLED
    1958             g_object_set(m_fpsSink, "text-overlay", FALSE , NULL);
    1959 #else
    1960             WTFLogChannel* channel = getChannelFromName("Media");
    1961             if (channel->state != WTFLogChannelOn)
    1962                 g_object_set(m_fpsSink, "text-overlay", FALSE , NULL);
    1963 #endif // LOG_DISABLED
    1964 
    1965             if (g_object_class_find_property(G_OBJECT_GET_CLASS(m_fpsSink), "video-sink")) {
    1966                 g_object_set(m_fpsSink, "video-sink", m_webkitVideoSink, NULL);
    1967 #if USE(NATIVE_FULLSCREEN_VIDEO)
    1968                 gst_bin_add(GST_BIN(m_videoSinkBin), m_fpsSink);
    1969 #endif
    1970                 actualVideoSink = m_fpsSink;
    1971             } else
    1972                 m_fpsSink = 0;
    1973         } else
    1974             m_fpsSink = 0;
    1975     }
    1976 
    1977     if (!m_fpsSink) {
    1978 #if USE(NATIVE_FULLSCREEN_VIDEO)
    1979         gst_bin_add(GST_BIN(m_videoSinkBin), m_webkitVideoSink);
    1980 #endif
    1981         actualVideoSink = m_webkitVideoSink;
    1982     }
    1983 
    1984     ASSERT(actualVideoSink);
    1985 
    1986 #if USE(NATIVE_FULLSCREEN_VIDEO)
    1987     // Faster elements linking.
    1988     gst_element_link_pads_full(queue, "src", actualVideoSink, "sink", GST_PAD_LINK_CHECK_NOTHING);
    1989 
    1990     // Add a ghostpad to the bin so it can proxy to tee.
    1991     GRefPtr<GstPad> pad = adoptGRef(gst_element_get_static_pad(videoTee, "sink"));
    1992     gst_element_add_pad(m_videoSinkBin, gst_ghost_pad_new("sink", pad.get()));
    1993 
    1994     // Set the bin as video sink of playbin.
    1995     g_object_set(m_playBin.get(), "video-sink", m_videoSinkBin, NULL);
    1996 #else
    1997     g_object_set(m_playBin.get(), "video-sink", actualVideoSink, NULL);
    1998 #endif
    1999 
    2000     GRefPtr<GstPad> videoSinkPad = adoptGRef(gst_element_get_static_pad(m_webkitVideoSink, "sink"));
     1535    GstElement* videoElement = createVideoSink(m_playBin.get());
     1536
     1537    g_object_set(m_playBin.get(), "video-sink", videoElement, NULL);
     1538
     1539    GRefPtr<GstPad> videoSinkPad = adoptGRef(gst_element_get_static_pad(m_webkitVideoSink.get(), "sink"));
    20011540    if (videoSinkPad)
    20021541        g_signal_connect(videoSinkPad.get(), "notify::caps", G_CALLBACK(mediaPlayerPrivateVideoSinkCapsChangedCallback), this);

  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h

    r141695 r142005  
    2626
    2727#include "GRefPtrGStreamer.h"
    28 #include "MediaPlayerPrivate.h"
     28#include "MediaPlayerPrivateGStreamerBase.h"
    2929#include "Timer.h"
    3030
    … …  
    3333#include <wtf/Forward.h>
    3434
    35 typedef struct _WebKitVideoSink WebKitVideoSink;
    3635typedef struct _GstBuffer GstBuffer;
    3736typedef struct _GstMessage GstMessage;
    … …  
    4039namespace WebCore {
    4140
    42 class FullscreenVideoControllerGStreamer;
    43 class GraphicsContext;
    44 class IntSize;
    45 class IntRect;
    46 class GStreamerGWorld;
    47 class MediaPlayerPrivateGStreamer;
    48 
    49 class MediaPlayerPrivateGStreamer : public MediaPlayerPrivateInterface {
     41class MediaPlayerPrivateGStreamer : public MediaPlayerPrivateGStreamerBase {
    5042
    5143        public:
    … …  
    5446            gboolean handleMessage(GstMessage*);
    5547
    56             IntSize naturalSize() const;
    5748            bool hasVideo() const { return m_hasVideo; }
    5849            bool hasAudio() const { return m_hasAudio; }
    … …  
    7667            void setPreservesPitch(bool);
    7768
    78             void setVolume(float);
    79             float volume() const;
    80             void volumeChanged();
    81             void notifyPlayerOfVolumeChange();
    82 
    83             bool supportsMuting() const;
    84             void setMuted(bool);
    85             bool muted() const;
    86             void muteChanged();
    87             void notifyPlayerOfMute();
    88 
    8969            void setPreload(MediaPlayer::Preload);
    9070            void fillTimerFired(Timer<MediaPlayerPrivateGStreamer>*);
    91 
    92             MediaPlayer::NetworkState networkState() const;
    93             MediaPlayer::ReadyState readyState() const;
    9471
    9572            PassRefPtr<TimeRanges> buffered() const;
    … …  
    9976            float maxTimeLoaded() const;
    10077
    101             void setVisible(bool);
    102             void setSize(const IntSize&);
    103 
    10478            void loadStateChanged();
    105             void sizeChanged();
    10679            void timeChanged();
    10780            void didEnd();
    10881            void durationChanged();
    10982            void loadingFailed(MediaPlayer::NetworkState);
    110 
    111             void triggerRepaint(GstBuffer*);
    112             void repaint();
    113             void paint(GraphicsContext*, const IntRect&);
    114 
    115             bool hasSingleSecurityOrigin() const;
    116 
    117 #if USE(NATIVE_FULLSCREEN_VIDEO)
    118             void enterFullscreen();
    119             void exitFullscreen();
    120             bool canEnterFullscreen() const { return true; }
    121 #endif
    122 
    123             bool supportsFullscreen() const;
    124             PlatformMedia platformMedia() const;
    12583
    12684            void videoChanged();
    … …  
    13088
    13189            void sourceChanged();
    132 
    133             unsigned decodedFrameCount() const;
    134             unsigned droppedFrameCount() const;
    135             unsigned audioDecodedByteCount() const;
    136             unsigned videoDecodedByteCount() const;
    137 
    138             MediaPlayer::MovieLoadType movieLoadType() const;
    139 
    140             MediaPlayer* mediaPlayer() const { return m_player; }
     90            GstElement* audioSink() const;
    14191
    14292            static KURL convertPlaybinURL(const gchar* uri);
    … …  
    172122
    173123            virtual String engineDescription() const { return "GStreamer"; }
    174             bool isLiveStream() const { return m_isStreaming; }
     124            virtual bool isLiveStream() const { return m_isStreaming; }
    175125
    176126        private:
    177             MediaPlayer* m_player;
    178127            GRefPtr<GstElement> m_playBin;
    179             GstElement* m_webkitVideoSink;
    180             GstElement* m_videoSinkBin;
    181             GstElement* m_fpsSink;
    182128            GRefPtr<GstElement> m_source;
    183129            float m_seekTime;
    … …  
    185131            float m_endTime;
    186132            bool m_isEndReached;
    187             MediaPlayer::NetworkState m_networkState;
    188             MediaPlayer::ReadyState m_readyState;
    189133            mutable bool m_isStreaming;
    190             IntSize m_size;
    191             GstBuffer* m_buffer;
    192134            GstStructure* m_mediaLocations;
    193135            int m_mediaLocationCurrentIndex;
    … …  
    207149            bool m_mediaDurationKnown;
    208150            mutable float m_maxTimeLoadedAtLastDidLoadingProgress;
    209 #if USE(NATIVE_FULLSCREEN_VIDEO)
    210             RefPtr<GStreamerGWorld> m_gstGWorld;
    211             OwnPtr<FullscreenVideoControllerGStreamer> m_fullscreenVideoController;
    212 #endif
    213             guint m_volumeTimerHandler;
    214             guint m_muteTimerHandler;
    215151            bool m_volumeAndMuteInitialized;
    216152            bool m_hasVideo;
    … …  
    220156            GRefPtr<GstElement> m_webkitAudioSink;
    221157            mutable long m_totalBytes;
    222             GRefPtr<GstPad> m_videoSinkPad;
    223             mutable IntSize m_videoSize;
    224158            KURL m_url;
    225159            bool m_originalPreloadWasAutoAndWasOverridden;

  • trunk/Source/WebCore/platform/graphics/gtk/FullscreenVideoControllerGtk.cpp

    r141566 r142005  
    2929#include "GtkVersioning.h"
    3030#include "MediaPlayer.h"
    31 #include "MediaPlayerPrivateGStreamer.h"
     31#include "MediaPlayerPrivateGStreamerBase.h"
    3232
    3333#include <gdk/gdk.h>
    … …  
    125125
    126126
    127 FullscreenVideoControllerGtk::FullscreenVideoControllerGtk(MediaPlayerPrivateGStreamer* player)
     127FullscreenVideoControllerGtk::FullscreenVideoControllerGtk(MediaPlayerPrivateGStreamerBase* player)
    128128    : FullscreenVideoControllerGStreamer(player)
    129129    , m_hudTimeoutId(0)

  • trunk/Source/WebCore/platform/graphics/gtk/FullscreenVideoControllerGtk.h

    r141566 r142005  
    2929class FullscreenVideoControllerGtk : public FullscreenVideoControllerGStreamer {
    3030public:
    31     FullscreenVideoControllerGtk(MediaPlayerPrivateGStreamer*);
     31    FullscreenVideoControllerGtk(MediaPlayerPrivateGStreamerBase*);
    3232
    3333    void gtkConfigure(GdkEventConfigure*);

  • trunk/configure.ac

    r141868 r142005  
    993993fi
    994994
    995 # farstream-0.1 depends on gstreamer 0.10 currently. Disable
    996 # media_stream if gstreamer 1.0 build support is enabled.
    997 if test "$have_gstreamer" != "yes" || test "$GST_API_VERSION" = "1.0"; then
    998    if test "$enable_media_stream" = "yes"; then
    999       AC_MSG_WARN([Disabling Media Stream because no GStreamer 0.10 support is enabled])
    1000    fi
    1001    enable_media_stream=false
    1002 fi
    1003 if test "$enable_media_stream" = "yes"; then
    1004    PKG_CHECK_MODULES([FARSTREAM], [farstream-0.1],
    1005                      [have_farstream=yes], [enable_media_stream=false])
    1006    AC_SUBST([FARSTREAM_CFLAGS])
    1007    AC_SUBST([FARSTREAM_LIBS])
    1008 fi
    1009 
    1010995acceleration_backend_description=$with_acceleration_backend
    1011996if test "$with_acceleration_backend" = "clutter"; then
Note: See TracChangeset for help on using the changeset viewer.