summaryrefslogtreecommitdiffstats
path: root/libs
diff options
context:
space:
mode:
authorDan Stoza2015-04-23 17:51:00 -0500
committerGerrit Code Review2015-04-23 17:51:01 -0500
commit82e4d49b0ecb205d49f02cc07496f7508c56443c (patch)
tree7f08cfdcf37afa58b2a42ee341a0e6a336855b08 /libs
parentde5c15b8bd12143829d043fa4ab457600e5682b3 (diff)
parenteea6d682b8b0f7081f0fe8fab8feadb16e22b30b (diff)
downloadframeworks-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.cpp133
-rw-r--r--libs/ui/GraphicBuffer.cpp4
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
40BufferItem::~BufferItem() {} 40BufferItem::~BufferItem() {}
41 41
42template <typename T>
43static void addAligned(size_t& size, T /* value */) {
44 size = FlattenableUtils::align<sizeof(T)>(size);
45 size += sizeof(T);
46}
47
42size_t BufferItem::getPodSize() const { 48size_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
57size_t BufferItem::getFlattenedSize() const { 65size_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
72size_t BufferItem::getFdCount() const { 80size_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
91template <typename T>
92static 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
83status_t BufferItem::flatten( 97status_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
152template <typename T>
153static 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
134status_t BufferItem::unflatten( 158status_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;