int SurfaceTextureClient::dispatchSetScalingMode(va_list args) {
int m = va_arg(args, int);
return setScalingMode(m);
}
int GonkNativeWindowClient::dispatchSetScalingMode(va_list args) {
int m = va_arg(args, int);
return setScalingMode(m);
}
void SurfaceUtils::showTestFrame(const frame_t *f, int idx) {
ANativeWindowBuffer *buf;
void *ptr;
const Rect rect(LAYER_WIDTH, LAYER_HEIGHT);
// set buffer size
setBuffersDimensions(LAYER_WIDTH, LAYER_HEIGHT);
// set usage software write-able and hardware texture bind-able
setUsage(GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_HW_TEXTURE);
// set scaling to match window display size
setScalingMode(NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
// set transform
switch(idx) {
case 0:
// LOGD("layer no rotation");
break;
case 1:
// LOGD("layer %d: ROT_90", idx);
setBuffersTransform(HAL_TRANSFORM_ROT_90);
break;
case 2:
// LOGD("layer %d: ROT_180", idx);
setBuffersTransform(HAL_TRANSFORM_ROT_180);
break;
default:
// LOGD("layer %d: ROT_270", idx);
setBuffersTransform(HAL_TRANSFORM_ROT_270);
}
// get the buffer handle
mWindow->dequeueBuffer(mWindow, &buf);
// get the buffer addr
// LOGD("lock GraphicBuffer: %d", idx_frame);
GraphicBufferMapper::getInstance().lock(buf->handle,
GRALLOC_USAGE_SW_WRITE_OFTEN,
rect,
&ptr);
/*
LOGD("(w,h,s,f)=(%d,%d,%d,%d)",
buf->width, buf->height, buf->stride,
buf->format);
*/
// fill buffer
//LOGD("load bitmap");
SkBitmap bitmap;
ssize_t bpr = buf->stride * BPP;
bitmap.setConfig(convertPixelFormat(buf->format), buf->width, buf->height, bpr);
SkImageDecoder::DecodeFile(f->name, &bitmap,
SkBitmap::kARGB_8888_Config,
SkImageDecoder::kDecodePixels_Mode, NULL);
int w = bitmap.width();
int h = bitmap.height();
for (int j = 0; j < h; j++) {
for (int i = 0; i < w; i++) {
memcpy((uint8_t *)ptr + (j * bpr) + (i * BPP),
bitmap.getAddr32(i, j),
sizeof(uint32_t));
}
}
// set transparent/translucent region
setAlpha((uint8_t *)ptr, &f->blk[0], buf, false);
setAlpha((uint8_t *)ptr, &f->blk[1], buf, true);
//LOGD("end fill buffer");
// call unlock after finishing changes against the buffer
//LOGD("unlock GraphicBuffer");
GraphicBufferMapper::getInstance().unlock(buf->handle);
// transfer the ownership back to the server
mWindow->queueBuffer(mWindow, buf);
}
status_t BnSurfaceTexture::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case REQUEST_BUFFER: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int bufferIdx = data.readInt32();
sp<GraphicBuffer> buffer;
int result = requestBuffer(bufferIdx, &buffer);
reply->writeInt32(buffer != 0);
if (buffer != 0) {
reply->write(*buffer);
}
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_BUFFER_COUNT: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int bufferCount = data.readInt32();
int result = setBufferCount(bufferCount);
reply->writeInt32(result);
return NO_ERROR;
} break;
case DEQUEUE_BUFFER: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
uint32_t w = data.readInt32();
uint32_t h = data.readInt32();
uint32_t format = data.readInt32();
uint32_t usage = data.readInt32();
int buf;
int result = dequeueBuffer(&buf, w, h, format, usage);
reply->writeInt32(buf);
reply->writeInt32(result);
return NO_ERROR;
} break;
case QUEUE_BUFFER: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int buf = data.readInt32();
int64_t timestamp = data.readInt64();
uint32_t outWidth, outHeight, outTransform;
status_t result = queueBuffer(buf, timestamp,
&outWidth, &outHeight, &outTransform);
reply->writeInt32(outWidth);
reply->writeInt32(outHeight);
reply->writeInt32(outTransform);
reply->writeInt32(result);
return NO_ERROR;
} break;
case CANCEL_BUFFER: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int buf = data.readInt32();
cancelBuffer(buf);
return NO_ERROR;
} break;
case SET_CROP: {
Rect reg;
CHECK_INTERFACE(ISurfaceTexture, data, reply);
reg.left = data.readFloat();
reg.top = data.readFloat();
reg.right = data.readFloat();
reg.bottom = data.readFloat();
status_t result = setCrop(reg);
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_TRANSFORM: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
uint32_t transform = data.readInt32();
status_t result = setTransform(transform);
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_SCALING_MODE: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int mode = data.readInt32();
status_t result = setScalingMode(mode);
reply->writeInt32(result);
return NO_ERROR;
} break;
case QUERY: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int value;
int what = data.readInt32();
int res = query(what, &value);
reply->writeInt32(value);
reply->writeInt32(res);
return NO_ERROR;
} break;
case SET_SYNCHRONOUS_MODE: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
bool enabled = data.readInt32();
status_t res = setSynchronousMode(enabled);
reply->writeInt32(res);
return NO_ERROR;
} break;
case CONNECT: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int api = data.readInt32();
uint32_t outWidth, outHeight, outTransform;
status_t res = connect(api,
&outWidth, &outHeight, &outTransform);
reply->writeInt32(outWidth);
reply->writeInt32(outHeight);
reply->writeInt32(outTransform);
reply->writeInt32(res);
return NO_ERROR;
} break;
case DISCONNECT: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int api = data.readInt32();
status_t res = disconnect(api);
reply->writeInt32(res);
return NO_ERROR;
} break;
// [MTK] for S3D offset control
//--------------------------------------------------------------
case SET_S3DOFFSET: {
CHECK_INTERFACE(ISurfaceTexture, data, reply);
int32_t offset = data.readInt32();
status_t result = setS3DOffset(offset);
reply->writeInt32(result);
return NO_ERROR;
} break;
}
return BBinder::onTransact(code, data, reply, flags);
}
