diff options
author | Dan Stoza | 2015-04-23 17:51:00 -0500 |
---|---|---|
committer | Gerrit Code Review | 2015-04-23 17:51:01 -0500 |
commit | 82e4d49b0ecb205d49f02cc07496f7508c56443c (patch) | |
tree | 7f08cfdcf37afa58b2a42ee341a0e6a336855b08 /libs | |
parent | de5c15b8bd12143829d043fa4ab457600e5682b3 (diff) | |
parent | eea6d682b8b0f7081f0fe8fab8feadb16e22b30b (diff) | |
download | frameworks-native-82e4d49b0ecb205d49f02cc07496f7508c56443c.tar.gz frameworks-native-82e4d49b0ecb205d49f02cc07496f7508c56443c.tar.xz frameworks-native-82e4d49b0ecb205d49f02cc07496f7508c56443c.zip |
Merge "libui/libgui: Fix errors in parceling"
Diffstat (limited to 'libs')
-rw-r--r-- | libs/gui/BufferItem.cpp | 133 | ||||
-rw-r--r-- | libs/ui/GraphicBuffer.cpp | 4 |
2 files changed, 83 insertions, 54 deletions
diff --git a/libs/gui/BufferItem.cpp b/libs/gui/BufferItem.cpp index 239da20a0..5793d405e 100644 --- a/libs/gui/BufferItem.cpp +++ b/libs/gui/BufferItem.cpp | |||
@@ -39,52 +39,66 @@ BufferItem::BufferItem() : | |||
39 | 39 | ||
40 | BufferItem::~BufferItem() {} | 40 | BufferItem::~BufferItem() {} |
41 | 41 | ||
42 | template <typename T> | ||
43 | static void addAligned(size_t& size, T /* value */) { | ||
44 | size = FlattenableUtils::align<sizeof(T)>(size); | ||
45 | size += sizeof(T); | ||
46 | } | ||
47 | |||
42 | size_t BufferItem::getPodSize() const { | 48 | size_t BufferItem::getPodSize() const { |
43 | size_t c = sizeof(mCrop) + | 49 | // Must align<8> before writing these fields for this to be correct |
44 | sizeof(mTransform) + | 50 | size_t size = 0; |
45 | sizeof(mScalingMode) + | 51 | addAligned(size, mCrop); |
46 | sizeof(mTimestamp) + | 52 | addAligned(size, mTransform); |
47 | sizeof(mIsAutoTimestamp) + | 53 | addAligned(size, mScalingMode); |
48 | sizeof(mDataSpace) + | 54 | addAligned(size, mTimestamp); |
49 | sizeof(mFrameNumber) + | 55 | addAligned(size, mIsAutoTimestamp); |
50 | sizeof(mSlot) + | 56 | addAligned(size, mDataSpace); |
51 | sizeof(mIsDroppable) + | 57 | addAligned(size, mFrameNumber); |
52 | sizeof(mAcquireCalled) + | 58 | addAligned(size, mSlot); |
53 | sizeof(mTransformToDisplayInverse); | 59 | addAligned(size, mIsDroppable); |
54 | return c; | 60 | addAligned(size, mAcquireCalled); |
61 | addAligned(size, mTransformToDisplayInverse); | ||
62 | return size; | ||
55 | } | 63 | } |
56 | 64 | ||
57 | size_t BufferItem::getFlattenedSize() const { | 65 | size_t BufferItem::getFlattenedSize() const { |
58 | size_t c = 0; | 66 | size_t size = sizeof(uint32_t); // Flags |
59 | if (mGraphicBuffer != 0) { | 67 | if (mGraphicBuffer != 0) { |
60 | c += mGraphicBuffer->getFlattenedSize(); | 68 | size += mGraphicBuffer->getFlattenedSize(); |
61 | FlattenableUtils::align<4>(c); | 69 | FlattenableUtils::align<4>(size); |
62 | } | 70 | } |
63 | if (mFence != 0) { | 71 | if (mFence != 0) { |
64 | c += mFence->getFlattenedSize(); | 72 | size += mFence->getFlattenedSize(); |
65 | FlattenableUtils::align<4>(c); | 73 | FlattenableUtils::align<4>(size); |
66 | } | 74 | } |
67 | c += mSurfaceDamage.getFlattenedSize(); | 75 | size += mSurfaceDamage.getFlattenedSize(); |
68 | FlattenableUtils::align<4>(c); | 76 | size = FlattenableUtils::align<8>(size); |
69 | return sizeof(int32_t) + c + getPodSize(); | 77 | return size + getPodSize(); |
70 | } | 78 | } |
71 | 79 | ||
72 | size_t BufferItem::getFdCount() const { | 80 | size_t BufferItem::getFdCount() const { |
73 | size_t c = 0; | 81 | size_t count = 0; |
74 | if (mGraphicBuffer != 0) { | 82 | if (mGraphicBuffer != 0) { |
75 | c += mGraphicBuffer->getFdCount(); | 83 | count += mGraphicBuffer->getFdCount(); |
76 | } | 84 | } |
77 | if (mFence != 0) { | 85 | if (mFence != 0) { |
78 | c += mFence->getFdCount(); | 86 | count += mFence->getFdCount(); |
79 | } | 87 | } |
80 | return c; | 88 | return count; |
89 | } | ||
90 | |||
91 | template <typename T> | ||
92 | static void writeAligned(void*& buffer, size_t& size, T value) { | ||
93 | size -= FlattenableUtils::align<alignof(T)>(buffer); | ||
94 | FlattenableUtils::write(buffer, size, value); | ||
81 | } | 95 | } |
82 | 96 | ||
83 | status_t BufferItem::flatten( | 97 | status_t BufferItem::flatten( |
84 | void*& buffer, size_t& size, int*& fds, size_t& count) const { | 98 | void*& buffer, size_t& size, int*& fds, size_t& count) const { |
85 | 99 | ||
86 | // make sure we have enough space | 100 | // make sure we have enough space |
87 | if (count < BufferItem::getFlattenedSize()) { | 101 | if (size < BufferItem::getFlattenedSize()) { |
88 | return NO_MEMORY; | 102 | return NO_MEMORY; |
89 | } | 103 | } |
90 | 104 | ||
@@ -107,35 +121,46 @@ status_t BufferItem::flatten( | |||
107 | size -= FlattenableUtils::align<4>(buffer); | 121 | size -= FlattenableUtils::align<4>(buffer); |
108 | flags |= 2; | 122 | flags |= 2; |
109 | } | 123 | } |
124 | |||
110 | status_t err = mSurfaceDamage.flatten(buffer, size); | 125 | status_t err = mSurfaceDamage.flatten(buffer, size); |
111 | if (err) return err; | 126 | if (err) return err; |
112 | size -= FlattenableUtils::align<4>(buffer); | 127 | FlattenableUtils::advance(buffer, size, mSurfaceDamage.getFlattenedSize()); |
128 | |||
129 | // Must align<8> so that getPodSize returns the correct value | ||
130 | size -= FlattenableUtils::align<8>(buffer); | ||
113 | 131 | ||
114 | // check we have enough space (in case flattening the fence/graphicbuffer lied to us) | 132 | // Check we still have enough space |
115 | if (size < getPodSize()) { | 133 | if (size < getPodSize()) { |
116 | return NO_MEMORY; | 134 | return NO_MEMORY; |
117 | } | 135 | } |
118 | 136 | ||
119 | FlattenableUtils::write(buffer, size, mCrop); | 137 | writeAligned(buffer, size, mCrop); |
120 | FlattenableUtils::write(buffer, size, mTransform); | 138 | writeAligned(buffer, size, mTransform); |
121 | FlattenableUtils::write(buffer, size, mScalingMode); | 139 | writeAligned(buffer, size, mScalingMode); |
122 | FlattenableUtils::write(buffer, size, mTimestamp); | 140 | writeAligned(buffer, size, mTimestamp); |
123 | FlattenableUtils::write(buffer, size, mIsAutoTimestamp); | 141 | writeAligned(buffer, size, mIsAutoTimestamp); |
124 | FlattenableUtils::write(buffer, size, mDataSpace); | 142 | writeAligned(buffer, size, mDataSpace); |
125 | FlattenableUtils::write(buffer, size, mFrameNumber); | 143 | writeAligned(buffer, size, mFrameNumber); |
126 | FlattenableUtils::write(buffer, size, mSlot); | 144 | writeAligned(buffer, size, mSlot); |
127 | FlattenableUtils::write(buffer, size, mIsDroppable); | 145 | writeAligned(buffer, size, mIsDroppable); |
128 | FlattenableUtils::write(buffer, size, mAcquireCalled); | 146 | writeAligned(buffer, size, mAcquireCalled); |
129 | FlattenableUtils::write(buffer, size, mTransformToDisplayInverse); | 147 | writeAligned(buffer, size, mTransformToDisplayInverse); |
130 | 148 | ||
131 | return NO_ERROR; | 149 | return NO_ERROR; |
132 | } | 150 | } |
133 | 151 | ||
152 | template <typename T> | ||
153 | static void readAligned(const void*& buffer, size_t& size, T& value) { | ||
154 | size -= FlattenableUtils::align<alignof(T)>(buffer); | ||
155 | FlattenableUtils::read(buffer, size, value); | ||
156 | } | ||
157 | |||
134 | status_t BufferItem::unflatten( | 158 | status_t BufferItem::unflatten( |
135 | void const*& buffer, size_t& size, int const*& fds, size_t& count) { | 159 | void const*& buffer, size_t& size, int const*& fds, size_t& count) { |
136 | 160 | ||
137 | if (size < sizeof(uint32_t)) | 161 | if (size < sizeof(uint32_t)) { |
138 | return NO_MEMORY; | 162 | return NO_MEMORY; |
163 | } | ||
139 | 164 | ||
140 | uint32_t flags = 0; | 165 | uint32_t flags = 0; |
141 | FlattenableUtils::read(buffer, size, flags); | 166 | FlattenableUtils::read(buffer, size, flags); |
@@ -153,26 +178,30 @@ status_t BufferItem::unflatten( | |||
153 | if (err) return err; | 178 | if (err) return err; |
154 | size -= FlattenableUtils::align<4>(buffer); | 179 | size -= FlattenableUtils::align<4>(buffer); |
155 | } | 180 | } |
181 | |||
156 | status_t err = mSurfaceDamage.unflatten(buffer, size); | 182 | status_t err = mSurfaceDamage.unflatten(buffer, size); |
157 | if (err) return err; | 183 | if (err) return err; |
158 | size -= FlattenableUtils::align<4>(buffer); | 184 | FlattenableUtils::advance(buffer, size, mSurfaceDamage.getFlattenedSize()); |
185 | |||
186 | // Must align<8> so that getPodSize returns the correct value | ||
187 | size -= FlattenableUtils::align<8>(buffer); | ||
159 | 188 | ||
160 | // check we have enough space | 189 | // Check we still have enough space |
161 | if (size < getPodSize()) { | 190 | if (size < getPodSize()) { |
162 | return NO_MEMORY; | 191 | return NO_MEMORY; |
163 | } | 192 | } |
164 | 193 | ||
165 | FlattenableUtils::read(buffer, size, mCrop); | 194 | readAligned(buffer, size, mCrop); |
166 | FlattenableUtils::read(buffer, size, mTransform); | 195 | readAligned(buffer, size, mTransform); |
167 | FlattenableUtils::read(buffer, size, mScalingMode); | 196 | readAligned(buffer, size, mScalingMode); |
168 | FlattenableUtils::read(buffer, size, mTimestamp); | 197 | readAligned(buffer, size, mTimestamp); |
169 | FlattenableUtils::read(buffer, size, mIsAutoTimestamp); | 198 | readAligned(buffer, size, mIsAutoTimestamp); |
170 | FlattenableUtils::read(buffer, size, mDataSpace); | 199 | readAligned(buffer, size, mDataSpace); |
171 | FlattenableUtils::read(buffer, size, mFrameNumber); | 200 | readAligned(buffer, size, mFrameNumber); |
172 | FlattenableUtils::read(buffer, size, mSlot); | 201 | readAligned(buffer, size, mSlot); |
173 | FlattenableUtils::read(buffer, size, mIsDroppable); | 202 | readAligned(buffer, size, mIsDroppable); |
174 | FlattenableUtils::read(buffer, size, mAcquireCalled); | 203 | readAligned(buffer, size, mAcquireCalled); |
175 | FlattenableUtils::read(buffer, size, mTransformToDisplayInverse); | 204 | readAligned(buffer, size, mTransformToDisplayInverse); |
176 | 205 | ||
177 | return NO_ERROR; | 206 | return NO_ERROR; |
178 | } | 207 | } |
diff --git a/libs/ui/GraphicBuffer.cpp b/libs/ui/GraphicBuffer.cpp index 638ac6299..52fa0df0b 100644 --- a/libs/ui/GraphicBuffer.cpp +++ b/libs/ui/GraphicBuffer.cpp | |||
@@ -303,7 +303,7 @@ status_t GraphicBuffer::flatten(void*& buffer, size_t& size, int*& fds, size_t& | |||
303 | static_cast<size_t>(handle->numInts) * sizeof(int)); | 303 | static_cast<size_t>(handle->numInts) * sizeof(int)); |
304 | } | 304 | } |
305 | 305 | ||
306 | buffer = reinterpret_cast<void*>(static_cast<int*>(buffer) + sizeNeeded); | 306 | buffer = static_cast<void*>(static_cast<uint8_t*>(buffer) + sizeNeeded); |
307 | size -= sizeNeeded; | 307 | size -= sizeNeeded; |
308 | if (handle) { | 308 | if (handle) { |
309 | fds += handle->numFds; | 309 | fds += handle->numFds; |
@@ -385,7 +385,7 @@ status_t GraphicBuffer::unflatten( | |||
385 | } | 385 | } |
386 | } | 386 | } |
387 | 387 | ||
388 | buffer = reinterpret_cast<void const*>(static_cast<int const*>(buffer) + sizeNeeded); | 388 | buffer = static_cast<void const*>(static_cast<uint8_t const*>(buffer) + sizeNeeded); |
389 | size -= sizeNeeded; | 389 | size -= sizeNeeded; |
390 | fds += numFds; | 390 | fds += numFds; |
391 | count -= numFds; | 391 | count -= numFds; |