-Dclang=${USE_CLANG}
-Dwerror=
-Duse_wayland=0
- "
- # [M44_2403] Temporary disabling the multimedia flag for switching to new chromium
- # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14037
- ADDITIONAL_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
+ -Dtizen_multimedia_support=1
"
}
fi
if [ "$tizen_version" == "3.0" ]; then
- # [M47_2526] Temporary disabling the multimedia flag for switching to new chromium
- # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14519
- COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
- "
- elif [ "$tizen_version" == "2.4" -a "$target" == "tv" ]; then
- COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
+ COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=1
"
else
COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
uint32_t data_size);
private:
- friend struct DefaultSingletonTraits<WebAudioDecoderGStreamer>;
+ friend struct base::DefaultSingletonTraits<WebAudioDecoderGStreamer>;
WebAudioDecoderGStreamer();
virtual ~WebAudioDecoderGStreamer();
void DecodeUsingGST(base::SharedMemoryHandle foreign_memory_handle,
#include "base/bind.h"
#include "base/memory/shared_memory.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/message_loop/message_loop.h"
#include "base/process/process.h"
#include "base/synchronization/waitable_event.h"
-#include "base/time/time.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/timer/timer.h"
+#include "media/base/video_frame.h"
using media::VideoFrame;
struct TizenVideoDecodeAccelerator::BitstreamBufferRef {
BitstreamBufferRef(
base::WeakPtr<media::VideoDecodeAccelerator::Client> client,
- const scoped_refptr<base::MessageLoopProxy>& client_message_loop_proxy,
+ const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
base::SharedMemory* shm,
size_t size,
int32 input_id)
: client_(client),
- client_message_loop_proxy_(client_message_loop_proxy),
+ client_task_runner_(client_task_runner),
shm_(shm),
size_(size),
bytes_used_(0),
~BitstreamBufferRef() {
if (input_id_ < 0)
return;
- client_message_loop_proxy_->PostTask(
+ client_task_runner_->PostTask(
FROM_HERE,
base::Bind(
&media::VideoDecodeAccelerator::Client::NotifyEndOfBitstreamBuffer,
}
base::WeakPtr<media::VideoDecodeAccelerator::Client> client_;
- scoped_refptr<base::MessageLoopProxy> client_message_loop_proxy_;
+ scoped_refptr<base::SingleThreadTaskRunner> client_task_runner_;
scoped_ptr<base::SharedMemory> shm_;
size_t size_;
off_t bytes_used_;
pipeline_(NULL),
sink_(NULL),
appsrc_(NULL),
- io_message_loop_proxy_(base::MessageLoopProxy::current()),
+ io_task_runner_(base::ThreadTaskRunnerHandle::Get()),
gst_thread_("TizenDecoderThreadGst"),
bitstream_buffer_id_(0),
caps_width_(0),
GstElement* pipeline_;
GstElement* sink_;
GstElement* appsrc_;
- scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+ scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
scoped_ptr<base::WeakPtrFactory<Client> > io_client_weak_factory_;
base::Thread gst_thread_;
int bitstream_buffer_id_;
buffer_ref.reset(new BitstreamBufferRef(
impl_->io_client_weak_factory_->GetWeakPtr(),
- base::MessageLoopProxy::current(),
+ base::ThreadTaskRunnerHandle::Get(),
shm.release(),
bitstream_buffer.size(),
bitstream_buffer.id()));
LOG(ERROR) << "Could not get handle of Shared Memory";
} else {
memcpy(shared_memory.memory(), map.data, map.size);
- io_message_loop_proxy_->PostTask(
+ io_task_runner_->PostTask(
FROM_HERE,
base::Bind(&media::VideoDecodeAccelerator::Client::NotifyDecodeDone,
io_client_weak_factory_->GetWeakPtr(),
#include "content/common/gpu/media/efl/tizen_video_encode_accelerator.h"
-#include <gst/gst.h>
#include <gst/app/gstappsink.h>
#include <gst/app/gstappsrc.h>
+#include <gst/gst.h>
#include <gst/video/video.h>
#include "base/bind.h"
#include "base/command_line.h"
#include "base/logging.h"
#include "base/message_loop/message_loop.h"
+#include "base/thread_task_runner_handle.h"
#include "base/timer/timer.h"
#include "gpu/command_buffer/service/gpu_switches.h"
#include "media/base/bitstream_buffer.h"
+#include "media/base/video_frame.h"
#include "third_party/webrtc/common_video/libyuv/include/webrtc_libyuv.h"
using media::VideoFrame;
BitstreamBufferRef(
const scoped_refptr<media::VideoFrame>& frame,
base::WeakPtr<media::VideoEncodeAccelerator::Client> client_delegate,
- const scoped_refptr<base::MessageLoopProxy>& client_message_loop_proxy,
+ const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
size_t size)
: frame_(frame),
client_delegate_(client_delegate),
- client_message_loop_proxy_(client_message_loop_proxy),
+ client_task_runner_(client_task_runner),
size_(size),
bytes_used_(0),
gst_buffer_(NULL) {}
scoped_refptr<media::VideoFrame> frame_;
base::WeakPtr<media::VideoEncodeAccelerator::Client> client_delegate_;
- scoped_refptr<base::MessageLoopProxy> client_message_loop_proxy_;
+ scoped_refptr<base::SingleThreadTaskRunner> client_task_runner_;
size_t size_;
off_t bytes_used_;
GstBuffer* gst_buffer_;
struct TizenVideoEncodeAccelerator::Impl {
Impl(media::VideoEncodeAccelerator::Client* client,
- scoped_refptr<base::MessageLoopProxy> msg_loop)
+ scoped_refptr<base::SingleThreadTaskRunner> msg_loop)
: pipeline_(NULL),
encoder_(NULL),
appsrc_(NULL),
gst_thread_("TizenEncoderThreadGst"),
enable_framedrop_(false),
io_client_weak_factory_(client),
- child_message_loop_proxy_(msg_loop),
+ child_task_runner_(msg_loop),
gst_bitrate_(0),
is_running_(false),
is_destroying_(false),
base::Thread gst_thread_;
bool enable_framedrop_;
std::vector<media::BitstreamBuffer> encoder_output_queue_;
- base::WeakPtrFactory<media::VideoEncodeAccelerator::Client> io_client_weak_factory_;
- const scoped_refptr<base::MessageLoopProxy> child_message_loop_proxy_;
+ base::WeakPtrFactory<
+ media::VideoEncodeAccelerator::Client> io_client_weak_factory_;
+ const scoped_refptr<base::SingleThreadTaskRunner> child_task_runner_;
base::Lock destroy_lock_;
base::ThreadChecker thread_checker_;
gfx::Size view_size_;
volatile bool is_running_;
volatile bool is_destroying_;
volatile bool can_feed_;
- base::RepeatingTimer<TizenVideoEncodeAccelerator::Impl> io_timer_;
+ base::RepeatingTimer io_timer_;
std::queue<TizenVideoEncodeAccelerator::OutputBuffer*> output_buffers_;
base::Lock output_queue_lock_;
};
} else {
//copying data to shared memory.
memcpy(static_cast<uint8*>(shm->memory()), map.data, map.size);
- child_message_loop_proxy_->PostTask(
+ child_task_runner_->PostTask(
FROM_HERE,
base::Bind(&media::VideoEncodeAccelerator::Client::BitstreamBufferReady,
io_client_weak_factory_.GetWeakPtr(),
NULL };
guint64 max_input_buffer =
- INPUT_BUFFER_COUNT * VideoFrame::AllocationSize(VideoFrame::I420,
+ INPUT_BUFFER_COUNT * VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
view_size_);
gst_app_src_set_callbacks(GST_APP_SRC(appsrc_), &appsrc_callbacks,
static_cast<gpointer>(this), NULL);
}
bool TizenVideoEncodeAccelerator::Initialize(
- media::VideoFrame::Format input_format,
+ media::VideoPixelFormat input_format,
const gfx::Size& input_visible_size,
media::VideoCodecProfile output_profile,
uint32 initial_bitrate,
return false;
}
- impl_ = new Impl(client, base::MessageLoopProxy::current());
+ impl_ = new Impl(client, base::ThreadTaskRunnerHandle::Get());
impl_->gst_bitrate_ = initial_bitrate;
impl_->view_size_ = input_visible_size;
impl_->gst_thread_.Start();
return false;
}
- base::MessageLoop::current()->PostTask(
+ base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::Bind(
&media::VideoEncodeAccelerator::Client::RequireBitstreamBuffers,
void TizenVideoEncodeAccelerator::Encode(
const scoped_refptr<media::VideoFrame>& frame,
bool force_keyframe) {
- size_t frame_size = VideoFrame::AllocationSize(VideoFrame::I420,
+ size_t frame_size = VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
frame->coded_size());
DVLOG(3) << " coded_size :" << frame->coded_size().ToString()
<< " natural_size :" << frame->natural_size().ToString();
buffer_ref.reset(
new BitstreamBufferRef(frame,
impl_->io_client_weak_factory_.GetWeakPtr(),
- impl_->child_message_loop_proxy_,
+ impl_->child_task_runner_,
frame_size));
if (!buffer_ref) {
std::vector<media::VideoEncodeAccelerator::SupportedProfile>
GetSupportedProfiles() override;
- bool Initialize(media::VideoFrame::Format input_format,
+ bool Initialize(media::VideoPixelFormat input_format,
const gfx::Size& input_visible_size,
media::VideoCodecProfile output_profile,
uint32 initial_bitrate,
int demuxer_client_id,
const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
media::MediaLog* media_log)
- : main_loop_(base::MessageLoopProxy::current()),
+ : main_loop_(base::ThreadTaskRunnerHandle::Get()),
main_weak_factory_(this),
main_weak_this_(main_weak_factory_.GetWeakPtr()),
media_task_runner_(media_task_runner),
media::BindToCurrentLoop(
base::Bind(&MediaSourceDelegateEfl::OnEncryptedMediaInitData,
main_weak_this_)),
- base::Bind(&media::MediaLog::AddLogEvent, media_log_), media_log_, false));
+ media_log_, false));
media_task_runner_->PostTask(FROM_HERE,
base::Bind(&MediaSourceDelegateEfl::InitializeDemuxer,
if (media_source_opened_cb_.is_null())
return;
media_source_opened_cb_.Run(new media::WebMediaSourceImpl(
- chunk_demuxer_.get(), base::Bind(&media::MediaLog::AddLogEvent, media_log_)));
+ chunk_demuxer_.get(), media_log_));
}
void MediaSourceDelegateEfl::OnDemuxerError(
DCHECK(media_task_runner_->BelongsToCurrentThread());
audio_decrypting_demuxer_stream_.reset(
new media::DecryptingDemuxerStream(
- media_task_runner_, set_decryptor_ready_cb_,
+ media_task_runner_, media_log_, set_decryptor_ready_cb_,
waiting_for_decryption_key_cb_));
audio_decrypting_demuxer_stream_->Initialize(
video_decrypting_demuxer_stream_.reset(
new media::DecryptingDemuxerStream(
- media_task_runner_, set_decryptor_ready_cb_,
+ media_task_runner_, media_log_, set_decryptor_ready_cb_,
waiting_for_decryption_key_cb_));
video_decrypting_demuxer_stream_->Initialize(
#include "base/atomic_sequence_num.h"
#include "base/id_map.h"
+#include "base/memory/shared_memory.h"
#include "ipc/message_filter.h"
#include "media/base/efl/demuxer_stream_player_params_efl.h"
#include "media/base/video_frame.h"
#include "media/blink/webmediaplayer_util.h"
#include "third_party/libyuv/include/libyuv/planar_functions.h"
+#include "third_party/WebKit/public/platform/WebMediaPlayer.h"
#include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
#define BIND_TO_RENDER_LOOP(function) \
: frame_(frame),
network_state_(blink::WebMediaPlayer::NetworkStateEmpty),
ready_state_(blink::WebMediaPlayer::ReadyStateHaveNothing),
- main_loop_(base::MessageLoopProxy::current()),
+ main_loop_(base::ThreadTaskRunnerHandle::Get()),
media_task_runner_(
RenderThreadImpl::current()->GetMediaThreadTaskRunner()),
manager_(manager),
delegate_(delegate),
// Threaded compositing isn't enabled universally yet.
compositor_task_runner_(
- RenderThreadImpl::current()->compositor_message_loop_proxy().get()
- ? RenderThreadImpl::current()->compositor_message_loop_proxy()
- : base::MessageLoopProxy::current()),
+ RenderThreadImpl::current()->compositor_task_runner().get()
+ ? RenderThreadImpl::current()->compositor_task_runner()
+ : base::ThreadTaskRunnerHandle::Get()),
compositor_(new media::VideoFrameCompositor(
compositor_task_runner_,
BIND_TO_RENDER_LOOP(&WebMediaPlayerEfl::OnNaturalSizeChanged),
}
void WebMediaPlayerEfl::OnWaitingForDecryptionKey() {
- client_->didBlockPlaybackWaitingForKey();
+ encrypted_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();
+ encrypted_client_->didResumePlaybackBlockedForKey();
}
void WebMediaPlayerEfl::play() {
pending_seek_time_ = seconds;
if (media_source_delegate_)
media_source_delegate_->CancelPendingSeek(
- media::ConvertSecondsToTimestamp(pending_seek_time_));
+ base::TimeDelta::FromSecondsD(pending_seek_time_));
// Later, OnSeekComplete will trigger the pending seek.
return;
}
// Once Chunk demuxer seeks GST seek will be intiated.
if (media_source_delegate_)
media_source_delegate_->StartWaitingForSeek(
- media::ConvertSecondsToTimestamp(seek_time_));
+ base::TimeDelta::FromSecondsD(seek_time_));
manager_->Seek(player_id_, seek_time_);
// Draw empty frame during seek.
return blink::WebTimeRanges(&seekable_range, 1);
}
+void WebMediaPlayerEfl::setSinkId(const blink::WebString& device_id,
+ media::WebSetSinkIdCB* raw_web_callbacks) {
+ DCHECK(main_loop_->BelongsToCurrentThread());
+ scoped_ptr<media::WebSetSinkIdCB> web_callbacks(raw_web_callbacks);
+ web_callbacks->onError(new blink::WebSetSinkIdError(
+ blink::WebSetSinkIdError::ErrorTypeNotSupported, "Not Supported"));
+}
+
void WebMediaPlayerEfl::paint(blink::WebCanvas* canvas,
const blink::WebRect& rect,
unsigned char alpha,
scoped_refptr<VideoFrame> video_frame =
GetCurrentFrameFromCompositor();
- gfx::Rect gfx_rect(rect);
+ gfx::RectF gfx_rect(rect);
media::Context3D context_3d;
skcanvas_video_renderer_.Paint(
video_frame.get(), canvas, gfx_rect, alpha,
}
double WebMediaPlayerEfl::mediaTimeForTimeValue(double timeValue) const {
- return media::ConvertSecondsToTimestamp(timeValue).InSecondsF();
+ return base::TimeDelta::FromSecondsD(timeValue).InSecondsF();
}
unsigned WebMediaPlayerEfl::decodedFrameCount() const {
gfx::Size size(gst_width_, gst_height_);
scoped_refptr<VideoFrame> video_frame =
VideoFrame::CreateFrame(
- VideoFrame::YV12, size, gfx::Rect(size), size, timestamp);
+ media::PIXEL_FORMAT_YV12, size, gfx::Rect(size), size, timestamp);
// decoded format is SN12 on Tizen device
// video format converted from SN12 to YV12
SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
if (hasVideo() && !video_weblayer_.get()) {
scoped_refptr<cc::VideoLayer> layer =
- cc::VideoLayer::Create(compositor_, media::VIDEO_ROTATION_0);
+ cc::VideoLayer::Create(cc_blink::WebLayerImpl::LayerSettings(),
+ compositor_, media::VIDEO_ROTATION_0);
video_weblayer_.reset(new cc_blink::WebLayerImpl(layer));
video_weblayer_->setOpaque(opaque_);
client_->setWebLayer(video_weblayer_.get());
#include "cc/layers/video_frame_provider_client_impl.h"
#include "content/renderer/media/efl/media_source_delegate_efl.h"
#include "content/renderer/media/efl/renderer_media_player_manager_efl.h"
+#include "media/blink/webmediaplayer_util.h"
#include "media/base/efl/media_player_efl.h"
#include "media/blink/skcanvas_video_renderer.h"
#include "media/blink/video_frame_compositor.h"
#include "third_party/WebKit/public/platform/WebMediaPlayer.h"
+#include "third_party/WebKit/public/platform/WebMediaPlayerEncryptedMediaClient.h"
#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
#include "media/blink/encrypted_media_player_support.h"
class MediaLog;
class MediaPlayerEfl;
class WebMediaPlayerDelegate;
+class WebMediaPlayerEncryptedMediaClient;
}
namespace content {
void setVolume(double) override;
blink::WebTimeRanges buffered() const override;
blink::WebTimeRanges seekable() const override;
+ void setSinkId(const blink::WebString&, media::WebSetSinkIdCB*) override;
void paint(blink::WebCanvas*,
const blink::WebRect&,
// Message loops for posting tasks on Chrome's main thread. Also used
// for DCHECKs so methods calls won't execute in the wrong thread.
- const scoped_refptr<base::MessageLoopProxy> main_loop_;
+ const scoped_refptr<base::SingleThreadTaskRunner> main_loop_;
scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
// Manager for managing this object and for delegating method calls on
content::RendererMediaPlayerManager* manager_;
blink::WebMediaPlayerClient* client_;
+ blink::WebMediaPlayerEncryptedMediaClient* encrypted_client_;
scoped_refptr<media::MediaLog> media_log_;
#include <gst/pbutils/missing-plugins.h>
#include "base/basictypes.h"
+#include "base/thread_task_runner_handle.h"
#include "media/base/efl/media_player_manager_efl.h"
#include "media/base/efl/media_player_util_efl.h"
#include "ui/gfx/geometry/size.h"
double volume,
MediaPlayerManager* manager_in)
: MediaPlayerEfl(player_id, manager_in),
- main_loop_(base::MessageLoopProxy::current()),
+ main_loop_(base::ThreadTaskRunnerHandle::Get()),
pipeline_(NULL),
appsink_(NULL),
uridecodebinsrc_(NULL),
#endif
private:
- const scoped_refptr<base::MessageLoopProxy> main_loop_;
+ const scoped_refptr<base::SingleThreadTaskRunner> main_loop_;
GstElement* pipeline_;
GstElement* appsink_;
GstElement* uridecodebinsrc_;
bool error_occured_;
- base::RepeatingTimer<MediaPlayerBridgeGstreamer> current_time_update_timer_;
- base::RepeatingTimer<MediaPlayerBridgeGstreamer> buffering_update_timer_;
+ base::RepeatingTimer current_time_update_timer_;
+ base::RepeatingTimer buffering_update_timer_;
DISALLOW_COPY_AND_ASSIGN(MediaPlayerBridgeGstreamer);
};
#include <gst/video/videooverlay.h>
#include "base/process/process.h"
+#include "base/thread_task_runner_handle.h"
#include "media/base/efl/media_player_manager_efl.h"
#include "media/base/efl/media_player_util_efl.h"
bool is_end_reached_;
bool error_occured_;
- base::RepeatingTimer<MediaSourcePlayerGstreamer> current_time_update_timer_;
+ base::RepeatingTimer current_time_update_timer_;
int raw_video_frame_size_;
guint64 video_seek_offset_;
guint64 audio_seek_offset_;
#include "base/basictypes.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
#include "media/base/efl/media_player_manager_efl.h"
#include "media/base/efl/media_player_util_efl.h"
#include "ui/gfx/geometry/size.h"
int delayed_player_state_;
- base::RepeatingTimer<MediaPlayerBridgeCapi> current_time_update_timer_;
- base::RepeatingTimer<MediaPlayerBridgeCapi> buffering_update_timer_;
+ base::RepeatingTimer current_time_update_timer_;
+ base::RepeatingTimer buffering_update_timer_;
DISALLOW_COPY_AND_ASSIGN(MediaPlayerBridgeCapi);
};
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "media/video/capture/tizen/video_capture_device_factory_tizen.h"
+#include "media/capture/video/tizen/video_capture_device_factory_tizen.h"
#include <camera.h>
gfx::Rect rect(target_resolution.width(), target_resolution.height());
scoped_refptr<VideoFrame> videoframe =
- VideoFrame::CreateFrame(VideoFrame::I420, target_resolution,
+ VideoFrame::CreateFrame(media::PIXEL_FORMAT_I420, target_resolution,
rect, target_resolution, base::TimeDelta());
self->client_->OnIncomingCapturedVideoFrame(self->buffer_.Pass(),
DVLOG(3) << " width:" << width
<< " height:" << height
<< " frame_rate:" << frame_rate
- << " format:" << VideoCaptureFormat::PixelFormatToString(format);
+ << " format:" << media::VideoPixelFormatToString(format).c_str();
DCHECK_EQ(worker_.message_loop(), base::MessageLoop::current());
}
bool VideoCaptureDeviceTizen::AllocateVideoBuffers(int width, int height) {
- buffer_ = client_->ReserveOutputBuffer(media::PIXEL_FORMAT_I420,
- gfx::Size(width, height));
+ buffer_ = client_->ReserveOutputBuffer(gfx::Size(width, height),
+ media::PIXEL_FORMAT_I420,
+ media::PIXEL_STORAGE_GPUMEMORYBUFFER);
return (buffer_.get() != NULL);
}
projects / platform / framework / web / chromium-efl.git / commitdiff