2018-11-27  YUHAN WU  <yuhan_wu@apple.com>

        Implement non-timeslice mode encoding for MediaRecorder

        https://bugs.webkit.org/show_bug.cgi?id=192069

        Reviewed by NOBODY (OOPS!).

        Implement the encoding for non-timeslice mode of MediaRecorder.

        It only supports to record MP4 file through H264 and AAC encoding, we will need to support more MIME types and encoding methods.

        Tests: http/wpt/mediarecorder/MediaRecorder-real-audio-only-dataavailable.html

               http/wpt/mediarecorder/MediaRecorder-real-audio-video-dataavailable.html

               http/wpt/mediarecorder/MediaRecorder-real-video-only-dataavailable.html

        * Modules/mediarecorder/MediaRecorder.cpp:

        (WebCore::MediaRecorder::getPrivate):

        (WebCore::MediaRecorder::MediaRecorder):

        (WebCore::MediaRecorder::stopRecording):

        * Modules/mediarecorder/MediaRecorder.h:

        * Sources.txt:

        * SourcesCocoa.txt:

        * WebCore.xcodeproj/project.pbxproj:

        * platform/mediarecorder/MediaRecorderPrivate.h:

        (WebCore::MediaRecorderPrivate::stopRecording):

        * platform/mediarecorder/MediaRecorderPrivateReal.cpp: Added.

        (WebCore::MediaRecorderPrivateReal::MediaRecorderPrivateReal):

        (WebCore::MediaRecorderPrivateReal::sampleBufferUpdated):

        (WebCore::MediaRecorderPrivateReal::audioSamplesAvailable):

        (WebCore::MediaRecorderPrivateReal::stopRecording):

        (WebCore::MediaRecorderPrivateReal::fetchData):

        * platform/mediarecorder/MediaRecorderPrivateReal.h: Added.

        * platform/mediarecorder/MediaRecorderPrivateWriter.h: Added.

        * platform/mediarecorder/MediaRecorderPrivateWriter.mm: Added.

        (WebCore::MediaRecorderPrivateWriter::setupWriter):

        (WebCore::MediaRecorderPrivateWriter::setVideoInput):

        (WebCore::MediaRecorderPrivateWriter::setAudioInput):

        (WebCore::MediaRecorderPrivateWriter::appendVideoSampleBuffer):

        (WebCore::MediaRecorderPrivateWriter::appendAudioSampleBuffer):

        (WebCore::MediaRecorderPrivateWriter::stopRecording):

        (WebCore::MediaRecorderPrivateWriter::fetchData):

#include "DeprecatedGlobalSettings.h"

#include "MediaRecorderPrivateReal.h"

UniqueRef<MediaRecorderPrivate> MediaRecorder::getPrivate(Ref<MediaStream>&& stream)

{

    if (DeprecatedGlobalSettings::mockCaptureDevicesEnabled())

        return makeUniqueRef<MediaRecorderPrivateMock>();

    return makeUniqueRef<MediaRecorderPrivateReal>(WTFMove(stream));

}

    m_private->stopRecording();

    UniqueRef<MediaRecorderPrivate> getPrivate(Ref<MediaStream>&&);

platform/mediarecorder/MediaRecorderPrivateReal.cpp

platform/mediarecorder/MediaRecorderPrivateWriter.mm

		4D73F946218BC5FA003A3ED6 /* MediaRecorderPrivateReal.h in Headers */ = {isa = PBXBuildFile; fileRef = 4D73F944218BC5FA003A3ED6 /* MediaRecorderPrivateReal.h */; };

		4D73F94E218C4A87003A3ED6 /* MediaRecorderPrivateWriter.h in Headers */ = {isa = PBXBuildFile; fileRef = 4D73F94C218C4A87003A3ED6 /* MediaRecorderPrivateWriter.h */; };

		4D73F944218BC5FA003A3ED6 /* MediaRecorderPrivateReal.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MediaRecorderPrivateReal.h; sourceTree = "<group>"; };

		4D73F945218BC5FA003A3ED6 /* MediaRecorderPrivateReal.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = MediaRecorderPrivateReal.cpp; sourceTree = "<group>"; };

		4D73F94C218C4A87003A3ED6 /* MediaRecorderPrivateWriter.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MediaRecorderPrivateWriter.h; sourceTree = "<group>"; };

		4D73F94D218C4A87003A3ED6 /* MediaRecorderPrivateWriter.mm */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; path = MediaRecorderPrivateWriter.mm; sourceTree = "<group>"; wrapsLines = 0; };

				4D73F945218BC5FA003A3ED6 /* MediaRecorderPrivateReal.cpp */,

				4D73F944218BC5FA003A3ED6 /* MediaRecorderPrivateReal.h */,

				4D73F94C218C4A87003A3ED6 /* MediaRecorderPrivateWriter.h */,

				4D73F94D218C4A87003A3ED6 /* MediaRecorderPrivateWriter.mm */,

				4D73F946218BC5FA003A3ED6 /* MediaRecorderPrivateReal.h in Headers */,

				4D73F94E218C4A87003A3ED6 /* MediaRecorderPrivateWriter.h in Headers */,

    virtual void stopRecording() { }

/*

 * Copyright (C) 2018 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "MediaRecorderPrivateReal.h"

#if ENABLE(MEDIA_STREAM)

#include "AudioStreamDescription.h"

#include "Blob.h"

#include "MediaSample.h"

#include "MediaStream.h"

#include "SharedBuffer.h"

#include "WebAudioBufferList.h"

namespace WebCore {

MediaRecorderPrivateReal::MediaRecorderPrivateReal(Ref<MediaStream>&& stream)

    : m_writer(makeUniqueRef<MediaRecorderPrivateWriter>())

    , m_stream(WTFMove(stream))

{

    m_writer->setupWriter();

    auto videoTracks = m_stream->getVideoTracks();

    if (videoTracks.size()) {

        auto settings = videoTracks[0]->getSettings();

        if (settings.width && settings.height) {

            m_writer->setVideoInput(*settings.width, *settings.height);

            m_recordedVideoTrackID = videoTracks[0]->id(); // FIXME: we will need to implement support for multiple video tracks, currently we only choose the first track as the recorded track

        }

    }

    auto audioTracks = m_stream->getAudioTracks();

    if (audioTracks.size()) {

        m_writer->setAudioInput();

        m_recordedAudioTrackID = audioTracks[0]->id(); // ditto

    }

}

void MediaRecorderPrivateReal::sampleBufferUpdated(MediaStreamTrackPrivate& track, MediaSample& sampleBuffer)

{

    if (track.id() != m_recordedVideoTrackID)

        return;

    m_writer->appendVideoSampleBuffer(sampleBuffer.platformSample().sample.cmSampleBuffer);

}

void MediaRecorderPrivateReal::audioSamplesAvailable(MediaStreamTrackPrivate& track, const WTF::MediaTime& mediaTime, const PlatformAudioData& data, const AudioStreamDescription& description, size_t sampleCount)

{

    if (track.id() != m_recordedAudioTrackID)

        return;

    ASSERT(is<WebAudioBufferList>(data));

    ASSERT(description.platformDescription().type == PlatformDescription::CAAudioStreamBasicType);

    m_writer->appendAudioSampleBuffer(data, description, mediaTime, sampleCount);

}

void MediaRecorderPrivateReal::stopRecording()

{

    m_writer->stopRecording();

}

Ref<Blob> MediaRecorderPrivateReal::fetchData()

{

    return m_writer->fetchData();

}

} // namespace WebCore

#endif // ENABLE(MEDIA_STREAM)

/*

 * Copyright (C) 2018 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#if ENABLE(MEDIA_STREAM)

#include "MediaRecorderPrivate.h"

#include "MediaRecorderPrivateWriter.h"

#include <wtf/Lock.h>

#include <wtf/UniqueRef.h>

namespace WebCore {

class Blob;

class MediaStream;

class MediaRecorderPrivateReal final : public MediaRecorderPrivate {

public:

    MediaRecorderPrivateReal(Ref<MediaStream>&&);

private:

    void sampleBufferUpdated(MediaStreamTrackPrivate&, MediaSample&) final;

    void audioSamplesAvailable(MediaStreamTrackPrivate&, const WTF::MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;

    Ref<Blob> fetchData() final;

    void stopRecording();

    String m_recordedVideoTrackID;

    String m_recordedAudioTrackID;

    mutable Lock m_bufferLock;

    UniqueRef<MediaRecorderPrivateWriter> m_writer;

    Ref<MediaStream> m_stream;

};

} // namespace WebCore

#endif // ENABLE(MEDIA_STREAM)

/*

 * Copyright (C) 2018 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#if ENABLE(MEDIA_STREAM)

#include <wtf/Deque.h>

#include <wtf/Lock.h>

#include <wtf/RetainPtr.h>

#include <wtf/ThreadSafeRefCounted.h>

#include <wtf/WeakPtr.h>

#include <wtf/threads/BinarySemaphore.h>

typedef struct opaqueCMSampleBuffer *CMSampleBufferRef;

OBJC_CLASS AVAssetWriter;

OBJC_CLASS AVAssetWriterInput;

namespace WTF {

class MediaTime;

}

namespace WebCore {

class Blob;

class PlatformAudioData;

class AudioStreamDescription;

class MediaRecorderPrivateWriter : public ThreadSafeRefCounted<MediaRecorderPrivateWriter>, public CanMakeWeakPtr<MediaRecorderPrivateWriter> {

public:

    bool setupWriter();

    bool setVideoInput(int width, int height);

    bool setAudioInput();

    void appendVideoSampleBuffer(CMSampleBufferRef);

    void appendAudioSampleBuffer(const PlatformAudioData&, const AudioStreamDescription&, const WTF::MediaTime&, size_t);

    void stopRecording();

    Ref<Blob> fetchData();

private:    

    RetainPtr<AVAssetWriter> m_writer;

    RetainPtr<AVAssetWriterInput> m_videoInput;

    RetainPtr<AVAssetWriterInput> m_audioInput;

    String m_path;

    Lock m_videoLock;

    Lock m_audioLock;

    BinarySemaphore m_FinishWritingSemaphore;

    BinarySemaphore m_FinishWritingAudioSemaphore;

    BinarySemaphore m_FinishWritingVideoSemaphore;

    bool canWrite { false };

    bool isStopped { false };

    bool firstAudioSample { true };

    dispatch_queue_t m_audioPullQueue;

    dispatch_queue_t m_videoPullQueue;

    Deque<RetainPtr<CMSampleBufferRef>> m_videoBufferPool;

    Deque<RetainPtr<CMSampleBufferRef>> m_audioBufferPool;

};

} // namespace WebCore

#endif // ENABLE(MEDIA_STREAM)

/*

 * Copyright (C) 2015 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "MediaRecorderPrivateWriter.h"

#if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)

#include "AudioStreamDescription.h"

#include "Blob.h"

#include "FileSystem.h"

#include "SharedBuffer.h"

#include "WebAudioBufferList.h"

#include <AVFoundation/AVAssetWriter.h>

#include <AVFoundation/AVAssetWriterInput.h>

#include <pal/cf/CoreMediaSoftLink.h>

typedef AVAssetWriter AVAssetWriterType;

typedef AVAssetWriterInput AVAssetWriterInputType;

SOFT_LINK_FRAMEWORK_OPTIONAL(AVFoundation)

SOFT_LINK_CLASS(AVFoundation, AVAssetWriter)

SOFT_LINK_CLASS(AVFoundation, AVAssetWriterInput)

SOFT_LINK_CONSTANT(AVFoundation, AVFileTypeMPEG4, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVVideoCodecKey, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVVideoCodecTypeH264, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVVideoWidthKey, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVVideoHeightKey, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVMediaTypeVideo, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVMediaTypeAudio, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVEncoderBitRatePerChannelKey, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVFormatIDKey, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVNumberOfChannelsKey, NSString *)

SOFT_LINK_CONSTANT(AVFoundation, AVSampleRateKey, NSString *)

#define AVFileTypeMPEG4 getAVFileTypeMPEG4()

#define AVMediaTypeAudio getAVMediaTypeAudio()

#define AVMediaTypeVideo getAVMediaTypeVideo()

#define AVVideoCodecKey getAVVideoCodecKey()

#define AVVideoCodecTypeH264 getAVVideoCodecTypeH264()

#define AVVideoWidthKey getAVVideoWidthKey()

#define AVVideoHeightKey getAVVideoHeightKey()

#define AVEncoderBitRatePerChannelKey getAVEncoderBitRatePerChannelKey()

#define AVFormatIDKey getAVFormatIDKey()

#define AVNumberOfChannelsKey getAVNumberOfChannelsKey()

#define AVSampleRateKey getAVSampleRateKey()

using namespace WebCore;

namespace WebCore {

using namespace PAL;

bool MediaRecorderPrivateWriter::setupWriter()

{

    if (m_writer)

        return false;

    NSString *directory = FileSystem::createTemporaryDirectory(@"videos");

    NSString *path = [directory stringByAppendingString:@"/test.mp4"];

    NSURL *outputURL = [NSURL fileURLWithPath:path];

    m_path = [path UTF8String];

    NSError *error = nil;

    m_writer = adoptNS([allocAVAssetWriterInstance() initWithURL:outputURL fileType:AVFileTypeMPEG4 error:&error]);

    if (error)

        return false;

    return true;

}

bool MediaRecorderPrivateWriter::setVideoInput(int width, int height)

{

    if (m_videoInput)

        return false;

    NSDictionary *videoSettings = @{ AVVideoCodecKey: AVVideoCodecTypeH264, AVVideoWidthKey: [NSNumber numberWithInt:width], AVVideoHeightKey: [NSNumber numberWithInt:height] };

    m_videoInput = adoptNS([allocAVAssetWriterInputInstance() initWithMediaType:AVMediaTypeVideo outputSettings:videoSettings sourceFormatHint:NULL]);

    [m_videoInput setExpectsMediaDataInRealTime:true];

    if (![m_writer canAddInput:m_videoInput.get()])

        return false;

    [m_writer addInput:m_videoInput.get()];

    m_videoPullQueue = dispatch_queue_create("WebCoreVideoRecordingPullBufferQueue", DISPATCH_QUEUE_SERIAL);

    return true;

}

bool MediaRecorderPrivateWriter::setAudioInput()

{

    if (m_audioInput)

        return false;

    NSDictionary *audioSettings = @{ AVEncoderBitRatePerChannelKey : @(28000), AVFormatIDKey : @(kAudioFormatMPEG4AAC), AVNumberOfChannelsKey : @(1), AVSampleRateKey : @(22050) };

    m_audioInput = adoptNS([allocAVAssetWriterInputInstance() initWithMediaType:AVMediaTypeAudio outputSettings:audioSettings sourceFormatHint:NULL]);

    [m_audioInput setExpectsMediaDataInRealTime:true];

    if (![m_writer canAddInput:m_audioInput.get()])

        return false;

    [m_writer addInput:m_audioInput.get()];

    m_audioPullQueue = dispatch_queue_create("WebCoreAudioRecordingPushBufferQueue", DISPATCH_QUEUE_SERIAL);

    return true;

}

void MediaRecorderPrivateWriter::appendVideoSampleBuffer(CMSampleBufferRef sampleBuffer)

{

    if (!canWrite) {

        bool success = [m_writer startWriting];

        if (!success)

            isStopped = true;

        CMTime startTime = CMClockGetTime(CMClockGetHostTimeClock());

        [m_writer startSessionAtSourceTime:startTime];

        canWrite = true;

        [m_videoInput requestMediaDataWhenReadyOnQueue:m_videoPullQueue usingBlock:[this, weakThis = makeWeakPtr(*this)] {

            do {

                if (!weakThis)

                    return;

                if (![m_videoInput isReadyForMoreMediaData])

                    break;

                auto locker = holdLock(m_videoLock);

                if (m_videoBufferPool.isEmpty())

                    break;

                auto buf = m_videoBufferPool.takeFirst();

                locker.unlockEarly();

                if (![m_videoInput appendSampleBuffer:buf.get()])

                    break;

            } while (true);

            if (isStopped && m_videoBufferPool.isEmpty()) {

                [m_videoInput markAsFinished];

                m_FinishWritingVideoSemaphore.signal();

            }

        }];

        return;

    }

    CMTime startTime = CMClockGetTime(CMClockGetHostTimeClock());

    CMItemCount count;

    CMSampleBufferGetSampleTimingInfoArray(sampleBuffer, 0, nil, &count);

    CMSampleTimingInfo* pInfo = new CMSampleTimingInfo[count];

    CMSampleBufferGetSampleTimingInfoArray(sampleBuffer, count, pInfo, &count);

    for (CMItemCount i = 0; i < count; i++) {

        pInfo[i].decodeTimeStamp = kCMTimeInvalid;

        pInfo[i].presentationTimeStamp = startTime;

    }

    CMSampleBufferRef sout;

    CMSampleBufferCreateCopyWithNewTiming(kCFAllocatorDefault, sampleBuffer, count, pInfo, &sout);

    free(pInfo);

    auto locker = holdLock(m_videoLock);

    if (isStopped)

        return;

    m_videoBufferPool.append(retainPtr(sout));

}

void MediaRecorderPrivateWriter::appendAudioSampleBuffer(const PlatformAudioData& data, const AudioStreamDescription& description, const WTF::MediaTime&, size_t sampleCount)

{

    if ((!canWrite && m_videoInput) || isStopped)

        return;

    CMSampleBufferRef sampleBuffer;

    CMFormatDescriptionRef format;

    OSStatus error;

    auto& basicDescription = *WTF::get<const AudioStreamBasicDescription*>(description.platformDescription().description);

    error = CMAudioFormatDescriptionCreate(kCFAllocatorDefault, &basicDescription, 0, NULL, 0, NULL, NULL, &format);

    if (firstAudioSample) {

        if (!m_videoInput) {

            // audio-only recording

            bool success = [m_writer startWriting];

            if (!success)

                isStopped = true;

            CMTime startTime = CMClockGetTime(CMClockGetHostTimeClock());

            [m_writer startSessionAtSourceTime:startTime];

            canWrite = true;

        }

        firstAudioSample = false;

        [m_audioInput requestMediaDataWhenReadyOnQueue:m_audioPullQueue usingBlock:[this, weakThis = makeWeakPtr(*this)] {

            do {

                if (!weakThis)

                    return;

                if (![m_audioInput isReadyForMoreMediaData])

                    break;

                auto locker = holdLock(m_audioLock);

                if (m_audioBufferPool.isEmpty())

                    break;

                auto buf = m_audioBufferPool.takeFirst();

                locker.unlockEarly();

                [m_audioInput appendSampleBuffer:buf.get()];

            } while (true);

            if (isStopped && m_audioBufferPool.isEmpty()) {

                [m_audioInput markAsFinished];

                m_FinishWritingAudioSemaphore.signal();

            }

        }];

    }

    CMTime startTime = CMClockGetTime(CMClockGetHostTimeClock());

    error = CMAudioSampleBufferCreateWithPacketDescriptions(kCFAllocatorDefault, NULL, false, NULL, NULL, format, sampleCount, startTime, NULL, &sampleBuffer);

    if (error)

        return;

    error = CMSampleBufferSetDataBufferFromAudioBufferList(sampleBuffer, kCFAllocatorDefault, kCFAllocatorDefault, 0, downcast<WebAudioBufferList>(data).list());

    if (error)

        return;

    auto locker = holdLock(m_audioLock);

    m_audioBufferPool.append(retainPtr(sampleBuffer));

}

void MediaRecorderPrivateWriter::stopRecording()

{

    isStopped = true;

    ASSERT([m_writer status] == AVAssetWriterStatusWriting);

    if (m_videoInput)

        m_FinishWritingVideoSemaphore.wait();

    if (m_audioInput)

        m_FinishWritingAudioSemaphore.wait();

    [m_writer finishWritingWithCompletionHandler:^{

        isStopped = false;

        canWrite = false;

        firstAudioSample = true;

        if (m_videoInput) {

            m_videoInput.clear();

            m_videoInput = NULL;

            dispatch_release(m_videoPullQueue);

        }

        if (m_audioInput) {

            m_audioInput.clear();

            m_audioInput = NULL;

            dispatch_release(m_audioPullQueue);

        }

        m_writer.clear();

        m_writer = NULL;

        m_FinishWritingSemaphore.signal();

    }];

    m_FinishWritingSemaphore.wait();

}

Ref<Blob> MediaRecorderPrivateWriter::fetchData()

{

    if (m_path.isEmpty())

        return Blob::create();

    RefPtr<SharedBuffer> data = SharedBuffer::createWithContentsOfFile(m_path);

    if (!data)

        return Blob::create();

    return Blob::create(*data, "video/mp4"); // FIXME: we will need to support more MIME types

}

} // namespace WebCore

#endif // ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)

2018-11-27  YUHAN WU  <yuhan_wu@apple.com>

        Implement non-timeslice mode encoding for MediaRecorder

        https://bugs.webkit.org/show_bug.cgi?id=192069

        Reviewed by NOBODY (OOPS!).

        Create new tests for encoding of MediaRecorder. Check if the produced video and audio are correct.

        * http/wpt/mediarecorder/MediaRecorder-real-audio-only-dataavailable-expected.txt: Added.

        * http/wpt/mediarecorder/MediaRecorder-real-audio-only-dataavailable.html: Added.

        * http/wpt/mediarecorder/MediaRecorder-real-audio-video-dataavailable-expected.txt: Added.

        * http/wpt/mediarecorder/MediaRecorder-real-audio-video-dataavailable.html: Added.

        * http/wpt/mediarecorder/MediaRecorder-real-video-only-dataavailable-expected.txt: Added.

        * http/wpt/mediarecorder/MediaRecorder-real-video-only-dataavailable.html: Added.

PASS MediaRecorder can successfully record the audio for a audio-only stream 

<!doctype html>

<html>

<head>

    <title>MediaRecorder Dataavailable</title>

    <link rel="help" href="https://w3c.github.io/mediacapture-record/MediaRecorder.html#mediarecorder">

    <script src="/resources/testharness.js"></script>

    <script src="/resources/testharnessreport.js"></script>

</head>

<body>

<audio id="player">

</audio>

<script>

    if (window.internals)

        internals.setMockMediaCaptureDevicesEnabled(false);

    async_test(t => {

        const ac = new AudioContext();

        const osc = ac.createOscillator();

        const dest = ac.createMediaStreamDestination();

        const audio = dest.stream;

        osc.connect(dest);

        const recorder = new MediaRecorder(audio);

        recorder.ondataavailable = t.step_func(blobEvent => {

            assert_true(blobEvent instanceof BlobEvent, 'the type of event should be BlobEvent');

            assert_equals(blobEvent.type, 'dataavailable', 'the event type should be dataavailable');

            assert_true(blobEvent.isTrusted, 'isTrusted should be true when the event is created by C++');

            assert_true(blobEvent.data instanceof Blob, 'the type of data should be Blob');

            assert_true(blobEvent.data.size > 0, 'the blob should contain some buffers');

            const player = document.getElementById("player");

            player.src = window.URL.createObjectURL(blobEvent.data);

            player.oncanplay = () => {

                assert_greater_than(player.duration, 0, 'the duration should be greater than 0');

                t.done();

            };

            player.load();

        });

        recorder.start();

        osc.start();

        assert_equals(recorder.state, 'recording', 'MediaRecorder has been started successfully');

        setTimeout(() => {

            recorder.stop();

            osc.stop();

        }, 5000);

    }, 'MediaRecorder can successfully record the audio for a audio-only stream');

</script>

</body>

</html>

PASS MediaRecorder can successfully record the video for a audio-video stream 

<!doctype html>

<html>

<head>

    <title>MediaRecorder Dataavailable</title>

    <link rel="help" href="https://w3c.github.io/mediacapture-record/MediaRecorder.html#mediarecorder">

    <script src="/resources/testharness.js"></script>

    <script src="/resources/testharnessreport.js"></script>

    <script src="../common/canvas-tests.js"></script>

    <link rel="stylesheet" href="../common/canvas-tests.css">

</head>

<body>

<div>

    <video id="player">

    </video>

</div>

<div>

    <canvas id="canvas" width="200" height="200">

    </canvas>

    <canvas id="frame" width="200" height="200">

    </canvas>

</div>

<script>

    var context;

    var drawIterationsPerTest = 100;

    var drawTimes = 0;

    function createVideoStream() {

        const canvas = document.getElementById("canvas");

        context = canvas.getContext('2d');

        return canvas.captureStream();

    }

    function doDraw() {

        if (context) {

            context.fillStyle = "#ff0000";

            context.fillRect(0, 0, 100, 200);

            context.fillStyle = "#00ff00";

            context.fillRect(100, 0, 100, 200);

            if (drawTimes < drawIterationsPerTest) {

                drawTimes++;

                window.requestAnimationFrame(doDraw);

            }

        }

    }

    if (window.internals)

        internals.setMockMediaCaptureDevicesEnabled(false);

    async_test(t => {

        const ac = new AudioContext();

        const osc = ac.createOscillator();

        const dest = ac.createMediaStreamDestination();

        const audio = dest.stream;

        osc.connect(dest);

        const video = createVideoStream();

        assert_equals(video.getAudioTracks().length, 0, "video mediastream starts with no audio track");

        assert_equals(audio.getAudioTracks().length, 1, "audio mediastream starts with one audio track");

        video.addTrack(audio.getAudioTracks()[0]);

        assert_equals(video.getAudioTracks().length, 1, "video mediastream starts with one audio track");

        const recorder = new MediaRecorder(video);

        recorder.ondataavailable = t.step_func(blobEvent => {

            assert_true(blobEvent instanceof BlobEvent, 'the type of event should be BlobEvent');

            assert_equals(blobEvent.type, 'dataavailable', 'the event type should be dataavailable');

            assert_true(blobEvent.isTrusted, 'isTrusted should be true when the event is created by C++');

            assert_true(blobEvent.data instanceof Blob, 'the type of data should be Blob');

            assert_true(blobEvent.data.size > 0, 'the blob should contain some buffers');

            const player = document.getElementById("player");

            player.src = window.URL.createObjectURL(blobEvent.data);

            player.oncanplay = () => {

                assert_greater_than(player.duration, 0, 'the duration should be greater than 0');

                player.play();

            };

            player.onended = () => {

                const resFrame = document.getElementById("frame");

                const resContext = resFrame.getContext('2d');

                resContext.drawImage(player, 0, 0);

                _assertPixelApprox(resFrame, 0, 0, 255, 0, 0, 255, "0, 0", "255, 0, 0, 255", 5);

                _assertPixelApprox(resFrame, 50, 50, 255, 0, 0, 255, "50, 50", "255, 0, 0, 255", 5);

                _assertPixelApprox(resFrame, 199, 0, 0, 255, 0, 255, "199, 0", "0, 255, 0, 255", 5);

                _assertPixelApprox(resFrame, 199, 199, 0, 255, 0, 255, "199, 199", "0, 255, 0, 255", 5);

                t.done();

            };

            player.load();

        });

        doDraw();

        recorder.start();

        osc.start();

        assert_equals(recorder.state, 'recording', 'MediaRecorder has been started successfully');

        setTimeout(() => {

            recorder.stop();

            osc.stop();

        }, 2000);

    }, 'MediaRecorder can successfully record the video for a audio-video stream');

</script>

</body>

</html>

PASS MediaRecorder can successfully record the video for a video-only stream 

<!doctype html>

<html>

<head>

    <title>MediaRecorder Dataavailable</title>

    <link rel="help" href="https://w3c.github.io/mediacapture-record/MediaRecorder.html#mediarecorder">

    <script src="/resources/testharness.js"></script>

    <script src="/resources/testharnessreport.js"></script>

    <script src="../common/canvas-tests.js"></script>

    <link rel="stylesheet" href="../common/canvas-tests.css">

</head>

<body>

<div>

    <video id="player">

    </video>

</div>

<div>

    <canvas id="canvas" width="200" height="200">

    </canvas>

    <canvas id="frame" width="200" height="200">

    </canvas>

</div>

<script>

    var context;

    var drawIterationsPerTest = 100;

    var drawTimes = 0;

    function createVideoStream() {

        const canvas = document.getElementById("canvas");

        context = canvas.getContext('2d');

        return canvas.captureStream();

    }

    function doDraw() {

        if (context) {

            context.fillStyle = "#ff0000";

            context.fillRect(0, 0, 100, 200);

            context.fillStyle = "#00ff00";

            context.fillRect(100, 0, 100, 200);

            if (drawTimes < drawIterationsPerTest) {

                drawTimes++;

                window.requestAnimationFrame(doDraw);

            }

        }

    }

    if (window.internals)

        internals.setMockMediaCaptureDevicesEnabled(false);

    async_test(t => {

        const video = createVideoStream();

        const recorder = new MediaRecorder(video);

        recorder.ondataavailable = t.step_func(blobEvent => {

            assert_true(blobEvent instanceof BlobEvent, 'the type of event should be BlobEvent');

            assert_equals(blobEvent.type, 'dataavailable', 'the event type should be dataavailable');

            assert_true(blobEvent.isTrusted, 'isTrusted should be true when the event is created by C++');

            assert_true(blobEvent.data instanceof Blob, 'the type of data should be Blob');

            assert_true(blobEvent.data.size > 0, 'the blob should contain some buffers');

            const player = document.getElementById("player");

            player.src = window.URL.createObjectURL(blobEvent.data);

            player.oncanplay = () => {

                assert_greater_than(player.duration, 0, 'the duration should be greater than 0');

                player.play();

            };

            player.onended = () => {

                const resFrame = document.getElementById("frame");

                const resContext = resFrame.getContext('2d');

                resContext.drawImage(player, 0, 0);

                _assertPixelApprox(resFrame, 0, 0, 255, 0, 0, 255, "0, 0", "255, 0, 0, 255", 5);

                _assertPixelApprox(resFrame, 50, 50, 255, 0, 0, 255, "50, 50", "255, 0, 0, 255", 5);

                _assertPixelApprox(resFrame, 199, 0, 0, 255, 0, 255, "199, 0", "0, 255, 0, 255", 5);

                _assertPixelApprox(resFrame, 199, 199, 0, 255, 0, 255, "199, 199", "0, 255, 0, 255", 5);

                t.done();

            };

            player.load();

        });

        doDraw();

        recorder.start();

        assert_equals(recorder.state, 'recording', 'MediaRecorder has been started successfully');

        setTimeout(() => {

            recorder.stop();

        }, 2000);

    }, 'MediaRecorder can successfully record the video for a video-only stream');

</script>

</body>

</html>