flutter::CompositorSoftware Class Reference

#include <compositor_software.h>

Inheritance diagram for flutter::CompositorSoftware:

Public Member Functions
	CompositorSoftware ()
bool	CreateBackingStore (const FlutterBackingStoreConfig &config, FlutterBackingStore *result) override
	|Compositor| More...
bool	CollectBackingStore (const FlutterBackingStore *store) override
	|Compositor| More...
bool	Present (FlutterWindowsView *view, const FlutterLayer **layers, size_t layers_count) override
	|Compositor| More...
Public Member Functions inherited from flutter::Compositor
virtual	~Compositor ()=default
virtual bool	CreateBackingStore (const FlutterBackingStoreConfig &config, FlutterBackingStore *backing_store_out)=0
virtual bool	CollectBackingStore (const FlutterBackingStore *store)=0
virtual bool	Present (FlutterWindowsView *view, const FlutterLayer **layers, size_t layers_count)=0

Detailed Description

Definition at line 17 of file compositor_software.h.

Constructor & Destructor Documentation

CompositorSoftware()

flutter::CompositorSoftware::CompositorSoftware

(

)

Definition at line 84 of file compositor_software.cc.

{}

Member Function Documentation

CollectBackingStore()

bool flutter::CompositorSoftware::CollectBackingStore ( const FlutterBackingStore *  store )

overridevirtual

|Compositor|

Implements flutter::Compositor.

Definition at line 107 of file compositor_software.cc.

                                                                             {
  std::free(const_cast<void*>(store->software.allocation));
  return true;
}

CreateBackingStore()

bool flutter::CompositorSoftware::CreateBackingStore ( const FlutterBackingStoreConfig &  config, FlutterBackingStore *  result  )

overridevirtual

|Compositor|

Implements flutter::Compositor.

Definition at line 86 of file compositor_software.cc.

                                 {
  size_t size = config.size.width * config.size.height * 4;
  void* allocation = std::calloc(size, sizeof(uint8_t));
  if (!allocation) {
    return false;
  }
 
  result->type = kFlutterBackingStoreTypeSoftware;
  result->software.allocation = allocation;
  result->software.height = config.size.height;
  result->software.row_bytes = config.size.width * 4;
  result->software.user_data = nullptr;
  result->software.destruction_callback = [](void* user_data) {
    // Backing store destroyed in `CompositorSoftware::CollectBackingStore`, set
    // on FlutterCompositor.collect_backing_store_callback during engine start.
  };
  return true;
}

Present()

bool flutter::CompositorSoftware::Present ( FlutterWindowsView *  view, const FlutterLayer **  layers, size_t  layers_count  )

overridevirtual

|Compositor|

Implements flutter::Compositor.

Definition at line 112 of file compositor_software.cc.

                                                      {
  FML_DCHECK(view != nullptr);
 
  // Clear the view if there are no layers to present.
  if (layers_count == 0) {
    return view->ClearSoftwareBitmap();
  }
 
  // Bypass composition logic if there is only one layer.
  if (layers_count == 1) {
    const FlutterLayer* layer = layers[0];
    FML_DCHECK(layer != nullptr);
    if (layer->type == kFlutterLayerContentTypeBackingStore &&
        layer->offset.x == 0 && layer->offset.y == 0) {
      auto& backing_store = *layer->backing_store;
      FML_DCHECK(backing_store.type == kFlutterBackingStoreTypeSoftware);
      auto& software = backing_store.software;
      return view->PresentSoftwareBitmap(software.allocation,
                                         software.row_bytes, software.height);
    }
  }
 
  // Composite many layers.
  FlutterRect bounds = CalculateBounds(layers, layers_count);
  // Truncate from double to integer to represent whole pixels.
  int x_min = static_cast<int>(bounds.left);
  int x_max = static_cast<int>(bounds.right);
  int y_min = static_cast<int>(bounds.top);
  int y_max = static_cast<int>(bounds.bottom);
 
  int width = x_max - x_min;
  int height = y_max - y_min;
  std::vector<uint32_t> allocation(width * height, kOpaqueBlack);
 
  for (const FlutterLayer** layer = layers; layer < layers + layers_count;
       layer++) {
    // TODO(schectman): handle platform view type layers.
    // https://github.com/flutter/flutter/issues/143375
    if ((*layer)->type == kFlutterLayerContentTypeBackingStore) {
      BlendLayer(allocation, **layer, x_min, y_min, width, height);
    } else {
      FML_UNREACHABLE();
      return false;
    }
  }
 
  return view->PresentSoftwareBitmap(static_cast<void*>(allocation.data()),
                                     width * sizeof(uint32_t), height);
}

---

The documentation for this class was generated from the following files:

• shell/platform/windows/compositor_software.h
• shell/platform/windows/compositor_software.cc