⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 236466 in webkit


Ignore:
Timestamp:
Sep 25, 2018, 11:41:07 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

[WPE][GTK][WebRTC] Fixup VP8 encoding support
​https://bugs.webkit.org/show_bug.cgi?id=189921

Previous leak fixing commit introduced a regression in
the way the encoded buffer were prepared in the default
GStreamerVideoEncoder::Fragmentize implementation (when
encoding with VP8 basically).

+ Fix a build warning in the decoder.
+ Fix some wrong object members namings.
+ Properly move the caps reference when setting restriction caps.
+ Do not raise a GStreamer error when GStreamerVideoEncoder::OnEncodedImage

fails - this might be a network issue and other encoders do not consider that
fatal.

+ Use GstMappedBuffer where appropriate.

Patch by Thibault Saunier <​tsaunier@igalia.com> on 2018-09-25
Reviewed by Philippe Normand.

  • platform/mediastream/libwebrtc/GStreamerVideoDecoderFactory.cpp:
  • platform/mediastream/libwebrtc/GStreamerVideoEncoderFactory.cpp:

(WebCore::GStreamerVideoEncoder::InitEncode):
(WebCore::GStreamerVideoEncoder::newSampleCallback):
(WebCore::GStreamerVideoEncoder::Fragmentize):
(WebCore::GStreamerVideoEncoder::SetRestrictionCaps):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r236465 r236466  
     12018-09-25  Thibault Saunier  <tsaunier@igalia.com>
     2
     3        [WPE][GTK][WebRTC] Fixup VP8 encoding support
     4        https://bugs.webkit.org/show_bug.cgi?id=189921
     5
     6        Previous leak fixing commit introduced a regression in
     7        the way the encoded buffer were prepared in the default
     8        GStreamerVideoEncoder::Fragmentize implementation (when
     9        encoding with VP8 basically).
     10
     11        + Fix a build warning in the decoder.
     12        + Fix some wrong object members namings.
     13        + Properly move the caps reference when setting restriction caps.
     14        + Do not raise a GStreamer error when GStreamerVideoEncoder::OnEncodedImage
     15          fails - this might be a network issue and other encoders do not consider that
     16          fatal.
     17        + Use GstMappedBuffer where appropriate.
     18
     19        Reviewed by Philippe Normand.
     20
     21        * platform/mediastream/libwebrtc/GStreamerVideoDecoderFactory.cpp:
     22        * platform/mediastream/libwebrtc/GStreamerVideoEncoderFactory.cpp:
     23        (WebCore::GStreamerVideoEncoder::InitEncode):
     24        (WebCore::GStreamerVideoEncoder::newSampleCallback):
     25        (WebCore::GStreamerVideoEncoder::Fragmentize):
     26        (WebCore::GStreamerVideoEncoder::SetRestrictionCaps):
     27
    1282018-09-25  Eric Carlson  <eric.carlson@apple.com>
    229

  • trunk/Source/WebCore/platform/mediastream/libwebrtc/GStreamerVideoDecoderFactory.cpp

    r236397 r236466  
    166166        m_dtsPtsMap[GST_BUFFER_PTS(buffer.get())] = inputImage._timeStamp;
    167167
    168         GST_LOG_OBJECT(pipeline(), "%ld Decoding: %" GST_PTR_FORMAT, renderTimeMs, buffer);
     168        GST_LOG_OBJECT(pipeline(), "%ld Decoding: %" GST_PTR_FORMAT, renderTimeMs, buffer.get());
    169169        auto sample = adoptGRef(gst_sample_new(buffer.get(), GetCapsForFrame(inputImage), nullptr, nullptr));
    170170        switch (gst_app_src_push_sample(GST_APP_SRC(m_src), sample.get())) {

  • trunk/Source/WebCore/platform/mediastream/libwebrtc/GStreamerVideoEncoderFactory.cpp

    r236397 r236466  
    8282        gst_caps_set_simple(caps.get(), "framerate", GST_TYPE_FRACTION, frameRate, 1, nullptr);
    8383
    84         SetRestrictionCaps(caps);
     84        SetRestrictionCaps(WTFMove(caps));
    8585
    8686        if (m_bitrateSetter && m_encoder)
    … …  
    110110        m_encodedFrame._size = codecSettings->width * codecSettings->height * 3;
    111111        m_encodedFrame._buffer = new uint8_t[m_encodedFrame._size];
    112         encoded_image_buffer_.reset(m_encodedFrame._buffer);
     112        m_encodedImageBuffer.reset(m_encodedFrame._buffer);
    113113        m_encodedFrame._completeFrame = true;
    114114        m_encodedFrame._encodedWidth = 0;
    … …  
    160160    {
    161161        m_encodedFrame._buffer = nullptr;
    162         encoded_image_buffer_.reset();
     162        m_encodedImageBuffer.reset();
    163163        GRefPtr<GstBus> bus = adoptGRef(gst_pipeline_get_bus(GST_PIPELINE(m_pipeline.get())));
    164164        gst_bus_set_sync_handler(bus.get(), nullptr, nullptr, nullptr);
    … …  
    231231
    232232        webrtc::RTPFragmentationHeader fragmentationInfo;
    233         Fragmentize(&m_encodedFrame, &encoded_image_buffer_, buffer, &fragmentationInfo);
     233        Fragmentize(&m_encodedFrame, &m_encodedImageBuffer, &m_encodedImageBufferSize, buffer, &fragmentationInfo);
    234234        if (!m_encodedFrame._size)
    235235            return GST_FLOW_OK;
    … …  
    250250
    251251        webrtc::EncodedImageCallback::Result result = m_imageReadyCb->OnEncodedImage(m_encodedFrame, &codecSpecifiInfos, &fragmentationInfo);
    252         if (result.error != webrtc::EncodedImageCallback::Result::OK) {
    253             GST_ELEMENT_ERROR(m_pipeline.get(), LIBRARY, FAILED, (nullptr),
    254                 ("Encode callback failed: %d", result.error));
    255 
    256             return GST_FLOW_ERROR;
    257         }
     252        if (result.error != webrtc::EncodedImageCallback::Result::OK)
     253            GST_ERROR_OBJECT(m_pipeline.get(), "Encode callback failed: %d", result.error);
    258254
    259255        return GST_FLOW_OK;
    … …  
    360356    virtual void PopulateCodecSpecific(webrtc::CodecSpecificInfo*, GstBuffer*) = 0;
    361357
    362     virtual void Fragmentize(webrtc::EncodedImage* encodedImage, std::unique_ptr<uint8_t[]>* encoded_image_buffer, GstBuffer* buffer,
    363         webrtc::RTPFragmentationHeader* fragmentationInfo)
    364     {
    365         GstMapInfo map;
    366 
    367         gst_buffer_map(buffer, &map, GST_MAP_READ);
    368         if (encodedImage->_size < map.size) {
    369             encodedImage->_size = map.size;
     358    virtual void Fragmentize(webrtc::EncodedImage* encodedImage, std::unique_ptr<uint8_t[]>* encodedImageBuffer,
     359        size_t* bufferSize, GstBuffer* buffer, webrtc::RTPFragmentationHeader* fragmentationInfo)
     360    {
     361        GstMappedBuffer map(buffer, GST_MAP_READ);
     362
     363        if (*bufferSize < map.size()) {
     364            encodedImage->_size = map.size();
    370365            encodedImage->_buffer = new uint8_t[encodedImage->_size];
    371             encoded_image_buffer->reset(encodedImage->_buffer);
    372             memcpy(encodedImage->_buffer, map.data, map.size);
    373         }
    374         gst_buffer_unmap(buffer, &map);
     366            encodedImageBuffer->reset(encodedImage->_buffer);
     367            *bufferSize = map.size();
     368        }
     369
     370        memcpy(encodedImage->_buffer, map.data(), map.size());
     371        encodedImage->_length = map.size();
     372        encodedImage->_size = map.size();
    375373
    376374        fragmentationInfo->VerifyAndAllocateFragmentationHeader(1);
    377375        fragmentationInfo->fragmentationOffset[0] = 0;
    378         fragmentationInfo->fragmentationLength[0] = gst_buffer_get_size(buffer);
     376        fragmentationInfo->fragmentationLength[0] = map.size();
    379377        fragmentationInfo->fragmentationPlType[0] = 0;
    380378        fragmentationInfo->fragmentationTimeDiff[0] = 0;
    … …  
    393391    {
    394392        if (caps && m_profile.get() && gst_caps_is_equal(m_restrictionCaps.get(), caps.get()))
    395             g_object_set(m_profile.get(), "restriction-caps", caps, nullptr);
     393            g_object_set(m_profile.get(), "restriction-caps", caps.get(), nullptr);
    396394
    397395        m_restrictionCaps = caps;
    … …  
    414412    BitrateSetter m_bitrateSetter;
    415413    webrtc::EncodedImage m_encodedFrame;
    416     std::unique_ptr<uint8_t[]> encoded_image_buffer_;
     414    std::unique_ptr<uint8_t[]> m_encodedImageBuffer;
     415    size_t m_encodedImageBufferSize;
    417416};
    418417
    … …  
    432431
    433432    // FIXME - MT. safety!
    434     void Fragmentize(webrtc::EncodedImage* encodedImage, std::unique_ptr<uint8_t[]>* encoded_image_buffer,
     433    void Fragmentize(webrtc::EncodedImage* encodedImage, std::unique_ptr<uint8_t[]>* encodedImageBuffer, size_t *bufferSize,
    435434        GstBuffer* gstbuffer, webrtc::RTPFragmentationHeader* fragmentationHeader) final
    436435    {
    437         GstMapInfo map;
    438436        GstH264NalUnit nalu;
    439437        auto parserResult = GST_H264_PARSER_OK;
    … …  
    445443
    446444        const uint8_t startCode[4] = { 0, 0, 0, 1 };
    447         gst_buffer_map(gstbuffer, &map, GST_MAP_READ);
     445        GstMappedBuffer map(gstbuffer, GST_MAP_READ);
    448446        while (parserResult == GST_H264_PARSER_OK) {
    449             parserResult = gst_h264_parser_identify_nalu(m_parser, map.data, offset, map.size, &nalu);
     447            parserResult = gst_h264_parser_identify_nalu(m_parser, map.data(), offset, map.size(), &nalu);
    450448
    451449            nalu.sc_offset = offset;
    … …  
    462460            encodedImage->_size = requiredSize;
    463461            encodedImage->_buffer = new uint8_t[encodedImage->_size];
    464             encoded_image_buffer->reset(encodedImage->_buffer);
     462            encodedImageBuffer->reset(encodedImage->_buffer);
     463            *bufferSize = map.size();
    465464        }
    466465
    … …  
    471470        for (std::vector<GstH264NalUnit>::iterator nal = nals.begin(); nal != nals.end(); ++nal, fragmentIndex++) {
    472471
    473             ASSERT(map.data[nal->sc_offset + 0] == startCode[0]);
    474             ASSERT(map.data[nal->sc_offset + 1] == startCode[1]);
    475             ASSERT(map.data[nal->sc_offset + 2] == startCode[2]);
    476             ASSERT(map.data[nal->sc_offset + 3] == startCode[3]);
     472            ASSERT(map.data()[nal->sc_offset + 0] == startCode[0]);
     473            ASSERT(map.data()[nal->sc_offset + 1] == startCode[1]);
     474            ASSERT(map.data()[nal->sc_offset + 2] == startCode[2]);
     475            ASSERT(map.data()[nal->sc_offset + 3] == startCode[3]);
    477476
    478477            fragmentationHeader->fragmentationOffset[fragmentIndex] = nal->offset;
    479478            fragmentationHeader->fragmentationLength[fragmentIndex] = nal->size;
    480479
    481             memcpy(encodedImage->_buffer + encodedImage->_length, &map.data[nal->sc_offset],
     480            memcpy(encodedImage->_buffer + encodedImage->_length, &map.data()[nal->sc_offset],
    482481                sizeof(startCode) + nal->size);
    483482            encodedImage->_length += nal->size + sizeof(startCode);
    484483        }
    485 
    486         gst_buffer_unmap(gstbuffer, &map);
    487484    }
    488485
Note: See TracChangeset for help on using the changeset viewer.