Concernant la synchronisation des composants Layer et la problématique de la réduction de la bande passante GPU

Cet article partage principalement un article sur la synchronisation des composants Layer et la question de la réduction de la bande passante GPU. Il a une bonne valeur de référence et j'espère qu'il sera utile à tout le monde. Suivons l’éditeur et jetons un coup d’œil.

Questions :

1) Les calques peuvent-ils être mis à jour indépendamment, par exemple comment optimiser la scène de la barre d'état qui apparaît sur le calque vidéo

Idée initiale ; de chaque Mettez uniquement à jour la couche vidéo à ce moment-là ou contournez la couche vidéo pour le traitement par BQ.

2) Traitement commun de la couche vidéo par FW et GPU

3) Compréhension de plusieurs variables

(1) mCurrentTexture, nextTextureImage ; (2) BufferItem, BufferQueue, mslots; slot, mqueuedframe, mqueuedItem;

(3) syncForReleaseLocked, updateAndReleaseLocked, releaseBufferLocked, releaseBuffer

(4)

/ acquireBuffer attempts to acquire ownership of the next pending buffer in the BufferQueue.
      // If no buffer is pending then it returns NO_BUFFER_AVAILABLE. If a buffer is successfully
      // acquired, the information about the buffer is returned in BufferItem.
      //
      // If the buffer returned had previously been acquired then the BufferItem::mGraphicBuffer field
      // of buffer is set to NULL and it is assumed that the consumer still holds a reference to the
      // buffer.
      //
      // If presentWhen is non-zero, it indicates the time when the buffer will be displayed on
      // screen. If the buffer's timestamp is farther in the future, the buffer won't be acquired, and
      // PRESENT_LATER will be returned. The presentation time is in nanoseconds, and the time base
      // is CLOCK_MONOTONIC.
      //
      // If maxFrameNumber is non-zero, it indicates that acquireBuffer should only return a buffer
      // with a frame number less than or equal to maxFrameNumber. If no such frame is available
      // (such as when a buffer has been replaced but the consumer has not received the
      // onFrameReplaced callback), then PRESENT_LATER will be returned.
      //
      // Return of NO_ERROR means the operation completed as normal.
      //
      // Return of a positive value means the operation could not be completed at this time, but the
      // user should try again later:
      // * NO_BUFFER_AVAILABLE - no buffer is pending (nothing queued by producer)
      // * PRESENT_LATER - the buffer's timestamp is farther in the future
      //
      // Return of a negative value means an error has occurred:
      // * INVALID_OPERATION - too many buffers have been acquired

(5) La différence entre mslots, mframe et mframenumber

  // Returned by releaseBuffer, after which the consumer must free any references to the
            // just-released buffer that it might have.
            STALE_BUFFER_SLOT = 1,
          // Returned by dequeueBuffer if there are no pending buffers available.
          NO_BUFFER_AVAILABLE,
          // Returned by dequeueBuffer if it's too early for the buffer to be acquired.
          PRESENT_LATER,

(6) La logique de onframavailable et latchbuffer, rejet, updateteximage,.

Parmi eux updateteximage;

(7) La différence entre bufferitem et mslots

(8) La différence entre bufferqueueconsumer et bufferitemconsumer; (9) acquirebuffer La logique de clôture, d'où vient fencefd

Définitions d'interface liées à la clôture, voir ui/Fence.h

(10)

 status_t Fence::waitForever(const char* logname) {64      ATRACE_CALL();
      if (mFenceFd == -1) {
          return NO_ERROR;
      }
      int warningTimeout = 3000;
      int err = sync_wait(mFenceFd, warningTimeout);
      if (err < 0 && errno == ETIME) {
          ALOGE("%s: fence %d didn&#39;t signal in %u ms", logname, mFenceFd,
                  warningTimeout);
          err = sync_wait(mFenceFd, TIMEOUT_NEVER);
      }
      return err < 0 ? -errno : status_t(NO_ERROR);
  }

  struct EglSlot {
           EglSlot() : mEglFence(EGL_NO_SYNC_KHR) {}
            // mEglImage is the EGLImage created from mGraphicBuffer.
            sp<EglImage> mEglImage;
           // mFence is the EGL sync object that must signal before the buffer
            // associated with this buffer slot may be dequeued. It is initialized
            // to EGL_NO_SYNC_KHR when the buffer is created and (optionally, based
           // on a compile-time option) set to a new sync object in updateTexImage.
            EGLSyncKHR mEglFence;
      };

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!