1 // Copyright (c) 2012 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 "gpu/ipc/common/gpu_command_buffer_traits.h"
6
7 #include <stddef.h>
8 #include <stdint.h>
9
10 #include "gpu/command_buffer/common/command_buffer_id.h"
11 #include "gpu/command_buffer/common/mailbox_holder.h"
12 #include "gpu/command_buffer/common/sync_token.h"
13 #include "gpu/command_buffer/common/texture_in_use_response.h"
14 #include "gpu/ipc/common/vulkan_ycbcr_info.h"
15
16 // Generate param traits write methods.
17 #include "ipc/param_traits_write_macros.h"
18 namespace IPC {
19 #include "gpu/ipc/common/gpu_command_buffer_traits_multi.h"
20 } // namespace IPC
21
22 // Generate param traits read methods.
23 #include "ipc/param_traits_read_macros.h"
24 namespace IPC {
25 #include "gpu/ipc/common/gpu_command_buffer_traits_multi.h"
26 } // namespace IPC
27
28 // Generate param traits log methods.
29 #include "ipc/param_traits_log_macros.h"
30 namespace IPC {
31 #include "gpu/ipc/common/gpu_command_buffer_traits_multi.h"
32 } // namespace IPC
33
34 namespace IPC {
35
Write(base::Pickle * m,const param_type & p)36 void ParamTraits<gpu::SyncToken>::Write(base::Pickle* m, const param_type& p) {
37 DCHECK(!p.HasData() || p.verified_flush());
38
39 WriteParam(m, p.verified_flush());
40 WriteParam(m, p.namespace_id());
41 WriteParam(m, p.command_buffer_id());
42 WriteParam(m, p.release_count());
43 }
44
Read(const base::Pickle * m,base::PickleIterator * iter,param_type * p)45 bool ParamTraits<gpu::SyncToken>::Read(const base::Pickle* m,
46 base::PickleIterator* iter,
47 param_type* p) {
48 bool verified_flush = false;
49 gpu::CommandBufferNamespace namespace_id =
50 gpu::CommandBufferNamespace::INVALID;
51 gpu::CommandBufferId command_buffer_id;
52 uint64_t release_count = 0;
53
54 if (!ReadParam(m, iter, &verified_flush) ||
55 !ReadParam(m, iter, &namespace_id) ||
56 !ReadParam(m, iter, &command_buffer_id) ||
57 !ReadParam(m, iter, &release_count)) {
58 return false;
59 }
60
61 p->Set(namespace_id, command_buffer_id, release_count);
62 if (p->HasData()) {
63 if (!verified_flush)
64 return false;
65 p->SetVerifyFlush();
66 }
67
68 return true;
69 }
70
Log(const param_type & p,std::string * l)71 void ParamTraits<gpu::SyncToken>::Log(const param_type& p, std::string* l) {
72 *l += base::StringPrintf(
73 "[%" PRId8 ":%" PRIX64 "] %" PRIu64, p.namespace_id(),
74 p.command_buffer_id().GetUnsafeValue(), p.release_count());
75 }
76
Write(base::Pickle * m,const param_type & p)77 void ParamTraits<gpu::TextureInUseResponse>::Write(base::Pickle* m,
78 const param_type& p) {
79 WriteParam(m, p.texture);
80 WriteParam(m, p.in_use);
81 }
82
Read(const base::Pickle * m,base::PickleIterator * iter,param_type * p)83 bool ParamTraits<gpu::TextureInUseResponse>::Read(const base::Pickle* m,
84 base::PickleIterator* iter,
85 param_type* p) {
86 uint32_t texture = 0;
87 bool in_use = false;
88
89 if (!ReadParam(m, iter, &texture) || !ReadParam(m, iter, &in_use)) {
90 return false;
91 }
92
93 p->texture = texture;
94 p->in_use = in_use;
95 return true;
96 }
97
Log(const param_type & p,std::string * l)98 void ParamTraits<gpu::TextureInUseResponse>::Log(const param_type& p,
99 std::string* l) {
100 *l += base::StringPrintf("[%u: %d]", p.texture, static_cast<int>(p.in_use));
101 }
102
Write(base::Pickle * m,const param_type & p)103 void ParamTraits<gpu::Mailbox>::Write(base::Pickle* m, const param_type& p) {
104 m->WriteBytes(p.name, sizeof(p.name));
105 }
106
Read(const base::Pickle * m,base::PickleIterator * iter,param_type * p)107 bool ParamTraits<gpu::Mailbox>::Read(const base::Pickle* m,
108 base::PickleIterator* iter,
109 param_type* p) {
110 const char* bytes = nullptr;
111 if (!iter->ReadBytes(&bytes, sizeof(p->name)))
112 return false;
113 DCHECK(bytes);
114 memcpy(p->name, bytes, sizeof(p->name));
115 return true;
116 }
117
Log(const param_type & p,std::string * l)118 void ParamTraits<gpu::Mailbox>::Log(const param_type& p, std::string* l) {
119 for (size_t i = 0; i < sizeof(p.name); ++i)
120 *l += base::StringPrintf("%02x", p.name[i]);
121 }
122
Write(base::Pickle * m,const param_type & p)123 void ParamTraits<gpu::MailboxHolder>::Write(base::Pickle* m,
124 const param_type& p) {
125 WriteParam(m, p.mailbox);
126 WriteParam(m, p.sync_token);
127 WriteParam(m, p.texture_target);
128 }
129
Read(const base::Pickle * m,base::PickleIterator * iter,param_type * p)130 bool ParamTraits<gpu::MailboxHolder>::Read(const base::Pickle* m,
131 base::PickleIterator* iter,
132 param_type* p) {
133 if (!ReadParam(m, iter, &p->mailbox) || !ReadParam(m, iter, &p->sync_token) ||
134 !ReadParam(m, iter, &p->texture_target))
135 return false;
136 return true;
137 }
138
Log(const param_type & p,std::string * l)139 void ParamTraits<gpu::MailboxHolder>::Log(const param_type& p, std::string* l) {
140 LogParam(p.mailbox, l);
141 LogParam(p.sync_token, l);
142 *l += base::StringPrintf(":%04x@", p.texture_target);
143 }
144
Write(base::Pickle * m,const param_type & p)145 void ParamTraits<gpu::VulkanYCbCrInfo>::Write(base::Pickle* m,
146 const param_type& p) {
147 WriteParam(m, p.image_format);
148 WriteParam(m, p.external_format);
149 WriteParam(m, p.suggested_ycbcr_model);
150 WriteParam(m, p.suggested_ycbcr_range);
151 WriteParam(m, p.suggested_xchroma_offset);
152 WriteParam(m, p.suggested_ychroma_offset);
153 WriteParam(m, p.format_features);
154 }
155
Read(const base::Pickle * m,base::PickleIterator * iter,param_type * p)156 bool ParamTraits<gpu::VulkanYCbCrInfo>::Read(const base::Pickle* m,
157 base::PickleIterator* iter,
158 param_type* p) {
159 if (!ReadParam(m, iter, &p->image_format) ||
160 !ReadParam(m, iter, &p->external_format) ||
161 !ReadParam(m, iter, &p->suggested_ycbcr_model) ||
162 !ReadParam(m, iter, &p->suggested_ycbcr_range) ||
163 !ReadParam(m, iter, &p->suggested_xchroma_offset) ||
164 !ReadParam(m, iter, &p->suggested_ychroma_offset) ||
165 !ReadParam(m, iter, &p->format_features)) {
166 return false;
167 }
168 return true;
169 }
170
171 // Note that we are casting uint64_t explicitly to long long otherwise it gets
172 // implicit cast to long for 64 bit OS and long long for 32 bit OS.
Log(const param_type & p,std::string * l)173 void ParamTraits<gpu::VulkanYCbCrInfo>::Log(const param_type& p,
174 std::string* l) {
175 *l += base::StringPrintf(
176 "[%u] , [%llu], [%u], [%u], [%u], [%u], [%u]", p.image_format,
177 static_cast<long long>(p.external_format), p.suggested_ycbcr_model,
178 p.suggested_ycbcr_range, p.suggested_xchroma_offset,
179 p.suggested_ychroma_offset, p.format_features);
180 }
181
182 } // namespace IPC
183