1 /* 2 * Copyright 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_COMMAND_BUFFER_H 18 #define ANDROID_HARDWARE_GRAPHICS_COMPOSER_COMMAND_BUFFER_H 19 20 #ifndef LOG_TAG 21 #warn "IComposerCommandBuffer.h included without LOG_TAG" 22 #endif 23 24 #undef LOG_NDEBUG 25 #define LOG_NDEBUG 0 26 27 #include <algorithm> 28 #include <limits> 29 #include <memory> 30 #include <vector> 31 32 #include <inttypes.h> 33 #include <string.h> 34 35 #include <android/hardware/graphics/composer/2.1/IComposer.h> 36 #include <log/log.h> 37 #include <sync/sync.h> 38 #include <fmq/MessageQueue.h> 39 40 namespace android { 41 namespace hardware { 42 namespace graphics { 43 namespace composer { 44 namespace V2_1 { 45 46 using android::hardware::graphics::common::V1_0::ColorTransform; 47 using android::hardware::graphics::common::V1_0::Dataspace; 48 using android::hardware::graphics::common::V1_0::Transform; 49 using android::hardware::MessageQueue; 50 51 using CommandQueueType = MessageQueue<uint32_t, kSynchronizedReadWrite>; 52 53 // This class helps build a command queue. Note that all sizes/lengths are in 54 // units of uint32_t's. 55 class CommandWriterBase { 56 public: 57 CommandWriterBase(uint32_t initialMaxSize) 58 : mDataMaxSize(initialMaxSize) 59 { 60 mData = std::make_unique<uint32_t[]>(mDataMaxSize); 61 reset(); 62 } 63 64 virtual ~CommandWriterBase() 65 { 66 reset(); 67 } 68 69 void reset() 70 { 71 mDataWritten = 0; 72 mCommandEnd = 0; 73 74 // handles in mDataHandles are owned by the caller 75 mDataHandles.clear(); 76 77 // handles in mTemporaryHandles are owned by the writer 78 for (auto handle : mTemporaryHandles) { 79 native_handle_close(handle); 80 native_handle_delete(handle); 81 } 82 mTemporaryHandles.clear(); 83 } 84 85 IComposerClient::Command getCommand(uint32_t offset) 86 { 87 uint32_t val = (offset < mDataWritten) ? mData[offset] : 0; 88 return static_cast<IComposerClient::Command>(val & 89 static_cast<uint32_t>(IComposerClient::Command::OPCODE_MASK)); 90 } 91 92 bool writeQueue(bool* outQueueChanged, uint32_t* outCommandLength, 93 hidl_vec<hidl_handle>* outCommandHandles) 94 { 95 // After data are written to the queue, it may not be read by the 96 // remote reader when 97 // 98 // - the writer does not send them (because of other errors) 99 // - the hwbinder transaction fails 100 // - the reader does not read them (because of other errors) 101 // 102 // Discard the stale data here. 103 size_t staleDataSize = mQueue ? mQueue->availableToRead() : 0; 104 if (staleDataSize > 0) { 105 ALOGW("discarding stale data from message queue"); 106 CommandQueueType::MemTransaction tx; 107 if (mQueue->beginRead(staleDataSize, &tx)) { 108 mQueue->commitRead(staleDataSize); 109 } 110 } 111 112 // write data to queue, optionally resizing it 113 if (mQueue && (mDataMaxSize <= mQueue->getQuantumCount())) { 114 if (!mQueue->write(mData.get(), mDataWritten)) { 115 ALOGE("failed to write commands to message queue"); 116 return false; 117 } 118 119 *outQueueChanged = false; 120 } else { 121 auto newQueue = std::make_unique<CommandQueueType>(mDataMaxSize); 122 if (!newQueue->isValid() || 123 !newQueue->write(mData.get(), mDataWritten)) { 124 ALOGE("failed to prepare a new message queue "); 125 return false; 126 } 127 128 mQueue = std::move(newQueue); 129 *outQueueChanged = true; 130 } 131 132 *outCommandLength = mDataWritten; 133 outCommandHandles->setToExternal( 134 const_cast<hidl_handle*>(mDataHandles.data()), 135 mDataHandles.size()); 136 137 return true; 138 } 139 140 const MQDescriptorSync<uint32_t>* getMQDescriptor() const 141 { 142 return (mQueue) ? mQueue->getDesc() : nullptr; 143 } 144 145 static constexpr uint16_t kSelectDisplayLength = 2; 146 void selectDisplay(Display display) 147 { 148 beginCommand(IComposerClient::Command::SELECT_DISPLAY, 149 kSelectDisplayLength); 150 write64(display); 151 endCommand(); 152 } 153 154 static constexpr uint16_t kSelectLayerLength = 2; 155 void selectLayer(Layer layer) 156 { 157 beginCommand(IComposerClient::Command::SELECT_LAYER, 158 kSelectLayerLength); 159 write64(layer); 160 endCommand(); 161 } 162 163 static constexpr uint16_t kSetErrorLength = 2; 164 void setError(uint32_t location, Error error) 165 { 166 beginCommand(IComposerClient::Command::SET_ERROR, kSetErrorLength); 167 write(location); 168 writeSigned(static_cast<int32_t>(error)); 169 endCommand(); 170 } 171 172 static constexpr uint32_t kPresentOrValidateDisplayResultLength = 1; 173 void setPresentOrValidateResult(uint32_t state) { 174 beginCommand(IComposerClient::Command::SET_PRESENT_OR_VALIDATE_DISPLAY_RESULT, kPresentOrValidateDisplayResultLength); 175 write(state); 176 endCommand(); 177 } 178 179 void setChangedCompositionTypes(const std::vector<Layer>& layers, 180 const std::vector<IComposerClient::Composition>& types) 181 { 182 size_t totalLayers = std::min(layers.size(), types.size()); 183 size_t currentLayer = 0; 184 185 while (currentLayer < totalLayers) { 186 size_t count = std::min(totalLayers - currentLayer, 187 static_cast<size_t>(kMaxLength) / 3); 188 189 beginCommand( 190 IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES, 191 count * 3); 192 for (size_t i = 0; i < count; i++) { 193 write64(layers[currentLayer + i]); 194 writeSigned(static_cast<int32_t>(types[currentLayer + i])); 195 } 196 endCommand(); 197 198 currentLayer += count; 199 } 200 } 201 202 void setDisplayRequests(uint32_t displayRequestMask, 203 const std::vector<Layer>& layers, 204 const std::vector<uint32_t>& layerRequestMasks) 205 { 206 size_t totalLayers = std::min(layers.size(), 207 layerRequestMasks.size()); 208 size_t currentLayer = 0; 209 210 while (currentLayer < totalLayers) { 211 size_t count = std::min(totalLayers - currentLayer, 212 static_cast<size_t>(kMaxLength - 1) / 3); 213 214 beginCommand(IComposerClient::Command::SET_DISPLAY_REQUESTS, 215 1 + count * 3); 216 write(displayRequestMask); 217 for (size_t i = 0; i < count; i++) { 218 write64(layers[currentLayer + i]); 219 write(static_cast<int32_t>(layerRequestMasks[currentLayer + i])); 220 } 221 endCommand(); 222 223 currentLayer += count; 224 } 225 } 226 227 static constexpr uint16_t kSetPresentFenceLength = 1; 228 void setPresentFence(int presentFence) 229 { 230 beginCommand(IComposerClient::Command::SET_PRESENT_FENCE, 231 kSetPresentFenceLength); 232 writeFence(presentFence); 233 endCommand(); 234 } 235 236 void setReleaseFences(const std::vector<Layer>& layers, 237 const std::vector<int>& releaseFences) 238 { 239 size_t totalLayers = std::min(layers.size(), releaseFences.size()); 240 size_t currentLayer = 0; 241 242 while (currentLayer < totalLayers) { 243 size_t count = std::min(totalLayers - currentLayer, 244 static_cast<size_t>(kMaxLength) / 3); 245 246 beginCommand(IComposerClient::Command::SET_RELEASE_FENCES, 247 count * 3); 248 for (size_t i = 0; i < count; i++) { 249 write64(layers[currentLayer + i]); 250 writeFence(releaseFences[currentLayer + i]); 251 } 252 endCommand(); 253 254 currentLayer += count; 255 } 256 } 257 258 static constexpr uint16_t kSetColorTransformLength = 17; 259 void setColorTransform(const float* matrix, ColorTransform hint) 260 { 261 beginCommand(IComposerClient::Command::SET_COLOR_TRANSFORM, 262 kSetColorTransformLength); 263 for (int i = 0; i < 16; i++) { 264 writeFloat(matrix[i]); 265 } 266 writeSigned(static_cast<int32_t>(hint)); 267 endCommand(); 268 } 269 270 void setClientTarget(uint32_t slot, const native_handle_t* target, 271 int acquireFence, Dataspace dataspace, 272 const std::vector<IComposerClient::Rect>& damage) 273 { 274 bool doWrite = (damage.size() <= (kMaxLength - 4) / 4); 275 size_t length = 4 + ((doWrite) ? damage.size() * 4 : 0); 276 277 beginCommand(IComposerClient::Command::SET_CLIENT_TARGET, length); 278 write(slot); 279 writeHandle(target, true); 280 writeFence(acquireFence); 281 writeSigned(static_cast<int32_t>(dataspace)); 282 // When there are too many rectangles in the damage region and doWrite 283 // is false, we write no rectangle at all which means the entire 284 // client target is damaged. 285 if (doWrite) { 286 writeRegion(damage); 287 } 288 endCommand(); 289 } 290 291 static constexpr uint16_t kSetOutputBufferLength = 3; 292 void setOutputBuffer(uint32_t slot, const native_handle_t* buffer, 293 int releaseFence) 294 { 295 beginCommand(IComposerClient::Command::SET_OUTPUT_BUFFER, 296 kSetOutputBufferLength); 297 write(slot); 298 writeHandle(buffer, true); 299 writeFence(releaseFence); 300 endCommand(); 301 } 302 303 static constexpr uint16_t kValidateDisplayLength = 0; 304 void validateDisplay() 305 { 306 beginCommand(IComposerClient::Command::VALIDATE_DISPLAY, 307 kValidateDisplayLength); 308 endCommand(); 309 } 310 311 static constexpr uint16_t kPresentOrValidateDisplayLength = 0; 312 void presentOrvalidateDisplay() 313 { 314 beginCommand(IComposerClient::Command::PRESENT_OR_VALIDATE_DISPLAY, 315 kPresentOrValidateDisplayLength); 316 endCommand(); 317 } 318 319 static constexpr uint16_t kAcceptDisplayChangesLength = 0; 320 void acceptDisplayChanges() 321 { 322 beginCommand(IComposerClient::Command::ACCEPT_DISPLAY_CHANGES, 323 kAcceptDisplayChangesLength); 324 endCommand(); 325 } 326 327 static constexpr uint16_t kPresentDisplayLength = 0; 328 void presentDisplay() 329 { 330 beginCommand(IComposerClient::Command::PRESENT_DISPLAY, 331 kPresentDisplayLength); 332 endCommand(); 333 } 334 335 static constexpr uint16_t kSetLayerCursorPositionLength = 2; 336 void setLayerCursorPosition(int32_t x, int32_t y) 337 { 338 beginCommand(IComposerClient::Command::SET_LAYER_CURSOR_POSITION, 339 kSetLayerCursorPositionLength); 340 writeSigned(x); 341 writeSigned(y); 342 endCommand(); 343 } 344 345 static constexpr uint16_t kSetLayerBufferLength = 3; 346 void setLayerBuffer(uint32_t slot, const native_handle_t* buffer, 347 int acquireFence) 348 { 349 beginCommand(IComposerClient::Command::SET_LAYER_BUFFER, 350 kSetLayerBufferLength); 351 write(slot); 352 writeHandle(buffer, true); 353 writeFence(acquireFence); 354 endCommand(); 355 } 356 357 void setLayerSurfaceDamage( 358 const std::vector<IComposerClient::Rect>& damage) 359 { 360 bool doWrite = (damage.size() <= kMaxLength / 4); 361 size_t length = (doWrite) ? damage.size() * 4 : 0; 362 363 beginCommand(IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE, 364 length); 365 // When there are too many rectangles in the damage region and doWrite 366 // is false, we write no rectangle at all which means the entire 367 // layer is damaged. 368 if (doWrite) { 369 writeRegion(damage); 370 } 371 endCommand(); 372 } 373 374 static constexpr uint16_t kSetLayerBlendModeLength = 1; 375 void setLayerBlendMode(IComposerClient::BlendMode mode) 376 { 377 beginCommand(IComposerClient::Command::SET_LAYER_BLEND_MODE, 378 kSetLayerBlendModeLength); 379 writeSigned(static_cast<int32_t>(mode)); 380 endCommand(); 381 } 382 383 static constexpr uint16_t kSetLayerColorLength = 1; 384 void setLayerColor(IComposerClient::Color color) 385 { 386 beginCommand(IComposerClient::Command::SET_LAYER_COLOR, 387 kSetLayerColorLength); 388 writeColor(color); 389 endCommand(); 390 } 391 392 static constexpr uint16_t kSetLayerCompositionTypeLength = 1; 393 void setLayerCompositionType(IComposerClient::Composition type) 394 { 395 beginCommand(IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE, 396 kSetLayerCompositionTypeLength); 397 writeSigned(static_cast<int32_t>(type)); 398 endCommand(); 399 } 400 401 static constexpr uint16_t kSetLayerDataspaceLength = 1; 402 void setLayerDataspace(Dataspace dataspace) 403 { 404 beginCommand(IComposerClient::Command::SET_LAYER_DATASPACE, 405 kSetLayerDataspaceLength); 406 writeSigned(static_cast<int32_t>(dataspace)); 407 endCommand(); 408 } 409 410 static constexpr uint16_t kSetLayerDisplayFrameLength = 4; 411 void setLayerDisplayFrame(const IComposerClient::Rect& frame) 412 { 413 beginCommand(IComposerClient::Command::SET_LAYER_DISPLAY_FRAME, 414 kSetLayerDisplayFrameLength); 415 writeRect(frame); 416 endCommand(); 417 } 418 419 static constexpr uint16_t kSetLayerPlaneAlphaLength = 1; 420 void setLayerPlaneAlpha(float alpha) 421 { 422 beginCommand(IComposerClient::Command::SET_LAYER_PLANE_ALPHA, 423 kSetLayerPlaneAlphaLength); 424 writeFloat(alpha); 425 endCommand(); 426 } 427 428 static constexpr uint16_t kSetLayerSidebandStreamLength = 1; 429 void setLayerSidebandStream(const native_handle_t* stream) 430 { 431 beginCommand(IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM, 432 kSetLayerSidebandStreamLength); 433 writeHandle(stream); 434 endCommand(); 435 } 436 437 static constexpr uint16_t kSetLayerSourceCropLength = 4; 438 void setLayerSourceCrop(const IComposerClient::FRect& crop) 439 { 440 beginCommand(IComposerClient::Command::SET_LAYER_SOURCE_CROP, 441 kSetLayerSourceCropLength); 442 writeFRect(crop); 443 endCommand(); 444 } 445 446 static constexpr uint16_t kSetLayerTransformLength = 1; 447 void setLayerTransform(Transform transform) 448 { 449 beginCommand(IComposerClient::Command::SET_LAYER_TRANSFORM, 450 kSetLayerTransformLength); 451 writeSigned(static_cast<int32_t>(transform)); 452 endCommand(); 453 } 454 455 void setLayerVisibleRegion( 456 const std::vector<IComposerClient::Rect>& visible) 457 { 458 bool doWrite = (visible.size() <= kMaxLength / 4); 459 size_t length = (doWrite) ? visible.size() * 4 : 0; 460 461 beginCommand(IComposerClient::Command::SET_LAYER_VISIBLE_REGION, 462 length); 463 // When there are too many rectangles in the visible region and 464 // doWrite is false, we write no rectangle at all which means the 465 // entire layer is visible. 466 if (doWrite) { 467 writeRegion(visible); 468 } 469 endCommand(); 470 } 471 472 static constexpr uint16_t kSetLayerZOrderLength = 1; 473 void setLayerZOrder(uint32_t z) 474 { 475 beginCommand(IComposerClient::Command::SET_LAYER_Z_ORDER, 476 kSetLayerZOrderLength); 477 write(z); 478 endCommand(); 479 } 480 481 protected: 482 void beginCommand(IComposerClient::Command command, uint16_t length) 483 { 484 if (mCommandEnd) { 485 LOG_FATAL("endCommand was not called before command 0x%x", 486 command); 487 } 488 489 growData(1 + length); 490 write(static_cast<uint32_t>(command) | length); 491 492 mCommandEnd = mDataWritten + length; 493 } 494 495 void endCommand() 496 { 497 if (!mCommandEnd) { 498 LOG_FATAL("beginCommand was not called"); 499 } else if (mDataWritten > mCommandEnd) { 500 LOG_FATAL("too much data written"); 501 mDataWritten = mCommandEnd; 502 } else if (mDataWritten < mCommandEnd) { 503 LOG_FATAL("too little data written"); 504 while (mDataWritten < mCommandEnd) { 505 write(0); 506 } 507 } 508 509 mCommandEnd = 0; 510 } 511 512 void write(uint32_t val) 513 { 514 mData[mDataWritten++] = val; 515 } 516 517 void writeSigned(int32_t val) 518 { 519 memcpy(&mData[mDataWritten++], &val, sizeof(val)); 520 } 521 522 void writeFloat(float val) 523 { 524 memcpy(&mData[mDataWritten++], &val, sizeof(val)); 525 } 526 527 void write64(uint64_t val) 528 { 529 uint32_t lo = static_cast<uint32_t>(val & 0xffffffff); 530 uint32_t hi = static_cast<uint32_t>(val >> 32); 531 write(lo); 532 write(hi); 533 } 534 535 void writeRect(const IComposerClient::Rect& rect) 536 { 537 writeSigned(rect.left); 538 writeSigned(rect.top); 539 writeSigned(rect.right); 540 writeSigned(rect.bottom); 541 } 542 543 void writeRegion(const std::vector<IComposerClient::Rect>& region) 544 { 545 for (const auto& rect : region) { 546 writeRect(rect); 547 } 548 } 549 550 void writeFRect(const IComposerClient::FRect& rect) 551 { 552 writeFloat(rect.left); 553 writeFloat(rect.top); 554 writeFloat(rect.right); 555 writeFloat(rect.bottom); 556 } 557 558 void writeColor(const IComposerClient::Color& color) 559 { 560 write((color.r << 0) | 561 (color.g << 8) | 562 (color.b << 16) | 563 (color.a << 24)); 564 } 565 566 // ownership of handle is not transferred 567 void writeHandle(const native_handle_t* handle, bool useCache) 568 { 569 if (!handle) { 570 writeSigned(static_cast<int32_t>((useCache) ? 571 IComposerClient::HandleIndex::CACHED : 572 IComposerClient::HandleIndex::EMPTY)); 573 return; 574 } 575 576 mDataHandles.push_back(handle); 577 writeSigned(mDataHandles.size() - 1); 578 } 579 580 void writeHandle(const native_handle_t* handle) 581 { 582 writeHandle(handle, false); 583 } 584 585 // ownership of fence is transferred 586 void writeFence(int fence) 587 { 588 native_handle_t* handle = nullptr; 589 if (fence >= 0) { 590 handle = getTemporaryHandle(1, 0); 591 if (handle) { 592 handle->data[0] = fence; 593 } else { 594 ALOGW("failed to get temporary handle for fence %d", fence); 595 sync_wait(fence, -1); 596 close(fence); 597 } 598 } 599 600 writeHandle(handle); 601 } 602 603 native_handle_t* getTemporaryHandle(int numFds, int numInts) 604 { 605 native_handle_t* handle = native_handle_create(numFds, numInts); 606 if (handle) { 607 mTemporaryHandles.push_back(handle); 608 } 609 return handle; 610 } 611 612 static constexpr uint16_t kMaxLength = 613 std::numeric_limits<uint16_t>::max(); 614 615 private: 616 void growData(uint32_t grow) 617 { 618 uint32_t newWritten = mDataWritten + grow; 619 if (newWritten < mDataWritten) { 620 LOG_ALWAYS_FATAL("buffer overflowed; data written %" PRIu32 621 ", growing by %" PRIu32, mDataWritten, grow); 622 } 623 624 if (newWritten <= mDataMaxSize) { 625 return; 626 } 627 628 uint32_t newMaxSize = mDataMaxSize << 1; 629 if (newMaxSize < newWritten) { 630 newMaxSize = newWritten; 631 } 632 633 auto newData = std::make_unique<uint32_t[]>(newMaxSize); 634 std::copy_n(mData.get(), mDataWritten, newData.get()); 635 mDataMaxSize = newMaxSize; 636 mData = std::move(newData); 637 } 638 639 uint32_t mDataMaxSize; 640 std::unique_ptr<uint32_t[]> mData; 641 642 uint32_t mDataWritten; 643 // end offset of the current command 644 uint32_t mCommandEnd; 645 646 std::vector<hidl_handle> mDataHandles; 647 std::vector<native_handle_t *> mTemporaryHandles; 648 649 std::unique_ptr<CommandQueueType> mQueue; 650 }; 651 652 // This class helps parse a command queue. Note that all sizes/lengths are in 653 // units of uint32_t's. 654 class CommandReaderBase { 655 public: 656 CommandReaderBase() : mDataMaxSize(0) 657 { 658 reset(); 659 } 660 661 bool setMQDescriptor(const MQDescriptorSync<uint32_t>& descriptor) 662 { 663 mQueue = std::make_unique<CommandQueueType>(descriptor, false); 664 if (mQueue->isValid()) { 665 return true; 666 } else { 667 mQueue = nullptr; 668 return false; 669 } 670 } 671 672 bool readQueue(uint32_t commandLength, 673 const hidl_vec<hidl_handle>& commandHandles) 674 { 675 if (!mQueue) { 676 return false; 677 } 678 679 auto quantumCount = mQueue->getQuantumCount(); 680 if (mDataMaxSize < quantumCount) { 681 mDataMaxSize = quantumCount; 682 mData = std::make_unique<uint32_t[]>(mDataMaxSize); 683 } 684 685 if (commandLength > mDataMaxSize || 686 !mQueue->read(mData.get(), commandLength)) { 687 ALOGE("failed to read commands from message queue"); 688 return false; 689 } 690 691 mDataSize = commandLength; 692 mDataRead = 0; 693 mCommandBegin = 0; 694 mCommandEnd = 0; 695 mDataHandles.setToExternal( 696 const_cast<hidl_handle*>(commandHandles.data()), 697 commandHandles.size()); 698 699 return true; 700 } 701 702 void reset() 703 { 704 mDataSize = 0; 705 mDataRead = 0; 706 mCommandBegin = 0; 707 mCommandEnd = 0; 708 mDataHandles.setToExternal(nullptr, 0); 709 } 710 711 protected: 712 bool isEmpty() const 713 { 714 return (mDataRead >= mDataSize); 715 } 716 717 bool beginCommand(IComposerClient::Command* outCommand, 718 uint16_t* outLength) 719 { 720 if (mCommandEnd) { 721 LOG_FATAL("endCommand was not called for last command"); 722 } 723 724 constexpr uint32_t opcode_mask = 725 static_cast<uint32_t>(IComposerClient::Command::OPCODE_MASK); 726 constexpr uint32_t length_mask = 727 static_cast<uint32_t>(IComposerClient::Command::LENGTH_MASK); 728 729 uint32_t val = read(); 730 *outCommand = static_cast<IComposerClient::Command>( 731 val & opcode_mask); 732 *outLength = static_cast<uint16_t>(val & length_mask); 733 734 if (mDataRead + *outLength > mDataSize) { 735 ALOGE("command 0x%x has invalid command length %" PRIu16, 736 *outCommand, *outLength); 737 // undo the read() above 738 mDataRead--; 739 return false; 740 } 741 742 mCommandEnd = mDataRead + *outLength; 743 744 return true; 745 } 746 747 void endCommand() 748 { 749 if (!mCommandEnd) { 750 LOG_FATAL("beginCommand was not called"); 751 } else if (mDataRead > mCommandEnd) { 752 LOG_FATAL("too much data read"); 753 mDataRead = mCommandEnd; 754 } else if (mDataRead < mCommandEnd) { 755 LOG_FATAL("too little data read"); 756 mDataRead = mCommandEnd; 757 } 758 759 mCommandBegin = mCommandEnd; 760 mCommandEnd = 0; 761 } 762 763 uint32_t getCommandLoc() const 764 { 765 return mCommandBegin; 766 } 767 768 uint32_t read() 769 { 770 return mData[mDataRead++]; 771 } 772 773 int32_t readSigned() 774 { 775 int32_t val; 776 memcpy(&val, &mData[mDataRead++], sizeof(val)); 777 return val; 778 } 779 780 float readFloat() 781 { 782 float val; 783 memcpy(&val, &mData[mDataRead++], sizeof(val)); 784 return val; 785 } 786 787 uint64_t read64() 788 { 789 uint32_t lo = read(); 790 uint32_t hi = read(); 791 return (static_cast<uint64_t>(hi) << 32) | lo; 792 } 793 794 IComposerClient::Color readColor() 795 { 796 uint32_t val = read(); 797 return IComposerClient::Color{ 798 static_cast<uint8_t>((val >> 0) & 0xff), 799 static_cast<uint8_t>((val >> 8) & 0xff), 800 static_cast<uint8_t>((val >> 16) & 0xff), 801 static_cast<uint8_t>((val >> 24) & 0xff), 802 }; 803 } 804 805 // ownership of handle is not transferred 806 const native_handle_t* readHandle(bool* outUseCache) 807 { 808 const native_handle_t* handle = nullptr; 809 810 int32_t index = readSigned(); 811 switch (index) { 812 case static_cast<int32_t>(IComposerClient::HandleIndex::EMPTY): 813 *outUseCache = false; 814 break; 815 case static_cast<int32_t>(IComposerClient::HandleIndex::CACHED): 816 *outUseCache = true; 817 break; 818 default: 819 if (static_cast<size_t>(index) < mDataHandles.size()) { 820 handle = mDataHandles[index].getNativeHandle(); 821 } else { 822 ALOGE("invalid handle index %zu", static_cast<size_t>(index)); 823 } 824 *outUseCache = false; 825 break; 826 } 827 828 return handle; 829 } 830 831 const native_handle_t* readHandle() 832 { 833 bool useCache; 834 return readHandle(&useCache); 835 } 836 837 // ownership of fence is transferred 838 int readFence() 839 { 840 auto handle = readHandle(); 841 if (!handle || handle->numFds == 0) { 842 return -1; 843 } 844 845 if (handle->numFds != 1) { 846 ALOGE("invalid fence handle with %d fds", handle->numFds); 847 return -1; 848 } 849 850 int fd = dup(handle->data[0]); 851 if (fd < 0) { 852 ALOGW("failed to dup fence %d", handle->data[0]); 853 sync_wait(handle->data[0], -1); 854 fd = -1; 855 } 856 857 return fd; 858 } 859 860 private: 861 std::unique_ptr<CommandQueueType> mQueue; 862 uint32_t mDataMaxSize; 863 std::unique_ptr<uint32_t[]> mData; 864 865 uint32_t mDataSize; 866 uint32_t mDataRead; 867 868 // begin/end offsets of the current command 869 uint32_t mCommandBegin; 870 uint32_t mCommandEnd; 871 872 hidl_vec<hidl_handle> mDataHandles; 873 }; 874 875 } // namespace V2_1 876 } // namespace composer 877 } // namespace graphics 878 } // namespace hardware 879 } // namespace android 880 881 #endif // ANDROID_HARDWARE_GRAPHICS_COMPOSER_COMMAND_BUFFER_H 882
