OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "chromecast/common/media/cma_param_traits.h" |
| 6 |
| 7 #include <vector> |
| 8 |
| 9 #include "chromecast/common/media/cma_param_traits_macros.h" |
| 10 #include "content/public/common/common_param_traits.h" |
| 11 #include "ipc/ipc_message_macros.h" |
| 12 #include "media/base/audio_decoder_config.h" |
| 13 #include "media/base/video_decoder_config.h" |
| 14 #include "ui/gfx/ipc/gfx_param_traits.h" |
| 15 |
| 16 namespace IPC { |
| 17 |
| 18 void ParamTraits<media::AudioDecoderConfig>::Write( |
| 19 Message* m, const media::AudioDecoderConfig& p) { |
| 20 ParamTraits<media::AudioCodec>::Write(m, p.codec()); |
| 21 ParamTraits<media::SampleFormat>::Write(m, p.sample_format()); |
| 22 ParamTraits<media::ChannelLayout>::Write(m, p.channel_layout()); |
| 23 ParamTraits<int>::Write(m, p.samples_per_second()); |
| 24 ParamTraits<bool>::Write(m, p.is_encrypted()); |
| 25 std::vector<uint8> extra_data; |
| 26 if (p.extra_data_size() > 0) { |
| 27 extra_data = |
| 28 std::vector<uint8>(p.extra_data(), |
| 29 p.extra_data() + p.extra_data_size()); |
| 30 } |
| 31 ParamTraits<std::vector<uint8> >::Write(m, extra_data); |
| 32 } |
| 33 |
| 34 bool ParamTraits<media::AudioDecoderConfig>::Read( |
| 35 const Message* m, PickleIterator* iter, |
| 36 media::AudioDecoderConfig* r) { |
| 37 media::AudioCodec codec; |
| 38 media::SampleFormat sample_format; |
| 39 media::ChannelLayout channel_layout; |
| 40 int samples_per_second; |
| 41 bool is_encrypted; |
| 42 if (!ParamTraits<media::AudioCodec>::Read(m, iter, &codec) || |
| 43 !ParamTraits<media::SampleFormat>::Read(m, iter, &sample_format) || |
| 44 !ParamTraits<media::ChannelLayout>::Read(m, iter, &channel_layout) || |
| 45 !ParamTraits<int>::Read(m, iter, &samples_per_second) || |
| 46 !ParamTraits<bool>::Read(m, iter, &is_encrypted)) { |
| 47 return false; |
| 48 } |
| 49 std::vector<uint8> extra_data; |
| 50 if (!ParamTraits<std::vector<uint8> >::Read(m, iter, &extra_data)) |
| 51 return false; |
| 52 const uint8* extra_data_ptr = NULL; |
| 53 if (extra_data.size() > 0) |
| 54 extra_data_ptr = &extra_data[0]; |
| 55 *r = media::AudioDecoderConfig(codec, sample_format, channel_layout, |
| 56 samples_per_second, |
| 57 extra_data_ptr, extra_data.size(), |
| 58 is_encrypted); |
| 59 return true; |
| 60 } |
| 61 |
| 62 void ParamTraits<media::AudioDecoderConfig>::Log( |
| 63 const media::AudioDecoderConfig& p, std::string* l) { |
| 64 l->append(base::StringPrintf("<AudioDecoderConfig>")); |
| 65 } |
| 66 |
| 67 void ParamTraits<media::VideoDecoderConfig>::Write( |
| 68 Message* m, const media::VideoDecoderConfig& p) { |
| 69 ParamTraits<media::VideoCodec>::Write(m, p.codec()); |
| 70 ParamTraits<media::VideoCodecProfile>::Write(m, p.profile()); |
| 71 ParamTraits<media::VideoFrame::Format>::Write(m, p.format()); |
| 72 ParamTraits<gfx::Size>::Write(m, p.coded_size()); |
| 73 ParamTraits<gfx::Rect>::Write(m, p.visible_rect()); |
| 74 ParamTraits<gfx::Size>::Write(m, p.natural_size()); |
| 75 ParamTraits<bool>::Write(m, p.is_encrypted()); |
| 76 std::vector<uint8> extra_data; |
| 77 if (p.extra_data_size() > 0) { |
| 78 extra_data = |
| 79 std::vector<uint8>(p.extra_data(), |
| 80 p.extra_data() + p.extra_data_size()); |
| 81 } |
| 82 ParamTraits<std::vector<uint8> >::Write(m, extra_data); |
| 83 } |
| 84 |
| 85 bool ParamTraits<media::VideoDecoderConfig>::Read( |
| 86 const Message* m, PickleIterator* iter, |
| 87 media::VideoDecoderConfig* r) { |
| 88 media::VideoCodec codec; |
| 89 media::VideoCodecProfile profile; |
| 90 media::VideoFrame::Format format; |
| 91 gfx::Size coded_size; |
| 92 gfx::Rect visible_rect; |
| 93 gfx::Size natural_size; |
| 94 bool is_encrypted; |
| 95 if (!ParamTraits<media::VideoCodec>::Read(m, iter, &codec) || |
| 96 !ParamTraits<media::VideoCodecProfile>::Read(m, iter, &profile) || |
| 97 !ParamTraits<media::VideoFrame::Format>::Read(m, iter, &format) || |
| 98 !ParamTraits<gfx::Size>::Read(m, iter, &coded_size) || |
| 99 !ParamTraits<gfx::Rect>::Read(m, iter, &visible_rect) || |
| 100 !ParamTraits<gfx::Size>::Read(m, iter, &natural_size) || |
| 101 !ParamTraits<bool>::Read(m, iter, &is_encrypted)) { |
| 102 return false; |
| 103 } |
| 104 std::vector<uint8> extra_data; |
| 105 if (!ParamTraits<std::vector<uint8> >::Read(m, iter, &extra_data)) |
| 106 return false; |
| 107 const uint8* extra_data_ptr = NULL; |
| 108 if (extra_data.size() > 0) |
| 109 extra_data_ptr = &extra_data[0]; |
| 110 *r = media::VideoDecoderConfig(codec, profile, format, |
| 111 coded_size, visible_rect, natural_size, |
| 112 extra_data_ptr, extra_data.size(), |
| 113 is_encrypted); |
| 114 return true; |
| 115 } |
| 116 |
| 117 void ParamTraits<media::VideoDecoderConfig>::Log( |
| 118 const media::VideoDecoderConfig& p, std::string* l) { |
| 119 l->append(base::StringPrintf("<VideoDecoderConfig>")); |
| 120 } |
| 121 |
| 122 } // namespace IPC |
OLD | NEW |