OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 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/pgl/command_buffer_pepper.h" | |
6 | |
7 #include "gpu/command_buffer/common/logging.h" | |
8 | |
9 using base::SharedMemory; | |
10 using gpu::Buffer; | |
11 using gpu::CommandBuffer; | |
12 | |
13 CommandBufferPepper::CommandBufferPepper(NPP npp, | |
14 NPDevice* device, | |
15 NPDeviceContext3D* context) | |
16 : npp_(npp), | |
17 device_(device), | |
18 context_(context) { | |
19 } | |
20 | |
21 CommandBufferPepper::~CommandBufferPepper() { | |
22 } | |
23 | |
24 // Not implemented in CommandBufferPepper. | |
25 bool CommandBufferPepper::Initialize(int32 size) { | |
26 GPU_NOTREACHED(); | |
27 return false; | |
28 } | |
29 | |
30 bool CommandBufferPepper::Initialize(base::SharedMemory* buffer, int32 size) { | |
31 GPU_NOTREACHED(); | |
32 return false; | |
33 } | |
34 | |
35 Buffer CommandBufferPepper::GetRingBuffer() { | |
36 Buffer buffer; | |
37 #if defined(ENABLE_NEW_NPDEVICE_API) | |
38 NPDeviceBuffer np_buffer; | |
39 device_->mapBuffer(npp_, | |
40 context_, | |
41 NP3DCommandBufferId, | |
42 &np_buffer); | |
43 buffer.ptr = np_buffer.ptr; | |
44 buffer.size = np_buffer.size; | |
45 #else | |
46 buffer.ptr = context_->commandBuffer; | |
47 buffer.size = context_->commandBufferSize * sizeof(int32); | |
48 #endif | |
49 return buffer; | |
50 } | |
51 | |
52 CommandBuffer::State CommandBufferPepper::GetState() { | |
53 #if defined(ENABLE_NEW_NPDEVICE_API) | |
54 int32 output_attribs[] = { | |
55 NP3DAttrib_CommandBufferSize, 0, | |
56 NP3DAttrib_GetOffset, 0, | |
57 NP3DAttrib_PutOffset, 0, | |
58 NP3DAttrib_Token, 0, | |
59 NPAttrib_Error, 0, | |
60 NPAttrib_End | |
61 }; | |
62 device_->synchronizeContext(npp_, | |
63 context_, | |
64 NPDeviceSynchronizationMode_Immediate, | |
65 NULL, | |
66 output_attribs, | |
67 NULL, | |
68 NULL); | |
69 | |
70 CommandBuffer::State state; | |
71 state.num_entries = output_attribs[1]; | |
72 state.get_offset = output_attribs[3]; | |
73 state.put_offset = output_attribs[5]; | |
74 state.token = output_attribs[7]; | |
75 state.error = static_cast<gpu::error::Error>( | |
76 output_attribs[9]); | |
77 | |
78 return state; | |
79 #else | |
80 context_->waitForProgress = false; | |
81 | |
82 if (NPERR_NO_ERROR != device_->flushContext(npp_, context_, NULL, NULL)) | |
83 context_->error = NPDeviceContext3DError_GenericError; | |
84 | |
85 context_->waitForProgress = true; | |
86 | |
87 return ConvertState(); | |
88 #endif // ENABLE_NEW_NPDEVICE_API | |
89 } | |
90 | |
91 void CommandBufferPepper::Flush(int32 put_offset) { | |
92 FlushSync(put_offset); | |
93 } | |
94 | |
95 CommandBuffer::State CommandBufferPepper::FlushSync(int32 put_offset) { | |
96 #if defined(ENABLE_NEW_NPDEVICE_API) | |
97 int32 input_attribs[] = { | |
98 NP3DAttrib_PutOffset, put_offset, | |
99 NPAttrib_End | |
100 }; | |
101 int32 output_attribs[] = { | |
102 NP3DAttrib_CommandBufferSize, 0, | |
103 NP3DAttrib_GetOffset, 0, | |
104 NP3DAttrib_PutOffset, 0, | |
105 NP3DAttrib_Token, 0, | |
106 NPAttrib_Error, 0, | |
107 NPAttrib_End | |
108 }; | |
109 device_->synchronizeContext(npp_, | |
110 context_, | |
111 NPDeviceSynchronizationMode_Flush, | |
112 input_attribs, | |
113 output_attribs, | |
114 NULL, | |
115 NULL); | |
116 | |
117 CommandBuffer::State state; | |
118 state.num_entries = output_attribs[1]; | |
119 state.get_offset = output_attribs[3]; | |
120 state.put_offset = output_attribs[5]; | |
121 state.token = output_attribs[7]; | |
122 state.error = static_cast<gpu::error::Error>( | |
123 output_attribs[9]); | |
124 | |
125 return state; | |
126 #else | |
127 context_->waitForProgress = true; | |
128 context_->putOffset = put_offset; | |
129 | |
130 if (NPERR_NO_ERROR != device_->flushContext(npp_, context_, NULL, NULL)) | |
131 context_->error = NPDeviceContext3DError_GenericError; | |
132 | |
133 return ConvertState(); | |
134 #endif // ENABLE_NEW_NPDEVICE_API | |
135 } | |
136 | |
137 void CommandBufferPepper::SetGetOffset(int32 get_offset) { | |
138 // Not implemented by proxy. | |
139 GPU_NOTREACHED(); | |
140 } | |
141 | |
142 int32 CommandBufferPepper::CreateTransferBuffer(size_t size, int32 id_request) { | |
143 int32_t id; | |
144 if (NPERR_NO_ERROR != device_->createBuffer(npp_, context_, size, &id)) | |
145 return -1; | |
146 | |
147 return static_cast<int32>(id); | |
148 } | |
149 | |
150 int32 CommandBufferPepper::RegisterTransferBuffer( | |
151 base::SharedMemory* shared_memory, | |
152 size_t size, | |
153 int32 id_request) { | |
154 // Not implemented by proxy. | |
155 GPU_NOTREACHED(); | |
156 return -1; | |
157 } | |
158 | |
159 void CommandBufferPepper::DestroyTransferBuffer(int32 id) { | |
160 device_->destroyBuffer(npp_, context_, id); | |
161 } | |
162 | |
163 Buffer CommandBufferPepper::GetTransferBuffer(int32 id) { | |
164 NPDeviceBuffer np_buffer; | |
165 if (NPERR_NO_ERROR != device_->mapBuffer(npp_, context_, id, &np_buffer)) | |
166 return Buffer(); | |
167 | |
168 Buffer buffer; | |
169 buffer.ptr = np_buffer.ptr; | |
170 buffer.size = np_buffer.size; | |
171 return buffer; | |
172 } | |
173 | |
174 void CommandBufferPepper::SetToken(int32 token) { | |
175 // Not implemented by proxy. | |
176 GPU_NOTREACHED(); | |
177 } | |
178 | |
179 void CommandBufferPepper::SetParseError( | |
180 gpu::error::Error error) { | |
181 // Not implemented by proxy. | |
182 GPU_NOTREACHED(); | |
183 } | |
184 | |
185 gpu::error::Error CommandBufferPepper::GetCachedError() { | |
186 int32_t attrib_list[] = { | |
187 NPAttrib_Error, 0, | |
188 NPAttrib_End | |
189 }; | |
190 device_->synchronizeContext(npp_, | |
191 context_, | |
192 NPDeviceSynchronizationMode_Cached, | |
193 NULL, | |
194 attrib_list, | |
195 NULL, | |
196 NULL); | |
197 return static_cast<gpu::error::Error>(attrib_list[1]); | |
198 } | |
199 | |
200 CommandBuffer::State CommandBufferPepper::ConvertState() { | |
201 CommandBuffer::State state; | |
202 state.num_entries = context_->commandBufferSize; | |
203 state.get_offset = context_->getOffset; | |
204 state.put_offset = context_->putOffset; | |
205 state.token = context_->token; | |
206 state.error = static_cast<gpu::error::Error>( | |
207 context_->error); | |
208 return state; | |
209 } | |
OLD | NEW |