diff options
25 files changed, 417 insertions, 402 deletions
diff --git a/content/renderer/pepper/pepper_media_stream_audio_track_host.cc b/content/renderer/pepper/pepper_media_stream_audio_track_host.cc index ed44466..7d0695b 100644 --- a/content/renderer/pepper/pepper_media_stream_audio_track_host.cc +++ b/content/renderer/pepper/pepper_media_stream_audio_track_host.cc @@ -11,7 +11,7 @@ #include "base/message_loop/message_loop_proxy.h" #include "ppapi/c/pp_errors.h" #include "ppapi/c/ppb_audio_frame.h" -#include "ppapi/shared_impl/media_stream_frame.h" +#include "ppapi/shared_impl/media_stream_buffer.h" using media::AudioParameters; @@ -21,7 +21,7 @@ namespace { const uint32_t kMaxDuration = 10; // TODO(penghuang): make this configurable. -const int32_t kNumberOfFrames = 4; +const int32_t kNumberOfBuffers = 4; } // namespace @@ -30,7 +30,7 @@ namespace content { PepperMediaStreamAudioTrackHost::AudioSink::AudioSink( PepperMediaStreamAudioTrackHost* host) : host_(host), - frame_data_size_(0), + buffer_data_size_(0), main_message_loop_proxy_(base::MessageLoopProxy::current()), weak_factory_(this) { } @@ -39,33 +39,33 @@ PepperMediaStreamAudioTrackHost::AudioSink::~AudioSink() { DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current()); } -void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueFrame(int32_t index) { +void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueBuffer(int32_t index) { DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current()); DCHECK_GE(index, 0); - DCHECK_LT(index, host_->frame_buffer()->number_of_frames()); + DCHECK_LT(index, host_->buffer_manager()->number_of_buffers()); base::AutoLock lock(lock_); - frames_.push_back(index); + buffers_.push_back(index); } -void PepperMediaStreamAudioTrackHost::AudioSink::InitFramesOnMainThread( - int32_t number_of_frames, int32_t frame_size) { +void PepperMediaStreamAudioTrackHost::AudioSink::InitBuffersOnMainThread( + int32_t number_of_buffers, int32_t buffer_size) { DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current()); - bool result = host_->InitFrames(number_of_frames, frame_size); + bool result = host_->InitBuffers(number_of_buffers, buffer_size); // TODO(penghuang): Send PP_ERROR_NOMEMORY to plugin. CHECK(result); base::AutoLock lock(lock_); - for (int32_t i = 0; i < number_of_frames; ++i) { - int32_t index = host_->frame_buffer()->DequeueFrame(); + for (int32_t i = 0; i < number_of_buffers; ++i) { + int32_t index = host_->buffer_manager()->DequeueBuffer(); DCHECK_GE(index, 0); - frames_.push_back(index); + buffers_.push_back(index); } } void -PepperMediaStreamAudioTrackHost::AudioSink::SendEnqueueFrameMessageOnMainThread( - int32_t index) { +PepperMediaStreamAudioTrackHost::AudioSink:: + SendEnqueueBufferMessageOnMainThread(int32_t index) { DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current()); - host_->SendEnqueueFrameMessageToPlugin(index); + host_->SendEnqueueBufferMessageToPlugin(index); } void PepperMediaStreamAudioTrackHost::AudioSink::OnData(const int16* audio_data, @@ -80,31 +80,31 @@ void PepperMediaStreamAudioTrackHost::AudioSink::OnData(const int16* audio_data, int32_t index = -1; { base::AutoLock lock(lock_); - if (!frames_.empty()) { - index = frames_.front(); - frames_.pop_front(); + if (!buffers_.empty()) { + index = buffers_.front(); + buffers_.pop_front(); } } if (index != -1) { // TODO(penghuang): support re-sampling, etc. - ppapi::MediaStreamFrame::Audio* frame = - &(host_->frame_buffer()->GetFramePointer(index)->audio); - frame->header.size = host_->frame_buffer()->frame_size(); - frame->header.type = ppapi::MediaStreamFrame::TYPE_AUDIO; - frame->timestamp = timestamp_.InMillisecondsF(); - frame->sample_rate = static_cast<PP_AudioFrame_SampleRate>(sample_rate); - frame->number_of_channels = number_of_channels; - frame->number_of_samples = number_of_channels * number_of_frames; - frame->data_size = frame_data_size_; - memcpy(frame->data, audio_data, frame_data_size_); + ppapi::MediaStreamBuffer::Audio* buffer = + &(host_->buffer_manager()->GetBufferPointer(index)->audio); + buffer->header.size = host_->buffer_manager()->buffer_size(); + buffer->header.type = ppapi::MediaStreamBuffer::TYPE_AUDIO; + buffer->timestamp = timestamp_.InMillisecondsF(); + buffer->sample_rate = static_cast<PP_AudioFrame_SampleRate>(sample_rate); + buffer->number_of_channels = number_of_channels; + buffer->number_of_samples = number_of_channels * number_of_frames; + buffer->data_size = buffer_data_size_; + memcpy(buffer->data, audio_data, buffer_data_size_); main_message_loop_proxy_->PostTask( FROM_HERE, - base::Bind(&AudioSink::SendEnqueueFrameMessageOnMainThread, + base::Bind(&AudioSink::SendEnqueueBufferMessageOnMainThread, weak_factory_.GetWeakPtr(), index)); } - timestamp_ += frame_duration_; + timestamp_ += buffer_duration_; } void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat( @@ -124,8 +124,8 @@ void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat( audio_params_ = params; // TODO(penghuang): support setting format more than once. - frame_duration_ = params.GetBufferDuration(); - frame_data_size_ = params.GetBytesPerBuffer(); + buffer_duration_ = params.GetBufferDuration(); + buffer_data_size_ = params.GetBytesPerBuffer(); if (original_audio_params_.IsValid()) { DCHECK_EQ(params.sample_rate(), original_audio_params_.sample_rate()); @@ -136,17 +136,17 @@ void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat( audio_thread_checker_.DetachFromThread(); original_audio_params_ = params; // The size is slightly bigger than necessary, because 8 extra bytes are - // added into the struct. Also see |MediaStreamFrame|. - size_t max_frame_size = + // added into the struct. Also see |MediaStreamBuffer|. + size_t max_data_size = params.sample_rate() * params.bits_per_sample() / 8 * params.channels() * kMaxDuration / 1000; - size_t size = sizeof(ppapi::MediaStreamFrame::Audio) + max_frame_size; + size_t size = sizeof(ppapi::MediaStreamBuffer::Audio) + max_data_size; main_message_loop_proxy_->PostTask( FROM_HERE, - base::Bind(&AudioSink::InitFramesOnMainThread, + base::Bind(&AudioSink::InitBuffersOnMainThread, weak_factory_.GetWeakPtr(), - kNumberOfFrames, + kNumberOfBuffers, static_cast<int32_t>(size))); } } @@ -174,10 +174,10 @@ void PepperMediaStreamAudioTrackHost::OnClose() { } } -void PepperMediaStreamAudioTrackHost::OnNewFrameEnqueued() { - int32_t index = frame_buffer()->DequeueFrame(); +void PepperMediaStreamAudioTrackHost::OnNewBufferEnqueued() { + int32_t index = buffer_manager()->DequeueBuffer(); DCHECK_GE(index, 0); - audio_sink_.EnqueueFrame(index); + audio_sink_.EnqueueBuffer(index); } void PepperMediaStreamAudioTrackHost::DidConnectPendingHostToResource() { diff --git a/content/renderer/pepper/pepper_media_stream_audio_track_host.h b/content/renderer/pepper/pepper_media_stream_audio_track_host.h index ec19ea1..8c0706f 100644 --- a/content/renderer/pepper/pepper_media_stream_audio_track_host.h +++ b/content/renderer/pepper/pepper_media_stream_audio_track_host.h @@ -38,14 +38,18 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase { explicit AudioSink(PepperMediaStreamAudioTrackHost* host); virtual ~AudioSink(); - // Enqueues a free frame index into |frames_| which will be used for + // Enqueues a free buffer index into |buffers_| which will be used for // sending audio samples to plugin. - // This function is called on the renderer main thread. - void EnqueueFrame(int32_t index); + // This function is called on the main thread. + void EnqueueBuffer(int32_t index); private: - void InitFramesOnMainThread(int32_t number_of_frames, int32_t frame_size); - void SendEnqueueFrameMessageOnMainThread(int32_t index); + // Initializes buffers on the main thread. + void InitBuffersOnMainThread(int32_t number_of_buffers, + int32_t buffer_size); + + // Send enqueue buffer message on the main thread. + void SendEnqueueBufferMessageOnMainThread(int32_t index); // MediaStreamAudioSink overrides: // These two functions should be called on the audio thread. @@ -57,18 +61,18 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase { // Unowned host which is available during the AudioSink's lifespan. // It is mainly used in the main thread. But the audio thread will use - // host_->frame_buffer() to read some buffer properties. It is safe - // because the frame_buffer()'s properties will not be changed after + // host_->buffer_manager() to read some buffer properties. It is safe + // because the buffer_manager()'s properties will not be changed after // initialization. PepperMediaStreamAudioTrackHost* host_; - // Timestamp of the next received audio frame. + // Timestamp of the next received audio buffer. // Access only on the audio thread. base::TimeDelta timestamp_; - // Duration of one audio frame. + // Duration of one audio buffer. // Access only on the audio thread. - base::TimeDelta frame_duration_; + base::TimeDelta buffer_duration_; // The current audio parameters. // Access only on the audio thread. @@ -79,15 +83,15 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase { // Access only on the audio thread. media::AudioParameters original_audio_params_; - // The size of a frame in bytes. + // The audio data size of one audio buffer in bytes. // Access only on the audio thread. - uint32_t frame_data_size_; + uint32_t buffer_data_size_; - // A lock to protect the index queue |frames_|. + // A lock to protect the index queue |buffers_|. base::Lock lock_; - // A queue for free frame indices. - std::deque<int32_t> frames_; + // A queue for free buffer indices. + std::deque<int32_t> buffers_; scoped_refptr<base::MessageLoopProxy> main_message_loop_proxy_; @@ -103,8 +107,8 @@ class PepperMediaStreamAudioTrackHost : public PepperMediaStreamTrackHostBase { // PepperMediaStreamTrackHostBase overrides: virtual void OnClose() OVERRIDE; - // MediaStreamFrameBuffer::Delegate overrides: - virtual void OnNewFrameEnqueued() OVERRIDE; + // MediaStreamBufferManager::Delegate overrides: + virtual void OnNewBufferEnqueued() OVERRIDE; // ResourceHost overrides: virtual void DidConnectPendingHostToResource() OVERRIDE; diff --git a/content/renderer/pepper/pepper_media_stream_track_host_base.cc b/content/renderer/pepper/pepper_media_stream_track_host_base.cc index aadc7ab..207de39 100644 --- a/content/renderer/pepper/pepper_media_stream_track_host_base.cc +++ b/content/renderer/pepper/pepper_media_stream_track_host_base.cc @@ -12,7 +12,7 @@ #include "ppapi/host/host_message_context.h" #include "ppapi/host/ppapi_host.h" #include "ppapi/proxy/ppapi_messages.h" -#include "ppapi/shared_impl/media_stream_frame.h" +#include "ppapi/shared_impl/media_stream_buffer.h" using ppapi::host::HostMessageContext; using ppapi::proxy::SerializedHandle; @@ -25,23 +25,23 @@ PepperMediaStreamTrackHostBase::PepperMediaStreamTrackHostBase( PP_Resource resource) : ResourceHost(host->GetPpapiHost(), instance, resource), host_(host), - frame_buffer_(this) { + buffer_manager_(this) { } PepperMediaStreamTrackHostBase::~PepperMediaStreamTrackHostBase() { } -bool PepperMediaStreamTrackHostBase::InitFrames(int32_t number_of_frames, - int32_t frame_size) { - DCHECK_GT(number_of_frames, 0); - DCHECK_GT(frame_size, - static_cast<int32_t>(sizeof(ppapi::MediaStreamFrame::Header))); - // Make each frame 4 byte aligned. - frame_size = (frame_size + 3) & ~0x3; +bool PepperMediaStreamTrackHostBase::InitBuffers(int32_t number_of_buffers, + int32_t buffer_size) { + DCHECK_GT(number_of_buffers, 0); + DCHECK_GT(buffer_size, + static_cast<int32_t>(sizeof(ppapi::MediaStreamBuffer::Header))); + // Make each buffer 4 byte aligned. + buffer_size = (buffer_size + 3) & ~0x3; // TODO(penghuang): |HostAllocateSharedMemoryBuffer| uses sync IPC. We should // avoid it. - int32_t size = number_of_frames * frame_size; + int32_t size = number_of_buffers * buffer_size; content::RenderThread* render_thread = content::RenderThread::Get(); scoped_ptr<base::SharedMemory> shm( render_thread->HostAllocateSharedMemoryBuffer(size).Pass()); @@ -49,8 +49,10 @@ bool PepperMediaStreamTrackHostBase::InitFrames(int32_t number_of_frames, return false; base::SharedMemoryHandle shm_handle = shm->handle(); - if (!frame_buffer_.SetFrames(number_of_frames, frame_size, shm.Pass(), true)) + if (!buffer_manager_.SetBuffers( + number_of_buffers, buffer_size, shm.Pass(), true)) { return false; + } base::PlatformFile platform_file = #if defined(OS_WIN) @@ -63,17 +65,18 @@ bool PepperMediaStreamTrackHostBase::InitFrames(int32_t number_of_frames, SerializedHandle handle( host_->ShareHandleWithRemote(platform_file, false), size); host()->SendUnsolicitedReplyWithHandles(pp_resource(), - PpapiPluginMsg_MediaStreamTrack_InitFrames(number_of_frames, frame_size), + PpapiPluginMsg_MediaStreamTrack_InitBuffers(number_of_buffers, + buffer_size), std::vector<SerializedHandle>(1, handle)); return true; } -void PepperMediaStreamTrackHostBase::SendEnqueueFrameMessageToPlugin( +void PepperMediaStreamTrackHostBase::SendEnqueueBufferMessageToPlugin( int32_t index) { DCHECK_GE(index, 0); - DCHECK_LT(index, frame_buffer_.number_of_frames()); + DCHECK_LT(index, buffer_manager_.number_of_buffers()); host()->SendUnsolicitedReply(pp_resource(), - PpapiPluginMsg_MediaStreamTrack_EnqueueFrame(index)); + PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer(index)); } int32_t PepperMediaStreamTrackHostBase::OnResourceMessageReceived( @@ -81,17 +84,17 @@ int32_t PepperMediaStreamTrackHostBase::OnResourceMessageReceived( HostMessageContext* context) { IPC_BEGIN_MESSAGE_MAP(PepperMediaStreamTrackHostBase, msg) PPAPI_DISPATCH_HOST_RESOURCE_CALL( - PpapiHostMsg_MediaStreamTrack_EnqueueFrame, OnHostMsgEnqueueFrame) + PpapiHostMsg_MediaStreamTrack_EnqueueBuffer, OnHostMsgEnqueueBuffer) PPAPI_DISPATCH_HOST_RESOURCE_CALL_0( PpapiHostMsg_MediaStreamTrack_Close, OnHostMsgClose) IPC_END_MESSAGE_MAP() return ppapi::host::ResourceHost::OnResourceMessageReceived(msg, context); } -int32_t PepperMediaStreamTrackHostBase::OnHostMsgEnqueueFrame( +int32_t PepperMediaStreamTrackHostBase::OnHostMsgEnqueueBuffer( HostMessageContext* context, int32_t index) { - frame_buffer_.EnqueueFrame(index); + buffer_manager_.EnqueueBuffer(index); return PP_OK; } diff --git a/content/renderer/pepper/pepper_media_stream_track_host_base.h b/content/renderer/pepper/pepper_media_stream_track_host_base.h index bb34eb5..a31c1e1 100644 --- a/content/renderer/pepper/pepper_media_stream_track_host_base.h +++ b/content/renderer/pepper/pepper_media_stream_track_host_base.h @@ -8,7 +8,7 @@ #include "base/compiler_specific.h" #include "content/common/content_export.h" #include "ppapi/host/resource_host.h" -#include "ppapi/shared_impl/media_stream_frame_buffer.h" +#include "ppapi/shared_impl/media_stream_buffer_manager.h" namespace content { @@ -16,21 +16,22 @@ class RendererPpapiHost; class PepperMediaStreamTrackHostBase : public ppapi::host::ResourceHost, - public ppapi::MediaStreamFrameBuffer::Delegate { + public ppapi::MediaStreamBufferManager::Delegate { protected: PepperMediaStreamTrackHostBase(RendererPpapiHost* host, PP_Instance instance, PP_Resource resource); virtual ~PepperMediaStreamTrackHostBase(); - bool InitFrames(int32_t number_of_frames, int32_t frame_size); + bool InitBuffers(int32_t number_of_buffers, int32_t buffer_size); - ppapi::MediaStreamFrameBuffer* frame_buffer() { return &frame_buffer_; } + ppapi::MediaStreamBufferManager* buffer_manager() { return &buffer_manager_; } - // Sends a frame index to the corresponding MediaStreamTrackResourceBase - // via an IPC message. The resource adds the frame index into its - // |frame_buffer_| for reading or writing. Also see |MediaStreamFrameBuffer|. - void SendEnqueueFrameMessageToPlugin(int32_t index); + // Sends a buffer index to the corresponding MediaStreamTrackResourceBase + // via an IPC message. The resource adds the buffer index into its + // |buffer_manager_| for reading or writing. + // Also see |MediaStreamBufferManager|. + void SendEnqueueBufferMessageToPlugin(int32_t index); private: // Subclasses must implement this method to clean up when the track is closed. @@ -42,13 +43,13 @@ class PepperMediaStreamTrackHostBase ppapi::host::HostMessageContext* context) OVERRIDE; // Message handlers: - int32_t OnHostMsgEnqueueFrame(ppapi::host::HostMessageContext* context, + int32_t OnHostMsgEnqueueBuffer(ppapi::host::HostMessageContext* context, int32_t index); int32_t OnHostMsgClose(ppapi::host::HostMessageContext* context); RendererPpapiHost* host_; - ppapi::MediaStreamFrameBuffer frame_buffer_; + ppapi::MediaStreamBufferManager buffer_manager_; DISALLOW_COPY_AND_ASSIGN(PepperMediaStreamTrackHostBase); }; diff --git a/content/renderer/pepper/pepper_media_stream_video_track_host.cc b/content/renderer/pepper/pepper_media_stream_video_track_host.cc index 0cf8036c..7512c5a 100644 --- a/content/renderer/pepper/pepper_media_stream_video_track_host.cc +++ b/content/renderer/pepper/pepper_media_stream_video_track_host.cc @@ -7,7 +7,7 @@ #include "base/logging.h" #include "ppapi/c/pp_errors.h" #include "ppapi/c/ppb_video_frame.h" -#include "ppapi/shared_impl/media_stream_frame.h" +#include "ppapi/shared_impl/media_stream_buffer.h" using media::VideoFrame; @@ -77,33 +77,33 @@ void PepperMediaStreamVideoTrackHost::OnVideoFrame( // than once. DCHECK(!frame_data_size_); frame_data_size_ = VideoFrame::AllocationSize(frame_format_, frame_size_); - int32_t size = sizeof(ppapi::MediaStreamFrame::Video) + frame_data_size_; - bool result = InitFrames(kNumberOfFrames, size); + int32_t size = sizeof(ppapi::MediaStreamBuffer::Video) + frame_data_size_; + bool result = InitBuffers(kNumberOfFrames, size); // TODO(penghuang): Send PP_ERROR_NOMEMORY to plugin. CHECK(result); } - int32_t index = frame_buffer()->DequeueFrame(); + int32_t index = buffer_manager()->DequeueBuffer(); // Drop frames if the underlying buffer is full. if (index < 0) return; // TODO(penghuang): support format conversion and size scaling. - ppapi::MediaStreamFrame::Video* ppframe = - &(frame_buffer()->GetFramePointer(index)->video); - ppframe->header.size = frame_buffer()->frame_size(); - ppframe->header.type = ppapi::MediaStreamFrame::TYPE_VIDEO; - ppframe->timestamp = frame->GetTimestamp().InSecondsF(); - ppframe->format = ppformat; - ppframe->size.width = frame->coded_size().width(); - ppframe->size.height = frame->coded_size().height(); - ppframe->data_size = frame_data_size_; + ppapi::MediaStreamBuffer::Video* buffer = + &(buffer_manager()->GetBufferPointer(index)->video); + buffer->header.size = buffer_manager()->buffer_size(); + buffer->header.type = ppapi::MediaStreamBuffer::TYPE_VIDEO; + buffer->timestamp = frame->GetTimestamp().InSecondsF(); + buffer->format = ppformat; + buffer->size.width = frame->coded_size().width(); + buffer->size.height = frame->coded_size().height(); + buffer->data_size = frame_data_size_; COMPILE_ASSERT(VideoFrame::kYPlane == 0, y_plane_should_be_0); COMPILE_ASSERT(VideoFrame::kUPlane == 1, u_plane_should_be_1); COMPILE_ASSERT(VideoFrame::kVPlane == 2, v_plane_should_be_2); - uint8_t* dst = ppframe->data; + uint8_t* dst = buffer->data; size_t num_planes = VideoFrame::NumPlanes(frame->format()); for (size_t i = 0; i < num_planes; ++i) { const uint8_t* src = frame->data(i); @@ -117,7 +117,7 @@ void PepperMediaStreamVideoTrackHost::OnVideoFrame( } } - SendEnqueueFrameMessageToPlugin(index); + SendEnqueueBufferMessageToPlugin(index); } void PepperMediaStreamVideoTrackHost::DidConnectPendingHostToResource() { diff --git a/ppapi/examples/media_stream_video/media_stream_video.cc b/ppapi/examples/media_stream_video/media_stream_video.cc index b23f3ed..3635e0e 100644 --- a/ppapi/examples/media_stream_video/media_stream_video.cc +++ b/ppapi/examples/media_stream_video/media_stream_video.cc @@ -342,7 +342,7 @@ void MediaStreamVideoDemoInstance::OnGetFrame( return; const char* data = static_cast<const char*>(frame.GetDataBuffer()); pp::Size size; - PP_DCHECK(frame.GetSize(&size)); + frame.GetSize(&size); if (size != frame_size_) { frame_size_ = size; diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi index 43f5b71..580bf01 100644 --- a/ppapi/ppapi_shared.gypi +++ b/ppapi/ppapi_shared.gypi @@ -39,9 +39,9 @@ 'shared_impl/host_resource.h', 'shared_impl/id_assignment.cc', 'shared_impl/id_assignment.h', - 'shared_impl/media_stream_frame.h', - 'shared_impl/media_stream_frame_buffer.cc', - 'shared_impl/media_stream_frame_buffer.h', + 'shared_impl/media_stream_buffer.h', + 'shared_impl/media_stream_buffer_manager.cc', + 'shared_impl/media_stream_buffer_manager.h', 'shared_impl/platform_file.cc', 'shared_impl/platform_file.h', 'shared_impl/ppapi_globals.cc', diff --git a/ppapi/proxy/audio_frame_resource.cc b/ppapi/proxy/audio_frame_resource.cc index 4954857..0827df7 100644 --- a/ppapi/proxy/audio_frame_resource.cc +++ b/ppapi/proxy/audio_frame_resource.cc @@ -6,6 +6,7 @@ #include "base/logging.h" #include "ppapi/c/pp_bool.h" +#include "ppapi/shared_impl/media_stream_buffer.h" #include "ppapi/shared_impl/var.h" namespace ppapi { @@ -13,15 +14,15 @@ namespace proxy { AudioFrameResource::AudioFrameResource(PP_Instance instance, int32_t index, - MediaStreamFrame* frame) + MediaStreamBuffer* buffer) : Resource(OBJECT_IS_PROXY, instance), index_(index), - frame_(frame) { - DCHECK_EQ(frame_->header.type, MediaStreamFrame::TYPE_AUDIO); + buffer_(buffer) { + DCHECK_EQ(buffer_->header.type, MediaStreamBuffer::TYPE_AUDIO); } AudioFrameResource::~AudioFrameResource() { - CHECK(!frame_) << "An unused (or unrecycled) frame is destroyed."; + CHECK(!buffer_) << "An unused (or unrecycled) frame is destroyed."; } thunk::PPB_AudioFrame_API* AudioFrameResource::AsPPB_AudioFrame_API() { @@ -29,81 +30,81 @@ thunk::PPB_AudioFrame_API* AudioFrameResource::AsPPB_AudioFrame_API() { } PP_TimeDelta AudioFrameResource::GetTimestamp() { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return 0.0; } - return frame_->audio.timestamp; + return buffer_->audio.timestamp; } void AudioFrameResource::SetTimestamp(PP_TimeDelta timestamp) { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return; } - frame_->audio.timestamp = timestamp; + buffer_->audio.timestamp = timestamp; } PP_AudioFrame_SampleRate AudioFrameResource::GetSampleRate() { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return PP_AUDIOFRAME_SAMPLERATE_UNKNOWN; } - return frame_->audio.sample_rate; + return buffer_->audio.sample_rate; } PP_AudioFrame_SampleSize AudioFrameResource::GetSampleSize() { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return PP_AUDIOFRAME_SAMPLESIZE_UNKNOWN; } return PP_AUDIOFRAME_SAMPLESIZE_16_BITS; } uint32_t AudioFrameResource::GetNumberOfChannels() { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return 0; } - return frame_->audio.number_of_channels; + return buffer_->audio.number_of_channels; } uint32_t AudioFrameResource::GetNumberOfSamples() { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return 0; } - return frame_->audio.number_of_samples; + return buffer_->audio.number_of_samples; } void* AudioFrameResource::GetDataBuffer() { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return NULL; } - return frame_->audio.data; + return buffer_->audio.data; } uint32_t AudioFrameResource::GetDataBufferSize() { - if (!frame_) { - VLOG(1) << "Frame is invalid"; + if (!buffer_) { + VLOG(1) << "Buffer is invalid"; return 0; } - return frame_->audio.data_size; + return buffer_->audio.data_size; } -MediaStreamFrame* AudioFrameResource::GetFrameBuffer() { - return frame_; +MediaStreamBuffer* AudioFrameResource::GetBuffer() { + return buffer_; } -int32_t AudioFrameResource::GetFrameBufferIndex() { +int32_t AudioFrameResource::GetBufferIndex() { return index_; } void AudioFrameResource::Invalidate() { - DCHECK(frame_); + DCHECK(buffer_); DCHECK_GE(index_, 0); - frame_ = NULL; + buffer_ = NULL; index_ = -1; } diff --git a/ppapi/proxy/audio_frame_resource.h b/ppapi/proxy/audio_frame_resource.h index a463bba..8332ec2 100644 --- a/ppapi/proxy/audio_frame_resource.h +++ b/ppapi/proxy/audio_frame_resource.h @@ -8,11 +8,13 @@ #include "base/basictypes.h" #include "base/compiler_specific.h" #include "ppapi/proxy/ppapi_proxy_export.h" -#include "ppapi/shared_impl/media_stream_frame.h" #include "ppapi/shared_impl/resource.h" #include "ppapi/thunk/ppb_audio_frame_api.h" namespace ppapi { + +union MediaStreamBuffer; + namespace proxy { class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource, @@ -20,7 +22,7 @@ class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource, public: AudioFrameResource(PP_Instance instance, int32_t index, - MediaStreamFrame* frame); + MediaStreamBuffer* buffer); virtual ~AudioFrameResource(); @@ -36,14 +38,14 @@ class PPAPI_PROXY_EXPORT AudioFrameResource : public Resource, virtual uint32_t GetNumberOfSamples() OVERRIDE; virtual void* GetDataBuffer() OVERRIDE; virtual uint32_t GetDataBufferSize() OVERRIDE; - virtual MediaStreamFrame* GetFrameBuffer(); - virtual int32_t GetFrameBufferIndex(); - virtual void Invalidate(); + virtual MediaStreamBuffer* GetBuffer() OVERRIDE; + virtual int32_t GetBufferIndex() OVERRIDE; + virtual void Invalidate() OVERRIDE; // Frame index int32_t index_; - MediaStreamFrame* frame_; + MediaStreamBuffer* buffer_; DISALLOW_COPY_AND_ASSIGN(AudioFrameResource); }; diff --git a/ppapi/proxy/media_stream_audio_track_resource.cc b/ppapi/proxy/media_stream_audio_track_resource.cc index 10956ab..951bda8 100644 --- a/ppapi/proxy/media_stream_audio_track_resource.cc +++ b/ppapi/proxy/media_stream_audio_track_resource.cc @@ -5,7 +5,7 @@ #include "ppapi/proxy/media_stream_audio_track_resource.h" #include "ppapi/proxy/audio_frame_resource.h" -#include "ppapi/shared_impl/media_stream_frame.h" +#include "ppapi/shared_impl/media_stream_buffer.h" #include "ppapi/shared_impl/var.h" namespace ppapi { @@ -84,9 +84,9 @@ int32_t MediaStreamAudioTrackResource::RecycleFrame(PP_Resource frame) { if (has_ended()) return PP_OK; - DCHECK_GE(frame_resource->GetFrameBufferIndex(), 0); + DCHECK_GE(frame_resource->GetBufferIndex(), 0); - SendEnqueueFrameMessageToHost(frame_resource->GetFrameBufferIndex()); + SendEnqueueBufferMessageToHost(frame_resource->GetBufferIndex()); frame_resource->Invalidate(); return PP_OK; } @@ -106,7 +106,7 @@ void MediaStreamAudioTrackResource::Close() { MediaStreamTrackResourceBase::CloseInternal(); } -void MediaStreamAudioTrackResource::OnNewFrameEnqueued() { +void MediaStreamAudioTrackResource::OnNewBufferEnqueued() { if (!TrackedCallback::IsPending(get_frame_callback_)) return; @@ -119,14 +119,14 @@ void MediaStreamAudioTrackResource::OnNewFrameEnqueued() { } PP_Resource MediaStreamAudioTrackResource::GetAudioFrame() { - int32_t index = frame_buffer()->DequeueFrame(); + int32_t index = buffer_manager()->DequeueBuffer(); if (index < 0) return 0; - MediaStreamFrame* frame = frame_buffer()->GetFramePointer(index); - DCHECK(frame); + MediaStreamBuffer* buffer = buffer_manager()->GetBufferPointer(index); + DCHECK(buffer); scoped_refptr<AudioFrameResource> resource = - new AudioFrameResource(pp_instance(), index, frame); + new AudioFrameResource(pp_instance(), index, buffer); // Add |pp_resource()| and |resource| into |frames_|. // |frames_| uses scoped_ptr<> to hold a ref of |resource|. It keeps the // resource alive. diff --git a/ppapi/proxy/media_stream_audio_track_resource.h b/ppapi/proxy/media_stream_audio_track_resource.h index 2686381..8b9d9ec 100644 --- a/ppapi/proxy/media_stream_audio_track_resource.h +++ b/ppapi/proxy/media_stream_audio_track_resource.h @@ -45,8 +45,8 @@ class PPAPI_PROXY_EXPORT MediaStreamAudioTrackResource virtual int32_t RecycleFrame(PP_Resource frame) OVERRIDE; virtual void Close() OVERRIDE; - // MediaStreamFrameBuffer::Delegate overrides: - virtual void OnNewFrameEnqueued() OVERRIDE; + // MediaStreamBufferManager::Delegate overrides: + virtual void OnNewBufferEnqueued() OVERRIDE; private: PP_Resource GetAudioFrame(); diff --git a/ppapi/proxy/media_stream_track_resource_base.cc b/ppapi/proxy/media_stream_track_resource_base.cc index 73aa470..d259036 100644 --- a/ppapi/proxy/media_stream_track_resource_base.cc +++ b/ppapi/proxy/media_stream_track_resource_base.cc @@ -16,7 +16,7 @@ MediaStreamTrackResourceBase::MediaStreamTrackResourceBase( int pending_renderer_id, const std::string& id) : PluginResource(connection, instance), - frame_buffer_(this), + buffer_manager_(this), id_(id), has_ended_(false) { AttachToPendingHost(RENDERER, pending_renderer_id); @@ -25,11 +25,11 @@ MediaStreamTrackResourceBase::MediaStreamTrackResourceBase( MediaStreamTrackResourceBase::~MediaStreamTrackResourceBase() { } -void MediaStreamTrackResourceBase::SendEnqueueFrameMessageToHost( +void MediaStreamTrackResourceBase::SendEnqueueBufferMessageToHost( int32_t index) { DCHECK_GE(index, 0); - DCHECK_LT(index, frame_buffer()->number_of_frames()); - Post(RENDERER, PpapiHostMsg_MediaStreamTrack_EnqueueFrame(index)); + DCHECK_LT(index, buffer_manager()->number_of_buffers()); + Post(RENDERER, PpapiHostMsg_MediaStreamTrack_EnqueueBuffer(index)); } void MediaStreamTrackResourceBase::OnReplyReceived( @@ -37,9 +37,9 @@ void MediaStreamTrackResourceBase::OnReplyReceived( const IPC::Message& msg) { IPC_BEGIN_MESSAGE_MAP(MediaStreamTrackResourceBase, msg) PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL( - PpapiPluginMsg_MediaStreamTrack_InitFrames, OnPluginMsgInitFrames) + PpapiPluginMsg_MediaStreamTrack_InitBuffers, OnPluginMsgInitBuffers) PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL( - PpapiPluginMsg_MediaStreamTrack_EnqueueFrame, OnPluginMsgEnqueueFrame) + PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer, OnPluginMsgEnqueueBuffer) PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED( PluginResource::OnReplyReceived(params, msg)) IPC_END_MESSAGE_MAP() @@ -52,21 +52,21 @@ void MediaStreamTrackResourceBase::CloseInternal() { } } -void MediaStreamTrackResourceBase::OnPluginMsgInitFrames( +void MediaStreamTrackResourceBase::OnPluginMsgInitBuffers( const ResourceMessageReplyParams& params, - int32_t number_of_frames, - int32_t frame_size) { + int32_t number_of_buffers, + int32_t buffer_size) { base::SharedMemoryHandle shm_handle = base::SharedMemory::NULLHandle(); params.TakeSharedMemoryHandleAtIndex(0, &shm_handle); - frame_buffer_.SetFrames(number_of_frames, frame_size, + buffer_manager_.SetBuffers(number_of_buffers, buffer_size, scoped_ptr<base::SharedMemory>(new base::SharedMemory(shm_handle, true)), false); } -void MediaStreamTrackResourceBase::OnPluginMsgEnqueueFrame( +void MediaStreamTrackResourceBase::OnPluginMsgEnqueueBuffer( const ResourceMessageReplyParams& params, int32_t index) { - frame_buffer_.EnqueueFrame(index); + buffer_manager_.EnqueueBuffer(index); } } // namespace proxy diff --git a/ppapi/proxy/media_stream_track_resource_base.h b/ppapi/proxy/media_stream_track_resource_base.h index 4a4aa3b..b5438ce 100644 --- a/ppapi/proxy/media_stream_track_resource_base.h +++ b/ppapi/proxy/media_stream_track_resource_base.h @@ -7,14 +7,14 @@ #include "ppapi/proxy/plugin_resource.h" #include "ppapi/proxy/ppapi_proxy_export.h" -#include "ppapi/shared_impl/media_stream_frame_buffer.h" +#include "ppapi/shared_impl/media_stream_buffer_manager.h" namespace ppapi { namespace proxy { class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase : public PluginResource, - public MediaStreamFrameBuffer::Delegate { + public MediaStreamBufferManager::Delegate { protected: MediaStreamTrackResourceBase(Connection connection, PP_Instance instance, @@ -27,14 +27,15 @@ class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase bool has_ended() const { return has_ended_; } - MediaStreamFrameBuffer* frame_buffer() { return &frame_buffer_; } + MediaStreamBufferManager* buffer_manager() { return &buffer_manager_; } void CloseInternal(); - // Sends a frame index to the corresponding PepperMediaStreamTrackHostBase - // via an IPC message. The host adds the frame index into its - // |frame_buffer_| for reading or writing. Also see |MediaStreamFrameBuffer|. - void SendEnqueueFrameMessageToHost(int32_t index); + // Sends a buffer index to the corresponding PepperMediaStreamTrackHostBase + // via an IPC message. The host adds the buffer index into its + // |buffer_manager_| for reading or writing. + // Also see |MediaStreamBufferManager|. + void SendEnqueueBufferMessageToHost(int32_t index); // PluginResource overrides: virtual void OnReplyReceived(const ResourceMessageReplyParams& params, @@ -42,13 +43,13 @@ class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase private: // Message handlers: - void OnPluginMsgInitFrames(const ResourceMessageReplyParams& params, - int32_t number_of_frames, - int32_t frame_size); - void OnPluginMsgEnqueueFrame(const ResourceMessageReplyParams& params, - int32_t index); + void OnPluginMsgInitBuffers(const ResourceMessageReplyParams& params, + int32_t number_of_buffers, + int32_t buffer_size); + void OnPluginMsgEnqueueBuffer(const ResourceMessageReplyParams& params, + int32_t index); - MediaStreamFrameBuffer frame_buffer_; + MediaStreamBufferManager buffer_manager_; std::string id_; diff --git a/ppapi/proxy/media_stream_video_track_resource.cc b/ppapi/proxy/media_stream_video_track_resource.cc index 804df00..451f259 100644 --- a/ppapi/proxy/media_stream_video_track_resource.cc +++ b/ppapi/proxy/media_stream_video_track_resource.cc @@ -6,7 +6,7 @@ #include "base/logging.h" #include "ppapi/proxy/video_frame_resource.h" -#include "ppapi/shared_impl/media_stream_frame.h" +#include "ppapi/shared_impl/media_stream_buffer.h" #include "ppapi/shared_impl/var.h" namespace ppapi { @@ -84,9 +84,9 @@ int32_t MediaStreamVideoTrackResource::RecycleFrame(PP_Resource frame) { if (has_ended()) return PP_OK; - DCHECK_GE(frame_resource->GetFrameBufferIndex(), 0); + DCHECK_GE(frame_resource->GetBufferIndex(), 0); - SendEnqueueFrameMessageToHost(frame_resource->GetFrameBufferIndex()); + SendEnqueueBufferMessageToHost(frame_resource->GetBufferIndex()); frame_resource->Invalidate(); return PP_OK; } @@ -106,7 +106,7 @@ void MediaStreamVideoTrackResource::Close() { MediaStreamTrackResourceBase::CloseInternal(); } -void MediaStreamVideoTrackResource::OnNewFrameEnqueued() { +void MediaStreamVideoTrackResource::OnNewBufferEnqueued() { if (!TrackedCallback::IsPending(get_frame_callback_)) return; @@ -119,14 +119,14 @@ void MediaStreamVideoTrackResource::OnNewFrameEnqueued() { } PP_Resource MediaStreamVideoTrackResource::GetVideoFrame() { - int32_t index = frame_buffer()->DequeueFrame(); + int32_t index = buffer_manager()->DequeueBuffer(); if (index < 0) return 0; - MediaStreamFrame* frame = frame_buffer()->GetFramePointer(index); - DCHECK(frame); + MediaStreamBuffer* buffer = buffer_manager()->GetBufferPointer(index); + DCHECK(buffer); scoped_refptr<VideoFrameResource> resource = - new VideoFrameResource(pp_instance(), index, frame); + new VideoFrameResource(pp_instance(), index, buffer); // Add |pp_resource()| and |resource| into |frames_|. // |frames_| uses scoped_ptr<> to hold a ref of |resource|. It keeps the // resource alive. diff --git a/ppapi/proxy/media_stream_video_track_resource.h b/ppapi/proxy/media_stream_video_track_resource.h index 935a8a9..ee301d2 100644 --- a/ppapi/proxy/media_stream_video_track_resource.h +++ b/ppapi/proxy/media_stream_video_track_resource.h @@ -44,8 +44,8 @@ class PPAPI_PROXY_EXPORT MediaStreamVideoTrackResource virtual int32_t RecycleFrame(PP_Resource frame) OVERRIDE; virtual void Close() OVERRIDE; - // MediaStreamFrameBuffer::Delegate overrides: - virtual void OnNewFrameEnqueued() OVERRIDE; + // MediaStreamBufferManager::Delegate overrides: + virtual void OnNewBufferEnqueued() OVERRIDE; private: PP_Resource GetVideoFrame(); diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h index 04148f6..d750f9c 100644 --- a/ppapi/proxy/ppapi_messages.h +++ b/ppapi/proxy/ppapi_messages.h @@ -1442,14 +1442,14 @@ IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamAudioTrack_CreateFromPendingHost, IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamVideoTrack_CreateFromPendingHost, std::string /* track_id */) -// Message for init frames. It also takes a shared memory handle which is put in -// the outer ResourceReplyMessage. -IPC_MESSAGE_CONTROL2(PpapiPluginMsg_MediaStreamTrack_InitFrames, - int32_t /* number_of_frames */, - int32_t /* frame_size */) -IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamTrack_EnqueueFrame, +// Message for init buffers. It also takes a shared memory handle which is put +// in the outer ResourceReplyMessage. +IPC_MESSAGE_CONTROL2(PpapiPluginMsg_MediaStreamTrack_InitBuffers, + int32_t /* number_of_buffers */, + int32_t /* buffer_size */) +IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer, int32_t /* index */); -IPC_MESSAGE_CONTROL1(PpapiHostMsg_MediaStreamTrack_EnqueueFrame, +IPC_MESSAGE_CONTROL1(PpapiHostMsg_MediaStreamTrack_EnqueueBuffer, int32_t /* index */); IPC_MESSAGE_CONTROL0(PpapiHostMsg_MediaStreamTrack_Close) diff --git a/ppapi/proxy/video_frame_resource.cc b/ppapi/proxy/video_frame_resource.cc index b314838..9414712 100644 --- a/ppapi/proxy/video_frame_resource.cc +++ b/ppapi/proxy/video_frame_resource.cc @@ -13,15 +13,15 @@ namespace proxy { VideoFrameResource::VideoFrameResource(PP_Instance instance, int32_t index, - MediaStreamFrame* frame) + MediaStreamBuffer* buffer) : Resource(OBJECT_IS_PROXY, instance), index_(index), - frame_(frame) { - DCHECK_EQ(frame_->header.type, MediaStreamFrame::TYPE_VIDEO); + buffer_(buffer) { + DCHECK_EQ(buffer_->header.type, MediaStreamBuffer::TYPE_VIDEO); } VideoFrameResource::~VideoFrameResource() { - CHECK(!frame_) << "An unused (or unrecycled) frame is destroyed."; + CHECK(!buffer_) << "An unused (or unrecycled) frame is destroyed."; } thunk::PPB_VideoFrame_API* VideoFrameResource::AsPPB_VideoFrame_API() { @@ -29,66 +29,66 @@ thunk::PPB_VideoFrame_API* VideoFrameResource::AsPPB_VideoFrame_API() { } PP_TimeDelta VideoFrameResource::GetTimestamp() { - if (!frame_) { + if (!buffer_) { VLOG(1) << "Frame is invalid"; return 0.0; } - return frame_->video.timestamp; + return buffer_->video.timestamp; } void VideoFrameResource::SetTimestamp(PP_TimeDelta timestamp) { - if (!frame_) { + if (!buffer_) { VLOG(1) << "Frame is invalid"; return; } - frame_->video.timestamp = timestamp; + buffer_->video.timestamp = timestamp; } PP_VideoFrame_Format VideoFrameResource::GetFormat() { - if (!frame_) { + if (!buffer_) { VLOG(1) << "Frame is invalid"; return PP_VIDEOFRAME_FORMAT_UNKNOWN; } - return frame_->video.format; + return buffer_->video.format; } PP_Bool VideoFrameResource::GetSize(PP_Size* size) { - if (!frame_) { + if (!buffer_) { VLOG(1) << "Frame is invalid"; return PP_FALSE; } - *size = frame_->video.size; + *size = buffer_->video.size; return PP_TRUE; } void* VideoFrameResource::GetDataBuffer() { - if (!frame_) { + if (!buffer_) { VLOG(1) << "Frame is invalid"; return NULL; } - return frame_->video.data; + return buffer_->video.data; } uint32_t VideoFrameResource::GetDataBufferSize() { - if (!frame_) { + if (!buffer_) { VLOG(1) << "Frame is invalid"; return 0; } - return frame_->video.data_size; + return buffer_->video.data_size; } -MediaStreamFrame* VideoFrameResource::GetFrameBuffer() { - return frame_; +MediaStreamBuffer* VideoFrameResource::GetBuffer() { + return buffer_; } -int32_t VideoFrameResource::GetFrameBufferIndex() { +int32_t VideoFrameResource::GetBufferIndex() { return index_; } void VideoFrameResource::Invalidate() { - DCHECK(frame_); + DCHECK(buffer_); DCHECK_GE(index_, 0); - frame_ = NULL; + buffer_ = NULL; index_ = -1; } diff --git a/ppapi/proxy/video_frame_resource.h b/ppapi/proxy/video_frame_resource.h index ba92f4d..92ac08e 100644 --- a/ppapi/proxy/video_frame_resource.h +++ b/ppapi/proxy/video_frame_resource.h @@ -8,7 +8,7 @@ #include "base/basictypes.h" #include "base/compiler_specific.h" #include "ppapi/proxy/ppapi_proxy_export.h" -#include "ppapi/shared_impl/media_stream_frame.h" +#include "ppapi/shared_impl/media_stream_buffer.h" #include "ppapi/shared_impl/resource.h" #include "ppapi/thunk/ppb_video_frame_api.h" @@ -20,7 +20,7 @@ class PPAPI_PROXY_EXPORT VideoFrameResource : public Resource, public: VideoFrameResource(PP_Instance instance, int32_t index, - MediaStreamFrame* frame); + MediaStreamBuffer* buffer); virtual ~VideoFrameResource(); @@ -34,14 +34,14 @@ class PPAPI_PROXY_EXPORT VideoFrameResource : public Resource, virtual PP_Bool GetSize(PP_Size* size) OVERRIDE; virtual void* GetDataBuffer() OVERRIDE; virtual uint32_t GetDataBufferSize() OVERRIDE; - virtual MediaStreamFrame* GetFrameBuffer(); - virtual int32_t GetFrameBufferIndex(); - virtual void Invalidate(); + virtual MediaStreamBuffer* GetBuffer() OVERRIDE; + virtual int32_t GetBufferIndex() OVERRIDE; + virtual void Invalidate() OVERRIDE; // Frame index int32_t index_; - MediaStreamFrame* frame_; + MediaStreamBuffer* buffer_; DISALLOW_COPY_AND_ASSIGN(VideoFrameResource); }; diff --git a/ppapi/shared_impl/media_stream_frame.h b/ppapi/shared_impl/media_stream_buffer.h index 72eeef9..9010403 100644 --- a/ppapi/shared_impl/media_stream_frame.h +++ b/ppapi/shared_impl/media_stream_buffer.h @@ -2,15 +2,15 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_H_ -#define PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_H_ +#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_H_ +#define PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_H_ #include "ppapi/c/ppb_audio_frame.h" #include "ppapi/c/ppb_video_frame.h" namespace ppapi { -union MediaStreamFrame { +union MediaStreamBuffer { enum Type { TYPE_UNKNOWN = 0, TYPE_AUDIO = 1, @@ -59,4 +59,4 @@ union MediaStreamFrame { } // namespace ppapi -#endif // PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_H_ +#endif // PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_H_ diff --git a/ppapi/shared_impl/media_stream_buffer_manager.cc b/ppapi/shared_impl/media_stream_buffer_manager.cc new file mode 100644 index 0000000..b0588d6d --- /dev/null +++ b/ppapi/shared_impl/media_stream_buffer_manager.cc @@ -0,0 +1,80 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "ppapi/shared_impl/media_stream_buffer_manager.h" + +#include "base/logging.h" +#include "ppapi/c/pp_errors.h" +#include "ppapi/shared_impl/media_stream_buffer.h" + +namespace ppapi { + +MediaStreamBufferManager::Delegate::~Delegate() {} + +void MediaStreamBufferManager::Delegate::OnNewBufferEnqueued() { +} + +MediaStreamBufferManager::MediaStreamBufferManager(Delegate* delegate) + : delegate_(delegate), + buffer_size_(0), + number_of_buffers_(0) { + DCHECK(delegate_); +} + +MediaStreamBufferManager::~MediaStreamBufferManager() { +} + +bool MediaStreamBufferManager::SetBuffers( + int32_t number_of_buffers, + int32_t buffer_size, + scoped_ptr<base::SharedMemory> shm, + bool enqueue_all_buffers) { + DCHECK(shm); + DCHECK(!shm_); + DCHECK_GT(number_of_buffers, 0); + DCHECK_GT(buffer_size, + static_cast<int32_t>(sizeof(MediaStreamBuffer::Header))); + DCHECK_EQ(buffer_size & 0x3, 0); + + number_of_buffers_ = number_of_buffers; + buffer_size_ = buffer_size; + + int32_t size = number_of_buffers_ * buffer_size; + shm_ = shm.Pass(); + if (!shm_->Map(size)) + return false; + + uint8_t* p = reinterpret_cast<uint8_t*>(shm_->memory()); + for (int32_t i = 0; i < number_of_buffers; ++i) { + if (enqueue_all_buffers) + buffer_queue_.push_back(i); + buffers_.push_back(reinterpret_cast<MediaStreamBuffer*>(p)); + p += buffer_size_; + } + return true; +} + +int32_t MediaStreamBufferManager::DequeueBuffer() { + if (buffer_queue_.empty()) + return PP_ERROR_FAILED; + int32_t buffer = buffer_queue_.front(); + buffer_queue_.pop_front(); + return buffer; +} + +void MediaStreamBufferManager::EnqueueBuffer(int32_t index) { + DCHECK_GE(index, 0); + DCHECK_LT(index, number_of_buffers_); + buffer_queue_.push_back(index); + delegate_->OnNewBufferEnqueued(); +} + +MediaStreamBuffer* MediaStreamBufferManager::GetBufferPointer( + int32_t index) { + DCHECK_GE(index, 0); + DCHECK_LT(index, number_of_buffers_); + return buffers_[index]; +} + +} // namespace ppapi diff --git a/ppapi/shared_impl/media_stream_buffer_manager.h b/ppapi/shared_impl/media_stream_buffer_manager.h new file mode 100644 index 0000000..b59d027 --- /dev/null +++ b/ppapi/shared_impl/media_stream_buffer_manager.h @@ -0,0 +1,94 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_MANAGER_H_ +#define PPAPI_SHARED_IMPL_MEDIA_STREAM_BUFFER_MANAGER_H_ + +#include <deque> +#include <vector> + +#include "base/compiler_specific.h" +#include "base/memory/scoped_ptr.h" +#include "base/memory/shared_memory.h" +#include "ppapi/shared_impl/ppapi_shared_export.h" + +namespace ppapi { + +union MediaStreamBuffer; + +// This class is used by both read side and write side of a MediaStreamTrack to +// maintain a queue of buffers for reading or writing. +// +// An example: +// 1. The writer calls the writer's |buffer_manager_.Dequeue()| to get a free +// buffer. +// 2. The writer fills data into the buffer. +// 3. The writer sends the buffer index to the reader via an IPC message. +// 4. The reader receives the buffer index and calls the reader's +// |buffer_buffer.Enqueue()| to put the buffer into the read's queue. +// 5. The reader calls reader's |buffer_buffer_.Dequeue()| to get a received +// buffer. +// 6. When the buffer from the step 5 is consumed, the reader sends the buffer +// index back to writer via an IPC message. +// 7. The writer receives the buffer index and puts it back to the writer's +// free buffer queue by calling the writer's |buffer_manager_.Enqueue()|. +// 8. Go back to step 1. +class PPAPI_SHARED_EXPORT MediaStreamBufferManager { + public: + class PPAPI_SHARED_EXPORT Delegate { + public: + virtual ~Delegate(); + // It is called when a new buffer is enqueued. + virtual void OnNewBufferEnqueued(); + }; + + // MediaStreamBufferManager doesn't own |delegate|, the caller should keep + // it alive during the MediaStreamBufferManager's lifecycle. + explicit MediaStreamBufferManager(Delegate* delegate); + + ~MediaStreamBufferManager(); + + int32_t number_of_buffers() const { return number_of_buffers_; } + + int32_t buffer_size() const { return buffer_size_; } + + // Initializes shared memory for buffers transmission. + bool SetBuffers(int32_t number_of_buffers, + int32_t buffer_size, + scoped_ptr<base::SharedMemory> shm, + bool enqueue_all_buffers); + + // Dequeues a buffer from |buffer_queue_|. + int32_t DequeueBuffer(); + + // Puts a buffer into |buffer_queue_|. + void EnqueueBuffer(int32_t index); + + // Gets the buffer address for the given buffer index. + MediaStreamBuffer* GetBufferPointer(int32_t index); + + private: + Delegate* delegate_; + + // A queue of buffer indices. + std::deque<int32_t> buffer_queue_; + + // A vector of buffer pointers. It is used for index to pointer converting. + std::vector<MediaStreamBuffer*> buffers_; + + // The buffer size in bytes. + int32_t buffer_size_; + + // The number of buffers in the shared memory. + int32_t number_of_buffers_; + + // A memory block shared between renderer process and plugin process. + scoped_ptr<base::SharedMemory> shm_; + + DISALLOW_COPY_AND_ASSIGN(MediaStreamBufferManager); +}; + +} // namespace ppapi + +#endif // PPAPI_SHAERD_IMPL_MEDIA_STREAM_BUFFER_MANAGER_H_ diff --git a/ppapi/shared_impl/media_stream_frame_buffer.cc b/ppapi/shared_impl/media_stream_frame_buffer.cc deleted file mode 100644 index 6248830..0000000 --- a/ppapi/shared_impl/media_stream_frame_buffer.cc +++ /dev/null @@ -1,78 +0,0 @@ -// Copyright 2014 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "ppapi/shared_impl/media_stream_frame_buffer.h" - -#include "base/logging.h" -#include "ppapi/c/pp_errors.h" - -namespace ppapi { - -MediaStreamFrameBuffer::Delegate::~Delegate() {} - -void MediaStreamFrameBuffer::Delegate::OnNewFrameEnqueued() { -} - -MediaStreamFrameBuffer::MediaStreamFrameBuffer(Delegate* delegate) - : delegate_(delegate), - frame_size_(0), - number_of_frames_(0) { - DCHECK(delegate_); -} - -MediaStreamFrameBuffer::~MediaStreamFrameBuffer() { -} - -bool MediaStreamFrameBuffer::SetFrames( - int32_t number_of_frames, - int32_t frame_size, - scoped_ptr<base::SharedMemory> shm, - bool enqueue_all_frames) { - DCHECK(shm); - DCHECK(!shm_); - DCHECK_GT(number_of_frames, 0); - DCHECK_GT(frame_size, static_cast<int32_t>(sizeof(MediaStreamFrame::Header))); - DCHECK_EQ(frame_size & 0x3, 0); - - number_of_frames_ = number_of_frames; - frame_size_ = frame_size; - - int32_t size = number_of_frames_ * frame_size; - shm_ = shm.Pass(); - if (!shm_->Map(size)) - return false; - - uint8_t* p = reinterpret_cast<uint8_t*>(shm_->memory()); - for (int32_t i = 0; i < number_of_frames; ++i) { - if (enqueue_all_frames) - frame_queue_.push_back(i); - frames_.push_back(reinterpret_cast<MediaStreamFrame*>(p)); - p += frame_size_; - } - return true; -} - -int32_t MediaStreamFrameBuffer::DequeueFrame() { - if (frame_queue_.empty()) - return PP_ERROR_FAILED; - int32_t frame = frame_queue_.front(); - frame_queue_.pop_front(); - return frame; -} - -void MediaStreamFrameBuffer::EnqueueFrame(int32_t index) { - DCHECK_GE(index, 0); - DCHECK_LT(index, number_of_frames_); - frame_queue_.push_back(index); - delegate_->OnNewFrameEnqueued(); -} - -MediaStreamFrame* MediaStreamFrameBuffer::GetFramePointer( - int32_t index) { - DCHECK_GE(index, 0); - DCHECK_LT(index, number_of_frames_); - return frames_[index]; -} - -} // namespace ppapi diff --git a/ppapi/shared_impl/media_stream_frame_buffer.h b/ppapi/shared_impl/media_stream_frame_buffer.h deleted file mode 100644 index e950846..0000000 --- a/ppapi/shared_impl/media_stream_frame_buffer.h +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright 2014 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_BUFFER_H_ -#define PPAPI_SHARED_IMPL_MEDIA_STREAM_FRAME_BUFFER_H_ - -#include <deque> -#include <vector> - -#include "base/compiler_specific.h" -#include "base/memory/scoped_ptr.h" -#include "base/memory/shared_memory.h" -#include "ppapi/shared_impl/media_stream_frame.h" -#include "ppapi/shared_impl/ppapi_shared_export.h" - -namespace ppapi { - -// This class is used by both read side and write side of a MediaStreamTrack to -// maintain a queue of frames for reading or writing. -// -// An example: -// 1. The writer calls the writer's |frame_buffer_.Dequeue()| to get a free -// frame. -// 2. The writer fills data into the frame. -// 3. The writer sends the frame index to the reader via an IPC message. -// 4. The reader receives the frame index and calls the reader's -// |frame_buffer.Enqueue()| to put the frame into the read's queue. -// 5. The reader calls reader's |frame_buffer_.Dequeue()| to get a received -// frame. -// 6. When the frame from the step 5 is consumed, the reader sends the frame -// index back to writer via an IPC message. -// 7. The writer receives the frame index and puts it back to the writer's free -// frame queue by calling the writer's |frame_buffer_.Enqueue()|. -// 8. Go back to step 1. -class PPAPI_SHARED_EXPORT MediaStreamFrameBuffer { - public: - class PPAPI_SHARED_EXPORT Delegate { - public: - virtual ~Delegate(); - // It is called when a new frame is enqueued. - virtual void OnNewFrameEnqueued(); - }; - - // MediaStreamFrameBuffer doesn't own |delegate|, the caller should keep - // it alive during the MediaStreamFrameBuffer's lifecycle. - explicit MediaStreamFrameBuffer(Delegate* delegate); - - ~MediaStreamFrameBuffer(); - - int32_t number_of_frames() const { return number_of_frames_; } - - int32_t frame_size() const { return frame_size_; } - - // Initializes shared memory for frames transmission. - bool SetFrames(int32_t number_of_frames, - int32_t frame_size, - scoped_ptr<base::SharedMemory> shm, - bool enqueue_all_frames); - - // Dequeues a frame from |frame_queue_|. - int32_t DequeueFrame(); - - // Puts a frame into |frame_queue_|. - void EnqueueFrame(int32_t index); - - // Gets the frame address for the given frame index. - MediaStreamFrame* GetFramePointer(int32_t index); - - private: - Delegate* delegate_; - - // A queue of frame indexes. - std::deque<int32_t> frame_queue_; - - // A vector of frame pointers. It is used for index to pointer converting. - std::vector<MediaStreamFrame*> frames_; - - // The frame size in bytes. - int32_t frame_size_; - - // The number of frames in the shared memory. - int32_t number_of_frames_; - - // A memory block shared between renderer process and plugin process. - scoped_ptr<base::SharedMemory> shm_; - - DISALLOW_COPY_AND_ASSIGN(MediaStreamFrameBuffer); -}; - -} // namespace ppapi - -#endif // PPAPI_SHAERD_IMPL_MEDIA_STREAM_FRAME_BUFFER_H_ diff --git a/ppapi/thunk/ppb_audio_frame_api.h b/ppapi/thunk/ppb_audio_frame_api.h index ca9cd1f..6d106c6 100644 --- a/ppapi/thunk/ppb_audio_frame_api.h +++ b/ppapi/thunk/ppb_audio_frame_api.h @@ -10,7 +10,7 @@ namespace ppapi { -union MediaStreamFrame; +union MediaStreamBuffer; namespace thunk { @@ -27,8 +27,8 @@ class PPAPI_THUNK_EXPORT PPB_AudioFrame_API { virtual uint32_t GetDataBufferSize() = 0; // Methods used by Pepper internal implementation only. - virtual MediaStreamFrame* GetFrameBuffer() = 0; - virtual int32_t GetFrameBufferIndex() = 0; + virtual MediaStreamBuffer* GetBuffer() = 0; + virtual int32_t GetBufferIndex() = 0; virtual void Invalidate() = 0; }; diff --git a/ppapi/thunk/ppb_video_frame_api.h b/ppapi/thunk/ppb_video_frame_api.h index d3c46b8..105d72b 100644 --- a/ppapi/thunk/ppb_video_frame_api.h +++ b/ppapi/thunk/ppb_video_frame_api.h @@ -10,7 +10,7 @@ namespace ppapi { -union MediaStreamFrame; +union MediaStreamBuffer; namespace thunk { @@ -25,8 +25,8 @@ class PPAPI_THUNK_EXPORT PPB_VideoFrame_API { virtual uint32_t GetDataBufferSize() = 0; // Methods used by Pepper internal implementation only. - virtual MediaStreamFrame* GetFrameBuffer() = 0; - virtual int32_t GetFrameBufferIndex() = 0; + virtual MediaStreamBuffer* GetBuffer() = 0; + virtual int32_t GetBufferIndex() = 0; virtual void Invalidate() = 0; }; |