1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
// Copyright 2016 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.
// Delete this file when WMPI_CAST is no longer needed.
#ifndef MEDIA_BLINK_WEBMEDIAPLAYER_CAST_ANDROID_H_
#define MEDIA_BLINK_WEBMEDIAPLAYER_CAST_ANDROID_H_
#include "base/memory/weak_ptr.h"
#include "media/blink/media_blink_export.h"
#include "media/blink/renderer_media_player_interface.h"
#include "media/blink/webmediaplayer_params.h"
#include "url/gurl.h"
namespace blink {
class WebLocalFrame;
class WebMediaPlayerClient;
class WebURL;
}
namespace media {
class VideoFrame;
class WebMediaPlayerImpl;
// This shim allows WebMediaPlayer to act sufficiently similar to
// WebMediaPlayerAndroid (by extending RendererMediaPlayerInterface)
// to implement cast functionality.
class WebMediaPlayerCast : public RendererMediaPlayerInterface {
public:
WebMediaPlayerCast(WebMediaPlayerImpl* impl,
blink::WebMediaPlayerClient* client,
const WebMediaPlayerParams::Context3DCB& context_3d_cb);
~WebMediaPlayerCast();
void Initialize(const GURL& url,
blink::WebLocalFrame* frame,
int delegate_id);
void requestRemotePlayback();
void requestRemotePlaybackControl();
void requestRemotePlaybackStop();
void SetMediaPlayerManager(
RendererMediaPlayerManagerInterface* media_player_manager);
bool isRemote() const { return is_remote_; }
bool IsPaused() const { return paused_; }
double currentTime() const;
void play();
void pause();
void seek(base::TimeDelta t);
// RendererMediaPlayerInterface implementation
void OnMediaMetadataChanged(base::TimeDelta duration,
int width,
int height,
bool success) override;
void OnPlaybackComplete() override;
void OnBufferingUpdate(int percentage) override;
void OnSeekRequest(const base::TimeDelta& time_to_seek) override;
void OnSeekComplete(const base::TimeDelta& current_time) override;
void OnMediaError(int error_type) override;
void OnVideoSizeChanged(int width, int height) override;
// Called to update the current time.
void OnTimeUpdate(base::TimeDelta current_timestamp,
base::TimeTicks current_time_ticks) override;
// void OnWaitingForDecryptionKey() override;
void OnPlayerReleased() override;
// Functions called when media player status changes.
void OnConnectedToRemoteDevice(
const std::string& remote_playback_message) override;
void OnDisconnectedFromRemoteDevice() override;
void OnCancelledRemotePlaybackRequest() override;
void OnRemotePlaybackStarted() override;
void OnDidExitFullscreen() override;
void OnMediaPlayerPlay() override;
void OnMediaPlayerPause() override;
void OnRemoteRouteAvailabilityChanged(
blink::WebRemotePlaybackAvailability availability) override;
// This function is called by the RendererMediaPlayerManager to pause the
// video and release the media player and surface texture when we switch tabs.
// However, the actual GlTexture is not released to keep the video screenshot.
void SuspendAndReleaseResources() override;
void SetDeviceScaleFactor(float scale_factor);
scoped_refptr<VideoFrame> GetCastingBanner();
void setPoster(const blink::WebURL& poster);
private:
WebMediaPlayerImpl* webmediaplayer_;
blink::WebMediaPlayerClient* client_;
WebMediaPlayerParams::Context3DCB context_3d_cb_;
// Manages this object and delegates player calls to the browser process.
// Owned by RenderFrameImpl.
RendererMediaPlayerManagerInterface* player_manager_ = nullptr;
// Player ID assigned by the |player_manager_|.
int player_id_;
// Whether the browser is currently connected to a remote media player.
bool is_remote_ = false;
bool paused_ = true;
bool initializing_ = false;
bool should_notify_time_changed_ = false;
// Last reported playout time.
base::TimeDelta remote_time_;
base::TimeTicks remote_time_at_;
base::TimeDelta duration_;
// Whether the media player has been initialized.
bool is_player_initialized_ = false;
std::string remote_playback_message_;
float device_scale_factor_ = 1.0;
DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerCast);
};
// Make a texture-backed video of the given size containing the given message.
MEDIA_BLINK_EXPORT scoped_refptr<VideoFrame> MakeTextFrameForCast(
const std::string& remote_playback_message,
gfx::Size canvas_size,
gfx::Size natural_size,
const base::Callback<gpu::gles2::GLES2Interface*()>& context_3d_cb);
} // namespace media
#endif // MEDIA_BLINK_WEBMEDIAPLAYER_CAST_ANDROID_H_
|
