blob: 22f5a6432e1c955243ece0da880e3054d738e283 (
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
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// 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 "media/cast/cast_defines.h"
#include "media/cast/transport/cast_transport_config.h"
namespace media {
class VideoEncodeAccelerator;
namespace cast {
enum RtcpMode {
kRtcpCompound, // Compound RTCP mode is described by RFC 4585.
kRtcpReducedSize, // Reduced-size RTCP mode is described by RFC 5506.
};
struct AudioSenderConfig {
AudioSenderConfig();
uint32 sender_ssrc;
uint32 incoming_feedback_ssrc;
int rtcp_interval;
std::string rtcp_c_name;
RtcpMode rtcp_mode;
transport::RtpConfig rtp_config;
bool use_external_encoder;
int frequency;
int channels;
int bitrate; // Set to <= 0 for "auto variable bitrate" (libopus knows best).
transport::AudioCodec codec;
};
struct VideoSenderConfig {
VideoSenderConfig();
uint32 sender_ssrc;
uint32 incoming_feedback_ssrc;
int rtcp_interval;
std::string rtcp_c_name;
RtcpMode rtcp_mode;
transport::RtpConfig rtp_config;
bool use_external_encoder;
int width; // Incoming frames will be scaled to this size.
int height;
float congestion_control_back_off;
int max_bitrate;
int min_bitrate;
int start_bitrate;
int max_qp;
int min_qp;
int max_frame_rate;
int max_number_of_video_buffers_used; // Max value depend on codec.
transport::VideoCodec codec;
int number_of_encode_threads;
};
struct AudioReceiverConfig {
AudioReceiverConfig();
uint32 feedback_ssrc;
uint32 incoming_ssrc;
int rtcp_interval;
std::string rtcp_c_name;
RtcpMode rtcp_mode;
// The time the receiver is prepared to wait for retransmissions.
int rtp_max_delay_ms;
int rtp_payload_type;
bool use_external_decoder;
int frequency;
int channels;
transport::AudioCodec codec;
std::string aes_key; // Binary string of size kAesKeySize.
std::string aes_iv_mask; // Binary string of size kAesKeySize.
};
struct VideoReceiverConfig {
VideoReceiverConfig();
uint32 feedback_ssrc;
uint32 incoming_ssrc;
int rtcp_interval;
std::string rtcp_c_name;
RtcpMode rtcp_mode;
// The time the receiver is prepared to wait for retransmissions.
int rtp_max_delay_ms;
int rtp_payload_type;
bool use_external_decoder;
int max_frame_rate;
// Some HW decoders can not run faster than the frame rate, preventing it
// from catching up after a glitch.
bool decoder_faster_than_max_frame_rate;
transport::VideoCodec codec;
std::string aes_key; // Binary string of size kAesKeySize.
std::string aes_iv_mask; // Binary string of size kAesKeySize.
};
// import from media::cast::transport
typedef transport::Packet Packet;
typedef transport::PacketList PacketList;
typedef base::Callback<void(CastInitializationStatus)>
CastInitializationCallback;
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_
|
