OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/remoting/rpc/proto_utils.h" | 5 #include "media/remoting/proto_utils.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/big_endian.h" | 9 #include "base/big_endian.h" |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
11 #include "base/time/time.h" | 11 #include "base/time/time.h" |
12 #include "base/values.h" | 12 #include "base/values.h" |
13 #include "media/base/encryption_scheme.h" | 13 #include "media/base/encryption_scheme.h" |
14 #include "media/remoting/rpc/proto_enum_utils.h" | 14 #include "media/remoting/proto_enum_utils.h" |
15 | 15 |
16 namespace media { | 16 namespace media { |
17 namespace remoting { | 17 namespace remoting { |
18 | 18 |
19 namespace { | 19 namespace { |
20 | 20 |
21 constexpr size_t kPayloadVersionFieldSize = sizeof(uint8_t); | 21 constexpr size_t kPayloadVersionFieldSize = sizeof(uint8_t); |
22 constexpr size_t kProtoBufferHeaderSize = sizeof(uint16_t); | 22 constexpr size_t kProtoBufferHeaderSize = sizeof(uint16_t); |
23 constexpr size_t kDataBufferHeaderSize = sizeof(uint32_t); | 23 constexpr size_t kDataBufferHeaderSize = sizeof(uint32_t); |
24 | 24 |
25 std::unique_ptr<::media::DecryptConfig> ConvertProtoToDecryptConfig( | 25 std::unique_ptr<DecryptConfig> ConvertProtoToDecryptConfig( |
26 const pb::DecryptConfig& config_message) { | 26 const pb::DecryptConfig& config_message) { |
27 if (!config_message.has_key_id()) | 27 if (!config_message.has_key_id()) |
28 return nullptr; | 28 return nullptr; |
29 if (!config_message.has_iv()) | 29 if (!config_message.has_iv()) |
30 return nullptr; | 30 return nullptr; |
31 | 31 |
32 std::vector<::media::SubsampleEntry> entries( | 32 std::vector<SubsampleEntry> entries(config_message.sub_samples_size()); |
33 config_message.sub_samples_size()); | |
34 for (int i = 0; i < config_message.sub_samples_size(); ++i) { | 33 for (int i = 0; i < config_message.sub_samples_size(); ++i) { |
35 entries.push_back( | 34 entries.push_back( |
36 ::media::SubsampleEntry(config_message.sub_samples(i).clear_bytes(), | 35 SubsampleEntry(config_message.sub_samples(i).clear_bytes(), |
37 config_message.sub_samples(i).cypher_bytes())); | 36 config_message.sub_samples(i).cypher_bytes())); |
38 } | 37 } |
39 | 38 |
40 std::unique_ptr<::media::DecryptConfig> decrypt_config( | 39 std::unique_ptr<DecryptConfig> decrypt_config( |
41 new ::media::DecryptConfig(config_message.key_id(), config_message.iv(), | 40 new DecryptConfig(config_message.key_id(), config_message.iv(), entries)); |
42 entries)); | |
43 return decrypt_config; | 41 return decrypt_config; |
44 } | 42 } |
45 | 43 |
46 scoped_refptr<::media::DecoderBuffer> ConvertProtoToDecoderBuffer( | 44 scoped_refptr<DecoderBuffer> ConvertProtoToDecoderBuffer( |
47 const pb::DecoderBuffer& buffer_message, | 45 const pb::DecoderBuffer& buffer_message, |
48 scoped_refptr<::media::DecoderBuffer> buffer) { | 46 scoped_refptr<DecoderBuffer> buffer) { |
49 if (buffer_message.is_eos()) { | 47 if (buffer_message.is_eos()) { |
50 VLOG(1) << "EOS data"; | 48 VLOG(1) << "EOS data"; |
51 return ::media::DecoderBuffer::CreateEOSBuffer(); | 49 return DecoderBuffer::CreateEOSBuffer(); |
52 } | 50 } |
53 | 51 |
54 if (buffer_message.has_timestamp_usec()) { | 52 if (buffer_message.has_timestamp_usec()) { |
55 buffer->set_timestamp( | 53 buffer->set_timestamp( |
56 base::TimeDelta::FromMicroseconds(buffer_message.timestamp_usec())); | 54 base::TimeDelta::FromMicroseconds(buffer_message.timestamp_usec())); |
57 } | 55 } |
58 | 56 |
59 if (buffer_message.has_duration_usec()) { | 57 if (buffer_message.has_duration_usec()) { |
60 buffer->set_duration( | 58 buffer->set_duration( |
61 base::TimeDelta::FromMicroseconds(buffer_message.duration_usec())); | 59 base::TimeDelta::FromMicroseconds(buffer_message.duration_usec())); |
(...skipping 18 matching lines...) Expand all Loading... |
80 } | 78 } |
81 base::TimeDelta back_discard; | 79 base::TimeDelta back_discard; |
82 if (buffer_message.has_back_discard_usec()) { | 80 if (buffer_message.has_back_discard_usec()) { |
83 has_discard = true; | 81 has_discard = true; |
84 back_discard = | 82 back_discard = |
85 base::TimeDelta::FromMicroseconds(buffer_message.back_discard_usec()); | 83 base::TimeDelta::FromMicroseconds(buffer_message.back_discard_usec()); |
86 } | 84 } |
87 | 85 |
88 if (has_discard) { | 86 if (has_discard) { |
89 buffer->set_discard_padding( | 87 buffer->set_discard_padding( |
90 ::media::DecoderBuffer::DiscardPadding(front_discard, back_discard)); | 88 DecoderBuffer::DiscardPadding(front_discard, back_discard)); |
91 } | 89 } |
92 | 90 |
93 if (buffer_message.has_splice_timestamp_usec()) { | 91 if (buffer_message.has_splice_timestamp_usec()) { |
94 buffer->set_splice_timestamp(base::TimeDelta::FromMicroseconds( | 92 buffer->set_splice_timestamp(base::TimeDelta::FromMicroseconds( |
95 buffer_message.splice_timestamp_usec())); | 93 buffer_message.splice_timestamp_usec())); |
96 } | 94 } |
97 | 95 |
98 if (buffer_message.has_side_data()) { | 96 if (buffer_message.has_side_data()) { |
99 buffer->CopySideDataFrom( | 97 buffer->CopySideDataFrom( |
100 reinterpret_cast<const uint8_t*>(buffer_message.side_data().data()), | 98 reinterpret_cast<const uint8_t*>(buffer_message.side_data().data()), |
101 buffer_message.side_data().size()); | 99 buffer_message.side_data().size()); |
102 } | 100 } |
103 | 101 |
104 return buffer; | 102 return buffer; |
105 } | 103 } |
106 | 104 |
107 void ConvertDecryptConfigToProto(const ::media::DecryptConfig& decrypt_config, | 105 void ConvertDecryptConfigToProto(const DecryptConfig& decrypt_config, |
108 pb::DecryptConfig* config_message) { | 106 pb::DecryptConfig* config_message) { |
109 DCHECK(config_message); | 107 DCHECK(config_message); |
110 | 108 |
111 config_message->set_key_id(decrypt_config.key_id()); | 109 config_message->set_key_id(decrypt_config.key_id()); |
112 config_message->set_iv(decrypt_config.iv()); | 110 config_message->set_iv(decrypt_config.iv()); |
113 | 111 |
114 for (const auto& entry : decrypt_config.subsamples()) { | 112 for (const auto& entry : decrypt_config.subsamples()) { |
115 pb::DecryptConfig::SubSample* sub_sample = | 113 pb::DecryptConfig::SubSample* sub_sample = |
116 config_message->add_sub_samples(); | 114 config_message->add_sub_samples(); |
117 sub_sample->set_clear_bytes(entry.clear_bytes); | 115 sub_sample->set_clear_bytes(entry.clear_bytes); |
118 sub_sample->set_cypher_bytes(entry.cypher_bytes); | 116 sub_sample->set_cypher_bytes(entry.cypher_bytes); |
119 } | 117 } |
120 } | 118 } |
121 | 119 |
122 void ConvertDecoderBufferToProto( | 120 void ConvertDecoderBufferToProto(const DecoderBuffer& decoder_buffer, |
123 const scoped_refptr<::media::DecoderBuffer>& decoder_buffer, | 121 pb::DecoderBuffer* buffer_message) { |
124 pb::DecoderBuffer* buffer_message) { | 122 if (decoder_buffer.end_of_stream()) { |
125 if (decoder_buffer->end_of_stream()) { | |
126 buffer_message->set_is_eos(true); | 123 buffer_message->set_is_eos(true); |
127 return; | 124 return; |
128 } | 125 } |
129 | 126 |
130 VLOG(3) << "timestamp:" << decoder_buffer->timestamp().InMicroseconds() | 127 VLOG(3) << "timestamp:" << decoder_buffer.timestamp().InMicroseconds() |
131 << " duration:" << decoder_buffer->duration().InMicroseconds(); | 128 << " duration:" << decoder_buffer.duration().InMicroseconds(); |
132 buffer_message->set_timestamp_usec( | 129 buffer_message->set_timestamp_usec( |
133 decoder_buffer->timestamp().InMicroseconds()); | 130 decoder_buffer.timestamp().InMicroseconds()); |
134 buffer_message->set_duration_usec( | 131 buffer_message->set_duration_usec(decoder_buffer.duration().InMicroseconds()); |
135 decoder_buffer->duration().InMicroseconds()); | 132 buffer_message->set_is_key_frame(decoder_buffer.is_key_frame()); |
136 buffer_message->set_is_key_frame(decoder_buffer->is_key_frame()); | |
137 | 133 |
138 if (decoder_buffer->decrypt_config()) { | 134 if (decoder_buffer.decrypt_config()) { |
139 ConvertDecryptConfigToProto(*decoder_buffer->decrypt_config(), | 135 ConvertDecryptConfigToProto(*decoder_buffer.decrypt_config(), |
140 buffer_message->mutable_decrypt_config()); | 136 buffer_message->mutable_decrypt_config()); |
141 } | 137 } |
142 | 138 |
143 buffer_message->set_front_discard_usec( | 139 buffer_message->set_front_discard_usec( |
144 decoder_buffer->discard_padding().first.InMicroseconds()); | 140 decoder_buffer.discard_padding().first.InMicroseconds()); |
145 buffer_message->set_back_discard_usec( | 141 buffer_message->set_back_discard_usec( |
146 decoder_buffer->discard_padding().second.InMicroseconds()); | 142 decoder_buffer.discard_padding().second.InMicroseconds()); |
147 buffer_message->set_splice_timestamp_usec( | 143 buffer_message->set_splice_timestamp_usec( |
148 decoder_buffer->splice_timestamp().InMicroseconds()); | 144 decoder_buffer.splice_timestamp().InMicroseconds()); |
149 | 145 |
150 if (decoder_buffer->side_data_size()) { | 146 if (decoder_buffer.side_data_size()) { |
151 buffer_message->set_side_data(decoder_buffer->side_data(), | 147 buffer_message->set_side_data(decoder_buffer.side_data(), |
152 decoder_buffer->side_data_size()); | 148 decoder_buffer.side_data_size()); |
153 } | 149 } |
154 } | 150 } |
155 | 151 |
156 } // namespace | 152 } // namespace |
157 | 153 |
158 scoped_refptr<::media::DecoderBuffer> ByteArrayToDecoderBuffer( | 154 scoped_refptr<DecoderBuffer> ByteArrayToDecoderBuffer(const uint8_t* data, |
159 const uint8_t* data, | 155 uint32_t size) { |
160 uint32_t size) { | |
161 base::BigEndianReader reader(reinterpret_cast<const char*>(data), size); | 156 base::BigEndianReader reader(reinterpret_cast<const char*>(data), size); |
162 uint8_t payload_version = 0; | 157 uint8_t payload_version = 0; |
163 uint16_t proto_size = 0; | 158 uint16_t proto_size = 0; |
164 pb::DecoderBuffer segment; | 159 pb::DecoderBuffer segment; |
165 uint32_t buffer_size = 0; | 160 uint32_t buffer_size = 0; |
166 if (reader.ReadU8(&payload_version) && payload_version == 0 && | 161 if (reader.ReadU8(&payload_version) && payload_version == 0 && |
167 reader.ReadU16(&proto_size) && | 162 reader.ReadU16(&proto_size) && |
168 static_cast<int>(proto_size) < reader.remaining() && | 163 static_cast<int>(proto_size) < reader.remaining() && |
169 segment.ParseFromArray(reader.ptr(), proto_size) && | 164 segment.ParseFromArray(reader.ptr(), proto_size) && |
170 reader.Skip(proto_size) && reader.ReadU32(&buffer_size) && | 165 reader.Skip(proto_size) && reader.ReadU32(&buffer_size) && |
171 static_cast<int64_t>(buffer_size) <= reader.remaining()) { | 166 static_cast<int64_t>(buffer_size) <= reader.remaining()) { |
172 // Deserialize proto buffer. It passes the pre allocated DecoderBuffer into | 167 // Deserialize proto buffer. It passes the pre allocated DecoderBuffer into |
173 // the function because the proto buffer may overwrite DecoderBuffer since | 168 // the function because the proto buffer may overwrite DecoderBuffer since |
174 // it may be EOS buffer. | 169 // it may be EOS buffer. |
175 scoped_refptr<media::DecoderBuffer> decoder_buffer = | 170 scoped_refptr<DecoderBuffer> decoder_buffer = ConvertProtoToDecoderBuffer( |
176 ConvertProtoToDecoderBuffer( | 171 segment, |
177 segment, | 172 DecoderBuffer::CopyFrom(reinterpret_cast<const uint8_t*>(reader.ptr()), |
178 DecoderBuffer::CopyFrom( | 173 buffer_size)); |
179 reinterpret_cast<const uint8_t*>(reader.ptr()), buffer_size)); | |
180 return decoder_buffer; | 174 return decoder_buffer; |
181 } | 175 } |
182 | 176 |
183 LOG(ERROR) << "Not able to convert byte array to ::media::DecoderBuffer"; | |
184 return nullptr; | 177 return nullptr; |
185 } | 178 } |
186 | 179 |
187 std::vector<uint8_t> DecoderBufferToByteArray( | 180 std::vector<uint8_t> DecoderBufferToByteArray( |
188 const scoped_refptr<::media::DecoderBuffer>& decoder_buffer) { | 181 const DecoderBuffer& decoder_buffer) { |
189 pb::DecoderBuffer decoder_buffer_message; | 182 pb::DecoderBuffer decoder_buffer_message; |
190 ConvertDecoderBufferToProto(decoder_buffer, &decoder_buffer_message); | 183 ConvertDecoderBufferToProto(decoder_buffer, &decoder_buffer_message); |
191 | 184 |
192 size_t decoder_buffer_size = | 185 size_t decoder_buffer_size = |
193 decoder_buffer->end_of_stream() ? 0 : decoder_buffer->data_size(); | 186 decoder_buffer.end_of_stream() ? 0 : decoder_buffer.data_size(); |
194 size_t size = kPayloadVersionFieldSize + kProtoBufferHeaderSize + | 187 size_t size = kPayloadVersionFieldSize + kProtoBufferHeaderSize + |
195 decoder_buffer_message.ByteSize() + kDataBufferHeaderSize + | 188 decoder_buffer_message.ByteSize() + kDataBufferHeaderSize + |
196 decoder_buffer_size; | 189 decoder_buffer_size; |
197 std::vector<uint8_t> buffer(size); | 190 std::vector<uint8_t> buffer(size); |
198 base::BigEndianWriter writer(reinterpret_cast<char*>(buffer.data()), | 191 base::BigEndianWriter writer(reinterpret_cast<char*>(buffer.data()), |
199 buffer.size()); | 192 buffer.size()); |
200 if (writer.WriteU8(0) && | 193 if (writer.WriteU8(0) && |
201 writer.WriteU16( | 194 writer.WriteU16( |
202 static_cast<uint16_t>(decoder_buffer_message.GetCachedSize())) && | 195 static_cast<uint16_t>(decoder_buffer_message.GetCachedSize())) && |
203 decoder_buffer_message.SerializeToArray( | 196 decoder_buffer_message.SerializeToArray( |
204 writer.ptr(), decoder_buffer_message.GetCachedSize()) && | 197 writer.ptr(), decoder_buffer_message.GetCachedSize()) && |
205 writer.Skip(decoder_buffer_message.GetCachedSize()) && | 198 writer.Skip(decoder_buffer_message.GetCachedSize()) && |
206 writer.WriteU32(decoder_buffer_size)) { | 199 writer.WriteU32(decoder_buffer_size)) { |
207 if (decoder_buffer_size) { | 200 if (decoder_buffer_size) { |
208 // DecoderBuffer frame data. | 201 // DecoderBuffer frame data. |
209 writer.WriteBytes(reinterpret_cast<const void*>(decoder_buffer->data()), | 202 writer.WriteBytes(reinterpret_cast<const void*>(decoder_buffer.data()), |
210 decoder_buffer->data_size()); | 203 decoder_buffer.data_size()); |
211 } | 204 } |
212 return buffer; | 205 return buffer; |
213 } | 206 } |
214 | 207 |
| 208 NOTREACHED(); |
215 // Reset buffer since serialization of the data failed. | 209 // Reset buffer since serialization of the data failed. |
216 LOG(ERROR) << "Not able to convert ::media::DecoderBuffer to byte array"; | |
217 buffer.clear(); | 210 buffer.clear(); |
218 return buffer; | 211 return buffer; |
219 } | 212 } |
220 | 213 |
221 void ConvertEncryptionSchemeToProto( | 214 void ConvertEncryptionSchemeToProto(const EncryptionScheme& encryption_scheme, |
222 const ::media::EncryptionScheme& encryption_scheme, | 215 pb::EncryptionScheme* message) { |
223 pb::EncryptionScheme* message) { | |
224 DCHECK(message); | 216 DCHECK(message); |
225 message->set_mode( | 217 message->set_mode( |
226 ToProtoEncryptionSchemeCipherMode(encryption_scheme.mode()).value()); | 218 ToProtoEncryptionSchemeCipherMode(encryption_scheme.mode()).value()); |
227 message->set_encrypt_blocks(encryption_scheme.pattern().encrypt_blocks()); | 219 message->set_encrypt_blocks(encryption_scheme.pattern().encrypt_blocks()); |
228 message->set_skip_blocks(encryption_scheme.pattern().skip_blocks()); | 220 message->set_skip_blocks(encryption_scheme.pattern().skip_blocks()); |
229 } | 221 } |
230 | 222 |
231 ::media::EncryptionScheme ConvertProtoToEncryptionScheme( | 223 EncryptionScheme ConvertProtoToEncryptionScheme( |
232 const pb::EncryptionScheme& message) { | 224 const pb::EncryptionScheme& message) { |
233 return ::media::EncryptionScheme( | 225 return EncryptionScheme( |
234 ToMediaEncryptionSchemeCipherMode(message.mode()).value(), | 226 ToMediaEncryptionSchemeCipherMode(message.mode()).value(), |
235 ::media::EncryptionScheme::Pattern(message.encrypt_blocks(), | 227 EncryptionScheme::Pattern(message.encrypt_blocks(), |
236 message.skip_blocks())); | 228 message.skip_blocks())); |
237 } | 229 } |
238 | 230 |
239 void ConvertAudioDecoderConfigToProto( | 231 void ConvertAudioDecoderConfigToProto(const AudioDecoderConfig& audio_config, |
240 const ::media::AudioDecoderConfig& audio_config, | 232 pb::AudioDecoderConfig* audio_message) { |
241 pb::AudioDecoderConfig* audio_message) { | |
242 DCHECK(audio_config.IsValidConfig()); | 233 DCHECK(audio_config.IsValidConfig()); |
243 DCHECK(audio_message); | 234 DCHECK(audio_message); |
244 | 235 |
245 audio_message->set_codec( | 236 audio_message->set_codec( |
246 ToProtoAudioDecoderConfigCodec(audio_config.codec()).value()); | 237 ToProtoAudioDecoderConfigCodec(audio_config.codec()).value()); |
247 audio_message->set_sample_format( | 238 audio_message->set_sample_format( |
248 ToProtoAudioDecoderConfigSampleFormat(audio_config.sample_format()) | 239 ToProtoAudioDecoderConfigSampleFormat(audio_config.sample_format()) |
249 .value()); | 240 .value()); |
250 audio_message->set_channel_layout( | 241 audio_message->set_channel_layout( |
251 ToProtoAudioDecoderConfigChannelLayout(audio_config.channel_layout()) | 242 ToProtoAudioDecoderConfigChannelLayout(audio_config.channel_layout()) |
(...skipping 11 matching lines...) Expand all Loading... |
263 if (audio_config.is_encrypted()) { | 254 if (audio_config.is_encrypted()) { |
264 pb::EncryptionScheme* encryption_scheme_message = | 255 pb::EncryptionScheme* encryption_scheme_message = |
265 audio_message->mutable_encryption_scheme(); | 256 audio_message->mutable_encryption_scheme(); |
266 ConvertEncryptionSchemeToProto(audio_config.encryption_scheme(), | 257 ConvertEncryptionSchemeToProto(audio_config.encryption_scheme(), |
267 encryption_scheme_message); | 258 encryption_scheme_message); |
268 } | 259 } |
269 } | 260 } |
270 | 261 |
271 bool ConvertProtoToAudioDecoderConfig( | 262 bool ConvertProtoToAudioDecoderConfig( |
272 const pb::AudioDecoderConfig& audio_message, | 263 const pb::AudioDecoderConfig& audio_message, |
273 ::media::AudioDecoderConfig* audio_config) { | 264 AudioDecoderConfig* audio_config) { |
274 DCHECK(audio_config); | 265 DCHECK(audio_config); |
275 audio_config->Initialize( | 266 audio_config->Initialize( |
276 ToMediaAudioCodec(audio_message.codec()).value(), | 267 ToMediaAudioCodec(audio_message.codec()).value(), |
277 ToMediaSampleFormat(audio_message.sample_format()).value(), | 268 ToMediaSampleFormat(audio_message.sample_format()).value(), |
278 ToMediaChannelLayout(audio_message.channel_layout()).value(), | 269 ToMediaChannelLayout(audio_message.channel_layout()).value(), |
279 audio_message.samples_per_second(), | 270 audio_message.samples_per_second(), |
280 std::vector<uint8_t>(audio_message.extra_data().begin(), | 271 std::vector<uint8_t>(audio_message.extra_data().begin(), |
281 audio_message.extra_data().end()), | 272 audio_message.extra_data().end()), |
282 ConvertProtoToEncryptionScheme(audio_message.encryption_scheme()), | 273 ConvertProtoToEncryptionScheme(audio_message.encryption_scheme()), |
283 base::TimeDelta::FromMicroseconds(audio_message.seek_preroll_usec()), | 274 base::TimeDelta::FromMicroseconds(audio_message.seek_preroll_usec()), |
284 audio_message.codec_delay()); | 275 audio_message.codec_delay()); |
285 return audio_config->IsValidConfig(); | 276 return audio_config->IsValidConfig(); |
286 } | 277 } |
287 | 278 |
288 void ConvertVideoDecoderConfigToProto( | 279 void ConvertVideoDecoderConfigToProto(const VideoDecoderConfig& video_config, |
289 const ::media::VideoDecoderConfig& video_config, | 280 pb::VideoDecoderConfig* video_message) { |
290 pb::VideoDecoderConfig* video_message) { | |
291 DCHECK(video_config.IsValidConfig()); | 281 DCHECK(video_config.IsValidConfig()); |
292 DCHECK(video_message); | 282 DCHECK(video_message); |
293 | 283 |
294 video_message->set_codec( | 284 video_message->set_codec( |
295 ToProtoVideoDecoderConfigCodec(video_config.codec()).value()); | 285 ToProtoVideoDecoderConfigCodec(video_config.codec()).value()); |
296 video_message->set_profile( | 286 video_message->set_profile( |
297 ToProtoVideoDecoderConfigProfile(video_config.profile()).value()); | 287 ToProtoVideoDecoderConfigProfile(video_config.profile()).value()); |
298 video_message->set_format( | 288 video_message->set_format( |
299 ToProtoVideoDecoderConfigFormat(video_config.format()).value()); | 289 ToProtoVideoDecoderConfigFormat(video_config.format()).value()); |
300 video_message->set_color_space( | 290 video_message->set_color_space( |
(...skipping 21 matching lines...) Expand all Loading... |
322 if (video_config.is_encrypted()) { | 312 if (video_config.is_encrypted()) { |
323 pb::EncryptionScheme* encryption_scheme_message = | 313 pb::EncryptionScheme* encryption_scheme_message = |
324 video_message->mutable_encryption_scheme(); | 314 video_message->mutable_encryption_scheme(); |
325 ConvertEncryptionSchemeToProto(video_config.encryption_scheme(), | 315 ConvertEncryptionSchemeToProto(video_config.encryption_scheme(), |
326 encryption_scheme_message); | 316 encryption_scheme_message); |
327 } | 317 } |
328 } | 318 } |
329 | 319 |
330 bool ConvertProtoToVideoDecoderConfig( | 320 bool ConvertProtoToVideoDecoderConfig( |
331 const pb::VideoDecoderConfig& video_message, | 321 const pb::VideoDecoderConfig& video_message, |
332 ::media::VideoDecoderConfig* video_config) { | 322 VideoDecoderConfig* video_config) { |
333 DCHECK(video_config); | 323 DCHECK(video_config); |
334 ::media::EncryptionScheme encryption_scheme; | 324 EncryptionScheme encryption_scheme; |
335 video_config->Initialize( | 325 video_config->Initialize( |
336 ToMediaVideoCodec(video_message.codec()).value(), | 326 ToMediaVideoCodec(video_message.codec()).value(), |
337 ToMediaVideoCodecProfile(video_message.profile()).value(), | 327 ToMediaVideoCodecProfile(video_message.profile()).value(), |
338 ToMediaVideoPixelFormat(video_message.format()).value(), | 328 ToMediaVideoPixelFormat(video_message.format()).value(), |
339 ToMediaColorSpace(video_message.color_space()).value(), | 329 ToMediaColorSpace(video_message.color_space()).value(), |
340 gfx::Size(video_message.coded_size().width(), | 330 gfx::Size(video_message.coded_size().width(), |
341 video_message.coded_size().height()), | 331 video_message.coded_size().height()), |
342 gfx::Rect(video_message.visible_rect().x(), | 332 gfx::Rect(video_message.visible_rect().x(), |
343 video_message.visible_rect().y(), | 333 video_message.visible_rect().y(), |
344 video_message.visible_rect().width(), | 334 video_message.visible_rect().width(), |
345 video_message.visible_rect().height()), | 335 video_message.visible_rect().height()), |
346 gfx::Size(video_message.natural_size().width(), | 336 gfx::Size(video_message.natural_size().width(), |
347 video_message.natural_size().height()), | 337 video_message.natural_size().height()), |
348 std::vector<uint8_t>(video_message.extra_data().begin(), | 338 std::vector<uint8_t>(video_message.extra_data().begin(), |
349 video_message.extra_data().end()), | 339 video_message.extra_data().end()), |
350 ConvertProtoToEncryptionScheme(video_message.encryption_scheme())); | 340 ConvertProtoToEncryptionScheme(video_message.encryption_scheme())); |
351 return video_config->IsValidConfig(); | 341 return video_config->IsValidConfig(); |
352 } | 342 } |
353 | 343 |
| 344 void ConvertProtoToPipelineStatistics( |
| 345 const pb::PipelineStatistics& stats_message, |
| 346 PipelineStatistics* stats) { |
| 347 stats->audio_bytes_decoded = stats_message.audio_bytes_decoded(); |
| 348 stats->video_bytes_decoded = stats_message.video_bytes_decoded(); |
| 349 stats->video_frames_decoded = stats_message.video_frames_decoded(); |
| 350 stats->video_frames_dropped = stats_message.video_frames_dropped(); |
| 351 stats->audio_memory_usage = stats_message.audio_memory_usage(); |
| 352 stats->video_memory_usage = stats_message.video_memory_usage(); |
| 353 // HACK: Set the following to prevent "disable video when hidden" logic in |
| 354 // media::blink::WebMediaPlayerImpl. |
| 355 stats->video_keyframe_distance_average = base::TimeDelta::Max(); |
| 356 } |
| 357 |
354 void ConvertCdmKeyInfoToProto( | 358 void ConvertCdmKeyInfoToProto( |
355 const ::media::CdmKeysInfo& keys_information, | 359 const CdmKeysInfo& keys_information, |
356 pb::CdmClientOnSessionKeysChange* key_change_message) { | 360 pb::CdmClientOnSessionKeysChange* key_change_message) { |
357 for (const auto& info : keys_information) { | 361 for (const auto& info : keys_information) { |
358 pb::CdmKeyInformation* key = key_change_message->add_key_information(); | 362 pb::CdmKeyInformation* key = key_change_message->add_key_information(); |
359 key->set_key_id(info->key_id.data(), info->key_id.size()); | 363 key->set_key_id(info->key_id.data(), info->key_id.size()); |
360 key->set_status(ToProtoCdmKeyInformation(info->status).value()); | 364 key->set_status(ToProtoCdmKeyInformation(info->status).value()); |
361 key->set_system_code(info->system_code); | 365 key->set_system_code(info->system_code); |
362 } | 366 } |
363 } | 367 } |
364 | 368 |
365 void ConvertProtoToCdmKeyInfo( | 369 void ConvertProtoToCdmKeyInfo( |
366 const pb::CdmClientOnSessionKeysChange keychange_message, | 370 const pb::CdmClientOnSessionKeysChange keychange_message, |
367 CdmKeysInfo* key_information) { | 371 CdmKeysInfo* key_information) { |
368 DCHECK(key_information); | 372 DCHECK(key_information); |
369 key_information->reserve(keychange_message.key_information_size()); | 373 key_information->reserve(keychange_message.key_information_size()); |
370 for (int i = 0; i < keychange_message.key_information_size(); ++i) { | 374 for (int i = 0; i < keychange_message.key_information_size(); ++i) { |
371 const pb::CdmKeyInformation key_info_msg = | 375 const pb::CdmKeyInformation key_info_msg = |
372 keychange_message.key_information(i); | 376 keychange_message.key_information(i); |
373 | 377 |
374 std::unique_ptr<::media::CdmKeyInformation> key( | 378 std::unique_ptr<CdmKeyInformation> key(new CdmKeyInformation( |
375 new ::media::CdmKeyInformation( | 379 key_info_msg.key_id(), |
376 key_info_msg.key_id(), | 380 ToMediaCdmKeyInformationKeyStatus(key_info_msg.status()).value(), |
377 ToMediaCdmKeyInformationKeyStatus(key_info_msg.status()).value(), | 381 key_info_msg.system_code())); |
378 key_info_msg.system_code())); | |
379 key_information->push_back(std::move(key)); | 382 key_information->push_back(std::move(key)); |
380 } | 383 } |
381 } | 384 } |
382 | 385 |
383 void ConvertCdmPromiseToProto(const CdmPromiseResult& result, | 386 void ConvertCdmPromiseToProto(const CdmPromiseResult& result, |
384 pb::CdmPromise* promise_message) { | 387 pb::CdmPromise* promise_message) { |
385 promise_message->set_success(result.success()); | 388 promise_message->set_success(result.success()); |
386 if (!result.success()) { | 389 if (!result.success()) { |
387 promise_message->set_exception( | 390 promise_message->set_exception( |
388 ToProtoCdmException(result.exception()).value()); | 391 ToProtoCdmException(result.exception()).value()); |
(...skipping 20 matching lines...) Expand all Loading... |
409 CdmPromiseResult* result) { | 412 CdmPromiseResult* result) { |
410 if (!promise_message.has_success()) | 413 if (!promise_message.has_success()) |
411 return false; | 414 return false; |
412 | 415 |
413 bool success = promise_message.success(); | 416 bool success = promise_message.success(); |
414 if (success) { | 417 if (success) { |
415 *result = CdmPromiseResult::SuccessResult(); | 418 *result = CdmPromiseResult::SuccessResult(); |
416 return true; | 419 return true; |
417 } | 420 } |
418 | 421 |
419 ::media::CdmPromise::Exception exception = ::media::CdmPromise::UNKNOWN_ERROR; | 422 CdmPromise::Exception exception = CdmPromise::UNKNOWN_ERROR; |
420 uint32_t system_code = 0; | 423 uint32_t system_code = 0; |
421 std::string error_message; | 424 std::string error_message; |
422 | 425 |
423 exception = ToCdmPromiseException(promise_message.exception()).value(); | 426 exception = ToCdmPromiseException(promise_message.exception()).value(); |
424 system_code = promise_message.system_code(); | 427 system_code = promise_message.system_code(); |
425 error_message = promise_message.error_message(); | 428 error_message = promise_message.error_message(); |
426 *result = CdmPromiseResult(exception, system_code, error_message); | 429 *result = CdmPromiseResult(exception, system_code, error_message); |
427 return true; | 430 return true; |
428 } | 431 } |
429 | 432 |
(...skipping 11 matching lines...) Expand all Loading... |
441 if (cdm_id) | 444 if (cdm_id) |
442 *cdm_id = promise_message.cdm_id(); | 445 *cdm_id = promise_message.cdm_id(); |
443 if (session_id) | 446 if (session_id) |
444 *session_id = promise_message.session_id(); | 447 *session_id = promise_message.session_id(); |
445 | 448 |
446 return true; | 449 return true; |
447 } | 450 } |
448 | 451 |
449 //============================================================================== | 452 //============================================================================== |
450 CdmPromiseResult::CdmPromiseResult() | 453 CdmPromiseResult::CdmPromiseResult() |
451 : CdmPromiseResult(::media::CdmPromise::UNKNOWN_ERROR, 0, "") {} | 454 : CdmPromiseResult(CdmPromise::UNKNOWN_ERROR, 0, "") {} |
452 | 455 |
453 CdmPromiseResult::CdmPromiseResult(::media::CdmPromise::Exception exception, | 456 CdmPromiseResult::CdmPromiseResult(CdmPromise::Exception exception, |
454 uint32_t system_code, | 457 uint32_t system_code, |
455 std::string error_message) | 458 std::string error_message) |
456 : success_(false), | 459 : success_(false), |
457 exception_(exception), | 460 exception_(exception), |
458 system_code_(system_code), | 461 system_code_(system_code), |
459 error_message_(error_message) {} | 462 error_message_(error_message) {} |
460 | 463 |
461 CdmPromiseResult::CdmPromiseResult(const CdmPromiseResult& other) = default; | 464 CdmPromiseResult::CdmPromiseResult(const CdmPromiseResult& other) = default; |
462 | 465 |
463 CdmPromiseResult::~CdmPromiseResult() = default; | 466 CdmPromiseResult::~CdmPromiseResult() = default; |
464 | 467 |
465 CdmPromiseResult CdmPromiseResult::SuccessResult() { | 468 CdmPromiseResult CdmPromiseResult::SuccessResult() { |
466 CdmPromiseResult result(static_cast<::media::CdmPromise::Exception>(0), 0, | 469 CdmPromiseResult result(static_cast<CdmPromise::Exception>(0), 0, ""); |
467 ""); | |
468 result.success_ = true; | 470 result.success_ = true; |
469 return result; | 471 return result; |
470 } | 472 } |
471 | 473 |
472 } // namespace remoting | 474 } // namespace remoting |
473 } // namespace media | 475 } // namespace media |
OLD | NEW |