Merge changes Id4222c9b,I3c1a9172 (c5b4c45b) · Commits · e / os / android_frameworks_native

include/private/ui/sw_gralloc_handle.h

deleted100644 → 0

+0 −83

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_UI_PRIVATE_SW_GRALLOC_HANDLE_H
		#define ANDROID_UI_PRIVATE_SW_GRALLOC_HANDLE_H

		#include <stdint.h>
		#include <limits.h>
		#include <sys/cdefs.h>
		#include <hardware/gralloc.h>
		#include <errno.h>

		#include <cutils/native_handle.h>

		namespace android {

		/*****************************************************************************/

		struct sw_gralloc_handle_t : public native_handle
		{
		// file-descriptors
		int fd;
		// ints
		int magic;
		int size;
		int base;
		int prot;
		int pid;

		static const int sNumInts = 5;
		static const int sNumFds = 1;
		static const int sMagic = '_sgh';

		sw_gralloc_handle_t() :
		fd(-1), magic(sMagic), size(0), base(0), prot(0), pid(getpid())
		{
		version = sizeof(native_handle);
		numInts = sNumInts;
		numFds = sNumFds;
		}
		~sw_gralloc_handle_t() {
		magic = 0;
		}

		static int validate(const native_handle* h) {
		const sw_gralloc_handle_t* hnd = (const sw_gralloc_handle_t*)h;
		if (!h \|\| h->version != sizeof(native_handle) \|\|
		h->numInts != sNumInts \|\| h->numFds != sNumFds \|\|
		hnd->magic != sMagic)
		{
		return -EINVAL;
		}
		return 0;
		}

		static status_t alloc(uint32_t w, uint32_t h, int format,
		int usage, buffer_handle_t* handle, int32_t* stride);
		static status_t free(sw_gralloc_handle_t* hnd);
		static status_t registerBuffer(sw_gralloc_handle_t* hnd);
		static status_t unregisterBuffer(sw_gralloc_handle_t* hnd);
		static status_t lock(sw_gralloc_handle_t* hnd, int usage,
		int l, int t, int w, int h, void** vaddr);
		static status_t unlock(sw_gralloc_handle_t* hnd);
		};

		/*****************************************************************************/

		}; // namespace android

		#endif /* ANDROID_UI_PRIVATE_SW_GRALLOC_HANDLE_H */

libs/ui/GraphicBufferAllocator.cpp

+3 −12

Original line number	Diff line number	Diff line
		@@ -24,8 +24,6 @@

		#include <ui/GraphicBufferAllocator.h>

		#include <private/ui/sw_gralloc_handle.h>

		namespace android {
		// ---------------------------------------------------------------------------

		@@ -95,11 +93,7 @@ status_t GraphicBufferAllocator::alloc(uint32_t w, uint32_t h, PixelFormat forma
		// we have a h/w allocator and h/w buffer is requested
		status_t err;

		if (usage & GRALLOC_USAGE_HW_MASK) {
		err = mAllocDev->alloc(mAllocDev, w, h, format, usage, handle, stride);
		} else {
		err = sw_gralloc_handle_t::alloc(w, h, format, usage, handle, stride);
		}

		LOGW_IF(err, "alloc(%u, %u, %d, %08x, ...) failed %d (%s)",
		w, h, format, usage, err, strerror(-err));
		@@ -123,11 +117,8 @@ status_t GraphicBufferAllocator::alloc(uint32_t w, uint32_t h, PixelFormat forma
		status_t GraphicBufferAllocator::free(buffer_handle_t handle)
		{
		status_t err;
		if (sw_gralloc_handle_t::validate(handle) < 0) {

		err = mAllocDev->free(mAllocDev, handle);
		} else {
		err = sw_gralloc_handle_t::free((sw_gralloc_handle_t*)handle);
		}

		LOGW_IF(err, "free(...) failed %d (%s)", err, strerror(-err));
		if (err == NO_ERROR) {

libs/ui/GraphicBufferMapper.cpp

+14 −149

Original line number	Diff line number	Diff line
		@@ -17,15 +17,7 @@
		#define LOG_TAG "GraphicBufferMapper"

		#include <stdint.h>
		#ifdef HAVE_ANDROID_OS // just want PAGE_SIZE define
		# include <asm/page.h>
		#else
		# include <sys/user.h>
		#endif
		#include <errno.h>
		#include <sys/mman.h>

		#include <cutils/ashmem.h>

		#include <utils/Errors.h>
		#include <utils/Log.h>
		@@ -35,8 +27,6 @@

		#include <hardware/gralloc.h>

		#include <private/ui/sw_gralloc_handle.h>


		namespace android {
		// ---------------------------------------------------------------------------
		@@ -57,11 +47,9 @@ GraphicBufferMapper::GraphicBufferMapper()
		status_t GraphicBufferMapper::registerBuffer(buffer_handle_t handle)
		{
		status_t err;
		if (sw_gralloc_handle_t::validate(handle) < 0) {

		err = mAllocMod->registerBuffer(mAllocMod, handle);
		} else {
		err = sw_gralloc_handle_t::registerBuffer((sw_gralloc_handle_t*)handle);
		}

		LOGW_IF(err, "registerBuffer(%p) failed %d (%s)",
		handle, err, strerror(-err));
		return err;
		@@ -70,11 +58,9 @@ status_t GraphicBufferMapper::registerBuffer(buffer_handle_t handle)
		status_t GraphicBufferMapper::unregisterBuffer(buffer_handle_t handle)
		{
		status_t err;
		if (sw_gralloc_handle_t::validate(handle) < 0) {

		err = mAllocMod->unregisterBuffer(mAllocMod, handle);
		} else {
		err = sw_gralloc_handle_t::unregisterBuffer((sw_gralloc_handle_t*)handle);
		}

		LOGW_IF(err, "unregisterBuffer(%p) failed %d (%s)",
		handle, err, strerror(-err));
		return err;
		@@ -84,15 +70,11 @@ status_t GraphicBufferMapper::lock(buffer_handle_t handle,
		int usage, const Rect& bounds, void** vaddr)
		{
		status_t err;
		if (sw_gralloc_handle_t::validate(handle) < 0) {

		err = mAllocMod->lock(mAllocMod, handle, usage,
		bounds.left, bounds.top, bounds.width(), bounds.height(),
		vaddr);
		} else {
		err = sw_gralloc_handle_t::lock((sw_gralloc_handle_t*)handle, usage,
		bounds.left, bounds.top, bounds.width(), bounds.height(),
		vaddr);
		}

		LOGW_IF(err, "lock(...) failed %d (%s)", err, strerror(-err));
		return err;
		}
		@@ -100,129 +82,12 @@ status_t GraphicBufferMapper::lock(buffer_handle_t handle,
		status_t GraphicBufferMapper::unlock(buffer_handle_t handle)
		{
		status_t err;
		if (sw_gralloc_handle_t::validate(handle) < 0) {

		err = mAllocMod->unlock(mAllocMod, handle);
		} else {
		err = sw_gralloc_handle_t::unlock((sw_gralloc_handle_t*)handle);
		}

		LOGW_IF(err, "unlock(...) failed %d (%s)", err, strerror(-err));
		return err;
		}

		// ---------------------------------------------------------------------------

		status_t sw_gralloc_handle_t::alloc(uint32_t w, uint32_t h, int format,
		int usage, buffer_handle_t* pHandle, int32_t* pStride)
		{
		int align = 4;
		int bpp = 0;
		switch (format) {
		case HAL_PIXEL_FORMAT_RGBA_8888:
		case HAL_PIXEL_FORMAT_RGBX_8888:
		case HAL_PIXEL_FORMAT_BGRA_8888:
		bpp = 4;
		break;
		case HAL_PIXEL_FORMAT_RGB_888:
		bpp = 3;
		break;
		case HAL_PIXEL_FORMAT_RGB_565:
		case HAL_PIXEL_FORMAT_RGBA_5551:
		case HAL_PIXEL_FORMAT_RGBA_4444:
		bpp = 2;
		break;
		default:
		return -EINVAL;
		}
		size_t bpr = (w*bpp + (align-1)) & ~(align-1);
		size_t size = bpr * h;
		size_t stride = bpr / bpp;
		size = (size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);

		int fd = ashmem_create_region("sw-gralloc-buffer", size);
		if (fd < 0) {
		LOGE("ashmem_create_region(size=%d) failed (%s)",
		size, strerror(-errno));
		return -errno;
		}

		int prot = PROT_READ;
		if (usage & GRALLOC_USAGE_SW_WRITE_MASK)
		prot \|= PROT_WRITE;

		if (ashmem_set_prot_region(fd, prot) < 0) {
		LOGE("ashmem_set_prot_region(fd=%d, prot=%x) failed (%s)",
		fd, prot, strerror(-errno));
		close(fd);
		return -errno;
		}

		void* base = mmap(0, size, prot, MAP_SHARED, fd, 0);
		if (base == MAP_FAILED) {
		LOGE("alloc mmap(fd=%d, size=%d, prot=%x) failed (%s)",
		fd, size, prot, strerror(-errno));
		close(fd);
		return -errno;
		}

		sw_gralloc_handle_t* hnd = new sw_gralloc_handle_t();
		hnd->fd = fd;
		hnd->size = size;
		hnd->base = intptr_t(base);
		hnd->prot = prot;
		*pStride = stride;
		*pHandle = hnd;

		return NO_ERROR;
		}

		status_t sw_gralloc_handle_t::free(sw_gralloc_handle_t* hnd)
		{
		if (hnd->base) {
		munmap((void*)hnd->base, hnd->size);
		}
		if (hnd->fd >= 0) {
		close(hnd->fd);
		}
		delete hnd;
		return NO_ERROR;
		}

		status_t sw_gralloc_handle_t::registerBuffer(sw_gralloc_handle_t* hnd)
		{
		if (hnd->pid != getpid()) {
		void* base = mmap(0, hnd->size, hnd->prot, MAP_SHARED, hnd->fd, 0);
		if (base == MAP_FAILED) {
		LOGE("registerBuffer mmap(fd=%d, size=%d, prot=%x) failed (%s)",
		hnd->fd, hnd->size, hnd->prot, strerror(-errno));
		return -errno;
		}
		hnd->base = intptr_t(base);
		}
		return NO_ERROR;
		}

		status_t sw_gralloc_handle_t::unregisterBuffer(sw_gralloc_handle_t* hnd)
		{
		if (hnd->pid != getpid()) {
		if (hnd->base) {
		munmap((void*)hnd->base, hnd->size);
		}
		hnd->base = 0;
		}
		return NO_ERROR;
		}

		status_t sw_gralloc_handle_t::lock(sw_gralloc_handle_t* hnd, int usage,
		int l, int t, int w, int h, void** vaddr)
		{
		vaddr = (void)hnd->base;
		return NO_ERROR;
		}

		status_t sw_gralloc_handle_t::unlock(sw_gralloc_handle_t* hnd)
		{
		return NO_ERROR;
		}

		// ---------------------------------------------------------------------------
		}; // namespace android

services/surfaceflinger/Android.mk

+0 −2

Original line number	Diff line number	Diff line
		@@ -6,11 +6,9 @@ LOCAL_SRC_FILES:= \
		DisplayHardware/DisplayHardware.cpp \
		DisplayHardware/DisplayHardwareBase.cpp \
		DisplayHardware/HWComposer.cpp \
		BlurFilter.cpp.arm \
		GLExtensions.cpp \
		Layer.cpp \
		LayerBase.cpp \
		LayerBlur.cpp \
		LayerDim.cpp \
		MessageQueue.cpp \
		SurfaceFlinger.cpp \

services/surfaceflinger/BlurFilter.cpp

deleted100644 → 0

+0 −376

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2006, The Android Open Source Project
		**
		** Licensed under the Apache License, Version 2.0 (the "License");
		** you may not use this file except in compliance with the License.
		** You may obtain a copy of the License at
		**
		** http://www.apache.org/licenses/LICENSE-2.0
		**
		** Unless required by applicable law or agreed to in writing, software
		** distributed under the License is distributed on an "AS IS" BASIS,
		** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		** See the License for the specific language governing permissions and
		** limitations under the License.
		*/


		#include <stdlib.h>
		#include <stdio.h>
		#include <string.h>
		#include <stdint.h>
		#include <utils/Errors.h>

		#include <pixelflinger/pixelflinger.h>

		#include "clz.h"

		#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
		#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))

		namespace android {

		#if BYTE_ORDER == LITTLE_ENDIAN
		inline uint32_t BLUR_RGBA_TO_HOST(uint32_t v) {
		return v;
		}
		inline uint32_t BLUR_HOST_TO_RGBA(uint32_t v) {
		return v;
		}
		#else
		inline uint32_t BLUR_RGBA_TO_HOST(uint32_t v) {
		return (v<<24) \| (v>>24) \| ((v<<8)&0xff0000) \| ((v>>8)&0xff00);
		}
		inline uint32_t BLUR_HOST_TO_RGBA(uint32_t v) {
		return (v<<24) \| (v>>24) \| ((v<<8)&0xff0000) \| ((v>>8)&0xff00);
		}
		#endif

		const int BLUR_DITHER_BITS = 6; // dither weights stored on 6 bits
		const int BLUR_DITHER_ORDER_SHIFT= 3;
		const int BLUR_DITHER_ORDER = (1<<BLUR_DITHER_ORDER_SHIFT);
		const int BLUR_DITHER_SIZE = BLUR_DITHER_ORDER * BLUR_DITHER_ORDER;
		const int BLUR_DITHER_MASK = BLUR_DITHER_ORDER-1;

		static const uint8_t gDitherMatrix[BLUR_DITHER_SIZE] = {
		0, 32, 8, 40, 2, 34, 10, 42,
		48, 16, 56, 24, 50, 18, 58, 26,
		12, 44, 4, 36, 14, 46, 6, 38,
		60, 28, 52, 20, 62, 30, 54, 22,
		3, 35, 11, 43, 1, 33, 9, 41,
		51, 19, 59, 27, 49, 17, 57, 25,
		15, 47, 7, 39, 13, 45, 5, 37,
		63, 31, 55, 23, 61, 29, 53, 21
		};


		template <int FACTOR = 0>
		struct BlurColor565
		{
		typedef uint16_t type;
		int r, g, b;
		inline BlurColor565() { }
		inline BlurColor565(uint16_t v) {
		r = v >> 11;
		g = (v >> 5) & 0x3E;
		b = v & 0x1F;
		}
		inline void clear() { r=g=b=0; }
		inline uint16_t to(int shift, int last, int dither) const {
		int R = r;
		int G = g;
		int B = b;
		if (UNLIKELY(last)) {
		if (FACTOR>0) {
		int L = (R+G+B)>>1;
		R += (((L>>1) - R) * FACTOR) >> 8;
		G += (((L ) - G) * FACTOR) >> 8;
		B += (((L>>1) - B) * FACTOR) >> 8;
		}
		R += (dither << shift) >> BLUR_DITHER_BITS;
		G += (dither << shift) >> BLUR_DITHER_BITS;
		B += (dither << shift) >> BLUR_DITHER_BITS;
		}
		R >>= shift;
		G >>= shift;
		B >>= shift;
		return (R<<11) \| (G<<5) \| B;
		}
		inline BlurColor565& operator += (const BlurColor565& rhs) {
		r += rhs.r;
		g += rhs.g;
		b += rhs.b;
		return *this;
		}
		inline BlurColor565& operator -= (const BlurColor565& rhs) {
		r -= rhs.r;
		g -= rhs.g;
		b -= rhs.b;
		return *this;
		}
		};

		template <int FACTOR = 0>
		struct BlurColor888X
		{
		typedef uint32_t type;
		int r, g, b;
		inline BlurColor888X() { }
		inline BlurColor888X(uint32_t v) {
		v = BLUR_RGBA_TO_HOST(v);
		r = v & 0xFF;
		g = (v >> 8) & 0xFF;
		b = (v >> 16) & 0xFF;
		}
		inline void clear() { r=g=b=0; }
		inline uint32_t to(int shift, int last, int dither) const {
		int R = r;
		int G = g;
		int B = b;
		if (UNLIKELY(last)) {
		if (FACTOR>0) {
		int L = (R+G+G+B)>>2;
		R += ((L - R) * FACTOR) >> 8;
		G += ((L - G) * FACTOR) >> 8;
		B += ((L - B) * FACTOR) >> 8;
		}
		}
		R >>= shift;
		G >>= shift;
		B >>= shift;
		return BLUR_HOST_TO_RGBA((0xFF<<24) \| (B<<16) \| (G<<8) \| R);
		}
		inline BlurColor888X& operator += (const BlurColor888X& rhs) {
		r += rhs.r;
		g += rhs.g;
		b += rhs.b;
		return *this;
		}
		inline BlurColor888X& operator -= (const BlurColor888X& rhs) {
		r -= rhs.r;
		g -= rhs.g;
		b -= rhs.b;
		return *this;
		}
		};

		struct BlurGray565
		{
		typedef uint16_t type;
		int l;
		inline BlurGray565() { }
		inline BlurGray565(uint16_t v) {
		int r = v >> 11;
		int g = (v >> 5) & 0x3F;
		int b = v & 0x1F;
		l = (r + g + b + 1)>>1;
		}
		inline void clear() { l=0; }
		inline uint16_t to(int shift, int last, int dither) const {
		int L = l;
		if (UNLIKELY(last)) {
		L += (dither << shift) >> BLUR_DITHER_BITS;
		}
		L >>= shift;
		return ((L>>1)<<11) \| (L<<5) \| (L>>1);
		}
		inline BlurGray565& operator += (const BlurGray565& rhs) {
		l += rhs.l;
		return *this;
		}
		inline BlurGray565& operator -= (const BlurGray565& rhs) {
		l -= rhs.l;
		return *this;
		}
		};

		struct BlurGray8888
		{
		typedef uint32_t type;
		int l, a;
		inline BlurGray8888() { }
		inline BlurGray8888(uint32_t v) {
		v = BLUR_RGBA_TO_HOST(v);
		int r = v & 0xFF;
		int g = (v >> 8) & 0xFF;
		int b = (v >> 16) & 0xFF;
		a = v >> 24;
		l = r + g + g + b;
		}
		inline void clear() { l=a=0; }
		inline uint32_t to(int shift, int last, int dither) const {
		int L = l;
		int A = a;
		if (UNLIKELY(last)) {
		L += (dither << (shift+2)) >> BLUR_DITHER_BITS;
		A += (dither << shift) >> BLUR_DITHER_BITS;
		}
		L >>= (shift+2);
		A >>= shift;
		return BLUR_HOST_TO_RGBA((A<<24) \| (L<<16) \| (L<<8) \| L);
		}
		inline BlurGray8888& operator += (const BlurGray8888& rhs) {
		l += rhs.l;
		a += rhs.a;
		return *this;
		}
		inline BlurGray8888& operator -= (const BlurGray8888& rhs) {
		l -= rhs.l;
		a -= rhs.a;
		return *this;
		}
		};


		template<typename PIXEL>
		static status_t blurFilter(
		GGLSurface const* dst,
		GGLSurface const* src,
		int kernelSizeUser,
		int repeat)
		{
		typedef typename PIXEL::type TYPE;

		const int shift = 31 - clz(kernelSizeUser);
		const int areaShift = shift*2;
		const int kernelSize = 1<<shift;
		const int kernelHalfSize = kernelSize/2;
		const int mask = kernelSize-1;
		const int w = src->width;
		const int h = src->height;
		const uint8_t* ditherMatrix = gDitherMatrix;

		// we need a temporary buffer to store one line of blurred columns
		// as well as kernelSize lines of source pixels organized as a ring buffer.
		void* const temporary_buffer = malloc(
		(w + kernelSize) * sizeof(PIXEL) +
		(src->stride * kernelSize) * sizeof(TYPE));
		if (!temporary_buffer)
		return NO_MEMORY;

		PIXEL* const sums = (PIXEL*)temporary_buffer;
		TYPE* const scratch = (TYPE*)(sums + w + kernelSize);

		// Apply the blur 'repeat' times, this is used to approximate
		// gaussian blurs. 3 times gives good results.
		for (int k=0 ; k<repeat ; k++) {

		// Clear the columns sums for this round
		memset(sums, 0, (w + kernelSize) * sizeof(PIXEL));
		TYPE* head;
		TYPE pixel;
		PIXEL current;

		// Since we're going to override the source data we need
		// to copy it in a temporary buffer. Only kernelSize lines are
		// required. But since we start in the center of the kernel,
		// we only copy half of the data, and fill the rest with zeros
		// (assuming black/transparent pixels).
		memcpy( scratch + src->stride*kernelHalfSize,
		src->data,
		src->stridekernelHalfSizesizeof(TYPE));

		// sum half of each column, because we assume the first half is
		// zeros (black/transparent).
		for (int y=0 ; y<kernelHalfSize ; y++) {
		head = (TYPE)src->data + ysrc->stride;
		for (int x=0 ; x<w ; x++)
		sums[x] += PIXEL( *head++ );
		}

		for (int y=0 ; y<h ; y++) {
		TYPE* fb = (TYPE)dst->data + ydst->stride;

		// compute the dither matrix line
		uint8_t const * ditherY = ditherMatrix
		+ (y & BLUR_DITHER_MASK)*BLUR_DITHER_ORDER;

		// Horizontal blur pass on the columns sums
		int count, dither, x=0;
		PIXEL const * out= sums;
		PIXEL const * in = sums;
		current.clear();

		count = kernelHalfSize;
		do {
		current += *in;
		in++;
		} while (--count);

		count = kernelHalfSize;
		do {
		current += *in;
		dither = *(ditherY + ((x++)&BLUR_DITHER_MASK));
		*fb++ = current.to(areaShift, k==repeat-1, dither);
		in++;
		} while (--count);

		count = w-kernelSize;
		do {
		current += *in;
		current -= *out;
		dither = *(ditherY + ((x++)&BLUR_DITHER_MASK));
		*fb++ = current.to(areaShift, k==repeat-1, dither);
		in++, out++;
		} while (--count);

		count = kernelHalfSize;
		do {
		current -= *out;
		dither = *(ditherY + ((x++)&BLUR_DITHER_MASK));
		*fb++ = current.to(areaShift, k==repeat-1, dither);
		out++;
		} while (--count);

		// vertical blur pass, subtract the oldest line from each columns
		// and add a new line. Subtract or add zeros at the top
		// and bottom edges.
		TYPE* const tail = scratch + (y & mask) * src->stride;
		if (y >= kernelHalfSize) {
		for (int x=0 ; x<w ; x++)
		sums[x] -= PIXEL( tail[x] );
		}
		if (y < h-kernelSize) {
		memcpy( tail,
		(TYPE)src->data + (y+kernelHalfSize)src->stride,
		src->stride*sizeof(TYPE));
		for (int x=0 ; x<w ; x++)
		sums[x] += PIXEL( tail[x] );
		}
		}

		// The subsequent passes are always done in-place.
		src = dst;
		}

		free(temporary_buffer);

		return NO_ERROR;
		}

		template status_t blurFilter< BlurColor565<0x80> >(
		GGLSurface const* dst,
		GGLSurface const* src,
		int kernelSizeUser,
		int repeat);

		status_t blurFilter(
		GGLSurface const* image,
		int kernelSizeUser,
		int repeat)
		{
		status_t err = BAD_VALUE;
		if (image->format == GGL_PIXEL_FORMAT_RGB_565) {
		err = blurFilter< BlurColor565<0x80> >(image, image, kernelSizeUser, repeat);
		} else if (image->format == GGL_PIXEL_FORMAT_RGBX_8888) {
		err = blurFilter< BlurColor888X<0x80> >(image, image, kernelSizeUser, repeat);
		}
		return err;
		}

		} // namespace android

		//err = blur< BlurColor565<0x80> >(dst, src, kernelSizeUser, repeat);
		//err = blur<BlurGray565>(dst, src, kernelSizeUser, repeat);
		//err = blur<BlurGray8888>(dst, src, kernelSizeUser, repeat);