| /* |
| * Copyright (c) 2009-2011 Intel Corporation. All rights reserved. |
| * |
| * 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 "VideoEncoderLog.h" |
| #include "VideoEncoderUtils.h" |
| #include <va/va_android.h> |
| #include <va/va_drmcommon.h> |
| |
| #ifdef IMG_GFX |
| #include <hal/hal_public.h> |
| #include <hardware/gralloc.h> |
| |
| //#define GFX_DUMP |
| |
| #define OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar 0x7FA00E00 |
| |
| static hw_module_t const *gModule = NULL; |
| static gralloc_module_t *gAllocMod = NULL; /* get by force hw_module_t */ |
| static alloc_device_t *gAllocDev = NULL; |
| |
| static int gfx_init(void) { |
| |
| int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &gModule); |
| if (err) { |
| LOG_E("FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); |
| return -1; |
| } else |
| LOG_V("hw_get_module returned\n"); |
| gAllocMod = (gralloc_module_t *)gModule; |
| |
| return 0; |
| } |
| |
| static int gfx_alloc(uint32_t w, uint32_t h, int format, |
| int usage, buffer_handle_t* handle, int32_t* stride) { |
| |
| int err; |
| |
| if (!gAllocDev) { |
| if (!gModule) { |
| if (gfx_init()) { |
| LOG_E("can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); |
| return -1; |
| } |
| } |
| |
| err = gralloc_open(gModule, &gAllocDev); |
| if (err) { |
| LOG_E("FATAL: gralloc open failed\n"); |
| return -1; |
| } |
| } |
| |
| err = gAllocDev->alloc(gAllocDev, w, h, format, usage, handle, stride); |
| if (err) { |
| LOG_E("alloc(%u, %u, %d, %08x, ...) failed %d (%s)\n", |
| w, h, format, usage, err, strerror(-err)); |
| } |
| |
| return err; |
| } |
| |
| static int gfx_free(buffer_handle_t handle) { |
| |
| int err; |
| |
| if (!gAllocDev) { |
| if (!gModule) { |
| if (gfx_init()) { |
| LOG_E("can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); |
| return -1; |
| } |
| } |
| |
| err = gralloc_open(gModule, &gAllocDev); |
| if (err) { |
| LOG_E("FATAL: gralloc open failed\n"); |
| return -1; |
| } |
| } |
| |
| err = gAllocDev->free(gAllocDev, handle); |
| if (err) { |
| LOG_E("free(...) failed %d (%s)\n", err, strerror(-err)); |
| } |
| |
| return err; |
| } |
| |
| static int gfx_lock(buffer_handle_t handle, int usage, |
| int left, int top, int width, int height, void** vaddr) { |
| |
| int err; |
| |
| if (!gAllocMod) { |
| if (gfx_init()) { |
| LOG_E("can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); |
| return -1; |
| } |
| } |
| |
| err = gAllocMod->lock(gAllocMod, handle, usage, |
| left, top, width, height, vaddr); |
| LOG_V("gfx_lock: handle is %x, usage is %x, vaddr is %x.\n", (unsigned int)handle, usage, (unsigned int)*vaddr); |
| |
| if (err){ |
| LOG_E("lock(...) failed %d (%s).\n", err, strerror(-err)); |
| return -1; |
| } else |
| LOG_V("lock returned with address %p\n", *vaddr); |
| |
| return err; |
| } |
| |
| static int gfx_unlock(buffer_handle_t handle) { |
| |
| int err; |
| |
| if (!gAllocMod) { |
| if (gfx_init()) { |
| LOG_E("can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); |
| return -1; |
| } |
| } |
| |
| err = gAllocMod->unlock(gAllocMod, handle); |
| if (err) { |
| LOG_E("unlock(...) failed %d (%s)", err, strerror(-err)); |
| return -1; |
| } else |
| LOG_V("unlock returned\n"); |
| |
| return err; |
| } |
| |
| static int gfx_Blit(buffer_handle_t src, buffer_handle_t dest, |
| int w, int h, int , int ) |
| { |
| int err; |
| |
| if (!gAllocMod) { |
| if (gfx_init()) { |
| LOG_E("can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); |
| return -1; |
| } |
| } |
| |
| IMG_gralloc_module_public_t* GrallocMod = (IMG_gralloc_module_public_t*)gModule; |
| |
| #ifdef MRFLD_GFX |
| err = GrallocMod->Blit(GrallocMod, src, dest, w, h, 0, 0, 0, 0); |
| #else |
| err = GrallocMod->Blit2(GrallocMod, src, dest, w, h, 0, 0); |
| #endif |
| |
| if (err) { |
| LOG_E("Blit(...) failed %d (%s)", err, strerror(-err)); |
| return -1; |
| } else |
| LOG_V("Blit returned\n"); |
| |
| return err; |
| } |
| |
| Encode_Status GetGfxBufferInfo(intptr_t handle, ValueInfo& vinfo){ |
| |
| /* only support OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar |
| HAL_PIXEL_FORMAT_NV12 |
| HAL_PIXEL_FORMAT_BGRA_8888 |
| HAL_PIXEL_FORMAT_RGBA_8888 |
| HAL_PIXEL_FORMAT_RGBX_8888 |
| HAL_PIXEL_FORMAT_BGRX_8888 */ |
| IMG_native_handle_t* h = (IMG_native_handle_t*) handle; |
| |
| vinfo.width = h->iWidth; |
| vinfo.height = h->iHeight; |
| vinfo.lumaStride = h->iWidth; |
| |
| LOG_V("GetGfxBufferInfo: gfx iWidth=%d, iHeight=%d, iFormat=%x in handle structure\n", h->iWidth, h->iHeight, h->iFormat); |
| |
| if (h->iFormat == HAL_PIXEL_FORMAT_NV12) { |
| #ifdef MRFLD_GFX |
| if((h->usage & GRALLOC_USAGE_HW_CAMERA_READ) || (h->usage & GRALLOC_USAGE_HW_CAMERA_WRITE) ) |
| vinfo.lumaStride = (h->iWidth + 63) & ~63; //64 aligned |
| else |
| vinfo.lumaStride = (h->iWidth + 31) & ~31; //32 aligned |
| #else //on CTP |
| if (h->iWidth > 512) |
| vinfo.lumaStride = (h->iWidth + 63) & ~63; //64 aligned |
| else |
| vinfo.lumaStride = 512; |
| #endif |
| } else if ((h->iFormat == HAL_PIXEL_FORMAT_BGRA_8888)|| |
| (h->iFormat == HAL_PIXEL_FORMAT_RGBA_8888)|| |
| (h->iFormat == HAL_PIXEL_FORMAT_RGBX_8888)|| |
| (h->iFormat == HAL_PIXEL_FORMAT_BGRX_8888)) { |
| vinfo.lumaStride = (h->iWidth + 31) & ~31; |
| } else if (h->iFormat == OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar) { |
| //nothing to do |
| } else |
| return ENCODE_NOT_SUPPORTED; |
| |
| vinfo.format = h->iFormat; |
| |
| LOG_V("Actual Width=%d, Height=%d, Stride=%d\n\n", vinfo.width, vinfo.height, vinfo.lumaStride); |
| return ENCODE_SUCCESS; |
| } |
| |
| #ifdef GFX_DUMP |
| void DumpGfx(intptr_t handle, char* filename) { |
| ValueInfo vinfo; |
| void* vaddr[3]; |
| FILE* fp; |
| int usage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_SW_READ_OFTEN; |
| |
| GetGfxBufferInfo(handle, vinfo); |
| if (gfx_lock((buffer_handle_t)handle, usage, 0, 0, vinfo.width, vinfo.height, &vaddr[0]) != 0) |
| return ENCODE_DRIVER_FAIL; |
| fp = fopen(filename, "wb"); |
| fwrite(vaddr[0], 1, vinfo.lumaStride * vinfo.height * 4, fp); |
| fclose(fp); |
| LOG_I("dump %d bytes data to %s\n", vinfo.lumaStride * vinfo.height * 4, filename); |
| gfx_unlock((buffer_handle_t)handle); |
| |
| return; |
| } |
| #endif |
| |
| #endif |
| |
| extern "C" { |
| VAStatus vaLockSurface(VADisplay dpy, |
| VASurfaceID surface, |
| unsigned int *fourcc, |
| unsigned int *luma_stride, |
| unsigned int *chroma_u_stride, |
| unsigned int *chroma_v_stride, |
| unsigned int *luma_offset, |
| unsigned int *chroma_u_offset, |
| unsigned int *chroma_v_offset, |
| unsigned int *buffer_name, |
| void **buffer |
| ); |
| |
| VAStatus vaUnlockSurface(VADisplay dpy, |
| VASurfaceID surface |
| ); |
| } |
| |
| VASurfaceMap::VASurfaceMap(VADisplay display, int hwcap) { |
| |
| mVADisplay = display; |
| mSupportedSurfaceMemType = hwcap; |
| mValue = 0; |
| mVASurface = VA_INVALID_SURFACE; |
| mTracked = false; |
| mAction = 0; |
| memset(&mVinfo, 0, sizeof(ValueInfo)); |
| #ifdef IMG_GFX |
| mGfxHandle = NULL; |
| #endif |
| } |
| |
| VASurfaceMap::~VASurfaceMap() { |
| |
| if (!mTracked && (mVASurface != VA_INVALID_SURFACE)) |
| vaDestroySurfaces(mVADisplay, &mVASurface, 1); |
| |
| #ifdef IMG_GFX |
| if (mGfxHandle) |
| gfx_free(mGfxHandle); |
| #endif |
| } |
| |
| Encode_Status VASurfaceMap::doMapping() { |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| |
| if (mVASurface == VA_INVALID_SURFACE) { |
| |
| int width = mVASurfaceWidth = mVinfo.width; |
| int height = mVASurfaceHeight = mVinfo.height; |
| int stride = mVASurfaceStride = mVinfo.lumaStride; |
| |
| if (mAction & MAP_ACTION_COLORCONVERT) { |
| |
| //only support gfx buffer |
| if (mVinfo.mode != MEM_MODE_GFXHANDLE) |
| return ENCODE_NOT_SUPPORTED; |
| |
| #ifdef IMG_GFX //only enable on IMG chip |
| |
| //do not trust valueinfo for gfx case, directly get from structure |
| ValueInfo tmp; |
| |
| ret = GetGfxBufferInfo(mValue, tmp); |
| CHECK_ENCODE_STATUS_RETURN("GetGfxBufferInfo"); |
| width = tmp.width; |
| height = tmp.height; |
| stride = tmp.lumaStride; |
| |
| if (HAL_PIXEL_FORMAT_NV12 == tmp.format || OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar == tmp.format) |
| mAction &= ~MAP_ACTION_COLORCONVERT; |
| else { |
| //allocate new gfx buffer if format is not NV12 |
| int usage = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE; |
| |
| //use same size with original and HAL_PIXEL_FORMAT_NV12 format |
| if (gfx_alloc(width, height, HAL_PIXEL_FORMAT_NV12, usage, &mGfxHandle, &stride) != 0) |
| return ENCODE_DRIVER_FAIL; |
| |
| LOG_V("Create an new gfx buffer handle 0x%p for color convert, width=%d, height=%d, stride=%d\n", |
| mGfxHandle, width, height, stride); |
| } |
| |
| #else |
| return ENCODE_NOT_SUPPORTED; |
| #endif |
| } |
| |
| if (mAction & MAP_ACTION_ALIGN64 && stride % 64 != 0) { |
| //check if stride is not 64 aligned, must allocate new 64 aligned vasurface |
| stride = (stride + 63 ) & ~63; |
| mAction |= MAP_ACTION_COPY; |
| } |
| |
| if(mAction & MAP_ACTION_ALIGN64 && width <= 320 && height <= 240) { |
| mAction |= MAP_ACTION_COPY; |
| } |
| |
| if (mAction & MAP_ACTION_COPY) { //must allocate new vasurface(EXternalMemoryNULL, uncached) |
| //allocate new vasurface |
| mVASurface = CreateNewVASurface(mVADisplay, stride, height); |
| if (mVASurface == VA_INVALID_SURFACE) |
| return ENCODE_DRIVER_FAIL; |
| mVASurfaceWidth = mVASurfaceStride = stride; |
| mVASurfaceHeight = height; |
| LOGI("create new vaSurface for MAP_ACTION_COPY\n"); |
| } else { |
| #ifdef IMG_GFX |
| if (mGfxHandle != NULL) { |
| //map new gfx handle to vasurface |
| ret = MappingGfxHandle((intptr_t)mGfxHandle); |
| CHECK_ENCODE_STATUS_RETURN("MappingGfxHandle"); |
| LOGV("map new allocated gfx handle to vaSurface\n"); |
| } else |
| #endif |
| { |
| //map original value to vasurface |
| ret = MappingToVASurface(); |
| CHECK_ENCODE_STATUS_RETURN("MappingToVASurface"); |
| } |
| } |
| } |
| |
| if (mAction & MAP_ACTION_COLORCONVERT) { |
| ret = doActionColConv(); |
| CHECK_ENCODE_STATUS_RETURN("doActionColConv"); |
| } |
| |
| if (mAction & MAP_ACTION_COPY) { |
| //keep src color format is NV12, then do copy |
| ret = doActionCopy(); |
| CHECK_ENCODE_STATUS_RETURN("doActionCopy"); |
| } |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VASurfaceMap::MappingToVASurface() { |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| |
| if (mVASurface != VA_INVALID_SURFACE) { |
| LOG_I("VASurface is already set before, nothing to do here\n"); |
| return ENCODE_SUCCESS; |
| } |
| LOG_V("MappingToVASurface mode=%d, value=%p\n", mVinfo.mode, (void*)mValue); |
| |
| const char *mode = NULL; |
| switch (mVinfo.mode) { |
| case MEM_MODE_SURFACE: |
| mode = "SURFACE"; |
| ret = MappingSurfaceID(mValue); |
| break; |
| case MEM_MODE_GFXHANDLE: |
| mode = "GFXHANDLE"; |
| ret = MappingGfxHandle(mValue); |
| break; |
| case MEM_MODE_KBUFHANDLE: |
| mode = "KBUFHANDLE"; |
| ret = MappingKbufHandle(mValue); |
| break; |
| case MEM_MODE_MALLOC: |
| case MEM_MODE_NONECACHE_USRPTR: |
| mode = "MALLOC or NONCACHE_USRPTR"; |
| ret = MappingMallocPTR(mValue); |
| break; |
| case MEM_MODE_ION: |
| case MEM_MODE_V4L2: |
| case MEM_MODE_USRPTR: |
| case MEM_MODE_CI: |
| default: |
| LOG_I("UnSupported memory mode 0x%08x", mVinfo.mode); |
| return ENCODE_NOT_SUPPORTED; |
| } |
| |
| LOG_V("%s: Format=%x, lumaStride=%d, width=%d, height=%d\n", mode, mVinfo.format, mVinfo.lumaStride, mVinfo.width, mVinfo.height); |
| LOG_V("vaSurface 0x%08x is created for value = 0x%p\n", mVASurface, (void*)mValue); |
| |
| return ret; |
| } |
| |
| Encode_Status VASurfaceMap::MappingSurfaceID(intptr_t value) { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| VASurfaceID surface; |
| |
| //try to get kbufhandle from SurfaceID |
| uint32_t fourCC = 0; |
| uint32_t lumaStride = 0; |
| uint32_t chromaUStride = 0; |
| uint32_t chromaVStride = 0; |
| uint32_t lumaOffset = 0; |
| uint32_t chromaUOffset = 0; |
| uint32_t chromaVOffset = 0; |
| uint32_t kBufHandle = 0; |
| |
| vaStatus = vaLockSurface( |
| (VADisplay)mVinfo.handle, (VASurfaceID)value, |
| &fourCC, &lumaStride, &chromaUStride, &chromaVStride, |
| &lumaOffset, &chromaUOffset, &chromaVOffset, &kBufHandle, NULL); |
| |
| CHECK_VA_STATUS_RETURN("vaLockSurface"); |
| LOG_V("Surface incoming = 0x%p\n", (void*)value); |
| LOG_V("lumaStride = %d, chromaUStride = %d, chromaVStride=%d\n", lumaStride, chromaUStride, chromaVStride); |
| LOG_V("lumaOffset = %d, chromaUOffset = %d, chromaVOffset = %d\n", lumaOffset, chromaUOffset, chromaVOffset); |
| LOG_V("kBufHandle = 0x%08x, fourCC = %d\n", kBufHandle, fourCC); |
| |
| vaStatus = vaUnlockSurface((VADisplay)mVinfo.handle, (VASurfaceID)value); |
| CHECK_VA_STATUS_RETURN("vaUnlockSurface"); |
| |
| mVinfo.mode = MEM_MODE_KBUFHANDLE; |
| mVinfo.size = mVinfo.lumaStride * mVinfo.height * 1.5; |
| |
| mVASurface = CreateSurfaceFromExternalBuf(kBufHandle, mVinfo); |
| if (mVASurface == VA_INVALID_SURFACE) |
| return ENCODE_INVALID_SURFACE; |
| |
| mVASurfaceWidth = mVinfo.width; |
| mVASurfaceHeight = mVinfo.height; |
| mVASurfaceStride = mVinfo.lumaStride; |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VASurfaceMap::MappingGfxHandle(intptr_t value) { |
| |
| LOG_V("MappingGfxHandle %p......\n", (void*)value); |
| LOG_V("format = 0x%08x, lumaStride = %d in ValueInfo\n", mVinfo.format, mVinfo.lumaStride); |
| |
| //default value for all HW platforms, maybe not accurate |
| mVASurfaceWidth = mVinfo.width; |
| mVASurfaceHeight = mVinfo.height; |
| mVASurfaceStride = mVinfo.lumaStride; |
| |
| #ifdef IMG_GFX |
| Encode_Status ret; |
| ValueInfo tmp; |
| |
| ret = GetGfxBufferInfo(value, tmp); |
| CHECK_ENCODE_STATUS_RETURN("GetGfxBufferInfo"); |
| mVASurfaceWidth = tmp.width; |
| mVASurfaceHeight = tmp.height; |
| mVASurfaceStride = tmp.lumaStride; |
| #endif |
| |
| LOG_V("Mapping vasurface Width=%d, Height=%d, Stride=%d\n", mVASurfaceWidth, mVASurfaceHeight, mVASurfaceStride); |
| |
| ValueInfo vinfo; |
| memset(&vinfo, 0, sizeof(ValueInfo)); |
| vinfo.mode = MEM_MODE_GFXHANDLE; |
| vinfo.width = mVASurfaceWidth; |
| vinfo.height = mVASurfaceHeight; |
| vinfo.lumaStride = mVASurfaceStride; |
| mVASurface = CreateSurfaceFromExternalBuf(value, vinfo); |
| if (mVASurface == VA_INVALID_SURFACE) |
| return ENCODE_INVALID_SURFACE; |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VASurfaceMap::MappingKbufHandle(intptr_t value) { |
| |
| LOG_V("MappingKbufHandle value=%p\n", (void*)value); |
| |
| mVinfo.size = mVinfo.lumaStride * mVinfo.height * 1.5; |
| mVASurface = CreateSurfaceFromExternalBuf(value, mVinfo); |
| if (mVASurface == VA_INVALID_SURFACE) |
| return ENCODE_INVALID_SURFACE; |
| |
| mVASurfaceWidth = mVinfo.width; |
| mVASurfaceHeight = mVinfo.height; |
| mVASurfaceStride = mVinfo.lumaStride; |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VASurfaceMap::MappingMallocPTR(intptr_t value) { |
| |
| mVASurface = CreateSurfaceFromExternalBuf(value, mVinfo); |
| if (mVASurface == VA_INVALID_SURFACE) |
| return ENCODE_INVALID_SURFACE; |
| |
| mVASurfaceWidth = mVinfo.width; |
| mVASurfaceHeight = mVinfo.height; |
| mVASurfaceStride = mVinfo.lumaStride; |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| //always copy with same color format NV12 |
| Encode_Status VASurfaceMap::doActionCopy() { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| |
| uint32_t width = 0, height = 0, stride = 0; |
| uint8_t *pSrcBuffer, *pDestBuffer; |
| intptr_t handle = 0; |
| |
| LOG_V("Copying Src Buffer data to VASurface\n"); |
| |
| if (mVinfo.mode != MEM_MODE_MALLOC && mVinfo.mode != MEM_MODE_GFXHANDLE) { |
| LOG_E("Not support copy in mode %d", mVinfo.mode); |
| return ENCODE_NOT_SUPPORTED; |
| } |
| |
| LOG_V("Src Buffer information\n"); |
| LOG_V("Mode = %d, width = %d, stride = %d, height = %d\n", |
| mVinfo.mode, mVinfo.width, mVinfo.lumaStride, mVinfo.height); |
| |
| uint32_t srcY_offset, srcUV_offset; |
| uint32_t srcY_pitch, srcUV_pitch; |
| |
| if (mVinfo.mode == MEM_MODE_MALLOC) { |
| width = mVinfo.width; |
| height = mVinfo.height; |
| stride = mVinfo.lumaStride; |
| pSrcBuffer = (uint8_t*) mValue; |
| srcY_offset = 0; |
| srcUV_offset = stride * height; |
| srcY_pitch = stride; |
| srcUV_pitch = stride; |
| } else { |
| |
| #ifdef IMG_GFX //only enable on IMG chips |
| int usage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_SW_READ_OFTEN; |
| |
| //do not trust valueinfo, directly get from structure |
| Encode_Status ret; |
| ValueInfo tmp; |
| |
| if (mGfxHandle) |
| handle = (intptr_t) mGfxHandle; |
| else |
| handle = mValue; |
| |
| ret = GetGfxBufferInfo(handle, tmp); |
| CHECK_ENCODE_STATUS_RETURN("GetGfxBufferInfo"); |
| width = tmp.width; |
| height = tmp.height; |
| stride = tmp.lumaStride; |
| |
| //only support HAL_PIXEL_FORMAT_NV12 & OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar |
| if (HAL_PIXEL_FORMAT_NV12 != tmp.format && OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar != tmp.format) { |
| LOG_E("Not support gfx buffer format %x", tmp.format); |
| return ENCODE_NOT_SUPPORTED; |
| } |
| |
| srcY_offset = 0; |
| srcUV_offset = stride * height; |
| srcY_pitch = stride; |
| srcUV_pitch = stride; |
| |
| //lock gfx handle with buffer real size |
| void* vaddr[3]; |
| if (gfx_lock((buffer_handle_t) handle, usage, 0, 0, width, height, &vaddr[0]) != 0) |
| return ENCODE_DRIVER_FAIL; |
| pSrcBuffer = (uint8_t*)vaddr[0]; |
| #else |
| |
| return ENCODE_NOT_SUPPORTED; |
| #endif |
| } |
| |
| |
| VAImage destImage; |
| vaStatus = vaDeriveImage(mVADisplay, mVASurface, &destImage); |
| CHECK_VA_STATUS_RETURN("vaDeriveImage"); |
| vaStatus = vaMapBuffer(mVADisplay, destImage.buf, (void **)&pDestBuffer); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| LOG_V("\nDest VASurface information\n"); |
| LOG_V("pitches[0] = %d\n", destImage.pitches[0]); |
| LOG_V("pitches[1] = %d\n", destImage.pitches[1]); |
| LOG_V("offsets[0] = %d\n", destImage.offsets[0]); |
| LOG_V("offsets[1] = %d\n", destImage.offsets[1]); |
| LOG_V("num_planes = %d\n", destImage.num_planes); |
| LOG_V("width = %d\n", destImage.width); |
| LOG_V("height = %d\n", destImage.height); |
| |
| if (width > destImage.width || height > destImage.height) { |
| LOG_E("src buffer is bigger than destination buffer\n"); |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| uint8_t *srcY, *dstY; |
| uint8_t *srcU, *srcV; |
| uint8_t *srcUV, *dstUV; |
| |
| srcY = pSrcBuffer + srcY_offset; |
| dstY = pDestBuffer + destImage.offsets[0]; |
| srcUV = pSrcBuffer + srcUV_offset; |
| dstUV = pDestBuffer + destImage.offsets[1]; |
| |
| for (uint32_t i = 0; i < height; i++) { |
| memcpy(dstY, srcY, width); |
| srcY += srcY_pitch; |
| dstY += destImage.pitches[0]; |
| } |
| |
| for (uint32_t i = 0; i < height / 2; i++) { |
| memcpy(dstUV, srcUV, width); |
| srcUV += srcUV_pitch; |
| dstUV += destImage.pitches[1]; |
| } |
| |
| vaStatus = vaUnmapBuffer(mVADisplay, destImage.buf); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| vaStatus = vaDestroyImage(mVADisplay, destImage.image_id); |
| CHECK_VA_STATUS_RETURN("vaDestroyImage"); |
| |
| #ifdef IMG_GFX |
| if (mVinfo.mode == MEM_MODE_GFXHANDLE) { |
| //unlock gfx handle |
| gfx_unlock((buffer_handle_t) handle); |
| } |
| #endif |
| LOG_V("Copying Src Buffer data to VASurface Complete\n"); |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VASurfaceMap::doActionColConv() { |
| |
| #ifdef IMG_GFX |
| if (mGfxHandle == NULL) { |
| LOG_E("something wrong, why new gfxhandle is not allocated? \n"); |
| return ENCODE_FAIL; |
| } |
| |
| LOG_V("doActionColConv gfx_Blit width=%d, height=%d\n", mVinfo.width, mVinfo.height); |
| if (gfx_Blit((buffer_handle_t)mValue, mGfxHandle, |
| mVinfo.width, mVinfo.height, 0, 0) != 0) |
| return ENCODE_DRIVER_FAIL; |
| |
| #ifdef GFX_DUMP |
| LOG_I("dumpping gfx data.....\n"); |
| DumpGfx(mValue, "/data/dump.rgb"); |
| DumpGfx((intptr_t)mGfxHandle, "/data/dump.yuv"); |
| #endif |
| return ENCODE_SUCCESS; |
| |
| #else |
| return ENCODE_NOT_SUPPORTED; |
| #endif |
| } |
| |
| VASurfaceID VASurfaceMap::CreateSurfaceFromExternalBuf(intptr_t value, ValueInfo& vinfo) { |
| |
| VAStatus vaStatus; |
| VASurfaceAttribExternalBuffers extbuf; |
| VASurfaceAttrib attribs[2]; |
| VASurfaceID surface = VA_INVALID_SURFACE; |
| int type; |
| unsigned long data = value; |
| |
| extbuf.pixel_format = VA_FOURCC_NV12; |
| extbuf.width = vinfo.width; |
| extbuf.height = vinfo.height; |
| extbuf.data_size = vinfo.size; |
| if (extbuf.data_size == 0) |
| extbuf.data_size = vinfo.lumaStride * vinfo.height * 1.5; |
| extbuf.num_buffers = 1; |
| extbuf.num_planes = 3; |
| extbuf.pitches[0] = vinfo.lumaStride; |
| extbuf.pitches[1] = vinfo.lumaStride; |
| extbuf.pitches[2] = vinfo.lumaStride; |
| extbuf.pitches[3] = 0; |
| extbuf.offsets[0] = 0; |
| extbuf.offsets[1] = vinfo.lumaStride * vinfo.height; |
| extbuf.offsets[2] = extbuf.offsets[1]; |
| extbuf.offsets[3] = 0; |
| extbuf.buffers = &data; |
| extbuf.flags = 0; |
| extbuf.private_data = NULL; |
| |
| switch(vinfo.mode) { |
| case MEM_MODE_GFXHANDLE: |
| type = VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC; |
| break; |
| case MEM_MODE_KBUFHANDLE: |
| type = VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM; |
| break; |
| case MEM_MODE_MALLOC: |
| type = VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR; |
| break; |
| case MEM_MODE_NONECACHE_USRPTR: |
| type = VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR; |
| extbuf.flags |= VA_SURFACE_EXTBUF_DESC_UNCACHED; |
| break; |
| case MEM_MODE_SURFACE: |
| case MEM_MODE_ION: |
| case MEM_MODE_V4L2: |
| case MEM_MODE_USRPTR: |
| case MEM_MODE_CI: |
| default: |
| //not support |
| return VA_INVALID_SURFACE; |
| } |
| |
| if (!(mSupportedSurfaceMemType & type)) |
| return VA_INVALID_SURFACE; |
| |
| attribs[0].type = (VASurfaceAttribType)VASurfaceAttribMemoryType; |
| attribs[0].flags = VA_SURFACE_ATTRIB_SETTABLE; |
| attribs[0].value.type = VAGenericValueTypeInteger; |
| attribs[0].value.value.i = type; |
| |
| attribs[1].type = (VASurfaceAttribType)VASurfaceAttribExternalBufferDescriptor; |
| attribs[1].flags = VA_SURFACE_ATTRIB_SETTABLE; |
| attribs[1].value.type = VAGenericValueTypePointer; |
| attribs[1].value.value.p = (void *)&extbuf; |
| |
| vaStatus = vaCreateSurfaces(mVADisplay, VA_RT_FORMAT_YUV420, vinfo.width, |
| vinfo.height, &surface, 1, attribs, 2); |
| if (vaStatus != VA_STATUS_SUCCESS){ |
| LOG_E("vaCreateSurfaces failed. vaStatus = %d\n", vaStatus); |
| surface = VA_INVALID_SURFACE; |
| } |
| return surface; |
| } |
| |
| VASurfaceID CreateNewVASurface(VADisplay display, int32_t width, int32_t height) { |
| |
| VAStatus vaStatus; |
| VASurfaceID surface = VA_INVALID_SURFACE; |
| VASurfaceAttrib attribs[2]; |
| VASurfaceAttribExternalBuffers extbuf; |
| unsigned long data; |
| |
| extbuf.pixel_format = VA_FOURCC_NV12; |
| extbuf.width = width; |
| extbuf.height = height; |
| extbuf.data_size = width * height * 3 / 2; |
| extbuf.num_buffers = 1; |
| extbuf.num_planes = 3; |
| extbuf.pitches[0] = width; |
| extbuf.pitches[1] = width; |
| extbuf.pitches[2] = width; |
| extbuf.pitches[3] = 0; |
| extbuf.offsets[0] = 0; |
| extbuf.offsets[1] = width * height; |
| extbuf.offsets[2] = extbuf.offsets[1]; |
| extbuf.offsets[3] = 0; |
| extbuf.buffers = &data; |
| extbuf.flags = 0; |
| extbuf.private_data = NULL; |
| |
| attribs[0].type = (VASurfaceAttribType)VASurfaceAttribMemoryType; |
| attribs[0].flags = VA_SURFACE_ATTRIB_SETTABLE; |
| attribs[0].value.type = VAGenericValueTypeInteger; |
| attribs[0].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA; |
| |
| attribs[1].type = (VASurfaceAttribType)VASurfaceAttribExternalBufferDescriptor; |
| attribs[1].flags = VA_SURFACE_ATTRIB_SETTABLE; |
| attribs[1].value.type = VAGenericValueTypePointer; |
| attribs[1].value.value.p = (void *)&extbuf; |
| |
| vaStatus = vaCreateSurfaces(display, VA_RT_FORMAT_YUV420, width, |
| height, &surface, 1, attribs, 2); |
| if (vaStatus != VA_STATUS_SUCCESS) |
| LOG_E("vaCreateSurfaces failed. vaStatus = %d\n", vaStatus); |
| |
| return surface; |
| } |