| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "VideoVPPBase" |
| |
| #include "VideoVPPBase.h" |
| |
| #define NATIVE_DISPLAY 0x18c34078 |
| |
| #define CHECK_VA_STATUS(FUNC) \ |
| if (vret != VA_STATUS_SUCCESS) {\ |
| LOGE("[%d] " FUNC" failed with 0x%x\n", __LINE__, vret);\ |
| return vret;\ |
| } |
| |
| VPParameters::VPParameters(VideoVPPBase *vvb) { |
| va_display = vvb->va_display; |
| va_context = vvb->va_context; |
| |
| vret = init(); |
| |
| if (vret != VA_STATUS_SUCCESS) |
| mInitialized = false; |
| else |
| mInitialized = true; |
| } |
| |
| VPParameters* VPParameters::create(VideoVPPBase *vvb) { |
| VPParameters* v = new VPParameters(vvb); |
| |
| if (v->mInitialized) |
| return v; |
| else |
| return NULL; |
| } |
| |
| VAStatus VPParameters::init() { |
| num_supported_filters = VAProcFilterCount; |
| vret = vaQueryVideoProcFilters(va_display, |
| va_context, supported_filters, |
| &num_supported_filters); |
| CHECK_VA_STATUS("vaQueryVideoProcFilters"); |
| |
| for (size_t i = 0; i < num_supported_filters; i++) { |
| switch(supported_filters[i]) { |
| case VAProcFilterNoiseReduction: |
| num_denoise_caps = 1; |
| vret = vaQueryVideoProcFilterCaps(va_display, va_context, |
| VAProcFilterNoiseReduction, &denoise_caps, &num_denoise_caps); |
| CHECK_VA_STATUS("vaQueryVideoProcFilterCaps"); |
| |
| nr.valid = true; |
| nr.min = denoise_caps.range.min_value; |
| nr.max = denoise_caps.range.max_value; |
| nr.def = denoise_caps.range.default_value; |
| nr.step = denoise_caps.range.step; |
| nr.cur = 0.0; |
| break; |
| |
| case VAProcFilterSharpening: |
| num_sharpen_caps = 1; |
| vret = vaQueryVideoProcFilterCaps(va_display, va_context, |
| VAProcFilterSharpening, &sharpen_caps, &num_sharpen_caps); |
| CHECK_VA_STATUS("vaQueryVideoProcFilterCaps"); |
| |
| sharpen.valid = true; |
| sharpen.min = sharpen_caps.range.min_value; |
| sharpen.max = sharpen_caps.range.max_value; |
| sharpen.def = sharpen_caps.range.default_value; |
| sharpen.step = sharpen_caps.range.step; |
| sharpen.cur = 0.0; |
| break; |
| |
| case VAProcFilterDeblocking: |
| num_denoise_caps = 1; |
| vret = vaQueryVideoProcFilterCaps(va_display, va_context, |
| VAProcFilterDeblocking, &deblock_caps, &num_deblock_caps); |
| CHECK_VA_STATUS("vaQueryVideoProcFilterCaps"); |
| |
| deblock.valid = true; |
| deblock.min = deblock_caps.range.min_value; |
| deblock.max = deblock_caps.range.max_value; |
| deblock.def = deblock_caps.range.default_value; |
| deblock.step = deblock_caps.range.step; |
| deblock.cur = 0.0; |
| break; |
| |
| case VAProcFilterColorBalance: |
| num_color_balance_caps = VAProcColorBalanceCount; |
| vret = vaQueryVideoProcFilterCaps(va_display, va_context, |
| VAProcFilterColorBalance, &color_balance_caps, &num_color_balance_caps); |
| CHECK_VA_STATUS("vaQueryVideoProcFilterCaps"); |
| |
| for (size_t i = 0; i< num_color_balance_caps; i++) { |
| colorbalance[i].type = color_balance_caps[i].type; |
| colorbalance[i].valid = true; |
| colorbalance[i].min = color_balance_caps[i].range.min_value; |
| colorbalance[i].max = color_balance_caps[i].range.max_value; |
| colorbalance[i].def = color_balance_caps[i].range.default_value; |
| colorbalance[i].step = color_balance_caps[i].range.step; |
| colorbalance[i].cur = 0.0; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| vret = reset(true); |
| CHECK_VA_STATUS("reset"); |
| |
| return vret; |
| } |
| |
| VAStatus VPParameters::buildfilters() { |
| for (size_t i = 0; i < num_supported_filters; i++) { |
| switch (supported_filters[i]) { |
| case VAProcFilterNoiseReduction: |
| if (nr.cur != -1) { |
| denoise_buf.type = VAProcFilterNoiseReduction; |
| denoise_buf.value = nr.min + nr.cur * nr.step; |
| vret = vaCreateBuffer(va_display, va_context, |
| VAProcFilterParameterBufferType, |
| sizeof(denoise_buf), 1, &denoise_buf, &denoise_buf_id); |
| CHECK_VA_STATUS("vaCreateBuffer"); |
| filter_bufs[num_filter_bufs] = denoise_buf_id; |
| num_filter_bufs++; |
| } |
| break; |
| |
| case VAProcFilterDeblocking: |
| if (deblock.cur != -1) { |
| deblock_buf.type = VAProcFilterDeblocking; |
| deblock_buf.value = deblock.min + deblock.cur * deblock.step; |
| vret = vaCreateBuffer(va_display, va_context, |
| VAProcFilterParameterBufferType, |
| sizeof(deblock_buf), 1, &deblock_buf, &deblock_buf_id); |
| CHECK_VA_STATUS("vaCreateBuffer"); |
| filter_bufs[num_filter_bufs] = deblock_buf_id; |
| num_filter_bufs++; |
| } |
| break; |
| |
| case VAProcFilterSharpening: |
| if (sharpen.cur != -1) { |
| sharpen_buf.type = VAProcFilterSharpening; |
| sharpen_buf.value = sharpen.cur; |
| vret = vaCreateBuffer(va_display, va_context, |
| VAProcFilterParameterBufferType, |
| sizeof(sharpen_buf), 1, &sharpen_buf, &sharpen_buf_id); |
| CHECK_VA_STATUS("vaCreateBuffer"); |
| filter_bufs[num_filter_bufs] = sharpen_buf_id; |
| num_filter_bufs++; |
| } |
| break; |
| |
| case VAProcFilterColorBalance: |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| return vret; |
| } |
| |
| VAStatus VPParameters::reset(bool start) { |
| for (size_t i = 0; i < VAProcFilterCount; i++) { |
| if (start) { |
| filter_bufs[i] = VA_INVALID_ID; |
| } else { |
| if (filter_bufs[i] != VA_INVALID_ID) { |
| vret = vaDestroyBuffer(va_display, filter_bufs[i]); |
| CHECK_VA_STATUS("vaDestroyBuffer"); |
| filter_bufs[i] = VA_INVALID_ID; |
| } |
| } |
| } |
| num_filter_bufs = 0; |
| |
| sharpen_buf_id = denoise_buf_id = deblock_buf_id = balance_buf_id = VA_INVALID_ID; |
| memset(&deblock_buf, 0, sizeof(VAProcFilterParameterBuffer)); |
| memset(&sharpen_buf, 0, sizeof(VAProcFilterParameterBuffer)); |
| memset(&denoise_buf, 0, sizeof(VAProcFilterParameterBuffer)); |
| memset(&balance_buf, 0, |
| sizeof(VAProcFilterParameterBufferColorBalance)* VAProcColorBalanceCount); |
| |
| nr.cur = deblock.cur = sharpen.cur = -1; |
| for (size_t i = 0; i < VAProcColorBalanceCount; i++) |
| colorbalance[i].cur = -1; |
| |
| return vret; |
| } |
| |
| VPParameters::~VPParameters() { |
| reset(false); |
| } |
| |
| VideoVPPBase::VideoVPPBase() |
| : mInitialized(false), |
| width(1280), |
| height(720), |
| va_display(NULL), |
| va_config(VA_INVALID_ID), |
| va_context(VA_INVALID_ID), |
| vpp_pipeline_buf(VA_INVALID_ID), |
| SrcSurf(VA_INVALID_SURFACE), |
| DstSurf(VA_INVALID_SURFACE) { |
| |
| } |
| |
| VAStatus VideoVPPBase::start() { |
| if (mInitialized) |
| return VA_STATUS_SUCCESS; |
| |
| int va_major_version, va_minor_version; |
| unsigned int nativeDisplay = NATIVE_DISPLAY; |
| VAConfigAttrib vaAttrib; |
| |
| va_display = vaGetDisplay(&nativeDisplay); |
| |
| vret = vaInitialize(va_display, &va_major_version, &va_minor_version); |
| CHECK_VA_STATUS("vaInitialize"); |
| |
| vaAttrib.type = VAConfigAttribRTFormat; |
| vaAttrib.value = VA_RT_FORMAT_YUV420; |
| vret = vaCreateConfig(va_display, VAProfileNone, |
| VAEntrypointVideoProc, &vaAttrib, 1, &va_config); |
| CHECK_VA_STATUS("vaCreateConfig"); |
| |
| vret = vaCreateContext(va_display, va_config, width, |
| height, 0, NULL, 0, &va_context); |
| CHECK_VA_STATUS("vaCreateContext"); |
| |
| mInitialized = true; |
| |
| return vret; |
| } |
| |
| VAStatus VideoVPPBase::stop() { |
| if (!mInitialized) |
| return VA_STATUS_SUCCESS; |
| |
| int c = SrcSurfHandleMap.size(); |
| for (int i = 0; i < c; i++) { |
| SrcSurf = SrcSurfHandleMap.valueAt(i); |
| if (SrcSurf != VA_INVALID_SURFACE) { |
| vret = vaDestroySurfaces(va_display, &SrcSurf, 1); |
| CHECK_VA_STATUS("vaDestroySurfaces"); |
| } |
| LOGV("remove src surf %x\n", SrcSurf); |
| } |
| SrcSurfHandleMap.clear(); |
| |
| c = DstSurfHandleMap.size(); |
| for (int i = 0; i < c; i++) { |
| DstSurf = DstSurfHandleMap.valueAt(i); |
| if (DstSurf != VA_INVALID_SURFACE) { |
| vret = vaDestroySurfaces(va_display, &DstSurf, 1); |
| CHECK_VA_STATUS("vaDestroySurfaces"); |
| } |
| LOGV("remove dst surf %x\n", DstSurf); |
| } |
| DstSurfHandleMap.clear(); |
| |
| if (vpp_pipeline_buf != VA_INVALID_ID) { |
| vret = vaDestroyBuffer(va_display, vpp_pipeline_buf); |
| CHECK_VA_STATUS("vaDestroyBuffer"); |
| vpp_pipeline_buf = VA_INVALID_ID; |
| } |
| |
| if (va_context != VA_INVALID_ID) { |
| vret = vaDestroyContext(va_display, va_context); |
| CHECK_VA_STATUS("vaDestroyContext"); |
| va_context = VA_INVALID_ID; |
| } |
| |
| if (va_config != VA_INVALID_ID) { |
| vret = vaDestroyConfig(va_display, va_config); |
| CHECK_VA_STATUS("vaDestroyConfig"); |
| va_config = VA_INVALID_ID; |
| } |
| |
| if (va_display != NULL) { |
| vret = vaTerminate(va_display); |
| CHECK_VA_STATUS("vaTerminate"); |
| va_display = NULL; |
| } |
| |
| mInitialized = false; |
| |
| return vret; |
| } |
| |
| VAStatus VideoVPPBase::_CreateSurfaceFromGrallocHandle(RenderTarget rt, VASurfaceID *surf) { |
| unsigned int buffer; |
| VASurfaceAttrib SurfAttrib; |
| VASurfaceAttribExternalBuffers SurfExtBuf; |
| |
| SurfExtBuf.pixel_format = rt.pixel_format; |
| SurfExtBuf.width = rt.width; |
| SurfExtBuf.height = rt.height; |
| SurfExtBuf.pitches[0] = rt.stride; |
| buffer = rt.handle; |
| SurfExtBuf.buffers = (unsigned long*)&buffer; |
| SurfExtBuf.num_buffers = 1; |
| if (rt.type == RenderTarget::KERNEL_DRM) |
| SurfExtBuf.flags = VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM; |
| else |
| SurfExtBuf.flags = VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC; |
| |
| SurfAttrib.type = (VASurfaceAttribType)VASurfaceAttribExternalBufferDescriptor; |
| SurfAttrib.flags = VA_SURFACE_ATTRIB_SETTABLE; |
| SurfAttrib.value.type = VAGenericValueTypePointer; |
| SurfAttrib.value.value.p = &SurfExtBuf; |
| |
| vret = vaCreateSurfaces(va_display, rt.format, |
| rt.width, rt.height, surf, 1, |
| &SurfAttrib, 1); |
| CHECK_VA_STATUS("vaCreateSurfaces"); |
| |
| return vret; |
| } |
| |
| VAStatus VideoVPPBase::_perform(VASurfaceID SrcSurf, VARectangle SrcRect, |
| VASurfaceID DstSurf, VARectangle DstRect, bool no_wait) { |
| vpp_param.surface = SrcSurf; |
| vpp_param.output_region = &DstRect; |
| vpp_param.surface_region = &SrcRect; |
| vpp_param.surface_color_standard = VAProcColorStandardBT601; |
| vpp_param.output_background_color = 0; |
| vpp_param.output_color_standard = VAProcColorStandardBT601; |
| vpp_param.filter_flags = VA_FRAME_PICTURE; |
| vpp_param.filters = filter_bufs; |
| vpp_param.num_filters = num_filter_bufs; |
| vpp_param.forward_references = NULL; |
| vpp_param.num_forward_references = 0; |
| vpp_param.backward_references = NULL; |
| vpp_param.num_backward_references = 0; |
| vpp_param.blend_state = NULL; |
| vpp_param.rotation_state = VA_ROTATION_NONE; |
| vpp_param.mirror_state = VA_MIRROR_NONE; |
| |
| vret = vaCreateBuffer(va_display, va_context, |
| VAProcPipelineParameterBufferType, |
| sizeof(VAProcPipelineParameterBuffer), |
| 1, &vpp_param, &vpp_pipeline_buf); |
| CHECK_VA_STATUS("vaCreateBuffer"); |
| |
| vret = vaBeginPicture(va_display, va_context, DstSurf); |
| CHECK_VA_STATUS("vaBeginPicture"); |
| |
| vret = vaRenderPicture(va_display, va_context, &vpp_pipeline_buf, 1); |
| CHECK_VA_STATUS("vaRenderPicture"); |
| |
| vret = vaEndPicture(va_display, va_context); |
| CHECK_VA_STATUS("vaEndPicture"); |
| |
| if (!no_wait) { |
| vret = vaSyncSurface(va_display, DstSurf); |
| CHECK_VA_STATUS("vaSyncSurface"); |
| } |
| |
| vret = vaDestroyBuffer(va_display, vpp_pipeline_buf); |
| CHECK_VA_STATUS("vaDestroyBuffer"); |
| vpp_pipeline_buf = VA_INVALID_ID; |
| |
| return vret; |
| } |
| |
| VAStatus VideoVPPBase::perform(RenderTarget Src, RenderTarget Dst, VPParameters *vpp, bool no_wait) { |
| if (!mInitialized) { |
| vret = start(); |
| CHECK_VA_STATUS("start"); |
| } |
| |
| ssize_t i = SrcSurfHandleMap.indexOfKey(Src.handle); |
| if (i >= 0) { |
| SrcSurf = SrcSurfHandleMap.valueAt(i); |
| } else { |
| vret = _CreateSurfaceFromGrallocHandle(Src, &SrcSurf); |
| CHECK_VA_STATUS("_CreateSurfaceFromGrallocHandle"); |
| SrcSurfHandleMap.add(Src.handle, SrcSurf); |
| LOGV("add src surface %x\n", SrcSurf); |
| } |
| |
| i = DstSurfHandleMap.indexOfKey(Dst.handle); |
| if (i >= 0) { |
| DstSurf = DstSurfHandleMap.valueAt(i); |
| } else { |
| vret = _CreateSurfaceFromGrallocHandle(Dst, &DstSurf); |
| CHECK_VA_STATUS("_CreateSurfaceFromGrallocHandle"); |
| DstSurfHandleMap.add(Dst.handle, DstSurf); |
| LOGV("add dst surface %x\n", DstSurf); |
| } |
| |
| if (vpp != NULL && (vpp->num_filter_bufs > 0 && vpp->num_filter_bufs < VAProcFilterCount)) { |
| memcpy(filter_bufs, vpp->filter_bufs, sizeof(VABufferID) * vpp->num_filter_bufs); |
| num_filter_bufs = vpp->num_filter_bufs; |
| } else { |
| num_filter_bufs = 0; |
| } |
| |
| vret = _perform(SrcSurf, Src.rect, DstSurf, Dst.rect, no_wait); |
| CHECK_VA_STATUS("_perform"); |
| |
| return vret; |
| } |
| |
| VideoVPPBase::~VideoVPPBase() { |
| stop(); |
| } |
