summaryrefslogtreecommitdiffstats
path: root/gfx/layers/client/ImageClient.h
blob: 0e699179c8ecc925827b157f040b8814ac956bc9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef MOZILLA_GFX_IMAGECLIENT_H
#define MOZILLA_GFX_IMAGECLIENT_H

#include <stdint.h>                             // for uint32_t, uint64_t
#include <sys/types.h>                          // for int32_t
#include "mozilla/Attributes.h"                 // for override
#include "mozilla/RefPtr.h"                     // for RefPtr, already_AddRefed
#include "mozilla/gfx/Types.h"                  // for SurfaceFormat
#include "mozilla/layers/CompositableClient.h"  // for CompositableClient
#include "mozilla/layers/CompositorTypes.h"     // for CompositableType, etc
#include "mozilla/layers/LayersSurfaces.h"      // for SurfaceDescriptor
#include "mozilla/layers/TextureClient.h"       // for TextureClient, etc
#include "mozilla/mozalloc.h"                   // for operator delete
#include "nsCOMPtr.h"                           // for already_AddRefed
#include "nsRect.h"                             // for mozilla::gfx::IntRect

namespace mozilla {
namespace layers {

class ClientLayer;
class CompositableForwarder;
class Image;
class ImageContainer;
class ShadowableLayer;
class ImageClientSingle;

/**
 * Image clients are used by basic image layers on the content thread, they
 * always match with an ImageHost on the compositor thread. See
 * CompositableClient.h for information on connecting clients to hosts.
 */
class ImageClient : public CompositableClient {
 public:
  /**
   * Creates, configures, and returns a new image client. If necessary, a
   * message will be sent to the compositor to create a corresponding image
   * host.
   */
  static already_AddRefed<ImageClient> CreateImageClient(
      CompositableType aImageHostType, CompositableForwarder* aFwd,
      TextureFlags aFlags);

  virtual ~ImageClient() = default;

  /**
   * Update this ImageClient from aContainer in aLayer
   * returns false if this is the wrong kind of ImageClient for aContainer.
   * Note that returning true does not necessarily imply success
   */
  virtual bool UpdateImage(ImageContainer* aContainer,
                           uint32_t aContentFlags) = 0;

  void SetLayer(ClientLayer* aLayer) { mLayer = aLayer; }
  ClientLayer* GetLayer() const { return mLayer; }

  /**
   * asynchronously remove all the textures used by the image client.
   *
   */
  virtual void FlushAllImages() {}

  virtual void RemoveTexture(TextureClient* aTexture) override;

  virtual ImageClientSingle* AsImageClientSingle() { return nullptr; }

  static already_AddRefed<TextureClient> CreateTextureClientForImage(
      Image* aImage, KnowsCompositor* aForwarder);

  uint32_t GetLastUpdateGenerationCounter() {
    return mLastUpdateGenerationCounter;
  }

  virtual RefPtr<TextureClient> GetForwardedTexture() { return nullptr; }

 protected:
  ImageClient(CompositableForwarder* aFwd, TextureFlags aFlags,
              CompositableType aType);

  ClientLayer* mLayer;
  CompositableType mType;
  uint32_t mLastUpdateGenerationCounter;
};

/**
 * An image client which uses a single texture client.
 */
class ImageClientSingle : public ImageClient {
 public:
  ImageClientSingle(CompositableForwarder* aFwd, TextureFlags aFlags,
                    CompositableType aType);

  bool UpdateImage(ImageContainer* aContainer, uint32_t aContentFlag) override;

  void OnDetach() override;

  bool AddTextureClient(TextureClient* aTexture) override;

  TextureInfo GetTextureInfo() const override;

  void FlushAllImages() override;

  ImageClientSingle* AsImageClientSingle() override { return this; }

  RefPtr<TextureClient> GetForwardedTexture() override;

  bool IsEmpty() { return mBuffers.IsEmpty(); }

 protected:
  struct Buffer {
    RefPtr<TextureClient> mTextureClient;
    int32_t mImageSerial;
  };
  nsTArray<Buffer> mBuffers;
};

/**
 * Image class to be used for async image uploads using the image bridge
 * protocol.
 * We store the ImageBridge id in the TextureClientIdentifier.
 */
class ImageClientBridge : public ImageClient {
 public:
  ImageClientBridge(CompositableForwarder* aFwd, TextureFlags aFlags);

  bool UpdateImage(ImageContainer* aContainer, uint32_t aContentFlags) override;
  bool Connect(ImageContainer* aImageContainer) override { return false; }

  TextureInfo GetTextureInfo() const override { return TextureInfo(mType); }

 protected:
  CompositableHandle mAsyncContainerHandle;
};

}  // namespace layers
}  // namespace mozilla

#endif