The codes that were changed during the update to m120 are applied.
The features below are enabled.
tizen_multimedia
tizen_audio_io
tizen_web_speech_recognition
tizen_tbm_support is still disabled.
Change-Id: Idfe6f0b877107d00298f4ab772108abfb65b90c2
Signed-off-by: Sun-woo Nam <sunny.nam@samsung.com>
#include "cc/cc_export.h"
#if defined(TIZEN_VIDEO_HOLE)
-#include "base/callback.h"
+#include "base/functional/callback.h"
namespace gfx {
class Rect;
]
}
- if (is_linux || is_tizen) {
+ if (is_linux) {
sources += [ "speech/tts_linux.cc" ]
deps += [
"//third_party/speech-dispatcher",
blink::WebLocalFrame* frame = render_frame->GetWebFrame();
return std::make_unique<media::MediaUrlDemuxer>(
task_runner, url, frame->GetDocument().SiteForCookies(),
- frame->GetDocument().TopFrameOrigin(), true, false);
+ frame->GetDocument().TopFrameOrigin(),
+ frame->GetDocument().HasStorageAccess(), true, false);
}
#endif
return nullptr;
void PipelineImpl::RendererWrapper::OnRequestSeek(base::TimeDelta time) {
LOG(INFO) << __func__ << " time:" << time;
- if (!media_task_runner_->BelongsToCurrentThread()) {
+ if (!media_task_runner_->RunsTasksInCurrentSequence()) {
media_task_runner_->PostTask(
FROM_HERE,
base::BindOnce(&media::PipelineImpl::RendererWrapper::OnRequestSeek,
ResolutionChangePolicy resolution_change_policy;
PowerLineFrequency power_line_frequency;
bool enable_face_detection;
+ [EnableIf=tizen_multimedia]
+ bool lazy_start;
// TODO(https://crbug.com/1412589): remove this once HiDPI is enabled for
// all video capture sessions.
[MinVersion=1] bool is_high_dpi_enabled;
-
- [EnableIf=tizen_multimedia]
- bool lazy_start;
};
[Stable, RenamedFrom="media.mojom.VideoFrameFeedback"]
if (status == Status::kNeedBuffer) {
LOG(INFO) << __func__ << " (" << media::DemuxerStream::GetTypeName(stream_->type())
<< ") kNeedBuffer!";
- std::move(callback).Run(Status::kNeedBuffer, mojom::DecoderBufferPtr(),
+ std::move(callback).Run(Status::kNeedBuffer, {},
audio_config, video_config);
return;
}
#if defined(TIZEN_MULTIMEDIA)
void MojoRenderer::Seek(base::TimeDelta time, base::OnceClosure seek_cb) {
DVLOG(2) << __func__ << "(" << time << ")";
- DCHECK(task_runner_->BelongsToCurrentThread());
+ DCHECK(task_runner_->RunsTasksInCurrentSequence());
DCHECK(seek_cb);
if (encountered_error_) {
void MojoRenderer::Suspend() {
DVLOG(2) << __func__;
- DCHECK(task_runner_->BelongsToCurrentThread());
+ DCHECK(task_runner_->RunsTasksInCurrentSequence());
remote_renderer_->Suspend();
}
void MojoRenderer::OnSeekCompleted() {
DVLOG(1) << __func__;
- DCHECK(task_runner_->BelongsToCurrentThread());
+ DCHECK(task_runner_->RunsTasksInCurrentSequence());
DCHECK(seek_cb_);
std::move(seek_cb_).Run();
uint32 width,
uint32 height);
- [EnableIf=tizen_multimedia]
+ [EnableIf=tizen_tbm_support]
OnNewTbmFrameAvailable(uint32 playerId,
gfx.mojom.TbmBufferHandle tbm_buffer_handle,
mojo_base.mojom.TimeDelta timestamp);
InitiateScopedSurfaceRequest()
=> (mojo_base.mojom.UnguessableToken request_token);
- [EnableIf=tizen_multimedia]
+ [EnableIf=tizen_tbm_support]
OnTbmBufferExhausted(gfx.mojom.TbmBufferHandle tbm_buffer_handle);
};
#if defined(TIZEN_MULTIMEDIA)
if (status == kNeedBuffer) {
- std::move(read_cb_).Run(kNeedBuffer, nullptr);
+ std::move(read_cb_).Run(kNeedBuffer, {});
return;
}
#endif
#endif
#if defined(TIZEN_VIDEO_HOLE)
+#include "cc/base/math_util.h"
+
// NSW : Is this necessary?
namespace {
const base::TimeDelta kLayerBoundUpdateInterval = base::Milliseconds(50);
base::BindOnce(
&VideoFrameCompositor::SetDrawableContentRectChangedCallback,
base::Unretained(compositor_.get()),
- media::BindToCurrentLoop(base::BindRepeating(
+ base::BindPostTaskToCurrentDefault(base::BindRepeating(
&WebMediaPlayerImpl::OnDrawableContentRectChanged,
weak_this_))));
}
demuxer_manager_->SetLoadedUrl(GURL(url));
load_type_ = load_type;
-#if defined(TIZEN_MULTIMEDIA)
- // |MediaUrlDemuxer| will be created if |IsHbbTV| function returns true. In
- // this case, |demuxer_override_| is not null. (i.e, |demuxer_override_| is
- // allocated only for hbbtv case.) Even if hbbtv case, default MM path should
- // be used for MSE contents. Only ME HbbTV contents will use
- // |MediaUrlDemuxer| according to this condition.
- if (demuxer_override_ && load_type != kLoadTypeURL)
- demuxer_override_.release();
-#endif
-
ReportMetrics(load_type, demuxer_manager_->LoadedUrl(), media_log_.get());
// Set subresource URL for crash reporting; will be truncated to 256 bytes.
if (GetDemuxerType() == media::DemuxerType::kChunkDemuxer)
return true;
#if defined(TIZEN_MULTIMEDIA)
- if (demuxer_->GetType() == media::MediaResource::Type::URL) {
+ if (GetDemuxerType() == media::DemuxerType::kMediaUrlDemuxer) {
// TODO : Need to check buffered status
return true;
}
use_atk=false
"
fi
- ADDITIONAL_GN_PARAMETERS+="tizen_multimedia=false
+ ADDITIONAL_GN_PARAMETERS+="tizen_multimedia=true
proprietary_codecs=true
- tizen_audio_io=false
- tizen_web_speech_recognition=false
+ tizen_audio_io=true
+ tizen_web_speech_recognition=true
tizen_tbm_support=false
"
# Enable video hole only for standard and TV profile
if [ \( "$tizen_product_tv" == "true" \) -o \( "$tizen_product_da" != "true" -a "$tizen_emulator_support" != "true" \) ]; then
- ADDITIONAL_GN_PARAMETERS+="tizen_video_hole=false
+ ADDITIONAL_GN_PARAMETERS+="tizen_video_hole=true
"
else
ADDITIONAL_GN_PARAMETERS+="tizen_video_hole=false
#include "content/public/browser/web_contents.h"
#include "content/public/common/content_client.h"
#include "media/base/audio_decoder_config.h"
-#include "media/base/bind_to_current_loop.h"
#include "media/base/media_resource.h"
#include "media/base/media_switches.h"
#include "media/base/renderer_client.h"
init_cb_ = std::move(init_cb);
media_resource_ = media_resource;
- if (media_resource_->GetType() == media::MediaResource::STREAM) {
+ if (media_resource_->GetType() == media::MediaResource::Type::kStream) {
#if BUILDFLAG(IS_TIZEN_TV)
media_player_ = std::make_unique<media::MediaPlayerESPlusPlayerTV>();
#else
media_player_ = std::make_unique<media::MediaPlayerESPlusPlayer>();
#endif
} else {
- // When the type is media::MediaResource::URL
+ // When the type is media::MediaResource::Type::KUrl
std::string user_agent;
if (web_contents_) {
user_agent = web_contents_->GetUserAgentOverride().ua_string_override;
}
void TizenRendererImpl::SetStreamInfo() {
- if (media_resource_->GetType() == media::MediaResource::URL) {
+ if (media_resource_->GetType() == media::MediaResource::Type::KUrl) {
video_renderer_client_ = std::make_unique<RendererClientInternal>(
media::DemuxerStream::VIDEO, this);
media_player_->SetStreamInfo(media::DemuxerStream::VIDEO, 0,
return media_player_->GetCurrentTime();
}
+media::RendererType TizenRendererImpl::GetRendererType() {
+ return media::RendererType::kMediaPlayer;
+}
+
void TizenRendererImpl::OnSelectedVideoTracksChanged(
const std::vector<media::DemuxerStream*>& enabled_tracks,
base::OnceClosure change_completed_cb) {
void SetPlaybackRate(double playback_rate) override;
void SetVolume(float volume) override;
base::TimeDelta GetMediaTime() override;
+ media::RendererType GetRendererType() override;
void OnSelectedVideoTracksChanged(
const std::vector<media::DemuxerStream*>& enabled_tracks,
base::OnceClosure change_completed_cb) override;
MediaPlayerRendererClient::MediaPlayerRendererClient(
mojo::PendingRemote<RendererExtention> renderer_extension_remote,
mojo::PendingReceiver<ClientExtention> client_extension_receiver,
- scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+ scoped_refptr<base::SequencedTaskRunner> media_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
std::unique_ptr<media::MojoRenderer> mojo_renderer,
media::VideoRendererSink* sink)
media::MediaResource* media_resource,
media::RendererClient* client,
media::PipelineStatusCallback init_cb) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
+ DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
DCHECK(!init_cb_);
// Consume and bind the delayed PendingRemote and PendingReceiver now that we
weak_factory_.GetWeakPtr()));
}
+media::RendererType MediaPlayerRendererClient::GetRendererType() {
+ return media::RendererType::kMediaPlayer;
+}
+
#if defined(TIZEN_VIDEO_HOLE)
void MediaPlayerRendererClient::SetVideoHole(bool is_video_hole) {
is_video_hole_ = is_video_hole;
void MediaPlayerRendererClient::OnRemoteRendererInitialized(
media::PipelineStatus status) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
+ DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
DCHECK(!init_cb_.is_null());
if (status == media::PIPELINE_OK) {
}
void MediaPlayerRendererClient::OnDurationChange(base::TimeDelta duration) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
+ DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
media_resource_->ForwardDurationChangeToDemuxerHost(duration);
}
#if defined(TIZEN_MULTIMEDIA)
void MediaPlayerRendererClient::OnBufferUpdate(base::TimeDelta time) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
+ DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
media_resource_->ForwardBufferUpdateToDemuxerHost(time);
}
#endif
MediaPlayerRendererClient(
mojo::PendingRemote<RendererExtention> renderer_extension_remote,
mojo::PendingReceiver<ClientExtention> client_extension_receiver,
- scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+ scoped_refptr<base::SequencedTaskRunner> media_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
std::unique_ptr<media::MojoRenderer> mojo_renderer,
media::VideoRendererSink* sink);
void Initialize(media::MediaResource* media_resource,
media::RendererClient* client,
media::PipelineStatusCallback init_cb) override;
+ media::RendererType GetRendererType() override;
#if defined(TIZEN_VIDEO_HOLE)
void SetVideoHole(bool is_video_hole) override;
media::VideoRendererSink* sink_;
- scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
+ scoped_refptr<base::SequencedTaskRunner> media_task_runner_;
// VideoFrames to |sink_| on the right thread.
scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
std::unique_ptr<media::Renderer>
MediaPlayerRendererClientFactory::CreateRenderer(
- const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+ const scoped_refptr<base::SequencedTaskRunner>& media_task_runner,
const scoped_refptr<base::TaskRunner>& worker_task_runner,
media::AudioRendererSink* audio_renderer_sink,
media::VideoRendererSink* video_renderer_sink,
~MediaPlayerRendererClientFactory() override;
std::unique_ptr<media::Renderer> CreateRenderer(
- const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+ const scoped_refptr<base::SequencedTaskRunner>& media_task_runner,
const scoped_refptr<base::TaskRunner>& worker_task_runner,
media::AudioRendererSink* audio_renderer_sink,
media::VideoRendererSink* video_renderer_sink,
callback_->OnData(
audio_bus.get(),
base::TimeTicks::Now() - base::Seconds(hardware_delay_seconds),
- normalized_volume);
+ normalized_volume, {});
}
} // namespace media
int frames_filled = 0;
if (source_callback_) {
frames_filled = source_callback_->OnMoreData(
- base::TimeDelta(), base::TimeTicks::Now(), 0, audio_bus_.get());
+ base::TimeDelta(), base::TimeTicks::Now(), {}, audio_bus_.get());
}
memset(buffer_, 0, bytes_to_fill);
#include "device/udev_linux/scoped_udev.h"
#include "device/udev_linux/udev.h"
#include "media/capture/video/tizen/video_capture_device_tizen.h"
+#include "tizen_src/chromium_impl/build/tizen_version.h"
namespace {
return;
SetReadRequested(type, true);
- GetDemuxerStream(type)->Read(
+ uint32_t buffer_read_count = 1;
+ // TODO: Set correct buffer read count.
+ GetDemuxerStream(type)->Read(buffer_read_count,
base::BindOnce(&MediaPlayerESPlusPlayer::OnBufferReady,
weak_factory_.GetWeakPtr(), type));
}
void MediaPlayerESPlusPlayer::OnBufferReady(
DemuxerStream::Type type,
DemuxerStream::Status status,
- scoped_refptr<DecoderBuffer> buffer) {
+ DemuxerStream::DecoderBufferVector buffers) {
bool should_delay_read = false;
switch (status) {
case DemuxerStream::kAborted:
InitializeStreamConfig(type);
break;
case DemuxerStream::kOk: {
- GetBufferQueue(type).push_back(buffer);
+ GetBufferQueue(type).push_back(buffers[0]);
break;
}
}
void PostReadBuffer(DemuxerStream::Type type);
void OnBufferReady(DemuxerStream::Type type,
DemuxerStream::Status status,
- scoped_refptr<DecoderBuffer> buffer);
+ DemuxerStream::DecoderBufferVector buffer);
esplusplayer_submit_status SubmitEosPacket(DemuxerStream::Type type);
void SeekInternal(base::TimeDelta time);
#ifndef MEDIA_MEDIA_PLAYER_TIZEN_H_
#define MEDIA_MEDIA_PLAYER_TIZEN_H_
+#include "base/memory/unsafe_shared_memory_region.h"
#include "base/task/single_thread_task_runner.h"
#include "media/base/demuxer_stream.h"
#include "media/filters/flags.h"