blob: ef5788d953c8012ffe99b58d8d2ef8da5851ce55 (
plain)
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
|
// Copyright 2018 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 COMPONENTS_MIRRORING_SERVICE_RTP_STREAM_H_
#define COMPONENTS_MIRRORING_SERVICE_RTP_STREAM_H_
#include <memory>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "media/base/audio_bus.h"
#include "media/cast/cast_config.h"
#include "media/cast/constants.h"
#include "media/video/video_encode_accelerator.h"
namespace media {
class VideoFrame;
namespace cast {
class VideoSender;
class AudioSender;
} // namespace cast
} // namespace media
namespace mirroring {
class RtpStreamClient {
public:
virtual ~RtpStreamClient() {}
// Called when error happened during streaming.
virtual void OnError(const std::string& message) = 0;
// Request a fresh video frame from the capturer.
virtual void RequestRefreshFrame() = 0;
// The following are for hardware video encoding.
// Query the supported hardware encoding profiles.
virtual media::VideoEncodeAccelerator::SupportedProfiles
GetSupportedVideoEncodeAcceleratorProfiles() = 0;
virtual void CreateVideoEncodeAccelerator(
const media::cast::ReceiveVideoEncodeAcceleratorCallback& callback) = 0;
// TODO(xjz): Remove this interface. Instead, create the shared memory in
// external video encoder through mojo::ScopedSharedBufferHandle.
virtual void CreateVideoEncodeMemory(
size_t size,
const media::cast::ReceiveVideoEncodeMemoryCallback& callback) = 0;
};
// Receives video frames and submits the data to media::cast::VideoSender. It
// also includes a timer to request refresh frames when the source halts (e.g.,
// a screen capturer stops delivering frames because the screen is not being
// updated). When a halt is detected, refresh frames will be requested at
// regular intervals for a short period of time. This provides the video
// encoder, downstream, several copies of the last frame so that it may clear up
// lossy encoding artifacts.
class VideoRtpStream {
public:
VideoRtpStream(std::unique_ptr<media::cast::VideoSender> video_sender,
base::WeakPtr<RtpStreamClient> client);
~VideoRtpStream();
static std::vector<media::cast::FrameSenderConfig> GetSupportedConfigs(
RtpStreamClient* client);
// Called by VideoCaptureClient when a video frame is received.
// |video_frame| is required to provide REFERENCE_TIME in the metadata.
void InsertVideoFrame(scoped_refptr<media::VideoFrame> video_frame);
base::WeakPtr<VideoRtpStream> AsWeakPtr() {
return weak_factory_.GetWeakPtr();
}
void SetTargetPlayoutDelay(base::TimeDelta playout_delay);
private:
void OnRefreshTimerFired();
const std::unique_ptr<media::cast::VideoSender> video_sender_;
const base::WeakPtr<RtpStreamClient> client_;
// Requests refresh frames at a constant rate while the source is paused, up
// to a consecutive maximum.
base::RepeatingTimer refresh_timer_;
// Counter for the number of consecutive "refresh frames" requested.
int consecutive_refresh_count_;
// Set to true when a request for a refresh frame has been made. This is
// cleared once the next frame is received.
bool expecting_a_refresh_frame_;
base::WeakPtrFactory<VideoRtpStream> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(VideoRtpStream);
};
// Receives audio data and submits the data to media::cast::AudioSender.
// TODO(xjz): Complete implementation after Audio Service mirroring refactoring
// is landed.
class AudioRtpStream {
public:
AudioRtpStream(std::unique_ptr<media::cast::AudioSender> audio_sender,
base::WeakPtr<RtpStreamClient> client);
~AudioRtpStream();
static std::vector<media::cast::FrameSenderConfig> GetSupportedConfigs();
// Called by AudioCaptureClient when new audio data is available.
void InsertAudio(std::unique_ptr<media::AudioBus> audio_bus,
base::TimeTicks estimated_capture_time);
void SetTargetPlayoutDelay(base::TimeDelta playout_delay);
private:
const std::unique_ptr<media::cast::AudioSender> audio_sender_;
const base::WeakPtr<RtpStreamClient> client_;
DISALLOW_COPY_AND_ASSIGN(AudioRtpStream);
};
} // namespace mirroring
#endif // COMPONENTS_MIRRORING_SERVICE_RTP_STREAM_H_
|
