OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 "chromecast/common/media/cma_param_traits.h" | 5 #include "chromecast/common/media/cma_param_traits.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "chromecast/common/media/cma_param_traits_macros.h" | 9 #include "chromecast/common/media/cma_param_traits_macros.h" |
10 #include "content/public/common/common_param_traits.h" | 10 #include "content/public/common/common_param_traits.h" |
11 #include "ipc/ipc_message_macros.h" | 11 #include "ipc/ipc_message_macros.h" |
12 #include "media/base/audio_decoder_config.h" | 12 #include "media/base/audio_decoder_config.h" |
13 #include "media/base/encryption_scheme.h" | |
13 #include "media/base/video_decoder_config.h" | 14 #include "media/base/video_decoder_config.h" |
14 #include "ui/gfx/ipc/gfx_param_traits.h" | 15 #include "ui/gfx/ipc/gfx_param_traits.h" |
15 | 16 |
16 // Note(gunsch): these are currently defined in content/, but not declared in | 17 // Note(gunsch): these are currently defined in content/, but not declared in |
17 // content/public/. These headers need to be forward-declared for chromecast/, | 18 // content/public/. These headers need to be forward-declared for chromecast/, |
18 // but without new implementations linked in. | 19 // but without new implementations linked in. |
19 // The correct long-term fix is to use Mojo instead of the content/ IPCs. | 20 // The correct long-term fix is to use Mojo instead of the content/ IPCs. |
20 IPC_ENUM_TRAITS_MIN_MAX_VALUE(media::ChannelLayout, | 21 IPC_ENUM_TRAITS_MIN_MAX_VALUE(media::ChannelLayout, |
21 media::ChannelLayout::CHANNEL_LAYOUT_NONE, | 22 media::ChannelLayout::CHANNEL_LAYOUT_NONE, |
22 media::ChannelLayout::CHANNEL_LAYOUT_MAX) | 23 media::ChannelLayout::CHANNEL_LAYOUT_MAX) |
23 IPC_ENUM_TRAITS_MIN_MAX_VALUE(media::VideoCodecProfile, | 24 IPC_ENUM_TRAITS_MIN_MAX_VALUE(media::VideoCodecProfile, |
24 media::VIDEO_CODEC_PROFILE_MIN, | 25 media::VIDEO_CODEC_PROFILE_MIN, |
25 media::VIDEO_CODEC_PROFILE_MAX) | 26 media::VIDEO_CODEC_PROFILE_MAX) |
26 IPC_ENUM_TRAITS_MAX_VALUE(media::VideoPixelFormat, media::PIXEL_FORMAT_MAX) | 27 IPC_ENUM_TRAITS_MAX_VALUE(media::VideoPixelFormat, media::PIXEL_FORMAT_MAX) |
28 IPC_ENUM_TRAITS_MAX_VALUE(media::CipherMode, media::kCipherModeMax); | |
yucliu1
2015/12/10 00:12:19
This line should be in cma_param_traits_macros.h I
dougsteed
2015/12/14 21:19:01
Done.
| |
27 | 29 |
28 namespace IPC { | 30 namespace IPC { |
29 | 31 |
32 template <> | |
33 struct ParamTraits<media::EncryptionScheme::PatternSpec> { | |
34 typedef media::EncryptionScheme::PatternSpec param_type; | |
35 static void Write(Message* m, const param_type& p); | |
36 static bool Read(const Message* m, base::PickleIterator* iter, param_type* r); | |
37 static void Log(const param_type& p, std::string* l); | |
38 }; | |
39 | |
40 | |
30 void ParamTraits<media::AudioDecoderConfig>::Write( | 41 void ParamTraits<media::AudioDecoderConfig>::Write( |
31 Message* m, const media::AudioDecoderConfig& p) { | 42 Message* m, const media::AudioDecoderConfig& p) { |
32 WriteParam(m, p.codec()); | 43 WriteParam(m, p.codec()); |
33 WriteParam(m, p.sample_format()); | 44 WriteParam(m, p.sample_format()); |
34 WriteParam(m, p.channel_layout()); | 45 WriteParam(m, p.channel_layout()); |
35 WriteParam(m, p.samples_per_second()); | 46 WriteParam(m, p.samples_per_second()); |
36 WriteParam(m, p.is_encrypted()); | 47 WriteParam(m, p.encryption_scheme()); |
37 WriteParam(m, p.extra_data()); | 48 WriteParam(m, p.extra_data()); |
38 } | 49 } |
39 | 50 |
40 bool ParamTraits<media::AudioDecoderConfig>::Read( | 51 bool ParamTraits<media::AudioDecoderConfig>::Read( |
41 const Message* m, | 52 const Message* m, |
42 base::PickleIterator* iter, | 53 base::PickleIterator* iter, |
43 media::AudioDecoderConfig* r) { | 54 media::AudioDecoderConfig* r) { |
44 media::AudioCodec codec; | 55 media::AudioCodec codec; |
45 media::SampleFormat sample_format; | 56 media::SampleFormat sample_format; |
46 media::ChannelLayout channel_layout; | 57 media::ChannelLayout channel_layout; |
47 int samples_per_second; | 58 int samples_per_second; |
48 bool is_encrypted; | 59 media::EncryptionScheme encryption_scheme; |
49 std::vector<uint8> extra_data; | 60 std::vector<uint8> extra_data; |
50 if (!ReadParam(m, iter, &codec) || !ReadParam(m, iter, &sample_format) || | 61 if (!ReadParam(m, iter, &codec) || !ReadParam(m, iter, &sample_format) || |
51 !ReadParam(m, iter, &channel_layout) || | 62 !ReadParam(m, iter, &channel_layout) || |
52 !ReadParam(m, iter, &samples_per_second) || | 63 !ReadParam(m, iter, &samples_per_second) || |
53 !ReadParam(m, iter, &is_encrypted) || !ReadParam(m, iter, &extra_data)) | 64 !ReadParam(m, iter, &encryption_scheme) || |
65 !ReadParam(m, iter, &extra_data)) | |
54 return false; | 66 return false; |
55 *r = media::AudioDecoderConfig(codec, sample_format, channel_layout, | 67 *r = media::AudioDecoderConfig(codec, sample_format, channel_layout, |
56 samples_per_second, extra_data, is_encrypted); | 68 samples_per_second, extra_data, |
69 encryption_scheme); | |
57 return true; | 70 return true; |
58 } | 71 } |
59 | 72 |
60 void ParamTraits<media::AudioDecoderConfig>::Log( | 73 void ParamTraits<media::AudioDecoderConfig>::Log( |
61 const media::AudioDecoderConfig& p, std::string* l) { | 74 const media::AudioDecoderConfig& p, std::string* l) { |
62 l->append(base::StringPrintf("<AudioDecoderConfig>")); | 75 l->append(base::StringPrintf("<AudioDecoderConfig>")); |
63 } | 76 } |
64 | 77 |
65 void ParamTraits<media::VideoDecoderConfig>::Write( | 78 void ParamTraits<media::VideoDecoderConfig>::Write( |
66 Message* m, const media::VideoDecoderConfig& p) { | 79 Message* m, const media::VideoDecoderConfig& p) { |
67 WriteParam(m, p.codec()); | 80 WriteParam(m, p.codec()); |
68 WriteParam(m, p.profile()); | 81 WriteParam(m, p.profile()); |
69 WriteParam(m, p.format()); | 82 WriteParam(m, p.format()); |
70 WriteParam(m, p.color_space()); | 83 WriteParam(m, p.color_space()); |
71 WriteParam(m, p.coded_size()); | 84 WriteParam(m, p.coded_size()); |
72 WriteParam(m, p.visible_rect()); | 85 WriteParam(m, p.visible_rect()); |
73 WriteParam(m, p.natural_size()); | 86 WriteParam(m, p.natural_size()); |
74 WriteParam(m, p.is_encrypted()); | 87 WriteParam(m, p.encryption_scheme()); |
75 WriteParam(m, p.extra_data()); | 88 WriteParam(m, p.extra_data()); |
76 } | 89 } |
77 | 90 |
78 bool ParamTraits<media::VideoDecoderConfig>::Read( | 91 bool ParamTraits<media::VideoDecoderConfig>::Read( |
79 const Message* m, | 92 const Message* m, |
80 base::PickleIterator* iter, | 93 base::PickleIterator* iter, |
81 media::VideoDecoderConfig* r) { | 94 media::VideoDecoderConfig* r) { |
82 media::VideoCodec codec; | 95 media::VideoCodec codec; |
83 media::VideoCodecProfile profile; | 96 media::VideoCodecProfile profile; |
84 media::VideoPixelFormat format; | 97 media::VideoPixelFormat format; |
85 media::ColorSpace color_space; | 98 media::ColorSpace color_space; |
86 gfx::Size coded_size; | 99 gfx::Size coded_size; |
87 gfx::Rect visible_rect; | 100 gfx::Rect visible_rect; |
88 gfx::Size natural_size; | 101 gfx::Size natural_size; |
89 bool is_encrypted; | 102 media::EncryptionScheme encryption_scheme; |
90 std::vector<uint8> extra_data; | 103 std::vector<uint8> extra_data; |
91 if (!ReadParam(m, iter, &codec) || !ReadParam(m, iter, &profile) || | 104 if (!ReadParam(m, iter, &codec) || !ReadParam(m, iter, &profile) || |
92 !ReadParam(m, iter, &format) || !ReadParam(m, iter, &color_space) || | 105 !ReadParam(m, iter, &format) || !ReadParam(m, iter, &color_space) || |
93 !ReadParam(m, iter, &coded_size) || !ReadParam(m, iter, &visible_rect) || | 106 !ReadParam(m, iter, &coded_size) || !ReadParam(m, iter, &visible_rect) || |
94 !ReadParam(m, iter, &natural_size) || | 107 !ReadParam(m, iter, &natural_size) || |
95 !ReadParam(m, iter, &is_encrypted) || !ReadParam(m, iter, &extra_data)) | 108 !ReadParam(m, iter, &encryption_scheme) || |
109 !ReadParam(m, iter, &extra_data)) | |
96 return false; | 110 return false; |
97 *r = media::VideoDecoderConfig(codec, profile, format, color_space, | 111 *r = media::VideoDecoderConfig(codec, profile, format, color_space, |
98 coded_size, visible_rect, natural_size, | 112 coded_size, visible_rect, natural_size, |
99 extra_data, is_encrypted); | 113 extra_data, encryption_scheme); |
100 return true; | 114 return true; |
101 } | 115 } |
102 | 116 |
103 void ParamTraits<media::VideoDecoderConfig>::Log( | 117 void ParamTraits<media::VideoDecoderConfig>::Log( |
104 const media::VideoDecoderConfig& p, std::string* l) { | 118 const media::VideoDecoderConfig& p, std::string* l) { |
105 l->append(base::StringPrintf("<VideoDecoderConfig>")); | 119 l->append(base::StringPrintf("<VideoDecoderConfig>")); |
106 } | 120 } |
107 | 121 |
122 void ParamTraits<media::EncryptionScheme>::Write( | |
123 Message* m, const param_type& p) { | |
124 WriteParam(m, p.is_encrypted()); | |
125 WriteParam(m, p.mode()); | |
126 WriteParam(m, p.pattern()); | |
127 } | |
128 | |
129 bool ParamTraits<media::EncryptionScheme>::Read( | |
130 const Message* m, base::PickleIterator* iter, param_type* r) { | |
131 bool is_encrypted; | |
132 media::CipherMode mode; | |
133 media::EncryptionScheme::PatternSpec pattern; | |
134 if (!ReadParam(m, iter, &is_encrypted) || !ReadParam(m, iter, &mode) || | |
135 !ReadParam(m, iter, &pattern)) | |
136 return false; | |
137 *r = media::EncryptionScheme(is_encrypted, mode, pattern); | |
138 return true; | |
139 } | |
140 | |
141 void ParamTraits<media::EncryptionScheme>::Log( | |
142 const param_type& p, std::string* l) { | |
143 l->append(base::StringPrintf("<EncryptionScheme>")); | |
144 } | |
145 | |
146 void ParamTraits<media::EncryptionScheme::PatternSpec>::Write( | |
147 Message* m, const param_type& p) { | |
148 WriteParam(m, p.encrypt_blocks()); | |
149 WriteParam(m, p.skip_blocks()); | |
150 } | |
151 | |
152 bool ParamTraits<media::EncryptionScheme::PatternSpec>::Read( | |
153 const Message* m, base::PickleIterator* iter, param_type* r) { | |
154 uint32_t encrypt_blocks, skip_blocks; | |
155 if (!ReadParam(m, iter, &encrypt_blocks) || !ReadParam(m, iter, &skip_blocks)) | |
156 return false; | |
157 *r = media::EncryptionScheme::PatternSpec(encrypt_blocks, skip_blocks); | |
158 return true; | |
159 } | |
160 | |
161 void ParamTraits<media::EncryptionScheme::PatternSpec>::Log( | |
162 const param_type& p, std::string* l) { | |
163 l->append(base::StringPrintf("<PatternSpec>")); | |
164 } | |
165 | |
108 } // namespace IPC | 166 } // namespace IPC |
OLD | NEW |