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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// Copyright 2013 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 MEDIA_CAST_CAST_CONFIG_H_
#define MEDIA_CAST_CAST_CONFIG_H_
#include <list>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/memory/shared_memory.h"
#include "base/single_thread_task_runner.h"
#include "base/time/time.h"
#include "media/cast/cast_defines.h"
#include "media/cast/net/cast_transport_config.h"
namespace media {
class VideoEncodeAccelerator;
namespace cast {
// TODO(miu): Merge AudioSenderConfig and VideoSenderConfig and make their
// naming/documentation consistent with FrameReceiverConfig.
struct AudioSenderConfig {
AudioSenderConfig();
~AudioSenderConfig();
// Identifier referring to the sender, used by the receiver.
uint32 ssrc;
// The receiver's SSRC identifier.
uint32 receiver_ssrc;
// The total amount of time between a frame's capture/recording on the sender
// and its playback on the receiver (i.e., shown to a user). This should be
// set to a value large enough to give the system sufficient time to encode,
// transmit/retransmit, receive, decode, and render; given its run-time
// environment (sender/receiver hardware performance, network conditions,
// etc.).
base::TimeDelta min_playout_delay;
base::TimeDelta max_playout_delay;
// RTP payload type enum: Specifies the type/encoding of frame data.
int rtp_payload_type;
bool use_external_encoder;
int frequency;
int channels;
int bitrate; // Set to <= 0 for "auto variable bitrate" (libopus knows best).
Codec codec;
// The AES crypto key and initialization vector. Each of these strings
// contains the data in binary form, of size kAesKeySize. If they are empty
// strings, crypto is not being used.
std::string aes_key;
std::string aes_iv_mask;
};
struct VideoSenderConfig {
VideoSenderConfig();
~VideoSenderConfig();
// Identifier referring to the sender, used by the receiver.
uint32 ssrc;
// The receiver's SSRC identifier.
uint32 receiver_ssrc;
// The total amount of time between a frame's capture/recording on the sender
// and its playback on the receiver (i.e., shown to a user). This should be
// set to a value large enough to give the system sufficient time to encode,
// transmit/retransmit, receive, decode, and render; given its run-time
// environment (sender/receiver hardware performance, network conditions,
// etc.).
base::TimeDelta min_playout_delay;
base::TimeDelta max_playout_delay;
// RTP payload type enum: Specifies the type/encoding of frame data.
int rtp_payload_type;
bool use_external_encoder;
float congestion_control_back_off;
int max_bitrate;
int min_bitrate;
int start_bitrate;
int max_qp;
int min_qp;
int max_frame_rate; // TODO(miu): Should be double, not int.
// This field is used differently by various encoders. It defaults to 1.
//
// For VP8, it should be 1 to operate in single-buffer mode, or 3 to operate
// in multi-buffer mode. See
// http://www.webmproject.org/docs/encoder-parameters/ for details.
//
// For H.264 on Mac or iOS, it controls the max number of frames the encoder
// may hold before emitting a frame. A larger window may allow higher encoding
// efficiency at the cost of latency and memory. Set to 0 to let the encoder
// choose a suitable value for the platform and other encoding settings.
int max_number_of_video_buffers_used;
Codec codec;
int number_of_encode_threads;
// The AES crypto key and initialization vector. Each of these strings
// contains the data in binary form, of size kAesKeySize. If they are empty
// strings, crypto is not being used.
std::string aes_key;
std::string aes_iv_mask;
};
// TODO(miu): Naming and minor type changes are badly needed in a later CL.
struct FrameReceiverConfig {
FrameReceiverConfig();
~FrameReceiverConfig();
// The receiver's SSRC identifier.
uint32 receiver_ssrc;
// The sender's SSRC identifier.
uint32 sender_ssrc;
// The total amount of time between a frame's capture/recording on the sender
// and its playback on the receiver (i.e., shown to a user). This is fixed as
// a value large enough to give the system sufficient time to encode,
// transmit/retransmit, receive, decode, and render; given its run-time
// environment (sender/receiver hardware performance, network conditions,
// etc.).
int rtp_max_delay_ms; // TODO(miu): Change to TimeDelta target_playout_delay.
// RTP payload type enum: Specifies the type/encoding of frame data.
int rtp_payload_type;
// RTP timebase: The number of RTP units advanced per one second. For audio,
// this is the sampling rate. For video, by convention, this is 90 kHz.
int rtp_timebase;
// Number of channels. For audio, this is normally 2. For video, this must
// be 1 as Cast does not have support for stereoscopic video.
int channels;
// The target frame rate. For audio, this is normally 100 (i.e., frames have
// a duration of 10ms each). For video, this is normally 30, but any frame
// rate is supported.
int target_frame_rate;
// Codec used for the compression of signal data.
// TODO(miu): Merge the AudioCodec and VideoCodec enums into one so this union
// is not necessary.
Codec codec;
// The AES crypto key and initialization vector. Each of these strings
// contains the data in binary form, of size kAesKeySize. If they are empty
// strings, crypto is not being used.
std::string aes_key;
std::string aes_iv_mask;
};
// Import from media::cast.
typedef Packet Packet;
typedef PacketList PacketList;
// Callback that is run to update the client with current status. This is used
// to allow the client to wait for asynchronous initialization to complete
// before sending frames, and also to be notified of any runtime errors that
// have halted the session.
typedef base::Callback<void(OperationalStatus)> StatusChangeCallback;
typedef base::Callback<void(scoped_refptr<base::SingleThreadTaskRunner>,
scoped_ptr<media::VideoEncodeAccelerator>)>
ReceiveVideoEncodeAcceleratorCallback;
typedef base::Callback<void(const ReceiveVideoEncodeAcceleratorCallback&)>
CreateVideoEncodeAcceleratorCallback;
typedef base::Callback<void(scoped_ptr<base::SharedMemory>)>
ReceiveVideoEncodeMemoryCallback;
typedef base::Callback<void(size_t size,
const ReceiveVideoEncodeMemoryCallback&)>
CreateVideoEncodeMemoryCallback;
} // namespace cast
} // namespace media
#endif // MEDIA_CAST_CAST_CONFIG_H_
|
