SharedBitmapManager* shared_bitmap_manager,
int highp_threshold_min,
bool use_rgba_4444_texture_format,
- size_t id_allocation_chunk_size);
+ size_t id_allocation_chunk_size,
+ bool use_distance_field_text);
virtual ~ResourceProvider();
void InitializeSoftware();
- bool InitializeGL();
+ void InitializeGL();
void DidLoseOutputSurface() { lost_output_surface_ = true; }
return use_rgba_4444_texture_format_ ? RGBA_4444 : best_texture_format_;
}
ResourceFormat best_texture_format() const { return best_texture_format_; }
+ bool use_sync_query() const { return use_sync_query_; }
size_t num_resources() const { return resources_.size(); }
// Checks whether a resource is in use by a consumer.
bool InUseByConsumer(ResourceId id);
bool IsLost(ResourceId id);
+ bool AllowOverlay(ResourceId id);
// Producer interface.
ResourceFormat format);
ResourceId CreateBitmap(const gfx::Size& size, GLint wrap_mode);
- // Wraps an external texture into a GL resource.
- ResourceId CreateResourceFromExternalTexture(
- unsigned texture_target,
- unsigned texture_id);
+ // Wraps an IOSurface into a GL resource.
+ ResourceId CreateResourceFromIOSurface(const gfx::Size& size,
+ unsigned io_surface_id);
// Wraps an external texture mailbox into a GL resource.
ResourceId CreateResourceFromTextureMailbox(
void ReleaseCachedData();
base::TimeTicks EstimatedUploadCompletionTime(size_t uploads_per_tick);
- // Flush all context operations, kicking uploads and ensuring ordering with
- // respect to other contexts.
- void Flush();
-
- // Finish all context operations, causing any pending callbacks to be
- // scheduled.
- void Finish();
-
// Only flush the command buffer if supported.
// Returns true if the shallow flush occurred, false otherwise.
bool ShallowFlushIfSupported();
class Fence : public base::RefCounted<Fence> {
public:
Fence() {}
+
+ virtual void Set() = 0;
virtual bool HasPassed() = 0;
protected:
DISALLOW_COPY_AND_ASSIGN(Fence);
};
- // Returns a canvas for direct rasterization.
+ // Returns a canvas for gpu rasterization.
// Call Unmap before the resource can be read or used for compositing.
// It is used for direct gpu rasterization.
- SkCanvas* MapDirectRasterBuffer(ResourceId id);
- void UnmapDirectRasterBuffer(ResourceId id);
+ SkCanvas* MapGpuRasterBuffer(ResourceId id);
+ void UnmapGpuRasterBuffer(ResourceId id);
- // Returns a canvas backed by an image buffer.
+ // Returns a canvas backed by an image buffer. UnmapImageRasterBuffer
+ // returns true if canvas was written to while mapped.
// Rasterizing to the canvas writes the content into the image buffer,
// which is internally bound to the underlying resource when read.
// Call Unmap before the resource can be read or used for compositing.
// It is used by ImageRasterWorkerPool.
SkCanvas* MapImageRasterBuffer(ResourceId id);
- void UnmapImageRasterBuffer(ResourceId id);
+ bool UnmapImageRasterBuffer(ResourceId id);
- // Returns a canvas backed by pixel buffer.
+ // Returns a canvas backed by pixel buffer. UnmapPixelRasterBuffer
+ // returns true if canvas was written to while mapped.
// The pixel buffer needs to be uploaded to the underlying resource
// using BeginSetPixels before the resouce can be used for compositing.
// It is used by PixelRasterWorkerPool.
void AcquirePixelRasterBuffer(ResourceId id);
void ReleasePixelRasterBuffer(ResourceId id);
SkCanvas* MapPixelRasterBuffer(ResourceId id);
- void UnmapPixelRasterBuffer(ResourceId id);
+ bool UnmapPixelRasterBuffer(ResourceId id);
// Asynchronously update pixels from acquired pixel buffer.
void BeginSetPixels(ResourceId id);
// Sets the current read fence. If a resource is locked for read
// and has read fences enabled, the resource will not allow writes
// until this fence has passed.
- void SetReadLockFence(scoped_refptr<Fence> fence) {
- current_read_lock_fence_ = fence;
- }
- Fence* GetReadLockFence() { return current_read_lock_fence_.get(); }
+ void SetReadLockFence(Fence* fence) { current_read_lock_fence_ = fence; }
// Enable read lock fences for a specific resource.
- void EnableReadLockFences(ResourceProvider::ResourceId id, bool enable);
+ void EnableReadLockFences(ResourceProvider::ResourceId id);
// Indicates if we can currently lock this resource for write.
bool CanLockForWrite(ResourceId id);
+ // Copy pixels from source to destination.
+ void CopyResource(ResourceId source_id, ResourceId dest_id);
+
static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
private:
- class DirectRasterBuffer;
+ class GpuRasterBuffer;
class ImageRasterBuffer;
class PixelRasterBuffer;
unsigned gl_pixel_buffer_id;
// Query used to determine when asynchronous set pixels complete.
unsigned gl_upload_query_id;
+ // Query used to determine when read lock fence has passed.
+ unsigned gl_read_lock_query_id;
TextureMailbox mailbox;
ReleaseCallback release_callback;
uint8_t* pixels;
- uint8_t* pixel_buffer;
int lock_for_read_count;
int imported_count;
int exported_count;
- bool locked_for_write;
- Origin origin;
- bool marked_for_deletion;
- bool pending_set_pixels;
- bool set_pixels_completion_forced;
- bool allocated;
- bool enable_read_lock_fences;
+ bool dirty_image : 1;
+ bool locked_for_write : 1;
+ bool lost : 1;
+ bool marked_for_deletion : 1;
+ bool pending_set_pixels : 1;
+ bool set_pixels_completion_forced : 1;
+ bool allocated : 1;
+ bool read_lock_fences_enabled : 1;
+ bool has_shared_bitmap_id : 1;
+ bool allow_overlay : 1;
scoped_refptr<Fence> read_lock_fence;
gfx::Size size;
+ Origin origin;
GLenum target;
// TODO(skyostil): Use a separate sampler object for filter state.
GLenum original_filter;
GLenum filter;
unsigned image_id;
unsigned bound_image_id;
- bool dirty_image;
GLenum texture_pool;
GLint wrap_mode;
- bool lost;
TextureUsageHint hint;
ResourceType type;
ResourceFormat format;
- bool has_shared_bitmap_id;
SharedBitmapId shared_bitmap_id;
SharedBitmap* shared_bitmap;
- linked_ptr<DirectRasterBuffer> direct_raster_buffer;
+ linked_ptr<GpuRasterBuffer> gpu_raster_buffer;
linked_ptr<ImageRasterBuffer> image_raster_buffer;
linked_ptr<PixelRasterBuffer> pixel_raster_buffer;
};
virtual ~RasterBuffer();
SkCanvas* LockForWrite();
- void UnlockForWrite();
+ // Returns true if canvas was written to while locked.
+ bool UnlockForWrite();
protected:
RasterBuffer(const Resource* resource, ResourceProvider* resource_provider);
ResourceProvider* resource_provider() const { return resource_provider_; }
virtual SkCanvas* DoLockForWrite() = 0;
- virtual void DoUnlockForWrite() = 0;
+ virtual bool DoUnlockForWrite() = 0;
private:
const Resource* resource_;
int canvas_save_count_;
};
- class DirectRasterBuffer : public RasterBuffer {
+ class GpuRasterBuffer : public RasterBuffer {
public:
- DirectRasterBuffer(const Resource* resource,
- ResourceProvider* resource_provider);
- virtual ~DirectRasterBuffer();
+ GpuRasterBuffer(const Resource* resource,
+ ResourceProvider* resource_provider,
+ bool use_distance_field_text);
+ virtual ~GpuRasterBuffer();
protected:
virtual SkCanvas* DoLockForWrite() OVERRIDE;
- virtual void DoUnlockForWrite() OVERRIDE;
+ virtual bool DoUnlockForWrite() OVERRIDE;
skia::RefPtr<SkSurface> CreateSurface();
private:
skia::RefPtr<SkSurface> surface_;
- DISALLOW_COPY_AND_ASSIGN(DirectRasterBuffer);
+ uint32_t surface_generation_id_;
+ const bool use_distance_field_text_;
+
+ DISALLOW_COPY_AND_ASSIGN(GpuRasterBuffer);
};
class BitmapRasterBuffer : public RasterBuffer {
ResourceProvider* resource_provider);
virtual SkCanvas* DoLockForWrite() OVERRIDE;
- virtual void DoUnlockForWrite() OVERRIDE;
+ virtual bool DoUnlockForWrite() OVERRIDE;
virtual uint8_t* MapBuffer(int* stride) = 0;
virtual void UnmapBuffer() = 0;
private:
uint8_t* mapped_buffer_;
SkBitmap raster_bitmap_;
+ uint32_t raster_bitmap_generation_id_;
skia::RefPtr<SkCanvas> raster_canvas_;
};
SharedBitmapManager* shared_bitmap_manager,
int highp_threshold_min,
bool use_rgba_4444_texture_format,
- size_t id_allocation_chunk_size);
+ size_t id_allocation_chunk_size,
+ bool use_distance_field_text);
void CleanUpGLIfNeeded();
scoped_ptr<IdAllocator> texture_id_allocator_;
scoped_ptr<IdAllocator> buffer_id_allocator_;
+ bool use_sync_query_;
+
+ bool use_distance_field_text_;
+
DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
};
32, // RGBA_8888
16, // RGBA_4444
32, // BGRA_8888
+ 8, // ALPHA_8
8, // LUMINANCE_8
16, // RGB_565,
4 // ETC1
GL_UNSIGNED_BYTE, // RGBA_8888
GL_UNSIGNED_SHORT_4_4_4_4, // RGBA_4444
GL_UNSIGNED_BYTE, // BGRA_8888
+ GL_UNSIGNED_BYTE, // ALPHA_8
GL_UNSIGNED_BYTE, // LUMINANCE_8
GL_UNSIGNED_SHORT_5_6_5, // RGB_565,
GL_UNSIGNED_BYTE // ETC1
GL_RGBA, // RGBA_8888
GL_RGBA, // RGBA_4444
GL_BGRA_EXT, // BGRA_8888
+ GL_ALPHA, // ALPHA_8
GL_LUMINANCE, // LUMINANCE_8
GL_RGB, // RGB_565
GL_ETC1_RGB8_OES // ETC1
projects / platform / framework / web / crosswalk.git / blobdiff