| #include "JPEGDecoder.h" |
| #include "JPEGBlitter.h" |
| #include "JPEGCommon_Gen.h" |
| #include <utils/threads.h> |
| #include <utils/Timers.h> |
| #include <stdio.h> |
| #ifdef NDEBUG |
| #undef NDEBUG |
| #endif |
| #include <assert.h> |
| #include <hardware/gralloc.h> |
| |
| static char jpgfile[100]; |
| |
| RenderTarget& init_render_target_drm(RenderTarget &target, int width, int height, uint32_t fourcc, buffer_handle_t *handle) |
| { |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| int stride, bpp, err; |
| bpp = fourcc2LumaBitsPerPixel(fourcc); |
| err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err || !module) { |
| printf("%s failed to get gralloc module\n", __PRETTY_FUNCTION__); |
| assert(false); |
| } |
| gralloc_module = (struct gralloc_module_t *)module; |
| err = gralloc_open(module, &allocdev); |
| if (err || !allocdev) { |
| printf("%s failed to open alloc device\n", __PRETTY_FUNCTION__); |
| assert(false); |
| } |
| err = allocdev->alloc(allocdev, |
| width, |
| height, |
| fourcc2PixelFormat(fourcc), |
| GRALLOC_USAGE_HW_RENDER, |
| handle, |
| &stride); |
| if (err) { |
| gralloc_close(allocdev); |
| printf("%s failed to allocate surface %d, %dx%d, pixelformat %x\n", __PRETTY_FUNCTION__, err, |
| width, height, fourcc2PixelFormat(fourcc)); |
| assert(false); |
| } |
| unsigned long boname; |
| err = gralloc_module->perform(gralloc_module, |
| INTEL_UFO_GRALLOC_MODULE_PERFORM_GET_BO_NAME, |
| *handle, |
| &boname); |
| assert(!err); |
| target.type = RenderTarget::KERNEL_DRM; |
| target.handle = (int)boname; |
| switch(fourcc) { |
| case VA_FOURCC_NV12: |
| case VA_FOURCC_422H: |
| case VA_FOURCC_422V: |
| case VA_FOURCC_IMC3: |
| case VA_FOURCC_444P: |
| case VA_FOURCC_411P: |
| case VA_FOURCC('4','0','0','P'): |
| target.width = aligned_width(width, SURF_TILING_Y); |
| target.height = aligned_height(height, SURF_TILING_Y); |
| break; |
| default: |
| target.width = aligned_width(width, SURF_TILING_NONE); |
| target.height = aligned_height(height, SURF_TILING_NONE); |
| break; |
| } |
| target.format = fourcc2VaFormat(fourcc); |
| target.pixel_format = fourcc; |
| target.rect.x = target.rect.y = 0; |
| target.rect.width = width; |
| target.rect.height = height; |
| target.stride = stride * bpp; |
| gralloc_close(allocdev); |
| return target; |
| } |
| |
| RenderTarget& init_render_target_gralloc(RenderTarget &target, int width, int height, uint32_t fourcc) |
| { |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| buffer_handle_t handle; |
| int stride, bpp, err; |
| bpp = fourcc2LumaBitsPerPixel(fourcc); |
| err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err || !module) { |
| printf("%s failed to get gralloc module\n", __PRETTY_FUNCTION__); |
| assert(false); |
| } |
| gralloc_module = (struct gralloc_module_t *)module; |
| err = gralloc_open(module, &allocdev); |
| if (err || !allocdev) { |
| printf("%s failed to open alloc device\n", __PRETTY_FUNCTION__); |
| assert(false); |
| } |
| err = allocdev->alloc(allocdev, |
| width, |
| height, |
| fourcc2PixelFormat(fourcc), |
| GRALLOC_USAGE_HW_RENDER, |
| &handle, |
| &stride); |
| if (err) { |
| gralloc_close(allocdev); |
| printf("%s failed to allocate surface %d, %dx%d, pixelformat %x\n", __PRETTY_FUNCTION__, err, |
| width, height, fourcc2PixelFormat(fourcc)); |
| assert(false); |
| } |
| target.type = RenderTarget::ANDROID_GRALLOC; |
| target.handle = (int)handle; |
| switch(fourcc) { |
| case VA_FOURCC_NV12: |
| case VA_FOURCC_YUY2: |
| case VA_FOURCC_UYVY: |
| case VA_FOURCC_422H: |
| case VA_FOURCC_422V: |
| case VA_FOURCC_IMC3: |
| case VA_FOURCC_444P: |
| case VA_FOURCC_411P: |
| case VA_FOURCC('4','0','0','P'): |
| target.width = aligned_width(width, SURF_TILING_Y); |
| target.height = aligned_height(height, SURF_TILING_Y); |
| break; |
| default: |
| target.width = aligned_width(width, SURF_TILING_NONE); |
| target.height = aligned_height(height, SURF_TILING_NONE); |
| break; |
| } |
| |
| target.format = fourcc2VaFormat(fourcc); |
| target.pixel_format = fourcc; |
| target.rect.x = target.rect.y = 0; |
| target.rect.width = width; |
| target.rect.height = height; |
| target.stride = stride * bpp; |
| gralloc_close(allocdev); |
| return target; |
| } |
| |
| RenderTarget& init_render_target_userptr(RenderTarget &target, int width, int height, uint32_t fourcc) |
| { |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| static int surf_hnd = 0; |
| int stride, bpp, err; |
| void * userptr = NULL; |
| size_t mallocsize; |
| bpp = fourcc2LumaBitsPerPixel(fourcc); |
| target.type = RenderTarget::USER_PTR; |
| |
| // all linear, no alignment |
| switch(fourcc) { |
| case VA_FOURCC_NV12: |
| mallocsize = width * height * 3 / 2; |
| break; |
| case VA_FOURCC_YUY2: |
| case VA_FOURCC_UYVY: |
| mallocsize = width * height * 2; |
| break; |
| case VA_FOURCC_422H: |
| mallocsize = width * height * 3; |
| break; |
| case VA_FOURCC_422V: |
| mallocsize = width * height * 2; |
| break; |
| case VA_FOURCC_IMC3: |
| mallocsize = width * height * 2; |
| break; |
| case VA_FOURCC_444P: |
| mallocsize = width * height * 3; |
| break; |
| case VA_FOURCC_411P: |
| mallocsize = width * height * 3; |
| break; |
| case VA_FOURCC_411R: |
| mallocsize = width * height * 3 / 2; |
| break; |
| case VA_FOURCC('4','0','0','P'): |
| mallocsize = width * height; |
| break; |
| case VA_FOURCC_RGBA: |
| case VA_FOURCC_BGRA: |
| mallocsize = width * height * 4; |
| break; |
| default: |
| mallocsize = width * height * 3; |
| break; |
| } |
| userptr = memalign(0x1000, mallocsize); |
| target.width = width; |
| target.height = height; |
| target.pixel_format = fourcc; |
| target.rect.x = target.rect.y = 0; |
| target.rect.width = target.width; |
| target.rect.height = target.height; |
| target.handle = (int)userptr; |
| //target.stride = stride * bpp; |
| return target; |
| } |
| |
| RenderTarget& init_render_target(RenderTarget &target, int width, int height, uint32_t fourcc) |
| { |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| static int surf_hnd = 0; |
| int stride, bpp, err; |
| bpp = fourcc2LumaBitsPerPixel(fourcc); |
| target.type = RenderTarget::INTERNAL_BUF; |
| target.handle = generateHandle(); |
| switch(fourcc) { |
| case VA_FOURCC_NV12: |
| case VA_FOURCC_YUY2: |
| case VA_FOURCC_UYVY: |
| case VA_FOURCC_422H: |
| case VA_FOURCC_422V: |
| case VA_FOURCC_IMC3: |
| case VA_FOURCC_444P: |
| case VA_FOURCC_411P: |
| case VA_FOURCC('4','0','0','P'): |
| target.width = aligned_width(width, SURF_TILING_Y); |
| target.height = aligned_height(height, SURF_TILING_Y); |
| break; |
| default: |
| target.width = aligned_width(width, SURF_TILING_NONE); |
| target.height = aligned_height(height, SURF_TILING_NONE); |
| break; |
| } |
| target.pixel_format = fourcc; |
| target.rect.x = target.rect.y = 0; |
| target.rect.width = target.width; |
| target.rect.height = target.height; |
| //target.stride = stride * bpp; |
| return target; |
| } |
| |
| void deinit_render_target(RenderTarget &target, buffer_handle_t *handle = NULL) |
| { |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err || !module) { |
| printf("%s failed to get gralloc module\n", __PRETTY_FUNCTION__); |
| return; |
| } |
| gralloc_module = (struct gralloc_module_t *)module; |
| err = gralloc_open(module, &allocdev); |
| if (err || !allocdev) { |
| printf("%s failed to get gralloc module\n", __PRETTY_FUNCTION__); |
| return; |
| } |
| if (handle && target.type == RenderTarget::KERNEL_DRM) |
| allocdev->free(allocdev, *handle); |
| else if (target.type == RenderTarget::ANDROID_GRALLOC) |
| allocdev->free(allocdev, (buffer_handle_t)target.handle); |
| else if (target.type == RenderTarget::USER_PTR) |
| free((void*)target.handle); |
| gralloc_close(allocdev); |
| } |
| |
| void decode_blit_functionality_test(RenderTarget::bufType type, uint32_t format, int scale_factor) |
| { |
| JpegDecodeStatus st; |
| VAStatus vast; |
| JpegInfo jpginfo; |
| hw_module_t const* module = NULL; |
| alloc_device_t *allocdev = NULL; |
| struct gralloc_module_t *gralloc_module = NULL; |
| VAStatus vret; |
| char decdumpfile[100]; |
| char origdecdumpfile[100]; |
| char nv12dumpfile[100]; |
| char nv21dumpfile[100]; |
| char yuy2dumpfile[100]; |
| char yv12dumpfile[100]; |
| char rgbadumpfile[100]; |
| FILE* fpdump = NULL; |
| memset(&jpginfo, 0, sizeof(JpegInfo)); |
| memset(decdumpfile, 0, sizeof(decdumpfile)); |
| memset(origdecdumpfile, 0, sizeof(origdecdumpfile)); |
| memset(nv12dumpfile, 0, sizeof(nv12dumpfile)); |
| memset(nv21dumpfile, 0, sizeof(nv21dumpfile)); |
| memset(yuy2dumpfile, 0, sizeof(yuy2dumpfile)); |
| memset(yv12dumpfile, 0, sizeof(yv12dumpfile)); |
| memset(rgbadumpfile, 0, sizeof(rgbadumpfile)); |
| VADisplay display = NULL; |
| VAConfigID vpCfgId = VA_INVALID_ID; |
| VAContextID vpCtxId = VA_INVALID_ID; |
| typedef uint32_t Display; |
| Display dpy; |
| int va_major_version, va_minor_version; |
| VAConfigAttrib vpp_attrib; |
| display = vaGetDisplay(&dpy); |
| vast = vaInitialize(display, &va_major_version, &va_minor_version); |
| assert(vast == VA_STATUS_SUCCESS); |
| vpp_attrib.type = VAConfigAttribRTFormat; |
| vpp_attrib.value = VA_RT_FORMAT_YUV420; |
| vast = vaCreateConfig(display, VAProfileNone, |
| VAEntrypointVideoProc, |
| &vpp_attrib, |
| 1, &vpCfgId); |
| assert(vast == VA_STATUS_SUCCESS); |
| vast = vaCreateContext(display, vpCfgId, 1920, 1080, 0, NULL, 0, &vpCtxId); |
| assert(vast == VA_STATUS_SUCCESS); |
| JpegDecoder decoder(display, vpCfgId, vpCtxId, true); |
| |
| RenderTarget dec_target; |
| buffer_handle_t dec_handle, nv12_handle, yuy2_handle; |
| uint8_t *nv12_mem, *yuy2_mem, *nv21_mem, *yv12_mem, *rgba_mem; |
| int stride; |
| FILE* fp = fopen(jpgfile, "rb"); |
| assert(fp); |
| fseek(fp, 0, SEEK_END); |
| jpginfo.bufsize = ftell(fp); |
| fseek(fp, 0, SEEK_SET); |
| jpginfo.buf = new uint8_t[jpginfo.bufsize]; |
| fread(jpginfo.buf, 1, jpginfo.bufsize, fp); |
| fclose(fp); |
| |
| printf("finished loading src file: size %u\n", jpginfo.bufsize); |
| jpginfo.need_header_only = false; |
| jpginfo.use_vector_input = false; |
| st = decoder.parse(jpginfo); |
| assert(st == JD_SUCCESS); |
| printf("parse succeeded: %ux%u\n", jpginfo.image_width, jpginfo.image_height); |
| |
| if (format == 0) |
| format = jpginfo.image_color_fourcc; |
| |
| char buftypename[100]; |
| switch(type) { |
| case RenderTarget::KERNEL_DRM: |
| sprintf(buftypename, "DRM"); |
| init_render_target_drm(dec_target, jpginfo.image_width, jpginfo.image_height, format, &dec_handle); |
| break; |
| case RenderTarget::ANDROID_GRALLOC: |
| sprintf(buftypename, "GRALLOC"); |
| init_render_target_gralloc(dec_target, jpginfo.image_width, jpginfo.image_height, format); |
| break; |
| case RenderTarget::INTERNAL_BUF: |
| sprintf(buftypename, "DRIVER"); |
| init_render_target(dec_target, jpginfo.image_width, jpginfo.image_height, format); |
| break; |
| default: |
| assert(0); |
| break; |
| } |
| |
| uint32_t aligned_w = aligned_width(jpginfo.image_width, SURF_TILING_Y); |
| uint32_t aligned_h = aligned_height(jpginfo.image_height, SURF_TILING_Y); |
| uint32_t aligned_scaled_w = aligned_width(jpginfo.image_width / scale_factor, SURF_TILING_Y); |
| uint32_t aligned_scaled_h = aligned_width(jpginfo.image_height / scale_factor, SURF_TILING_Y); |
| int err; |
| err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); |
| if (err || !module) { |
| printf("%s failed to get gralloc module\n", __PRETTY_FUNCTION__); |
| assert(false); |
| } |
| gralloc_module = (struct gralloc_module_t *)module; |
| err = gralloc_open(module, &allocdev); |
| if (err || !allocdev) { |
| printf("%s failed to open alloc device\n", __PRETTY_FUNCTION__); |
| assert(false); |
| } |
| err = allocdev->alloc(allocdev, |
| aligned_w, |
| aligned_h, |
| fourcc2PixelFormat(VA_FOURCC_NV12), |
| GRALLOC_USAGE_HW_RENDER, |
| &nv12_handle, |
| &stride); |
| if (err) { |
| printf("%s failed to allocate surface %d, %dx%d, pixelformat %x\n", __PRETTY_FUNCTION__, err, |
| aligned_w, aligned_h, fourcc2PixelFormat(VA_FOURCC_NV12)); |
| assert(false); |
| } |
| err = allocdev->alloc(allocdev, |
| aligned_w, |
| aligned_h, |
| fourcc2PixelFormat(VA_FOURCC_YUY2), |
| GRALLOC_USAGE_HW_RENDER, |
| &yuy2_handle, |
| &stride); |
| if (err) { |
| printf("%s failed to allocate surface %d, %dx%d, pixelformat %x\n", __PRETTY_FUNCTION__, err, |
| aligned_w, aligned_h, fourcc2PixelFormat(VA_FOURCC_YUY2)); |
| assert(false); |
| } |
| |
| nv21_mem = (uint8_t*)memalign(0x1000, aligned_w * aligned_h * 3 / 2); |
| yv12_mem = (uint8_t*)memalign(0x1000, aligned_w * aligned_h * 3 / 2); |
| rgba_mem = (uint8_t*)memalign(0x1000, aligned_scaled_w * aligned_scaled_h * 4); |
| assert(nv21_mem && yv12_mem && rgba_mem); |
| |
| sprintf(decdumpfile, "/sdcard/jpeg_%s_dec_%dx%d.%s", buftypename, jpginfo.image_width, jpginfo.image_height, fourcc2str(format)); |
| sprintf(origdecdumpfile, "/sdcard/jpeg_%s_dec_orig_%dx%d.yuv", buftypename, aligned_w, aligned_h); |
| sprintf(nv12dumpfile, "/sdcard/jpeg_%s_out_%dx%d.nv12", buftypename, aligned_w, aligned_h); |
| sprintf(nv21dumpfile, "/sdcard/jpeg_%s_out_%dx%d.nv21", buftypename, aligned_w, aligned_h); |
| sprintf(yuy2dumpfile, "/sdcard/jpeg_%s_out_%dx%d.yuy2", buftypename, aligned_w, aligned_h); |
| sprintf(yv12dumpfile, "/sdcard/jpeg_%s_out_%dx%d.yv12", buftypename, aligned_w, aligned_h); |
| sprintf(rgbadumpfile, "/sdcard/jpeg_%s_out_%dx%d.rgba", buftypename, aligned_scaled_w, aligned_scaled_h); |
| |
| RenderTarget* targetlist[1] = {&dec_target}; |
| st = decoder.init(jpginfo.image_width, jpginfo.image_height, targetlist, 1); |
| assert(st == JD_SUCCESS); |
| |
| st = decoder.decode(jpginfo, dec_target); |
| printf("decode returns %d\n", st); |
| assert(st == JD_SUCCESS); |
| |
| uint8_t *data; |
| uint32_t offsets[3]; |
| uint32_t pitches[3]; |
| |
| JpegDecoder::MapHandle maphandle = decoder.mapData(dec_target, (void**) &data, offsets, pitches); |
| assert (maphandle); |
| fpdump = fopen(decdumpfile, "wb"); |
| assert(fpdump); |
| int hs, vs, nv12, yuy2, uyvy; |
| hs = vs = nv12 = yuy2 = uyvy = 0; |
| switch(format) { |
| case VA_FOURCC_NV12: |
| nv12 = 1; |
| break; |
| case VA_FOURCC_YUY2: |
| yuy2 = 1; |
| break; |
| case VA_FOURCC_UYVY: |
| uyvy = 1; |
| break; |
| case VA_FOURCC('4','0','0','P'): |
| hs = vs = 0; |
| break; |
| case VA_FOURCC_411P: |
| hs = 4; |
| vs = 1; |
| break; |
| case VA_FOURCC_411R: |
| hs = 1; |
| vs = 4; |
| break; |
| case VA_FOURCC_IMC3: |
| hs = 2; |
| vs = 2; |
| break; |
| case VA_FOURCC_422H: |
| hs = 2; |
| vs = 1; |
| break; |
| case VA_FOURCC_422V: |
| hs = 1; |
| vs = 2; |
| break; |
| case VA_FOURCC_444P: |
| hs = vs = 1; |
| break; |
| default: |
| printf("Invalid format %x\n", format); |
| assert(false); |
| break; |
| } |
| if (nv12) { |
| for (int i = 0; i < jpginfo.image_height; ++i) { |
| fwrite(data + offsets[0] + i * pitches[0], 1, jpginfo.image_width, fpdump); |
| } |
| for (int i = 0; i < jpginfo.image_height/2; ++i) { |
| fwrite(data + offsets[1] + i * pitches[1], 1, jpginfo.image_width, fpdump); |
| } |
| } |
| else if (yuy2 || uyvy) { |
| for (int i = 0; i < jpginfo.image_height; ++i) { |
| fwrite(data + offsets[0] + i * pitches[0], 2, jpginfo.image_width, fpdump); |
| } |
| } |
| else { // yuv planar |
| // Y |
| for (int i = 0; i < jpginfo.image_height; ++i) { |
| fwrite(data + offsets[0] + i * pitches[0], 1, jpginfo.image_width, fpdump); |
| } |
| if (hs != 0 && vs != 0) { |
| // U |
| for (int i = 0; i < jpginfo.image_height / vs; ++i) { |
| fwrite(data + offsets[1] + i * pitches[1], 1, jpginfo.image_width/hs, fpdump); |
| } |
| // V |
| for (int i = 0; i < jpginfo.image_height / vs; ++i) { |
| fwrite(data + offsets[2] + i * pitches[2], 1, jpginfo.image_width/hs, fpdump); |
| } |
| } |
| } |
| fclose(fpdump); |
| printf("Dumped decoded YUV to %s\n", decdumpfile); |
| decoder.unmapData(dec_target, maphandle); |
| |
| BlitEvent ev; |
| |
| st = decoder.blitToLinearRgba(dec_target, rgba_mem, aligned_w, aligned_h, ev, scale_factor); |
| assert(st == JD_SUCCESS); |
| |
| decoder.syncBlit(ev); |
| fpdump = fopen(rgbadumpfile, "wb"); |
| assert(fpdump); |
| fwrite(rgba_mem, 4, aligned_scaled_w * aligned_scaled_h, fpdump); |
| fclose(fpdump); |
| printf("Dumped RGBA into %s\n", rgbadumpfile); |
| |
| // test blit_to_camera_surfaces |
| if (format == VA_FOURCC_422H) { |
| |
| RenderTarget nv12_dst, yuy2_dst; |
| nsecs_t t1, t2; |
| init_render_target_gralloc(nv12_dst, aligned_w, aligned_h, VA_FOURCC_NV12); |
| init_render_target_gralloc(yuy2_dst, aligned_w, aligned_h, VA_FOURCC_YUY2); |
| t1 = systemTime(); |
| st = decoder.blit(dec_target, nv12_dst, 1); |
| st = decoder.blit(dec_target, yuy2_dst, 1); |
| t2 = systemTime(); |
| printf("422H->NV12+YUY2 VA took %.2f ms\n", (t2-t1)/1000000.0); |
| deinit_render_target(nv12_dst); |
| deinit_render_target(yuy2_dst); |
| t1 = systemTime(); |
| st = decoder.blitToCameraSurfaces(dec_target, nv12_handle, yuy2_handle, |
| NULL, NULL, |
| aligned_w, aligned_h, |
| ev); |
| t2 = systemTime(); |
| decoder.syncBlit(ev); |
| printf("422H->NV12+YUY2 CM took %.2f ms\n", (t2-t1)/1000000.0); |
| t1 = systemTime(); |
| st = decoder.blitToCameraSurfaces(dec_target, nv12_handle, yuy2_handle, |
| nv21_mem, yv12_mem, |
| aligned_w, aligned_h, |
| ev); |
| t2 = systemTime(); |
| decoder.syncBlit(ev); |
| printf("422H->NV12+YUY2+NV21+YV12 CM took %.2f ms\n", (t2-t1)/1000000.0); |
| assert(st == JD_SUCCESS); |
| fpdump = fopen(nv21dumpfile, "wb"); |
| assert(fpdump); |
| fwrite(nv21_mem, 1, aligned_w * aligned_h* 3 /2, fpdump); |
| fclose(fpdump); |
| printf("Dumped NV21 into %s\n", nv21dumpfile); |
| fpdump = fopen(yv12dumpfile, "wb"); |
| assert(fpdump); |
| fwrite(yv12_mem, 1, aligned_w * aligned_h * 3 / 2, fpdump); |
| fclose(fpdump); |
| printf("Dumped YV12 into %s\n", yv12dumpfile); |
| gralloc_module->lock(gralloc_module, nv12_handle, GRALLOC_USAGE_SW_READ_OFTEN, 0, 0, aligned_w, aligned_h, (void**)&nv12_mem); |
| fpdump = fopen(nv12dumpfile, "wb"); |
| assert(fpdump); |
| fwrite(nv12_mem, 1, aligned_w * aligned_h * 3 / 2, fpdump); |
| fclose(fpdump); |
| gralloc_module->unlock(gralloc_module, nv12_handle); |
| printf("Dumped NV12 into %s\n", nv12dumpfile); |
| gralloc_module->lock(gralloc_module, yuy2_handle, GRALLOC_USAGE_SW_READ_OFTEN, 0, 0, aligned_w, aligned_h, (void**)&yuy2_mem); |
| fpdump = fopen(yuy2dumpfile, "wb"); |
| assert(fpdump); |
| fwrite(yuy2_mem, 2, aligned_w * aligned_h, fpdump); |
| fclose(fpdump); |
| gralloc_module->unlock(gralloc_module, yuy2_handle); |
| printf("Dumped YUY2 into %s\n", yuy2dumpfile); |
| } |
| |
| decoder.deinit(); |
| |
| allocdev->free(allocdev, nv12_handle); |
| allocdev->free(allocdev, yuy2_handle); |
| free(nv21_mem); |
| free(yv12_mem); |
| free(rgba_mem); |
| |
| switch(type) { |
| case RenderTarget::KERNEL_DRM: |
| deinit_render_target(dec_target, &dec_handle); |
| break; |
| default: |
| deinit_render_target(dec_target); |
| break; |
| } |
| delete[] jpginfo.buf; |
| gralloc_close(allocdev); |
| vaDestroyContext(display, vpCtxId); |
| vaDestroyConfig(display, vpCfgId); |
| vaTerminate(display); |
| } |
| |
| int main(int argc, char ** argv) |
| { |
| int res, scale; |
| uint32_t format = 0; |
| scale = 1; |
| memset(jpgfile, 0, sizeof(jpgfile)); |
| while ((res = getopt(argc, argv, "i:f:s:")) >= 0) { |
| switch (res) { |
| case 'i': |
| { |
| strcpy(jpgfile, optarg); |
| break; |
| } |
| case 's': |
| { |
| scale = atoi(optarg); |
| break; |
| } |
| case 'f': |
| { |
| if (strcmp(optarg, "NV12") == 0) { |
| format = VA_FOURCC_NV12; |
| } |
| else if (strcmp(optarg, "YUY2") == 0) { |
| format = VA_FOURCC_YUY2; |
| } |
| else if (strcmp(optarg, "UYVY") == 0) { |
| format = VA_FOURCC_UYVY; |
| } |
| else { |
| format = 0; |
| printf("INVALID output decode format, using YUV planar\n"); |
| } |
| break; |
| } |
| default: |
| printf("usage: testjpegdec -i <filename> [-w <width> -h <height>]\n"); |
| exit(-1); |
| } |
| } |
| if (strcmp(jpgfile, "") == 0) { |
| printf("usage: testjpegdec -i <filename> [-f <decode output format FOURCC>] [-s <scaling_factor>]\n"); |
| printf(" available output FOURCC: NV12, YUY2, UYVY, 0. 0 by default (YUV planar)\n"); |
| printf(" available scaling_factor: 1, 2, 4, 8. 1 by default (no down-scale)\n"); |
| exit(-1); |
| } |
| printf("----- DRM surface type test -----\n"); |
| //decode_blit_functionality_test(RenderTarget::KERNEL_DRM, 0); |
| printf("----- GRALLOC surface type test -----\n"); |
| //decode_blit_functionality_test(RenderTarget::ANDROID_GRALLOC, 0); |
| printf("----- Normal surface type test, scale %d-----\n", scale); |
| decode_blit_functionality_test(RenderTarget::INTERNAL_BUF, format, scale); |
| printf("----- Userptr surface type test -----\n"); |
| //decode_blit_functionality_test(RenderTarget::USER_PTR, format); |
| return 0; |
| } |
