Build errors occurs when enabling MM feature, hence fixing them.
1. The arguments for ScopedPtrHashMap changed from <Key, value> to
<Key, ScopedPtr> updated the same.
2. VideoFrameCompositor constructor now accepts three arguments,
included compositor_task_runner as first argument.
3. UpdateCurrentFrame API was missing, hence added
4. Implementation for API UpdateCurrentFrame is changed,
and painting is done using PaintFrameUsingOldRenderingPath API
5. Implementation of OnIncomingCapturedVideoFrame API has changed,
such that we don't need to pass format, updated accordingly.
6. API ReserveOutputBuffer returns a scoped_ptr,
hence changed type for variable buffer_.
7. MessageLoopProxy is deprecated. Code should prefer to depend on
TaskRunner for passing task runners around.
scoped_refptr<base::MessageLoopProxy> -> scoped_refptr
<base::SingleThreadTaskRunner>
8. Removing some interfaces as not used anymore.
Verified ME, MSE, Webaudio working on Note4 64bit.
Bug: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=13291
Reviewed by: SeungSeop Park, Venugopal S M
Change-Id: I0e12ada6b85b1f91168a2e1d8fcd7541214f129a
Signed-off-by: puru <puru.dharma@samsung.com>
fi
if [ "$tizen_version" == "3.0" ]; then
- # [M44_2403] Temporary disabling the multimedia flag for switching to new chromium
- # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14037
- COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
+ COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=1
"
elif [ "$tizen_version" == "2.4" -a "$target" == "tv" ]; then
- # [M44_2403] Temporary disabling the multimedia flag for switching to new chromium
- # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14037
COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
"
else
private:
// Map from RenderFrameHost* to BrowserMediaPlayerManagerEfl.
- typedef base::ScopedPtrHashMap<uintptr_t, BrowserMediaPlayerManagerEfl>
+ typedef base::ScopedPtrHashMap<uintptr_t,
+ scoped_ptr<BrowserMediaPlayerManagerEfl>>
MediaPlayerManagerMap;
MediaPlayerManagerMap media_player_managers_;
const media::Demuxer::EncryptedMediaInitDataCB& emedia_init_data_cb,
const media::SetDecryptorReadyCB& set_decryptor_ready_cb,
const UpdateNetworkStateCB& update_network_state_cb,
- const DurationChangeCB& duration_change_cb) {
+ const DurationChangeCB& duration_change_cb,
+ const base::Closure& waiting_for_decryption_key_cb) {
DCHECK(main_loop_->BelongsToCurrentThread());
DCHECK(!media_source_opened_cb.is_null());
media_source_opened_cb_ = media_source_opened_cb;
set_decryptor_ready_cb_ = set_decryptor_ready_cb;
update_network_state_cb_ = media::BindToCurrentLoop(update_network_state_cb);
duration_change_cb_ = duration_change_cb;
+ waiting_for_decryption_key_cb_ =
+ media::BindToCurrentLoop(waiting_for_decryption_key_cb);
chunk_demuxer_.reset(new media::ChunkDemuxer(
media::BindToCurrentLoop(
media::BindToCurrentLoop(
base::Bind(&MediaSourceDelegateEfl::OnEncryptedMediaInitData,
main_weak_this_)),
- base::Bind(&media::MediaLog::AddLogEvent, media_log_, false));
+ base::Bind(&media::MediaLog::AddLogEvent, media_log_), media_log_, false));
media_task_runner_->PostTask(FROM_HERE,
base::Bind(&MediaSourceDelegateEfl::InitializeDemuxer,
}
void MediaSourceDelegateEfl::OnEncryptedMediaInitData (
- media::EmeInitDataType /* init_data_type */,
+ media::EmeInitDataType init_data_type,
const std::vector<uint8>& init_data) {
DCHECK(main_loop_->BelongsToCurrentThread());
if (emedia_init_data_cb_.is_null()) {
return;
}
- emedia_init_data_cb_.Run(type, init_data);
+ emedia_init_data_cb_.Run(init_data_type, init_data);
}
void MediaSourceDelegateEfl::OnDemuxerOpened() {
void MediaSourceDelegateEfl::InitAudioDecryptingDemuxerStream() {
DCHECK(media_task_runner_->BelongsToCurrentThread());
- audio_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
- media_task_runner_, set_decryptor_ready_cb_));
+ audio_decrypting_demuxer_stream_.reset(
+ new media::DecryptingDemuxerStream(
+ media_task_runner_, set_decryptor_ready_cb_,
+ waiting_for_decryption_key_cb_));
audio_decrypting_demuxer_stream_->Initialize(
audio_stream_,
void MediaSourceDelegateEfl::InitVideoDecryptingDemuxerStream() {
DCHECK(media_task_runner_->BelongsToCurrentThread());
- video_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
- media_task_runner_, set_decryptor_ready_cb_));
+ video_decrypting_demuxer_stream_.reset(
+ new media::DecryptingDemuxerStream(
+ media_task_runner_, set_decryptor_ready_cb_,
+ waiting_for_decryption_key_cb_));
video_decrypting_demuxer_stream_->Initialize(
video_stream_,
const media::Demuxer::EncryptedMediaInitDataCB& emedia_init_data_cb,
const media::SetDecryptorReadyCB& set_decryptor_ready_cb,
const UpdateNetworkStateCB& update_network_state_cb,
- const DurationChangeCB& duration_change_cb);
+ const DurationChangeCB& duration_change_cb,
+ const base::Closure& waiting_for_decryption_key_cb);
blink::WebTimeRanges Buffered() const;
void FinishResettingDecryptingDemuxerStreams();
// Message loop for main renderer thread and corresponding weak pointer.
- const scoped_refptr<base::MessageLoopProxy> main_loop_;
+ const scoped_refptr<base::SingleThreadTaskRunner> main_loop_;
base::WeakPtrFactory<MediaSourceDelegateEfl> main_weak_factory_;
base::WeakPtr<MediaSourceDelegateEfl> main_weak_this_;
MediaSourceOpenedCB media_source_opened_cb_;
UpdateNetworkStateCB update_network_state_cb_;
DurationChangeCB duration_change_cb_;
+ base::Closure waiting_for_decryption_key_cb_;
scoped_ptr<media::ChunkDemuxer> chunk_demuxer_;
media::DemuxerStream* audio_stream_;
client_(client),
media_log_(new RenderMediaLog()),
delegate_(delegate),
+ // Threaded compositing isn't enabled universally yet.
compositor_task_runner_(
- RenderThreadImpl::current()->compositor_message_loop_proxy()),
+ RenderThreadImpl::current()->compositor_message_loop_proxy().get()
+ ? RenderThreadImpl::current()->compositor_message_loop_proxy()
+ : base::MessageLoopProxy::current()),
compositor_(new media::VideoFrameCompositor(
+ compositor_task_runner_,
BIND_TO_RENDER_LOOP(&WebMediaPlayerEfl::OnNaturalSizeChanged),
BIND_TO_RENDER_LOOP(&WebMediaPlayerEfl::OnOpacityChanged))),
weak_factory_(this),
#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
DCHECK(encrypted_media_support_);
#endif
- // We want to be notified of |main_loop_| destruction.
- base::MessageLoop::current()->AddDestructionObserver(this);
player_id_ = manager_->RegisterMediaPlayer(this);
- // Threaded compositing isn't enabled universally yet.
- if (!compositor_task_runner_.get())
- compositor_task_runner_ = base::MessageLoopProxy::current();
-
media_log_->AddEvent(
media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
}
manager_->UnregisterMediaPlayer(player_id_);
}
- SetVideoFrameProviderClient(NULL);
+ compositor_->SetVideoFrameProviderClient(NULL);
client_->setWebLayer(NULL);
if (delegate_.get())
delegate_->PlayerGone(this);
- if (base::MessageLoop::current())
- base::MessageLoop::current()->RemoveDestructionObserver(this);
compositor_task_runner_->DeleteSoon(FROM_HERE, compositor_);
if (media_source_delegate_) {
// Part of |media_source_delegate_| needs to be stopped
base::Bind(&WebMediaPlayerEfl::SetNetworkState,
weak_factory_.GetWeakPtr()),
base::Bind(&WebMediaPlayerEfl::OnDurationChange,
+ weak_factory_.GetWeakPtr()),
+ base::Bind(&WebMediaPlayerEfl::OnWaitingForDecryptionKey,
weak_factory_.GetWeakPtr()));
} else if (load_type == LoadTypeURL) {
player_type_ = MEDIA_PLAYER_TYPE_URL;
client_->mediaSourceOpened(web_media_source);
}
+void WebMediaPlayerEfl::OnWaitingForDecryptionKey() {
+ client_->didBlockPlaybackWaitingForKey();
+
+ // TODO(jrummell): didResumePlaybackBlockedForKey() should only be called
+ // when a key has been successfully added (e.g. OnSessionKeysChange() with
+ // |has_additional_usable_key| = true). http://crbug.com/461903
+ client_->didResumePlaybackBlockedForKey();
+}
+
void WebMediaPlayerEfl::play() {
manager_->Play(player_id_);
// Has to be updated from |MediaPlayerBridgeGstreamer| but IPC causes delay.
return 0;
};
-void WebMediaPlayerEfl::SetVideoFrameProviderClient(
- cc::VideoFrameProvider::Client* client) {
- // This is called from both the main renderer thread and the compositor
- // thread (when the main thread is blocked).
- compositor_->SetVideoFrameProviderClient(client);
-}
-
-scoped_refptr<VideoFrame>WebMediaPlayerEfl::GetCurrentFrame() {
- scoped_refptr<VideoFrame> current_frame =
- GetCurrentFrameFromCompositor();
- return current_frame;
-}
-
void WebMediaPlayerEfl::SetReadyState(WebMediaPlayer::ReadyState state) {
ready_state_ = state;
client_->readyStateChanged();
const scoped_refptr<VideoFrame>& frame) {
compositor_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&media::VideoFrameCompositor::UpdateCurrentFrame,
+ base::Bind(&media::VideoFrameCompositor::PaintFrameUsingOldRenderingPath,
base::Unretained(compositor_),
frame));
}
#include "base/message_loop/message_loop.h"
#include "base/memory/shared_memory.h"
#include "cc/layers/video_frame_provider_client_impl.h"
-#include "content/common/media/tizen/media_player_messages_enums_tizen.h"
#include "content/renderer/media/efl/media_source_delegate_efl.h"
#include "content/renderer/media/efl/renderer_media_player_manager_efl.h"
#include "media/base/efl/media_player_efl.h"
// player.
class WebMediaPlayerEfl
: public blink::WebMediaPlayer,
- public cc::VideoFrameProvider,
- public base::MessageLoop::DestructionObserver,
public base::SupportsWeakPtr<WebMediaPlayerEfl> {
public:
// Construct a WebMediaPlayerEfl object. This class communicates
unsigned audioDecodedByteCount() const override;
unsigned videoDecodedByteCount() const override;
- // cc::VideoFrameProvider implementation.
- void SetVideoFrameProviderClient(
- cc::VideoFrameProvider::Client* client) override;
- scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
- void PutCurrentFrame(
- const scoped_refptr<media::VideoFrame>& frame) override {};
-
- // Method inherited from DestructionObserver.
- void WillDestroyCurrentMessageLoop() override {};
#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
virtual MediaKeyException generateKeyRequest(
const blink::WebString& key_system,
void RequestPause();
+ // Called when a decoder detects that the key needed to decrypt the stream
+ // is not available.
+ void OnWaitingForDecryptionKey();
+
private:
void OnNaturalSizeChanged(gfx::Size size);
void OnOpacityChanged(bool opaque);
LOG(ERROR) << " Error when rotating the video frame";
}
WEBRTC_DEBUG_DUMPFRAME(frame, yplane);
- VideoCaptureFormat capture_format;
- capture_format.frame_size.SetSize(target_resolution.width(),
- target_resolution.height());
- capture_format.frame_rate = current_fps;
- capture_format.pixel_format = PIXEL_FORMAT_I420;
gfx::Rect rect(target_resolution.width(), target_resolution.height());
VideoFrame::CreateFrame(VideoFrame::I420, target_resolution,
rect, target_resolution, base::TimeDelta());
- self->client_->OnIncomingCapturedVideoFrame(self->buffer_, capture_format,
+ self->client_->OnIncomingCapturedVideoFrame(self->buffer_.Pass(),
videoframe,
base::TimeTicks::Now());
}
}
bool VideoCaptureDeviceTizen::AllocateVideoBuffers(int width, int height) {
- buffer_ = client_->ReserveOutputBuffer(media::VideoFrame::I420,
+ buffer_ = client_->ReserveOutputBuffer(media::PIXEL_FORMAT_I420,
gfx::Size(width, height));
return (buffer_.get() != NULL);
}
scoped_ptr<VideoCaptureDevice::Client> client_;
Name device_name_;
base::Thread worker_; // Thread used for reading data from the device.
- scoped_refptr<VideoCaptureDevice::Client::Buffer> buffer_;
+ scoped_ptr<VideoCaptureDevice::Client::Buffer> buffer_;
camera_h camera_;
DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureDeviceTizen);
};
projects / platform / framework / web / chromium-efl.git / commitdiff