/* Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #define _CRT_SECURE_NO_WARNINGS #include "profiler.h" #include "kernels.h" #include "lens_distortion_remap.h" #include "warp.h" #include "merge.h" #include "seam_find.h" #include "exposure_compensation.h" #include "multiband_blender.h" #include #include #include #include // Version #define LS_VERSION "0.9.9" ////////////////////////////////////////////////////////////////////// //! \brief The magic number for validation #define LIVE_STITCH_MAGIC 0x600df00d ////////////////////////////////////////////////////////////////////// //! \brief The stitching modes enum { stitching_mode_normal = 0, // normal mode stitching_mode_quick_and_dirty = 1, // quick and dirty mode }; ////////////////////////////////////////////////////////////////////// //! \brief The LoomIO module info #define LOOMIO_MAX_LENGTH_MODULE_NAME 64 #define LOOMIO_MAX_LENGTH_KERNEL_NAME VX_MAX_KERNEL_NAME #define LOOMIO_MAX_LENGTH_KERNEL_ARGUMENTS 1024 #define LOOMIO_MIN_AUX_DATA_CAPACITY 256 #define LOOMIO_DEFAULT_AUX_DATA_CAPACITY 1024 struct ls_loomio_info { char module[LOOMIO_MAX_LENGTH_MODULE_NAME]; char kernelName[LOOMIO_MAX_LENGTH_KERNEL_NAME]; char kernelArguments[LOOMIO_MAX_LENGTH_KERNEL_ARGUMENTS]; }; ////////////////////////////////////////////////////////////////////// //! \brief The internal table buffer sizes struct ls_internal_table_size_info { vx_size warpTableSize; vx_size expCompOverlapTableSize; vx_size expCompValidTableSize; vx_size blendOffsetTableSize; vx_size seamFindValidTableSize; vx_size seamFindWeightTableSize; vx_size seamFindAccumTableSize; vx_size seamFindPrefInfoTableSize; vx_size seamFindPathTableSize; }; ////////////////////////////////////////////////////////////////////// //! \brief The stitch handle struct ls_context_t { // magic word and status int magic; // should be LIVE_STITCH_MAGIC bool feature_enable_reinitialize; // true if reinitialize feature is enabled bool initialized; // true if initialized bool scheduled; // true if scheduled bool reinitialize_required; // true if reinitialize required bool rig_params_updated; // true if rig parameters updated bool camera_params_updated; // true if camera parameters updated bool overlay_params_updated; // true if overlay parameters updated // configuration parameters vx_int32 stitching_mode; // stitching mode vx_uint32 num_cameras; // number of cameras vx_uint32 num_camera_rows; // camera buffer number of rows vx_uint32 num_camera_columns; // camera buffer number of cols vx_df_image camera_buffer_format; // camera buffer format (VX_DF_IMAGE_UYVY/YUYV/RGB) vx_uint32 camera_buffer_width; // camera buffer width vx_uint32 camera_buffer_height; // camera buffer height camera_params * camera_par; // individual camera parameters vx_uint32 camera_rgb_buffer_width; // camera buffer width after color conversion vx_uint32 camera_rgb_buffer_height; // camera buffer height after color conversion vx_uint32 num_overlays; // number of overlays vx_uint32 num_overlay_rows; // overlay buffer width vx_uint32 num_overlay_columns; // overlay buffer height vx_uint32 overlay_buffer_width; // overlay buffer width vx_uint32 overlay_buffer_height; // overlay buffer height camera_params * overlay_par; // individual overlay parameters rig_params rig_par; // rig parameters vx_uint32 output_buffer_width; // output equirectangular image width vx_uint32 output_buffer_height; // output equirectangular image height vx_df_image output_buffer_format; // output image format (VX_DF_IMAGE_UYVY/YUYV/RGB/NV12/IYUV) vx_uint32 output_rgb_buffer_width; // camera buffer width after color conversion vx_uint32 output_rgb_buffer_height; // camera buffer height after color conversion cl_context opencl_context; // OpenCL context for DGMA interop vx_uint32 camera_buffer_stride_in_bytes; // stride of each row in input opencl buffer vx_uint32 overlay_buffer_stride_in_bytes; // stride of each row in overlay opencl buffer (optional) vx_uint32 output_buffer_stride_in_bytes; // stride of each row in output opencl buffer // global options vx_uint32 EXPO_COMP, SEAM_FIND; // exposure comp seam find flags from environment variable vx_uint32 SEAM_COST_SELECT; // seam find cost generation flag from environment variable vx_uint32 SEAM_REFRESH, SEAM_FLAGS; // seamfind seam refresh flag from environment variable vx_uint32 MULTIBAND_BLEND; // multiband blend flag from environment variable vx_uint32 EXPO_COMP_GAINW, EXPO_COMP_GAINH;// exposure comp module gain image width and height vx_uint32 EXPO_COMP_GAINC; // exposure comp gain array number of gain values per camera. For mode 4, this should be 12 which is default if not specified. // global OpenVX objects bool context_is_external; // To avoid releaseing external OpenVX context vx_context context; // OpenVX context vx_graph graphStitch; // OpenVX graph for stitching // internal buffer sizes ls_internal_table_size_info table_sizes; // internal table sizes vx_image rgb_input, rgb_output; // internal images // data objects vx_remap overlay_remap; // remap table for overlay vx_remap camera_remap; // remap table for camera (in simple stitch mode) vx_image Img_input, Img_output, Img_overlay; vx_image Img_input_rgb, Img_output_rgb, Img_overlay_rgb, Img_overlay_rgba; vx_node InputColorConvertNode, SimpleStitchRemapNode, OutputColorConvertNode; vx_array ValidPixelEntry, WarpRemapEntry, OverlapPixelEntry, valid_array, gain_array; vx_matrix overlap_matrix, A_matrix; vx_image RGBY1, RGBY2, weight_image, cam_id_image, group1_image, group2_image; vx_node WarpNode, ExpcompComputeGainNode, ExpcompSolveGainNode, ExpcompApplyGainNode, MergeNode; vx_node nodeOverlayRemap, nodeOverlayBlend; vx_float32 alpha, beta; // needed for expcomp vx_int32 * A_matrix_initial_value; // needed for expcomp // seamfind data & node elements vx_array overlap_rect_array, seamfind_valid_array, seamfind_weight_array, seamfind_accum_array, seamfind_pref_array, seamfind_info_array, seamfind_path_array, seamfind_scene_array; vx_image valid_mask_image, warp_luma_image, sobelx_image, sobely_image, sobel_magnitude_s16_image, sobel_magnitude_image, sobel_phase_image, seamfind_weight_image; vx_node SobelNode, MagnitudeNode, PhaseNode, ConvertDepthNode, SeamfindStep1Node, SeamfindStep2Node, SeamfindStep3Node, SeamfindStep4Node, SeamfindStep5Node, SeamfindAnalyzeNode; vx_scalar current_frame, scene_threshold, seam_cost_enable; vx_int32 current_frame_value; vx_uint32 scene_threshold_value, SEAM_FIND_TARGET; // multiband data elements vx_int32 num_bands; vx_array blend_offsets; vx_image blend_mask_image; StitchMultibandData * pStitchMultiband; vx_size * multibandBlendOffsetIntoBuffer; // LoomIO support vx_uint32 loomioOutputAuxSelection, loomioCameraAuxDataLength, loomioOverlayAuxDataLength, loomioOutputAuxDataLength; vx_scalar cameraMediaConfig, overlayMediaConfig, outputMediaConfig, viewingMediaConfig; vx_array loomioCameraAuxData, loomioOverlayAuxData, loomioOutputAuxData, loomioViewingAuxData; vx_node nodeLoomIoCamera, nodeLoomIoOverlay, nodeLoomIoOutput, nodeLoomIoViewing; ls_loomio_info loomio_camera, loomio_output, loomio_overlay, loomio_viewing; FILE * loomioAuxDumpFile; // internal buffers for input camera lens models vx_uint32 paddingPixelCount, overlapCount; StitchCoord2dFloat * camSrcMap; vx_float32 * camIndexTmpBuf; vx_uint8 * camIndexBuf; vx_uint32 * validPixelCamMap, *paddedPixelCamMap; vx_rectangle_t * overlapRectBuf; vx_rectangle_t * overlapValid[LIVE_STITCH_MAX_CAMERAS], *overlapPadded[LIVE_STITCH_MAX_CAMERAS]; vx_uint32 validCamOverlapInfo[LIVE_STITCH_MAX_CAMERAS], paddedCamOverlapInfo[LIVE_STITCH_MAX_CAMERAS]; vx_int32 * overlapMatrixBuf; // internal buffers for overlay models StitchCoord2dFloat * overlaySrcMap; vx_uint32 * validPixelOverlayMap; vx_float32 * overlayIndexTmpBuf; vx_uint8 * overlayIndexBuf; // internal buffers for frame encode #define MAX_TILE_IMG 16 vx_uint32 output_encode_buffer_width; // buffer width after encode conversion vx_uint32 output_encode_buffer_height; // buffer height after encode conversion vx_uint32 output_encode_tiles; // total number of encode tiles vx_uint32 num_encode_sections; // total number of encode sectional images vx_image encode_src_rgb_imgs[MAX_TILE_IMG]; // encode intermediate images vx_image encode_dst_imgs[MAX_TILE_IMG]; // encode intermediate images vx_image encodetileOutput[MAX_TILE_IMG]; // encode tile output NV12 images vx_rectangle_t src_encode_tile_rect[MAX_TILE_IMG]; // src encode rectangles vx_rectangle_t dst_encode_tile_rect[MAX_TILE_IMG]; // dst encode rectangles vx_node encode_color_convert_nodes[MAX_TILE_IMG];// nodes to color convert each of the sectional ROI images // chroma key vx_uint32 CHROMA_KEY; // chroma key flag variable vx_uint32 CHROMA_KEY_EED; // chroma key flag variable vx_image chroma_key_input_img; // chroma key input RGB intermediate images vx_image chroma_key_mask_img; // chroma key U8 mask intermediate images vx_image chroma_key_input_RGB_img; // intermediate images vx_image chroma_key_dilate_mask_img; // chroma key U8 mask dilate intermediate images vx_image chroma_key_erode_mask_img; // chroma key U8 mask dilate intermediate images vx_node chromaKey_mask_generation_node; // nodes to generate chroma key mask vx_node chromaKey_dilate_node; // nodes to dilate chroma key mask vx_node chromaKey_erode_node; // nodes to erode chroma key mask vx_node chromaKey_merge_node; // nodes to merge chroma input and stitch output // temporal filter vx_uint32 NOISE_FILTER; // temporal noise filter enable/disable environment variable vx_float32 noiseFilterLambda; // temporal noise filter variable vx_scalar filterLambda; // temporal noise filter scalar lambda variable from user vx_delay noiseFilterImageDelay; // temporal noise filter delay element vx_image noiseFilterInput_image; // temporal noise filter delay input image vx_node noiseFilterNode; // temporal noise filter node // quick setup load vx_uint32 SETUP_LOAD; // quick setup load flag variable vx_bool SETUP_LOAD_FILES_FOUND; // quick setup load files found flag variable // data for Initialize tables vx_uint32 USE_CPU_INIT; StitchInitializeData *stitchInitData; // attributes vx_float32 live_stitch_attr[LIVE_STITCH_ATTR_MAX_COUNT]; }; ////////////////////////////////////////////////////////////////////// //! \brief The global attributes with default values static bool g_live_stitch_attr_initialized = false; static vx_float32 g_live_stitch_attr[LIVE_STITCH_ATTR_MAX_COUNT] = { 0 }; static stitch_log_callback_f g_live_stitch_log_message_callback = nullptr; ////////////////////////////////////////////////////////////////////// //! \brief The macro for object creation error checking and reporting. #define ERROR_CHECK_OBJECT_(call) { vx_reference obj = (vx_reference)(call); vx_status status = vxGetStatus(obj); if(status != VX_SUCCESS) { ls_printf("ERROR: OpenVX object creation failed at " __FILE__ "#%d\n", __LINE__); return status; } } //! \brief The macro for status error checking and reporting. #define ERROR_CHECK_STATUS_(call) {vx_status status = (call); if(status != VX_SUCCESS) { ls_printf("ERROR: OpenVX call failed with status = (%d) at " __FILE__ "#%d\n", status, __LINE__); return status; } } //! \brief The macro for type error checking and reporting. #define ERROR_CHECK_TYPE_(call) { vx_enum type_ = (call); if(type_ == VX_TYPE_INVALID) { ls_printf("ERROR: OpenVX call failed with type = VX_TYPE_INVALID at " __FILE__ "#%d\n", __LINE__); return VX_ERROR_NOT_SUFFICIENT; } } //! \brief The macro for object creation error checking and reporting. #define ERROR_CHECK_ALLOC_(call) { void * obj = (call); if(!obj) { ls_printf("ERROR: memory allocation failed at " __FILE__ "#%d\n", __LINE__); return VX_ERROR_NOT_ALLOCATED; } } //! \brief The macro for fread error checking and reporting. #define ERROR_CHECK_FREAD_(call,value) {size_t retVal = (call); if(retVal != (size_t)value) { ls_printf("ERROR: fread call expected to return [ %d elements ] but returned [ %d elements ] at " __FILE__ "#%d\n", (int)value, (int)retVal, __LINE__); return VX_FAILURE; } } //! \brief The log callback. void ls_printf(const char * format, ...) { char buffer[1024]; va_list args; va_start(args, format); vsnprintf(buffer, sizeof(buffer) - 1, format, args); if (g_live_stitch_log_message_callback) { g_live_stitch_log_message_callback(buffer); } else { printf("%s", buffer); fflush(stdout); } va_end(args); } //! \brief The log callback. static void VX_CALLBACK log_callback(vx_context context, vx_reference ref, vx_status status, const vx_char string[]) { if (g_live_stitch_log_message_callback) { g_live_stitch_log_message_callback(string); if (!(string[0] && string[strlen(string) - 1] == '\n')) g_live_stitch_log_message_callback("\n"); } else { printf("LOG:[status=%d] %s", status, string); if (!(string[0] && string[strlen(string) - 1] == '\n')) printf("\n"); fflush(stdout); } } //! \brief Dump utilities. vx_status DumpBuffer(const vx_uint8 * buf, vx_size size, const char * fileName) { FILE * fp = fopen(fileName, "wb"); if (!fp) { printf("ERROR: DumpBuffer: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } fwrite(buf, size, 1, fp); fclose(fp); printf("OK: DumpBuffer: %d bytes into %s\n", (int)size, fileName); return VX_SUCCESS; } vx_status DumpImage(vx_image img, const char * fileName) { FILE * fp = fopen(fileName, "wb"); if (!fp) { printf("ERROR: DumpImage: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_df_image format = VX_DF_IMAGE_VIRT; vx_size num_planes = 0; vx_rectangle_t rectFull = { 0, 0, 0, 0 }; int stride_y; ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format))); ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_PLANES, &num_planes, sizeof(num_planes))); ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_WIDTH, &rectFull.end_x, sizeof(rectFull.end_x))); ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_HEIGHT, &rectFull.end_y, sizeof(rectFull.end_y))); // write all image planes from vx_image for (vx_uint32 plane = 0; plane < (vx_uint32)num_planes; plane++){ vx_imagepatch_addressing_t addr = { 0 }; vx_uint8 * src = NULL; ERROR_CHECK_STATUS(vxAccessImagePatch(img, &rectFull, plane, &addr, (void **)&src, VX_READ_ONLY)); vx_size width = (addr.dim_x * addr.scale_x) / VX_SCALE_UNITY; vx_size width_in_bytes = (format == VX_DF_IMAGE_U1_AMD) ? ((width + 7) >> 3) : (width * addr.stride_x); stride_y = addr.stride_y; for (vx_uint32 y = 0; y < addr.dim_y; y += addr.step_y){ vx_uint8 *srcp = (vx_uint8 *)vxFormatImagePatchAddress2d(src, 0, y, &addr); fwrite(srcp, 1, width_in_bytes, fp); } ERROR_CHECK_STATUS(vxCommitImagePatch(img, &rectFull, plane, &addr, src)); } fclose(fp); printf("OK: Dump: Image %dx%d of stride %d %4.4s image into %s\n", rectFull.end_x, rectFull.end_y, stride_y, (const char *)&format, fileName); return VX_SUCCESS; } vx_status DumpArray(vx_array arr, const char * fileName) { FILE * fp = fopen(fileName, "wb"); if (!fp) { printf("ERROR: DumpArray: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_size numItems, itemSize; ERROR_CHECK_STATUS_(vxQueryArray(arr, VX_ARRAY_ITEMSIZE, &itemSize, sizeof(itemSize))); ERROR_CHECK_STATUS_(vxQueryArray(arr, VX_ARRAY_NUMITEMS, &numItems, sizeof(numItems))); vx_map_id map_id; vx_uint8 * ptr; vx_size stride; ERROR_CHECK_STATUS_(vxMapArrayRange(arr, 0, numItems, &map_id, &stride, (void **)&ptr, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); fwrite(ptr, itemSize, numItems, fp); ERROR_CHECK_STATUS_(vxUnmapArrayRange(arr, map_id)); fclose(fp); printf("OK: Dump: Array [%d][%d] into %s\n", (int)numItems, (int)itemSize, fileName); return VX_SUCCESS; } static vx_status DumpMatrix(vx_matrix mat, const char * fileName) { FILE * fp = fopen(fileName, "wb"); if (!fp) { printf("ERROR: DumpMatrix: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_size size; ERROR_CHECK_STATUS_(vxQueryMatrix(mat, VX_MATRIX_SIZE, &size, sizeof(size))); vx_uint8 * buf = new vx_uint8[size]; ERROR_CHECK_STATUS_(vxCopyMatrix(mat, buf, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); fwrite(buf, size, 1, fp); delete[] buf; fclose(fp); vx_size rows, columns; ERROR_CHECK_STATUS_(vxQueryMatrix(mat, VX_MATRIX_ROWS, &rows, sizeof(rows))); ERROR_CHECK_STATUS_(vxQueryMatrix(mat, VX_MATRIX_COLUMNS, &columns, sizeof(columns))); printf("OK: Dump: Matrix %dx%d (%d bytes) into %s\n", (int)rows, (int)columns, (int)size, fileName); return VX_SUCCESS; } static vx_status DumpRemap(vx_remap remap, const char * fileName) { FILE * fp = fopen(fileName, "wb"); if (!fp) { printf("ERROR: DumpRemap: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_uint32 dstWidth, dstHeight; ERROR_CHECK_STATUS_(vxQueryRemap(remap, VX_REMAP_DESTINATION_WIDTH, &dstWidth, sizeof(dstWidth))); ERROR_CHECK_STATUS_(vxQueryRemap(remap, VX_REMAP_DESTINATION_HEIGHT, &dstHeight, sizeof(dstHeight))); for (vx_uint32 y = 0; y < dstHeight; y++){ for (vx_uint32 x = 0; x < dstWidth; x++){ vx_float32 src_xy[2]; ERROR_CHECK_STATUS_(vxGetRemapPoint(remap, x, y, &src_xy[0], &src_xy[1])); fwrite(src_xy, sizeof(src_xy), 1, fp); } } fclose(fp); printf("OK: Dump: Remap %dx%d into %s\n", dstWidth, dstHeight, fileName); return VX_SUCCESS; } static vx_status DumpReference(vx_reference ref, const char * fileName) { vx_enum type; ERROR_CHECK_STATUS_(vxQueryReference(ref, VX_REFERENCE_TYPE, &type, sizeof(type))); if (type == VX_TYPE_IMAGE) return DumpImage((vx_image)ref, fileName); else if (type == VX_TYPE_ARRAY) return DumpArray((vx_array)ref, fileName); else if (type == VX_TYPE_MATRIX) return DumpMatrix((vx_matrix)ref, fileName); else if (type == VX_TYPE_REMAP) return DumpRemap((vx_remap)ref, fileName); else return VX_ERROR_NOT_SUPPORTED; } static vx_image CreateAlignedImage(ls_context stitch, vx_uint32 width, vx_uint32 height, vx_uint32 alignpixels, vx_df_image format, vx_enum mem_type) { if (mem_type == VX_MEMORY_TYPE_OPENCL){ cl_context opencl_context = nullptr; vx_imagepatch_addressing_t addr_in = { 0 }; void *ptr[1] = { nullptr }; addr_in.dim_x = width; addr_in.dim_y = height; addr_in.stride_x = ((format == VX_DF_IMAGE_RGBX) | (format == VX_DF_IMAGE_U32) | (format==VX_DF_IMAGE_S32)) ? 4 : (format == VX_DF_IMAGE_RGB4_AMD) ? 6 : 1; if (alignpixels == 0) addr_in.stride_y = addr_in.dim_x *addr_in.stride_x; else addr_in.stride_y = ((addr_in.dim_x + alignpixels - 1) & ~(alignpixels - 1))*addr_in.stride_x; // allocate opencl buffer with required dim vx_status status = vxQueryContext(stitch->context, VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT, &opencl_context, sizeof(opencl_context)); if (status != VX_SUCCESS){ ls_printf("vxQueryContext of failed(%d)\n", status); return nullptr; } vx_size size = (addr_in.dim_y + 1) * addr_in.stride_y; cl_int err = CL_SUCCESS; cl_mem clImg = clCreateBuffer(opencl_context, CL_MEM_READ_WRITE, size, NULL, &err); if (!clImg || err){ ls_printf("clCreateBuffer of size %d failed(%d)\n", (int)size, err); return nullptr; } ptr[0] = clImg; return vxCreateImageFromHandle(stitch->context, format, &addr_in, ptr, mem_type); } else { return vxCreateImage(stitch->context, width, height, format); } } //! \brief Function to set default values to global attributes static void ResetLiveStitchGlobalAttributes() { // set default settings only once if (!g_live_stitch_attr_initialized) { g_live_stitch_attr_initialized = true; memset(g_live_stitch_attr, 0, sizeof(g_live_stitch_attr)); g_live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_GAIN_IMG_W] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_GAIN_IMG_H] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_GAIN_IMG_C] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_ALPHA_VALUE] = 0.01f; g_live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_BETA_VALUE] = 100.0f; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAMFIND] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COST_SELECT] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_REFRESH] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_THRESHOLD] = 25; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_VERT_PRIORITY] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_HORT_PRIORITY] = -1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_FREQUENCY] = 6000; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_QUALITY] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_STAGGER] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_ENABLE] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_HFOV_MIN] = 120; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_PITCH_TOL] = 5; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_YAW_TOL] = 5; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_OVERLAP_HR] = 0.15f; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_OVERLAP_VD] = 20; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_TOPBOT_TOL] = 5; g_live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COEQUSH_TOPBOT_VGD] = 46; g_live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND_NUMBANDS] = 4; g_live_stitch_attr[LIVE_STITCH_ATTR_STITCH_MODE] = (float)stitching_mode_normal; // frame encoding default attributes g_live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_src_tile_overlap] = 0; g_live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_BUFFER_VALUE] = 0; g_live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_WIDTH] = 3840; g_live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_HEIGHT] = 2160; g_live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_STRIDE_Y] = 3840; // chroma key default g_live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY] = 0; g_live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY_VALUE] = 8454016; g_live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY_TOL] = 25; g_live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY_EED] = 0; // LoomIO specific attributes g_live_stitch_attr[LIVE_STITCH_ATTR_IO_CAMERA_AUX_DATA_SIZE] = (float)LOOMIO_DEFAULT_AUX_DATA_CAPACITY; g_live_stitch_attr[LIVE_STITCH_ATTR_IO_OVERLAY_AUX_DATA_SIZE] = (float)LOOMIO_DEFAULT_AUX_DATA_CAPACITY; g_live_stitch_attr[LIVE_STITCH_ATTR_IO_OUTPUT_AUX_DATA_SIZE] = (float)LOOMIO_DEFAULT_AUX_DATA_CAPACITY; // Temporal Filter g_live_stitch_attr[LIVE_STITCH_ATTR_NOISE_FILTER] = 0; g_live_stitch_attr[LIVE_STITCH_ATTR_NOISE_FILTER_LAMBDA] = 1; g_live_stitch_attr[LIVE_STITCH_ATTR_SAVE_AND_LOAD_INIT] = 0; } } static std::vector split(std::string str, char delimiter) { std::stringstream ss(str); std::string tok; std::vector internal; while (std::getline(ss, tok, delimiter)) { internal.push_back(tok); } return internal; } static vx_status IsValidContext(ls_context stitch) { if (!stitch || stitch->magic != LIVE_STITCH_MAGIC) return VX_ERROR_INVALID_REFERENCE; return VX_SUCCESS; } static vx_status IsValidContextAndInitialized(ls_context stitch) { if (!stitch || stitch->magic != LIVE_STITCH_MAGIC) return VX_ERROR_INVALID_REFERENCE; if (!stitch->initialized) return VX_ERROR_NOT_ALLOCATED; return VX_SUCCESS; } static vx_status IsValidContextAndNotInitialized(ls_context stitch) { if (!stitch || stitch->magic != LIVE_STITCH_MAGIC) return VX_ERROR_INVALID_REFERENCE; if (stitch->initialized) return VX_ERROR_NOT_SUPPORTED; return VX_SUCCESS; } static const char * GetFileNameSuffix(ls_context stitch, vx_reference ref, bool& isIntermediateTmpData, bool& isForCpuUseOnly) { struct { vx_reference ref; bool isIntermediateTmpData; bool isForCpuUseOnly; const char * fileNameSuffix; } refList[] = { // intermediate tables and data that needs initialization { (vx_reference)stitch->ValidPixelEntry, false, false, "warp-valid.bin" }, { (vx_reference)stitch->WarpRemapEntry, false, false, "warp-remap.bin" }, { (vx_reference)stitch->RGBY1, false, false, "warp-rgby.raw" }, { (vx_reference)stitch->cam_id_image, false, false, "merge-camid.raw" }, { (vx_reference)stitch->group1_image, false, false, "merge-group1.raw" }, { (vx_reference)stitch->group2_image, false, false, "merge-group2.raw" }, { (vx_reference)stitch->weight_image, false, false, "merge-weight.raw" }, { (vx_reference)stitch->valid_array, false, false, "exp-valid.bin" }, { (vx_reference)stitch->OverlapPixelEntry, false, false, "exp-overlap.bin" }, { (vx_reference)stitch->overlap_matrix, false, true, "exp-count.bin" }, { (vx_reference)stitch->RGBY2, false, false, "exp-rgby.raw" }, { (vx_reference)stitch->valid_mask_image, false, false, "valid-mask.raw" }, { (vx_reference)stitch->seamfind_valid_array, false, false, "seam-valid.bin" }, { (vx_reference)stitch->seamfind_weight_array, false, false, "seam-weight.bin" }, { (vx_reference)stitch->seamfind_accum_array, false, false, "seam-accum.bin" }, { (vx_reference)stitch->seamfind_pref_array, false, false, "seam-pref.bin" }, { (vx_reference)stitch->seamfind_info_array, false, false, "seam-info.bin" }, { (vx_reference)stitch->seamfind_path_array, false, false, "seam-path.bin" }, { (vx_reference)stitch->seamfind_scene_array, false, false, "seam-scene.bin" }, { (vx_reference)stitch->seamfind_weight_image, false, false, "seam-mask.raw" }, { (vx_reference)stitch->blend_mask_image, false, false, "blend-mask.raw" }, { (vx_reference)stitch->blend_offsets, false, false, "blend-offsets.bin" }, { (vx_reference)stitch->camera_remap, false, false, "remap-input.raw" }, { (vx_reference)stitch->overlay_remap, false, false, "remap-overlay.raw" }, // intermediate temporary data { (vx_reference)stitch->Img_input, true, false, "camera-input.raw" }, { (vx_reference)stitch->Img_overlay, true, false, "overlay-input.raw" }, { (vx_reference)stitch->Img_overlay_rgba, true, false, "overlay-warped.raw" }, { (vx_reference)stitch->Img_output, true, false, "stitch-output.raw" }, }; for (vx_size i = 0; i < dimof(refList); i++) { if (refList[i].ref && refList[i].ref == ref) { isIntermediateTmpData = refList[i].isIntermediateTmpData; isForCpuUseOnly = refList[i].isForCpuUseOnly; return refList[i].fileNameSuffix; } } return nullptr; } static vx_status DumpInternalTables(ls_context stitch, const char * fileNamePrefix, bool dumpIntermediateTmpDataToo) { vx_reference refList[] = { // intermediate tables and data that needs initialization (vx_reference)stitch->ValidPixelEntry, (vx_reference)stitch->WarpRemapEntry, (vx_reference)stitch->RGBY1, (vx_reference)stitch->cam_id_image, (vx_reference)stitch->group1_image, (vx_reference)stitch->group2_image, (vx_reference)stitch->weight_image, (vx_reference)stitch->valid_array, (vx_reference)stitch->OverlapPixelEntry, (vx_reference)stitch->overlap_matrix, (vx_reference)stitch->RGBY2, (vx_reference)stitch->valid_mask_image, (vx_reference)stitch->seamfind_valid_array, (vx_reference)stitch->seamfind_weight_array, (vx_reference)stitch->seamfind_accum_array, (vx_reference)stitch->seamfind_pref_array, (vx_reference)stitch->seamfind_info_array, (vx_reference)stitch->seamfind_path_array, (vx_reference)stitch->seamfind_scene_array, (vx_reference)stitch->seamfind_weight_image, (vx_reference)stitch->blend_mask_image, (vx_reference)stitch->blend_offsets, (vx_reference)stitch->camera_remap, (vx_reference)stitch->overlay_remap, // intermediate temporary data (vx_reference)stitch->Img_input, (vx_reference)stitch->Img_overlay, (vx_reference)stitch->Img_overlay_rgba, (vx_reference)stitch->Img_output, }; for (vx_size i = 0; i < dimof(refList); i++) { if (refList[i]) { bool isIntermediateTmpData = false, isForCpuUseOnly = false; const char * fileNameSuffix = GetFileNameSuffix(stitch, refList[i], isIntermediateTmpData, isForCpuUseOnly); if (fileNameSuffix && (!isIntermediateTmpData || dumpIntermediateTmpDataToo)) { char fileName[1024]; sprintf(fileName, "%s-%s", fileNamePrefix, fileNameSuffix); vx_status status = DumpReference(refList[i], fileName); if (status != VX_SUCCESS) return status; } } } if (dumpIntermediateTmpDataToo && stitch->MULTIBAND_BLEND) { for (vx_int32 level = 0; level < stitch->num_bands; level++) { vx_status status; char fileName[1024]; sprintf(fileName, "%s-blend-pyr-mask-%d.raw", fileNamePrefix, level); status = DumpImage(stitch->pStitchMultiband[level].WeightPyrImgGaussian, fileName); if (status != VX_SUCCESS) return status; sprintf(fileName, "%s-blend-pyr-gauss-%d.raw", fileNamePrefix, level); status = DumpImage(stitch->pStitchMultiband[level].DstPyrImgGaussian, fileName); if (status != VX_SUCCESS) return status; sprintf(fileName, "%s-blend-pyr-lap-%d.raw", fileNamePrefix, level); status = DumpImage(stitch->pStitchMultiband[level].DstPyrImgLaplacian, fileName); if (status != VX_SUCCESS) return status; sprintf(fileName, "%s-blend-pyr-lap-rec-%d.raw", fileNamePrefix, level); status = DumpImage(stitch->pStitchMultiband[level].DstPyrImgLaplacianRec, fileName); if (status != VX_SUCCESS) return status; } } return VX_SUCCESS; } static vx_status SyncInternalTables(ls_context stitch) { vx_reference refList[] = { (vx_reference)stitch->ValidPixelEntry, (vx_reference)stitch->WarpRemapEntry, (vx_reference)stitch->cam_id_image, (vx_reference)stitch->group1_image, (vx_reference)stitch->group2_image, (vx_reference)stitch->weight_image, (vx_reference)stitch->valid_mask_image, (vx_reference)stitch->valid_array, (vx_reference)stitch->OverlapPixelEntry, (vx_reference)stitch->seamfind_valid_array, (vx_reference)stitch->seamfind_weight_array, (vx_reference)stitch->seamfind_accum_array, (vx_reference)stitch->seamfind_pref_array, (vx_reference)stitch->seamfind_info_array, (vx_reference)stitch->seamfind_path_array, (vx_reference)stitch->seamfind_weight_image, (vx_reference)stitch->seamfind_scene_array, (vx_reference)stitch->blend_mask_image, (vx_reference)stitch->RGBY1, (vx_reference)stitch->RGBY2, (vx_reference)stitch->overlay_remap, (vx_reference)stitch->camera_remap, }; for (vx_size i = 0; i < dimof(refList); i++) { if (refList[i]) { vx_status status = vxDirective(refList[i], VX_DIRECTIVE_AMD_COPY_TO_OPENCL); if (status != VX_SUCCESS) { ls_printf("ERROR: SyncInternalTables: vxDirective([%d], VX_DIRECTIVE_AMD_COPY_TO_OPENCL) failed (%d)\n", (int)i, status); return status; } } } return VX_SUCCESS; } static vx_status quickSetupFilesLookup(ls_context stitch) { FILE * fp = fopen("StitchTableSizes.txt", "r"); if (!fp) { stitch->SETUP_LOAD_FILES_FOUND = vx_false_e; } else{ stitch->SETUP_LOAD_FILES_FOUND = vx_true_e; } if (fp != NULL) fclose(fp); return VX_SUCCESS; } static vx_status quickSetupDumpTableSizes(ls_context stitch) { FILE * fp = fopen("StitchTableSizes.txt", "w+"); if (!fp) { ls_printf("ERROR: quickSetupDumpTableSize: unable to create: StitchTableSizes.txt\n"); if (fp != NULL) fclose(fp); return VX_FAILURE; } fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.blendOffsetTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.expCompOverlapTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.expCompValidTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.seamFindAccumTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.seamFindPathTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.seamFindPrefInfoTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.seamFindValidTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.seamFindWeightTableSize); fprintf(fp, "\n"); fprintf(fp, VX_FMT_SIZE, stitch->table_sizes.warpTableSize); fprintf(fp, "\n"); fclose(fp); return VX_SUCCESS; } static vx_status quickSetupDumpTables(ls_context stitch) { vx_reference refList[] = { (vx_reference)stitch->ValidPixelEntry, (vx_reference)stitch->WarpRemapEntry, (vx_reference)stitch->RGBY1, (vx_reference)stitch->cam_id_image, (vx_reference)stitch->group1_image, (vx_reference)stitch->group2_image, (vx_reference)stitch->weight_image, (vx_reference)stitch->valid_array, (vx_reference)stitch->OverlapPixelEntry, (vx_reference)stitch->overlap_matrix, (vx_reference)stitch->RGBY2, (vx_reference)stitch->valid_mask_image, (vx_reference)stitch->seamfind_valid_array, (vx_reference)stitch->seamfind_weight_array, (vx_reference)stitch->seamfind_accum_array, (vx_reference)stitch->seamfind_pref_array, (vx_reference)stitch->seamfind_info_array, (vx_reference)stitch->seamfind_path_array, (vx_reference)stitch->seamfind_scene_array, (vx_reference)stitch->seamfind_weight_image, (vx_reference)stitch->blend_mask_image, (vx_reference)stitch->blend_offsets, (vx_reference)stitch->camera_remap, (vx_reference)stitch->overlay_remap, }; for (vx_size i = 0; i < dimof(refList); i++) { if (refList[i]) { bool isIntermediateTmpData = false, isForCpuUseOnly = false; const char * fileNameSuffix = GetFileNameSuffix(stitch, refList[i], isIntermediateTmpData, isForCpuUseOnly); if (fileNameSuffix && (!isIntermediateTmpData)) { char fileName[1024]; sprintf(fileName, "%s",fileNameSuffix); vx_status status = DumpReference(refList[i], fileName); if (status != VX_SUCCESS) return status; } } } return VX_SUCCESS; } vx_status loadImage(vx_image img, const char * fileName) { FILE * fp = fopen(fileName, "r"); if (!fp) { ls_printf("ERROR: loadImage: unable to open: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_df_image format = VX_DF_IMAGE_VIRT; vx_size num_planes = 0; vx_rectangle_t rectFull = { 0, 0, 0, 0 }; ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format))); ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_PLANES, &num_planes, sizeof(num_planes))); ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_WIDTH, &rectFull.end_x, sizeof(rectFull.end_x))); ERROR_CHECK_STATUS(vxQueryImage(img, VX_IMAGE_ATTRIBUTE_HEIGHT, &rectFull.end_y, sizeof(rectFull.end_y))); // write all image planes from vx_image for (vx_uint32 plane = 0; plane < (vx_uint32)num_planes; plane++){ vx_imagepatch_addressing_t addr = { 0 }; vx_uint8 * src = NULL; ERROR_CHECK_STATUS(vxAccessImagePatch(img, &rectFull, plane, &addr, (void **)&src, VX_WRITE_ONLY)); vx_size width = (addr.dim_x * addr.scale_x) / VX_SCALE_UNITY; vx_size width_in_bytes = (format == VX_DF_IMAGE_U1_AMD) ? ((width + 7) >> 3) : (width * addr.stride_x); for (vx_uint32 y = 0; y < addr.dim_y; y += addr.step_y){ vx_uint8 *srcp = (vx_uint8 *)vxFormatImagePatchAddress2d(src, 0, y, &addr); ERROR_CHECK_FREAD_(fread(srcp, 1, width_in_bytes, fp), width_in_bytes); } ERROR_CHECK_STATUS(vxCommitImagePatch(img, &rectFull, plane, &addr, src)); } fclose(fp); return VX_SUCCESS; } vx_status loadArray(vx_array arr, const char * fileName) { FILE * fp = fopen(fileName, "r"); if (!fp) { ls_printf("ERROR: loadArray: unable to open: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_size numItems, itemSize; ERROR_CHECK_STATUS_(vxQueryArray(arr, VX_ARRAY_ITEMSIZE, &itemSize, sizeof(itemSize))); ERROR_CHECK_STATUS_(vxQueryArray(arr, VX_ARRAY_CAPACITY, &numItems, sizeof(numItems))); StitchWarpRemapEntry validPixelEntry = { 0 }; ERROR_CHECK_STATUS_(vxTruncateArray(arr, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(arr, numItems, &validPixelEntry, 0)); vx_map_id map_id; vx_uint8 * ptr; vx_size stride; ERROR_CHECK_STATUS_(vxMapArrayRange(arr, 0, numItems, &map_id, &stride, (void **)&ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0)); ERROR_CHECK_FREAD_(fread(ptr, itemSize, numItems, fp),numItems); ERROR_CHECK_STATUS_(vxUnmapArrayRange(arr, map_id)); fclose(fp); return VX_SUCCESS; } static vx_status loadMatrix(vx_matrix mat, const char * fileName) { FILE * fp = fopen(fileName, "r"); if (!fp) { ls_printf("ERROR: loadMatrix: unable to read: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_size size; ERROR_CHECK_STATUS_(vxQueryMatrix(mat, VX_MATRIX_SIZE, &size, sizeof(size))); vx_uint8 * buf = new vx_uint8[size]; ERROR_CHECK_STATUS_(vxCopyMatrix(mat, buf, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); ERROR_CHECK_FREAD_(fread(buf, 4, size, fp),size); delete[] buf; fclose(fp); vx_size rows, columns; ERROR_CHECK_STATUS_(vxQueryMatrix(mat, VX_MATRIX_ROWS, &rows, sizeof(rows))); ERROR_CHECK_STATUS_(vxQueryMatrix(mat, VX_MATRIX_COLUMNS, &columns, sizeof(columns))); return VX_SUCCESS; } static vx_status loadRemap(vx_remap remap, const char * fileName) { FILE * fp = fopen(fileName, "r"); if (!fp) { ls_printf("ERROR: loadRemap: unable to read: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_uint32 dstWidth, dstHeight; ERROR_CHECK_STATUS_(vxQueryRemap(remap, VX_REMAP_DESTINATION_WIDTH, &dstWidth, sizeof(dstWidth))); ERROR_CHECK_STATUS_(vxQueryRemap(remap, VX_REMAP_DESTINATION_HEIGHT, &dstHeight, sizeof(dstHeight))); for (vx_uint32 y = 0; y < dstHeight; y++){ for (vx_uint32 x = 0; x < dstWidth; x++){ vx_float32 src_xy[2]; ERROR_CHECK_STATUS_(vxGetRemapPoint(remap, x, y, &src_xy[0], &src_xy[1])); ERROR_CHECK_FREAD_(fread(src_xy, sizeof(src_xy), 1, fp),1); } } fclose(fp); return VX_SUCCESS; } static vx_status loadReference(vx_reference ref, const char * fileName) { vx_enum type; ERROR_CHECK_STATUS_(vxQueryReference(ref, VX_REFERENCE_TYPE, &type, sizeof(type))); if (type == VX_TYPE_IMAGE) return loadImage((vx_image)ref, fileName); else if (type == VX_TYPE_ARRAY) return loadArray((vx_array)ref, fileName); else if (type == VX_TYPE_MATRIX) return loadMatrix((vx_matrix)ref, fileName); else if (type == VX_TYPE_REMAP) return loadRemap((vx_remap)ref, fileName); else return VX_ERROR_NOT_SUPPORTED; } static vx_status quickSetupLoadTableSizes(ls_context stitch) { FILE * fp = fopen("StitchTableSizes.txt", "r"); if (!fp) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to open: StitchTableSizes.txt\n"); if (fp != NULL) fclose(fp); return VX_FAILURE; } int readValue = 0; readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.blendOffsetTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.expCompOverlapTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.expCompValidTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.seamFindAccumTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.seamFindPathTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.seamFindPrefInfoTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.seamFindValidTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.seamFindWeightTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } readValue = fscanf(fp, VX_FMT_SIZE, &stitch->table_sizes.warpTableSize); if (!readValue) { ls_printf("ERROR: quickSetupLoadTableSizes: unable to read file\n"); return VX_FAILURE; } return VX_SUCCESS; } static vx_status quickSetupLoadTables(ls_context stitch) { vx_reference refList[] = { // intermediate tables and data that needs initialization (vx_reference)stitch->ValidPixelEntry, (vx_reference)stitch->WarpRemapEntry, (vx_reference)stitch->RGBY1, (vx_reference)stitch->cam_id_image, (vx_reference)stitch->group1_image, (vx_reference)stitch->group2_image, (vx_reference)stitch->weight_image, (vx_reference)stitch->valid_array, (vx_reference)stitch->OverlapPixelEntry, (vx_reference)stitch->overlap_matrix, (vx_reference)stitch->RGBY2, (vx_reference)stitch->valid_mask_image, (vx_reference)stitch->seamfind_valid_array, (vx_reference)stitch->seamfind_weight_array, (vx_reference)stitch->seamfind_accum_array, (vx_reference)stitch->seamfind_pref_array, (vx_reference)stitch->seamfind_info_array, (vx_reference)stitch->seamfind_path_array, (vx_reference)stitch->seamfind_scene_array, (vx_reference)stitch->seamfind_weight_image, (vx_reference)stitch->blend_mask_image, (vx_reference)stitch->blend_offsets, (vx_reference)stitch->camera_remap, (vx_reference)stitch->overlay_remap, }; for (vx_size i = 0; i < dimof(refList); i++) { if (refList[i]) { bool isIntermediateTmpData = false, isForCpuUseOnly = false; const char * fileNameSuffix = GetFileNameSuffix(stitch, refList[i], isIntermediateTmpData, isForCpuUseOnly); if (fileNameSuffix && (!isIntermediateTmpData)) { char fileName[1024]; sprintf(fileName, "%s", fileNameSuffix); vx_status status = loadReference(refList[i], fileName); if (status != VX_SUCCESS) return status; } } } return VX_SUCCESS; } static vx_status setupQuickInitializeParams(ls_context stitch) { vx_uint32 camWidth = stitch->camera_rgb_buffer_width / stitch->num_camera_columns; vx_uint32 camHeight = stitch->camera_rgb_buffer_height / stitch->num_camera_rows; vx_uint32 numCamera = stitch->num_camera_rows * stitch->num_camera_columns; vx_uint32 eqrWidth = stitch->output_rgb_buffer_width; vx_uint32 eqrHeight = stitch->output_rgb_buffer_height; // compute camera warp parameters and check for supported lens types float Mcam[32 * 9], Tcam[32 * 3], fcam[32 * 2], Mr[3 * 3]; vx_status status = CalculateCameraWarpParameters(numCamera, camWidth, camHeight, &stitch->rig_par, stitch->camera_par, Mcam, Tcam, fcam, Mr); if (status != VX_SUCCESS) return status; vx_uint32 paddingPixelCount = stitch->stitchInitData->paddingPixelCount; const camera_lens_params * lens = &stitch->camera_par[0].lens; // add nodes to the graph and verify. stitch->stitchInitData->params = { 0 }; stitch->stitchInitData->params.camWidth = camWidth; stitch->stitchInitData->params.camHeight = camHeight; stitch->stitchInitData->params.paddingPixelCount = paddingPixelCount; float cam_params_val = 0.0f; bool lens_fish_eye = 0; vx_map_id mapIdCamPar; vx_size stride = sizeof(vx_size); float *cam_params; ERROR_CHECK_STATUS(vxTruncateArray(stitch->stitchInitData->CameraParamsArr, 0)); ERROR_CHECK_STATUS(vxAddArrayItems(stitch->stitchInitData->CameraParamsArr, 32 * numCamera, &cam_params_val, 0)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->stitchInitData->CameraParamsArr, 0, 32 * numCamera, &mapIdCamPar, &stride, (void **)&cam_params, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); const float * T = Tcam, *M = Mcam, *f = fcam; for (vx_uint32 cam = 0; cam < numCamera; cam++, T += 3, M += 9, f += 2) { // perform lens distortion and warp for each pixel in the equirectangular destination image const camera_lens_params * lens = &stitch->camera_par[cam].lens; float k0 = 1.0f - (lens->k1 + lens->k2 + lens->k3); float left = 0, top = 0, right = (float)camWidth, bottom = (float)camHeight; if (lens->lens_type <= ptgui_lens_fisheye_circ && (lens->reserved[3] != 0 || lens->reserved[4] != 0 || lens->reserved[5] != 0 || lens->reserved[6] != 0)) { left = std::max(left, lens->reserved[3]); top = std::max(top, lens->reserved[4]); right = std::min(right, lens->reserved[5]); bottom = std::min(bottom, lens->reserved[6]); } stitch->stitchInitData->params.camId = cam; stitch->stitchInitData->params.lens_type = lens->lens_type; stitch->stitchInitData->params.F0 = f[0]; stitch->stitchInitData->params.F1 = f[1]; stitch->stitchInitData->params.TCam0 = T[0]; stitch->stitchInitData->params.TCam1 = T[1]; stitch->stitchInitData->params.TCam2 = T[2]; cam_params[0] = left; cam_params[1] = top; cam_params[2] = right; cam_params[3] = bottom; cam_params[4] = lens->k1; cam_params[5] = lens->k2; cam_params[6] = lens->k3; cam_params[7] = k0; cam_params[8] = lens->du0; cam_params[9] = lens->dv0; cam_params[10] = lens->r_crop; cam_params[11] = f[0]; cam_params[12] = f[1]; cam_params[13] = T[0]; cam_params[14] = T[1]; cam_params[15] = T[2]; memcpy(&cam_params[16], (void*)M, sizeof(float) * 9); cam_params[25] = (float)lens->lens_type; lens_fish_eye = (lens->lens_type == ptgui_lens_fisheye_circ); cam_params += 32; } ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->stitchInitData->CameraParamsArr, mapIdCamPar)); stitch->stitchInitData->params.camId = numCamera; stitch->stitchInitData->lens_fish_eye = lens_fish_eye; return VX_SUCCESS; } static vx_status setupQuickInitializeGraph(ls_context stitch) { vx_uint32 numCamera = stitch->num_camera_rows * stitch->num_camera_columns; vx_uint32 eqrWidth = stitch->output_rgb_buffer_width; vx_uint32 eqrHeight = stitch->output_rgb_buffer_height; vx_uint32 paddingPixelCount = stitch->stitchInitData->paddingPixelCount; bool lens_fish_eye = stitch->stitchInitData->lens_fish_eye; if (lens_fish_eye) { ERROR_CHECK_OBJECT_(stitch->stitchInitData->calc_warp_maps_node = stitchInitCalcCamWarpMaps(stitch->stitchInitData->graphInitialize, &stitch->stitchInitData->params, stitch->stitchInitData->CameraParamsArr, stitch->stitchInitData->ValidPixelMap, NULL, stitch->stitchInitData->SrcCoordMap, stitch->stitchInitData->CameraZBuffArr)); } else { ERROR_CHECK_OBJECT_(stitch->stitchInitData->calc_warp_maps_node = stitchInitCalcCamWarpMaps(stitch->stitchInitData->graphInitialize, &stitch->stitchInitData->params, stitch->stitchInitData->CameraParamsArr, stitch->stitchInitData->ValidPixelMap, stitch->stitchInitData->PaddedPixMap, stitch->stitchInitData->SrcCoordMap, stitch->stitchInitData->CameraZBuffArr)); } ERROR_CHECK_OBJECT_(stitch->stitchInitData->calc_default_idx_node = stitchInitCalcDefCamIdxNode(stitch->stitchInitData->graphInitialize, numCamera, eqrWidth, eqrHeight, stitch->stitchInitData->CameraZBuffArr, stitch->stitchInitData->DefaultCamMap)); if (paddingPixelCount && stitch->stitchInitData->PaddedPixMap && lens_fish_eye) { ERROR_CHECK_OBJECT_(stitch->stitchInitData->pad_dilate_node = stitchInitExtendPadDilateNode(stitch->stitchInitData->graphInitialize, paddingPixelCount, stitch->stitchInitData->ValidPixelMap, stitch->stitchInitData->PaddedPixMap)); } ERROR_CHECK_STATUS_(vxVerifyGraph(stitch->stitchInitData->graphInitialize)); return VX_SUCCESS; } static vx_status AllocateLensModelBuffersForCamera(ls_context stitch) { stitch->camSrcMap = new StitchCoord2dFloat[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height * stitch->num_cameras]; stitch->validPixelCamMap = new vx_uint32[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height]; stitch->camIndexTmpBuf = new vx_float32[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height]; stitch->camIndexBuf = new vx_uint8[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height]; if (stitch->stitching_mode == stitching_mode_normal) { if (stitch->EXPO_COMP) { stitch->overlapMatrixBuf = new vx_int32[stitch->num_cameras * stitch->num_cameras]; } if (stitch->MULTIBAND_BLEND) { if (stitch->live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND_PAD_PIXELS] == 0) { stitch->paddingPixelCount = (stitch->num_bands <= 4) ? 64 : 128; } else { stitch->paddingPixelCount = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND_PAD_PIXELS]; } stitch->paddedPixelCamMap = new vx_uint32[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height]; } stitch->overlapRectBuf = new vx_rectangle_t[2 * stitch->num_cameras * stitch->num_cameras]; for (vx_uint32 cam = 0; cam < stitch->num_cameras; cam++) { stitch->overlapValid[cam] = stitch->overlapRectBuf + cam * stitch->num_cameras; stitch->overlapPadded[cam] = stitch->overlapValid[cam] + stitch->num_cameras*stitch->num_cameras; } } if (!stitch->USE_CPU_INIT && !stitch->stitchInitData){ vx_enum StitchCoord2dFloatType; stitch->stitchInitData = new StitchInitializeData; memset(stitch->stitchInitData, 0, sizeof(StitchInitializeData)); vx_size arr_size = (stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height); ERROR_CHECK_TYPE_(StitchCoord2dFloatType = vxRegisterUserStruct(stitch->context, sizeof(StitchCoord2dFloat))); ERROR_CHECK_OBJECT_(stitch->stitchInitData->graphInitialize = vxCreateGraph(stitch->context)); ERROR_CHECK_OBJECT_(stitch->stitchInitData->ValidPixelMap = CreateAlignedImage(stitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, 16, VX_DF_IMAGE_U32, VX_MEMORY_TYPE_OPENCL)); if (stitch->MULTIBAND_BLEND) { ERROR_CHECK_OBJECT_(stitch->stitchInitData->PaddedPixMap = CreateAlignedImage(stitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, 16, VX_DF_IMAGE_U32, VX_MEMORY_TYPE_OPENCL)); } ERROR_CHECK_OBJECT_(stitch->stitchInitData->DefaultCamMap = CreateAlignedImage(stitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, 16, VX_DF_IMAGE_U8, VX_MEMORY_TYPE_OPENCL)); ERROR_CHECK_OBJECT_(stitch->stitchInitData->CameraParamsArr = vxCreateArray(stitch->context, VX_TYPE_FLOAT32, 32 * stitch->num_cameras)); ERROR_CHECK_OBJECT_(stitch->stitchInitData->SrcCoordMap = CreateAlignedImage(stitch, stitch->output_rgb_buffer_width * 2, stitch->output_rgb_buffer_height*stitch->num_cameras, 16, VX_DF_IMAGE_U32, VX_MEMORY_TYPE_OPENCL)); ERROR_CHECK_OBJECT_(stitch->stitchInitData->CameraZBuffArr = vxCreateVirtualArray(stitch->stitchInitData->graphInitialize, VX_TYPE_FLOAT32, arr_size*stitch->num_cameras)); // Quick Initailize enabled if (stitch->stitchInitData && stitch->stitchInitData->graphInitialize && !stitch->SETUP_LOAD_FILES_FOUND) { if (stitch->stitching_mode == stitching_mode_quick_and_dirty) stitch->stitchInitData->paddingPixelCount = 0; else stitch->stitchInitData->paddingPixelCount = stitch->paddingPixelCount; ERROR_CHECK_STATUS_(setupQuickInitializeParams(stitch)); ERROR_CHECK_STATUS_(setupQuickInitializeGraph(stitch)); } } return VX_SUCCESS; } static vx_status AllocateLensModelBuffersForOverlay(ls_context stitch) { stitch->overlaySrcMap = new StitchCoord2dFloat[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height * stitch->num_overlays]; stitch->validPixelOverlayMap = new vx_uint32[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height]; stitch->overlayIndexTmpBuf = new vx_float32[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height]; stitch->overlayIndexBuf = new vx_uint8[stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height]; return VX_SUCCESS; } static vx_status InitializeInternalTablesForRemap(ls_context stitch, vx_remap remap, vx_uint32 numCamera, vx_uint32 numCameraColumns, vx_uint32 camWidth, vx_uint32 camHeight, vx_uint32 eqrWidth, vx_uint32 eqrHeight, const rig_params * rig_par, const camera_params * cam_par, StitchCoord2dFloat * srcMap, vx_uint32 * validPixelMap, vx_float32 * camIndexTmpBuf, vx_uint8 * camIndexBuf) { // compute lens distortion and warp models vx_status status = CalculateLensDistortionAndWarpMaps(stitch->stitchInitData, numCamera, camWidth, camHeight, eqrWidth, eqrHeight, rig_par, cam_par, validPixelMap, 0, nullptr, srcMap, camIndexTmpBuf, camIndexBuf); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)remap, status, "ERROR: InitializeInternalTablesForRemap: CalculateLensDistortionAndWarpMaps() failed (%d)\n", status); return status; } { // initialize remap table vx_uint32 pixelsPerEqrImage = eqrWidth * eqrHeight; vx_uint32 x_offset[256], y_offset[256]; for (vx_uint32 camId = 0; camId < numCamera; camId++) { x_offset[camId] = (camId % numCameraColumns) * camWidth; y_offset[camId] = (camId / numCameraColumns) * camHeight; } for (vx_uint32 y = 0, pos = 0; y < eqrHeight; y++) { for (vx_uint32 x = 0; x < eqrWidth; x++, pos++) { vx_float32 x_src = -1, y_src = -1; vx_uint32 camId = camIndexBuf[pos]; if (camId < numCamera) { const StitchCoord2dFloat * mapEntry = &srcMap[pos + camId * pixelsPerEqrImage]; x_src = mapEntry->x + x_offset[camId]; y_src = mapEntry->y + y_offset[camId]; } vxSetRemapPoint(remap, x, y, x_src, y_src); } } } return VX_SUCCESS; } static vx_status InitializeInternalTablesForCamera(ls_context stitch) { vx_uint32 numCamera = stitch->num_cameras; vx_uint32 eqrWidth = stitch->output_rgb_buffer_width; vx_uint32 eqrHeight = stitch->output_rgb_buffer_height; const vx_uint32 * validPixelCamMap = stitch->validPixelCamMap; const vx_uint32 * paddedPixelCamMap = stitch->paddedPixelCamMap; const StitchCoord2dFloat * camSrcMap = stitch->camSrcMap; const vx_rectangle_t * const * overlapValid = stitch->overlapValid; const vx_rectangle_t * const * overlapPadded = stitch->overlapPadded; const vx_uint32 * validCamOverlapInfo = stitch->validCamOverlapInfo; const vx_uint32 * paddedCamOverlapInfo = stitch->paddedCamOverlapInfo; const vx_uint8 * camIndexBuf = stitch->camIndexBuf; if (stitch->feature_enable_reinitialize) { // compute lens distortion and warp models vx_status status = CalculateLensDistortionAndWarpMaps(!stitch->USE_CPU_INIT ? stitch->stitchInitData : nullptr, stitch->num_cameras, stitch->camera_rgb_buffer_width / stitch->num_camera_columns, stitch->camera_rgb_buffer_height / stitch->num_camera_rows, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->rig_par, stitch->camera_par, stitch->validPixelCamMap, stitch->paddingPixelCount, stitch->paddedPixelCamMap, stitch->camSrcMap, stitch->camIndexTmpBuf, stitch->camIndexBuf); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: CalculateLensDistortionAndWarpMaps() failed (%d)\n", status); return status; } stitch->overlapCount = CalculateValidOverlapRegions(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->validPixelCamMap, stitch->overlapValid, stitch->validCamOverlapInfo, stitch->paddedPixelCamMap, stitch->overlapPadded, stitch->paddedCamOverlapInfo); if (stitch->overlapCount > 6) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: number of overlaps (%d) greater than 6 not supported\n", stitch->overlapCount); return VX_ERROR_NOT_SUPPORTED; } } { // initialize warp tables StitchValidPixelEntry validPixelEntry = { 0 }, *validPixelBuf = nullptr; StitchWarpRemapEntry warpRemapEntry = { 0 }, *warpRemapBuf = nullptr; ERROR_CHECK_STATUS_(vxTruncateArray(stitch->ValidPixelEntry, 0)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->WarpRemapEntry, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->ValidPixelEntry, stitch->table_sizes.warpTableSize, &validPixelEntry, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->WarpRemapEntry, stitch->table_sizes.warpTableSize, &warpRemapEntry, 0)); vx_size stride = 0, warpEntryCount = 0; vx_map_id map_id_valid = 0, map_id_warp = 0; ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->ValidPixelEntry, 0, stitch->table_sizes.warpTableSize, &map_id_valid, &stride, (void **)&validPixelBuf, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->WarpRemapEntry, 0, stitch->table_sizes.warpTableSize, &map_id_warp, &stride, (void **)&warpRemapBuf, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0)); vx_status status = GenerateWarpBuffers(numCamera, eqrWidth, eqrHeight, validPixelCamMap, paddedPixelCamMap, camSrcMap, stitch->num_camera_columns, stitch->camera_rgb_buffer_width / stitch->num_camera_columns, stitch->table_sizes.warpTableSize, validPixelBuf, warpRemapBuf, &warpEntryCount); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->ValidPixelEntry, map_id_valid)); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->WarpRemapEntry, map_id_warp)); if (status != VX_SUCCESS) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateWarpBuffers() failed (%d)\n", status); return status; } if (!stitch->feature_enable_reinitialize && (warpEntryCount != stitch->table_sizes.warpTableSize)) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateWarpBuffers output doesn't have enough entries (%d) expected (%d)\n", (vx_uint32)warpEntryCount, (vx_uint32)stitch->table_sizes.warpTableSize); return VX_FAILURE; } if (stitch->feature_enable_reinitialize && (warpEntryCount > stitch->table_sizes.warpTableSize)) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateWarpBuffers output has more entries (%d) than (%d)\n", (vx_uint32)warpEntryCount, (vx_uint32)stitch->table_sizes.warpTableSize); return VX_FAILURE; } ERROR_CHECK_STATUS_(vxTruncateArray(stitch->ValidPixelEntry, warpEntryCount)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->WarpRemapEntry, warpEntryCount)); } { // initialize merge tables vx_rectangle_t rectId = { 0, 0, eqrWidth >> 3, eqrHeight }; vx_imagepatch_addressing_t addrId, addrG1, addrG2; vx_map_id map_id_camId, map_id_camG1, map_id_camG2; vx_uint8 * ptr_camId; StitchMergeCamIdEntry * ptr_camG1, *ptr_camG2; ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->cam_id_image, &rectId, 0, &map_id_camId, &addrId, (void **)&ptr_camId, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->group1_image, &rectId, 0, &map_id_camG1, &addrG1, (void **)&ptr_camG1, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->group2_image, &rectId, 0, &map_id_camG2, &addrG2, (void **)&ptr_camG2, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); vx_status status = GenerateMergeBuffers(numCamera, eqrWidth, eqrHeight, validPixelCamMap, paddedPixelCamMap, addrId.stride_y, addrG1.stride_y, addrG2.stride_y, ptr_camId, ptr_camG1, ptr_camG2); ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->cam_id_image, map_id_camId)); ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->group1_image, map_id_camG1)); ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->group2_image, map_id_camG2)); if (status != VX_SUCCESS) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateMergeBuffers() failed (%d)\n", status); return status; } } { // initialize weight and valid mask images vx_rectangle_t rectMask = { 0, 0, eqrWidth, eqrHeight * numCamera }; vx_imagepatch_addressing_t addrMask; vx_map_id map_id_mask; vx_uint8 * ptr_mask; ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->weight_image, &rectMask, 0, &map_id_mask, &addrMask, (void **)&ptr_mask, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); GenerateDefaultMergeMaskImage(numCamera, eqrWidth, eqrHeight, camIndexBuf, addrMask.stride_y, ptr_mask); ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->weight_image, map_id_mask)); } if (stitch->EXPO_COMP) { // exposure comp tables StitchExpCompCalcEntry validEntry = { 0 }, *validBuf = nullptr; StitchOverlapPixelEntry overlapEntry = { 0 }, *overlapBuf = nullptr; vx_size stride = 0, validEntryCount = 0, overlapEntryCount = 0; vx_map_id map_id_valid = 0, map_id_overlap = 0; ERROR_CHECK_STATUS_(vxTruncateArray(stitch->valid_array, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->valid_array, stitch->table_sizes.expCompValidTableSize, &validEntry, 0)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->valid_array, 0, stitch->table_sizes.expCompValidTableSize, &map_id_valid, &stride, (void **)&validBuf, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0)); // TBD: use no gap flag if (stitch->EXPO_COMP < 3) { ERROR_CHECK_STATUS_(vxTruncateArray(stitch->OverlapPixelEntry, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->OverlapPixelEntry, stitch->table_sizes.expCompOverlapTableSize, &overlapEntry, 0)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->OverlapPixelEntry, 0, stitch->table_sizes.expCompOverlapTableSize, &map_id_overlap, &stride, (void **)&overlapBuf, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0)); } vx_status status = GenerateExpCompBuffers(numCamera, eqrWidth, eqrHeight, validPixelCamMap, overlapValid, validCamOverlapInfo, paddedPixelCamMap, overlapPadded, paddedCamOverlapInfo, stitch->table_sizes.expCompValidTableSize, stitch->table_sizes.expCompOverlapTableSize, validBuf, overlapBuf, &validEntryCount, &overlapEntryCount, stitch->overlapMatrixBuf); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->valid_array, map_id_valid)); if (stitch->EXPO_COMP < 3) { ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->OverlapPixelEntry, map_id_overlap)); } if (status != VX_SUCCESS) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateExpCompBuffers() failed (%d)\n", status); return status; } if (!stitch->feature_enable_reinitialize && (validEntryCount != stitch->table_sizes.expCompValidTableSize || overlapEntryCount != stitch->table_sizes.expCompOverlapTableSize)) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateExpCompBuffers output doesn't have enough entries (%d,%d) expected (%d,%d)\n", (vx_uint32)validEntryCount, (vx_uint32)overlapEntryCount, (vx_uint32)stitch->table_sizes.expCompValidTableSize, (vx_uint32)stitch->table_sizes.expCompOverlapTableSize); return VX_FAILURE; } if (stitch->feature_enable_reinitialize && (validEntryCount > stitch->table_sizes.expCompValidTableSize || overlapEntryCount > stitch->table_sizes.expCompOverlapTableSize)) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateExpCompBuffers output has more entries (%d,%d) than (%d,%d)\n", (vx_uint32)validEntryCount, (vx_uint32)overlapEntryCount, (vx_uint32)stitch->table_sizes.expCompValidTableSize, (vx_uint32)stitch->table_sizes.expCompOverlapTableSize); return VX_FAILURE; } ERROR_CHECK_STATUS_(vxTruncateArray(stitch->valid_array, validEntryCount)); if (stitch->EXPO_COMP < 3) { ERROR_CHECK_STATUS_(vxTruncateArray(stitch->OverlapPixelEntry, overlapEntryCount)); } ERROR_CHECK_STATUS_(vxWriteMatrix(stitch->overlap_matrix, stitch->overlapMatrixBuf)); } if (stitch->SEAM_FIND) { // seam find tables vx_size seamFindValidEntryCount, seamFindWeightEntryCount, seamFindAccumEntryCount; vx_size seamFindPrefInfoEntryCount, seamFindPathEntryCount, stride; vx_map_id mapIdValid, mapIdWeight, mapIdAccum, mapIdPref, mapIdInfo; StitchSeamFindValidEntry validEntry = { 0 }, *validTable = nullptr; StitchSeamFindWeightEntry weightEntry = { 0 }, *weightTable = nullptr; StitchSeamFindAccumEntry accumEntry = { 0 }, *accumTable = nullptr; StitchSeamFindPreference prefEntry = { 0 }, *prefTable = nullptr; StitchSeamFindInformation infoEntry = { 0 }, *infoTable = nullptr; ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_valid_array, 0)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_weight_array, 0)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_accum_array, 0)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_pref_array, 0)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_info_array, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->seamfind_valid_array, stitch->table_sizes.seamFindValidTableSize, &validEntry, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->seamfind_weight_array, stitch->table_sizes.seamFindWeightTableSize, &weightEntry, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->seamfind_accum_array, stitch->table_sizes.seamFindAccumTableSize, &accumEntry, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->seamfind_pref_array, stitch->table_sizes.seamFindPrefInfoTableSize, &prefEntry, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->seamfind_info_array, stitch->table_sizes.seamFindPrefInfoTableSize, &infoEntry, 0)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->seamfind_valid_array, 0, stitch->table_sizes.seamFindValidTableSize, &mapIdValid, &stride, (void **)&validTable, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->seamfind_weight_array, 0, stitch->table_sizes.seamFindWeightTableSize, &mapIdWeight, &stride, (void **)&weightTable, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->seamfind_accum_array, 0, stitch->table_sizes.seamFindAccumTableSize, &mapIdAccum, &stride, (void **)&accumTable, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->seamfind_pref_array, 0, stitch->table_sizes.seamFindPrefInfoTableSize, &mapIdPref, &stride, (void **)&prefTable, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->seamfind_info_array, 0, stitch->table_sizes.seamFindPrefInfoTableSize, &mapIdInfo, &stride, (void **)&infoTable, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); vx_status status = GenerateSeamFindBuffers(numCamera, eqrWidth, eqrHeight, stitch->camera_par, validPixelCamMap, overlapValid, validCamOverlapInfo, paddedPixelCamMap, overlapPadded, paddedCamOverlapInfo, stitch->live_stitch_attr, stitch->table_sizes.seamFindValidTableSize, stitch->table_sizes.seamFindWeightTableSize, stitch->table_sizes.seamFindAccumTableSize, stitch->table_sizes.seamFindPrefInfoTableSize, validTable, weightTable, accumTable, prefTable, infoTable, &seamFindValidEntryCount, &seamFindWeightEntryCount, &seamFindAccumEntryCount, &seamFindPrefInfoEntryCount, &seamFindPathEntryCount); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->seamfind_valid_array, mapIdValid)); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->seamfind_weight_array, mapIdWeight)); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->seamfind_accum_array, mapIdAccum)); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->seamfind_pref_array, mapIdPref)); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->seamfind_info_array, mapIdInfo)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_valid_array, seamFindValidEntryCount)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_weight_array, seamFindWeightEntryCount)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_accum_array, seamFindAccumEntryCount)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_pref_array, seamFindPrefInfoEntryCount)); ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_info_array, seamFindPrefInfoEntryCount)); if (status != VX_SUCCESS) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateSeamFindBuffers() failed (%d)\n", status); return status; } if (!stitch->feature_enable_reinitialize && (seamFindValidEntryCount != stitch->table_sizes.seamFindValidTableSize || seamFindWeightEntryCount != stitch->table_sizes.seamFindWeightTableSize || seamFindAccumEntryCount != stitch->table_sizes.seamFindAccumTableSize || seamFindPrefInfoEntryCount != stitch->table_sizes.seamFindPrefInfoTableSize || seamFindPathEntryCount != stitch->table_sizes.seamFindPathTableSize)) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateSeamFindBuffers output doesn't have enough entries (%d,%d,%d,%d,%d) expected (%d,%d,%d,%d,%d)\n", (vx_uint32)seamFindValidEntryCount, (vx_uint32)seamFindWeightEntryCount, (vx_uint32)seamFindAccumEntryCount, (vx_uint32)seamFindPrefInfoEntryCount, (vx_uint32)seamFindPathEntryCount, (vx_uint32)stitch->table_sizes.seamFindValidTableSize, (vx_uint32)stitch->table_sizes.seamFindWeightTableSize, (vx_uint32)stitch->table_sizes.seamFindAccumTableSize, (vx_uint32)stitch->table_sizes.seamFindPrefInfoTableSize, (vx_uint32)stitch->table_sizes.seamFindPathTableSize); return VX_FAILURE; } if (stitch->feature_enable_reinitialize && (seamFindValidEntryCount > stitch->table_sizes.seamFindValidTableSize || seamFindWeightEntryCount > stitch->table_sizes.seamFindWeightTableSize || seamFindAccumEntryCount > stitch->table_sizes.seamFindAccumTableSize || seamFindPrefInfoEntryCount > stitch->table_sizes.seamFindPrefInfoTableSize || seamFindPathEntryCount > stitch->table_sizes.seamFindPathTableSize)) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateSeamFindBuffers output has more entries (%d,%d,%d,%d,%d) than (%d,%d,%d,%d,%d)\n", (vx_uint32)seamFindValidEntryCount, (vx_uint32)seamFindWeightEntryCount, (vx_uint32)seamFindAccumEntryCount, (vx_uint32)seamFindPrefInfoEntryCount, (vx_uint32)seamFindPathEntryCount, (vx_uint32)stitch->table_sizes.seamFindValidTableSize, (vx_uint32)stitch->table_sizes.seamFindWeightTableSize, (vx_uint32)stitch->table_sizes.seamFindAccumTableSize, (vx_uint32)stitch->table_sizes.seamFindPrefInfoTableSize, (vx_uint32)stitch->table_sizes.seamFindPathTableSize); return VX_FAILURE; } // reset current frame value and path & scene arrays (if used) stitch->current_frame_value = 0; ERROR_CHECK_STATUS_(vxWriteScalarValue(stitch->current_frame, &stitch->current_frame_value)); StitchSeamFindPathEntry pathEntry = { 0 }; ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_path_array, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->seamfind_path_array, seamFindPathEntryCount, &pathEntry, 0)); if (stitch->seamfind_scene_array) { StitchSeamFindSceneEntry sceneEntry = { 0 }; ERROR_CHECK_STATUS_(vxTruncateArray(stitch->seamfind_scene_array, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->seamfind_scene_array, seamFindPrefInfoEntryCount, &sceneEntry, 0)); } // initialize seamfind mask image vx_rectangle_t rectMask = { 0, 0, eqrWidth, eqrHeight * numCamera }; vx_imagepatch_addressing_t addrMask; vx_map_id map_id_mask; vx_uint8 * ptr_mask; ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->seamfind_weight_image, &rectMask, 0, &map_id_mask, &addrMask, (void **)&ptr_mask, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); GenerateDefaultMergeMaskImage(numCamera, eqrWidth, eqrHeight, camIndexBuf, addrMask.stride_y, ptr_mask); ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->seamfind_weight_image, map_id_mask)); } if (stitch->MULTIBAND_BLEND) { // multiband blend tables vx_size stride; StitchBlendValidEntry blendValidEntry = { 0 }, *blendOffsetTable = nullptr; vx_map_id mapIdValid; ERROR_CHECK_STATUS_(vxTruncateArray(stitch->blend_offsets, 0)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->blend_offsets, stitch->table_sizes.blendOffsetTableSize, &blendValidEntry, 0)); ERROR_CHECK_STATUS_(vxMapArrayRange(stitch->blend_offsets, 0, stitch->table_sizes.blendOffsetTableSize, &mapIdValid, &stride, (void **)&blendOffsetTable, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); vx_status status = GenerateBlendBuffers(numCamera, eqrWidth, eqrHeight, stitch->num_bands, validPixelCamMap, paddedPixelCamMap, overlapPadded, paddedCamOverlapInfo, stitch->multibandBlendOffsetIntoBuffer, stitch->table_sizes.blendOffsetTableSize, blendOffsetTable); ERROR_CHECK_STATUS_(vxUnmapArrayRange(stitch->blend_offsets, mapIdValid)); if (status != VX_SUCCESS) { ls_printf("ERROR: InitializeInternalTablesForCamera: GenerateBlendBuffers() failed (%d)\n", status); return status; } } if (stitch->valid_mask_image) { // initialize valid pixel mask vx_rectangle_t rectMask = { 0, 0, eqrWidth, eqrHeight * numCamera }; vx_imagepatch_addressing_t addrMask; vx_map_id map_id_mask; vx_uint8 * ptr_mask; ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->valid_mask_image, &rectMask, 0, &map_id_mask, &addrMask, (void **)&ptr_mask, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); GenerateValidMaskImage(numCamera, eqrWidth, eqrHeight, validPixelCamMap, addrMask.stride_y, ptr_mask); ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->valid_mask_image, map_id_mask)); } // initialize blend mask image if (stitch->blend_mask_image) { vx_rectangle_t rectMask = { 0, 0, eqrWidth, eqrHeight * numCamera }; vx_imagepatch_addressing_t addrMask; vx_map_id map_id_mask; vx_uint8 * ptr_mask; ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->blend_mask_image, &rectMask, 0, &map_id_mask, &addrMask, (void **)&ptr_mask, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); memset(ptr_mask, 255, addrMask.stride_y * addrMask.dim_y); ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->blend_mask_image, map_id_mask)); } { // initialize RGBY1 & RGBY2 to invalid pixels and sync to GPU vx_rectangle_t rect = { 0, 0, eqrWidth, eqrHeight * numCamera }; vx_imagepatch_addressing_t addr; vx_map_id map_id; vx_uint32 * ptr; const __m128i r0 = _mm_set1_epi32(0x80000000); ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->RGBY1, &rect, 0, &map_id, &addr, (void **)&ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); __m128i *dst = (__m128i*) ptr; vx_size size_in_bytes = (addr.stride_y * addr.dim_y)&~127; for (vx_uint32 i = 0; i < size_in_bytes; i += 128){ _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); } ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->RGBY1, map_id)); if (stitch->RGBY2) { ERROR_CHECK_STATUS_(vxMapImagePatch(stitch->RGBY2, &rect, 0, &map_id, &addr, (void **)&ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); __m128i *dst = (__m128i*) ptr; vx_size size_in_bytes = (addr.stride_y * addr.dim_y)&~127; for (vx_uint32 i = 0; i < size_in_bytes; i += 128){ _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); _mm_store_si128(dst++, r0); } ERROR_CHECK_STATUS_(vxUnmapImagePatch(stitch->RGBY2, map_id)); } } return VX_SUCCESS; } static vx_status AllocateInternalTablesForCamera(ls_context stitch) { // make sure to allocate internal buffers for initialize atleast once if (!stitch->camSrcMap) { vx_status status = AllocateLensModelBuffersForCamera(stitch); if (status) return status; } if (!stitch->feature_enable_reinitialize) { if (!stitch->SETUP_LOAD_FILES_FOUND) { // when re-initialize support is not required, only allocate smallest buffers needed // ------ // compute lens distortion and warp models vx_status status = CalculateLensDistortionAndWarpMaps(!stitch->USE_CPU_INIT ? stitch->stitchInitData : nullptr, stitch->num_cameras, stitch->camera_rgb_buffer_width / stitch->num_camera_columns, stitch->camera_rgb_buffer_height / stitch->num_camera_rows, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->rig_par, stitch->camera_par, stitch->validPixelCamMap, stitch->paddingPixelCount, stitch->paddedPixelCamMap, stitch->camSrcMap, stitch->camIndexTmpBuf, stitch->camIndexBuf); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: CalculateLensDistortionAndWarpMaps() failed (%d)\n", status); return status; } stitch->overlapCount = CalculateValidOverlapRegions(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->validPixelCamMap, stitch->overlapValid, stitch->validCamOverlapInfo, stitch->paddedPixelCamMap, stitch->overlapPadded, stitch->paddedCamOverlapInfo); if (stitch->overlapCount > 6) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: number of overlaps (%d) greater than 6 not supported\n", stitch->overlapCount); return VX_ERROR_NOT_SUPPORTED; } // calculate minimum buffer sizes needed CalculateSmallestWarpBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->validPixelCamMap, stitch->paddedPixelCamMap, &stitch->table_sizes.warpTableSize); if (stitch->EXPO_COMP) { CalculateSmallestExpCompBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->validPixelCamMap, stitch->overlapValid, stitch->validCamOverlapInfo, stitch->paddedPixelCamMap, stitch->overlapPadded, stitch->paddedCamOverlapInfo, &stitch->table_sizes.expCompValidTableSize, &stitch->table_sizes.expCompOverlapTableSize); if (stitch->EXPO_COMP >= 3) { // no overlap table needed stitch->table_sizes.expCompOverlapTableSize = 0; } } if (stitch->SEAM_FIND) { CalculateSmallestSeamFindBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->camera_par, stitch->validPixelCamMap, stitch->overlapValid, stitch->validCamOverlapInfo, stitch->paddedPixelCamMap, stitch->overlapPadded, stitch->paddedCamOverlapInfo, stitch->live_stitch_attr, &stitch->table_sizes.seamFindValidTableSize, &stitch->table_sizes.seamFindWeightTableSize, &stitch->table_sizes.seamFindAccumTableSize, &stitch->table_sizes.seamFindPrefInfoTableSize, &stitch->table_sizes.seamFindPathTableSize); } if (stitch->MULTIBAND_BLEND) { ERROR_CHECK_ALLOC_(stitch->multibandBlendOffsetIntoBuffer = new vx_size[stitch->num_bands]()); CalculateSmallestBlendBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->num_bands, stitch->validPixelCamMap, stitch->paddedPixelCamMap, stitch->overlapPadded, stitch->paddedCamOverlapInfo, stitch->multibandBlendOffsetIntoBuffer, &stitch->table_sizes.blendOffsetTableSize); } //If load Buffer - dump table sizes if (stitch->SETUP_LOAD){ status = quickSetupDumpTableSizes(stitch); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: quickSetupDumpTableSizes() failed (%d)\n", status); return status; } } } else{ //If load Buffer - load table sizes vx_status status = quickSetupLoadTableSizes(stitch); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: quickSetupLoadTableSizes() failed (%d)\n", status); return status; } } } else { // when re-initialize support is required, allocate largest buffers to accomodate changes during reinitialize CalculateLargestWarpBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->table_sizes.warpTableSize); if (stitch->EXPO_COMP) { CalculateLargestExpCompBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->table_sizes.expCompValidTableSize, &stitch->table_sizes.expCompOverlapTableSize); } if (stitch->SEAM_FIND) { CalculateLargestSeamFindBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->table_sizes.seamFindValidTableSize, &stitch->table_sizes.seamFindWeightTableSize, &stitch->table_sizes.seamFindAccumTableSize, &stitch->table_sizes.seamFindPrefInfoTableSize, &stitch->table_sizes.seamFindPathTableSize); } if (stitch->MULTIBAND_BLEND) { ERROR_CHECK_ALLOC_(stitch->multibandBlendOffsetIntoBuffer = new vx_size[stitch->num_bands]()); CalculateLargestBlendBufferSizes(stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->num_bands, stitch->multibandBlendOffsetIntoBuffer, &stitch->table_sizes.blendOffsetTableSize); } } // disable features if can't be supported with buffer sizes if (stitch->EXPO_COMP) { if (stitch->table_sizes.expCompValidTableSize == 0 || ((stitch->EXPO_COMP < 3) && stitch->table_sizes.expCompOverlapTableSize == 0)) { ls_printf("WARNING: AllocateInternalTablesForCamera: ExpComp has been disabled because of not enough overlap\n"); stitch->EXPO_COMP = 0; } } if (stitch->SEAM_FIND) { if (stitch->table_sizes.seamFindValidTableSize == 0 || stitch->table_sizes.seamFindWeightTableSize == 0 || stitch->table_sizes.seamFindAccumTableSize == 0 || stitch->table_sizes.seamFindPrefInfoTableSize == 0 || stitch->table_sizes.seamFindPathTableSize == 0) { ls_printf("WARNING: AllocateInternalTablesForCamera: SeamFind has been disabled because of not enough overlap\n"); stitch->SEAM_FIND = 0; } } if (stitch->MULTIBAND_BLEND) { if (stitch->table_sizes.blendOffsetTableSize == 0) { ls_printf("WARNING: AllocateInternalTablesForCamera: Blend has been disabled because of not enough overlap\n"); stitch->MULTIBAND_BLEND = 0; } } if (stitch->table_sizes.warpTableSize == 0) { ls_printf("ERROR: AllocateInternalTablesForCamera: there are no pixels to warp: check parameters\n"); return VX_ERROR_INVALID_PARAMETERS; } // create data objects needed by warp kernel vx_enum StitchValidPixelEntryType, StitchWarpRemapEntryType; ERROR_CHECK_TYPE_(StitchValidPixelEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchValidPixelEntry))); ERROR_CHECK_TYPE_(StitchWarpRemapEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchWarpRemapEntry))); ERROR_CHECK_OBJECT_(stitch->ValidPixelEntry = vxCreateArray(stitch->context, StitchValidPixelEntryType, stitch->table_sizes.warpTableSize)); ERROR_CHECK_OBJECT_(stitch->WarpRemapEntry = vxCreateArray(stitch->context, StitchWarpRemapEntryType, stitch->table_sizes.warpTableSize)); ERROR_CHECK_OBJECT_(stitch->RGBY1 = vxCreateImage(stitch->context, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_RGBX)); // create data objects needed by merge kernel ERROR_CHECK_OBJECT_(stitch->weight_image = vxCreateImage(stitch->context, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_U8)); ERROR_CHECK_OBJECT_(stitch->cam_id_image = vxCreateImage(stitch->context, (stitch->output_rgb_buffer_width / 8), stitch->output_rgb_buffer_height, VX_DF_IMAGE_U8)); ERROR_CHECK_OBJECT_(stitch->group1_image = vxCreateImage(stitch->context, (stitch->output_rgb_buffer_width / 8), stitch->output_rgb_buffer_height, VX_DF_IMAGE_U16)); ERROR_CHECK_OBJECT_(stitch->group2_image = vxCreateImage(stitch->context, (stitch->output_rgb_buffer_width / 8), stitch->output_rgb_buffer_height, VX_DF_IMAGE_U16)); // create data objects needed by exposure comp kernel if (stitch->EXPO_COMP) { vx_enum StitchOverlapPixelEntryType, StitchExpCompCalcEntryType; vx_float32 one = 1.0f; // initialize gain_array with default gains as one ERROR_CHECK_TYPE_(StitchOverlapPixelEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchOverlapPixelEntry))); ERROR_CHECK_TYPE_(StitchExpCompCalcEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchExpCompCalcEntry))); ERROR_CHECK_OBJECT_(stitch->valid_array = vxCreateArray(stitch->context, StitchExpCompCalcEntryType, stitch->table_sizes.expCompValidTableSize)); if (stitch->EXPO_COMP < 3) { ERROR_CHECK_OBJECT_(stitch->OverlapPixelEntry = vxCreateArray(stitch->context, StitchOverlapPixelEntryType, stitch->table_sizes.expCompOverlapTableSize)); } ERROR_CHECK_OBJECT_(stitch->overlap_matrix = vxCreateMatrix(stitch->context, VX_TYPE_INT32, stitch->num_cameras, stitch->num_cameras)); ERROR_CHECK_OBJECT_(stitch->RGBY2 = vxCreateImage(stitch->context, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_RGBX)); if (stitch->EXPO_COMP == 1) { ERROR_CHECK_OBJECT_(stitch->A_matrix = vxCreateMatrix(stitch->context, VX_TYPE_INT32, stitch->num_cameras, stitch->num_cameras)); ERROR_CHECK_ALLOC_(stitch->A_matrix_initial_value = new vx_int32[stitch->num_cameras * stitch->num_cameras]()); ERROR_CHECK_STATUS_(vxWriteMatrix(stitch->A_matrix, stitch->A_matrix_initial_value)); } else if (stitch->EXPO_COMP == 2) { ERROR_CHECK_OBJECT_(stitch->A_matrix = vxCreateMatrix(stitch->context, VX_TYPE_INT32, stitch->num_cameras, stitch->num_cameras*3)); ERROR_CHECK_ALLOC_(stitch->A_matrix_initial_value = new vx_int32[stitch->num_cameras * stitch->num_cameras*3]()); ERROR_CHECK_STATUS_(vxWriteMatrix(stitch->A_matrix, stitch->A_matrix_initial_value)); } // create gain array ERROR_CHECK_OBJECT_(stitch->gain_array = vxCreateArray(stitch->context, VX_TYPE_FLOAT32, stitch->num_cameras * stitch->EXPO_COMP_GAINW * stitch->EXPO_COMP_GAINH*stitch->EXPO_COMP_GAINC)); ERROR_CHECK_STATUS_(vxAddArrayItems(stitch->gain_array, stitch->num_cameras*stitch->EXPO_COMP_GAINW * stitch->EXPO_COMP_GAINC *stitch->EXPO_COMP_GAINH, &one, 0)); } // create data objects needed by seamfind kernel if (stitch->SEAM_FIND) { vx_enum StitchSeamFindValidEntryType, StitchSeamFindWeightEntryType; vx_enum StitchSeamFindAccumEntryType, StitchSeamFindPreferenceType; vx_enum StitchSeamFindInformationType, StitchSeamFindPathEntryType; ERROR_CHECK_TYPE_(StitchSeamFindValidEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchSeamFindValidEntry))); ERROR_CHECK_TYPE_(StitchSeamFindWeightEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchSeamFindWeightEntry))); ERROR_CHECK_TYPE_(StitchSeamFindAccumEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchSeamFindAccumEntry))); ERROR_CHECK_TYPE_(StitchSeamFindPreferenceType = vxRegisterUserStruct(stitch->context, sizeof(StitchSeamFindPreference))); ERROR_CHECK_TYPE_(StitchSeamFindInformationType = vxRegisterUserStruct(stitch->context, sizeof(StitchSeamFindInformation))); ERROR_CHECK_TYPE_(StitchSeamFindPathEntryType = vxRegisterUserStruct(stitch->context, sizeof(StitchSeamFindPathEntry))); ERROR_CHECK_OBJECT_(stitch->seamfind_valid_array = vxCreateArray(stitch->context, StitchSeamFindValidEntryType, stitch->table_sizes.seamFindValidTableSize)); ERROR_CHECK_OBJECT_(stitch->seamfind_weight_array = vxCreateArray(stitch->context, StitchSeamFindWeightEntryType, stitch->table_sizes.seamFindWeightTableSize)); ERROR_CHECK_OBJECT_(stitch->seamfind_accum_array = vxCreateArray(stitch->context, StitchSeamFindAccumEntryType, stitch->table_sizes.seamFindAccumTableSize)); ERROR_CHECK_OBJECT_(stitch->seamfind_pref_array = vxCreateArray(stitch->context, StitchSeamFindPreferenceType, stitch->table_sizes.seamFindPrefInfoTableSize)); ERROR_CHECK_OBJECT_(stitch->seamfind_info_array = vxCreateArray(stitch->context, StitchSeamFindInformationType, stitch->table_sizes.seamFindPrefInfoTableSize)); ERROR_CHECK_OBJECT_(stitch->seamfind_path_array = vxCreateArray(stitch->context, StitchSeamFindPathEntryType, stitch->table_sizes.seamFindPathTableSize)); ERROR_CHECK_OBJECT_(stitch->warp_luma_image = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_U8)); if (!stitch->SEAM_COST_SELECT) { ERROR_CHECK_OBJECT_(stitch->sobelx_image = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_S16)); ERROR_CHECK_OBJECT_(stitch->sobely_image = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_S16)); ERROR_CHECK_OBJECT_(stitch->sobel_magnitude_s16_image = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_S16)); } ERROR_CHECK_OBJECT_(stitch->sobel_magnitude_image = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_U8)); ERROR_CHECK_OBJECT_(stitch->sobel_phase_image = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_U8)); ERROR_CHECK_OBJECT_(stitch->seamfind_weight_image = vxCreateImage(stitch->context, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_U8)); ERROR_CHECK_OBJECT_(stitch->current_frame = vxCreateScalar(stitch->context, VX_TYPE_UINT32, &stitch->current_frame_value)); if (stitch->SEAM_REFRESH) { vx_enum StitchSeamSceneType; ERROR_CHECK_TYPE_(StitchSeamSceneType = vxRegisterUserStruct(stitch->context, sizeof(StitchSeamFindSceneEntry))); ERROR_CHECK_OBJECT_(stitch->seamfind_scene_array = vxCreateArray(stitch->context, StitchSeamSceneType, stitch->table_sizes.seamFindPrefInfoTableSize)); ERROR_CHECK_OBJECT_(stitch->scene_threshold = vxCreateScalar(stitch->context, VX_TYPE_UINT32, &stitch->scene_threshold_value)); } if (stitch->SEAM_COST_SELECT) { vx_uint32 cost_enable = 1; ERROR_CHECK_OBJECT_(stitch->seam_cost_enable = vxCreateScalar(stitch->context, VX_TYPE_UINT32, &cost_enable)); } } // create data objects needed by multiband blend if (stitch->MULTIBAND_BLEND) { vx_enum StitchBlendValidType; ERROR_CHECK_TYPE_(StitchBlendValidType = vxRegisterUserStruct(stitch->context, sizeof(StitchBlendValidEntry))); ERROR_CHECK_OBJECT_(stitch->blend_offsets = vxCreateArray(stitch->context, StitchBlendValidType, stitch->table_sizes.blendOffsetTableSize)); ERROR_CHECK_ALLOC_(stitch->pStitchMultiband = new StitchMultibandData[stitch->num_bands]()); memset(stitch->pStitchMultiband, 0, sizeof(StitchMultibandData)*stitch->num_bands); stitch->pStitchMultiband[0].WeightPyrImgGaussian = stitch->SEAM_FIND ? stitch->seamfind_weight_image : stitch->weight_image; // for level#0: weight image is mask image after seem find stitch->pStitchMultiband[0].DstPyrImgGaussian = stitch->EXPO_COMP ? stitch->RGBY2 : stitch->RGBY1; // for level#0: dst image is image after exposure_comp ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[0].DstPyrImgLaplacian = CreateAlignedImage(stitch, stitch->output_rgb_buffer_width, (stitch->output_rgb_buffer_height * stitch->num_cameras), 8, VX_DF_IMAGE_RGB4_AMD, VX_MEMORY_TYPE_OPENCL)); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[0].DstPyrImgLaplacianRec = CreateAlignedImage(stitch, stitch->output_rgb_buffer_width, (stitch->output_rgb_buffer_height * stitch->num_cameras), 8, VX_DF_IMAGE_RGBX, VX_MEMORY_TYPE_OPENCL)); for (vx_int32 level = 1, levelAlign = 1; level < stitch->num_bands; level++, levelAlign = ((levelAlign << 1) | 1)) { vx_uint32 width_l = (stitch->output_rgb_buffer_width + levelAlign) >> level; vx_uint32 height_l = ((stitch->output_rgb_buffer_height + levelAlign) >> level) * stitch->num_cameras; ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[level].WeightPyrImgGaussian = CreateAlignedImage(stitch, width_l, height_l, 16, VX_DF_IMAGE_U8, VX_MEMORY_TYPE_OPENCL)); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[level].DstPyrImgGaussian = CreateAlignedImage(stitch, width_l, height_l, 8, VX_DF_IMAGE_RGBX, VX_MEMORY_TYPE_OPENCL)); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[level].DstPyrImgLaplacian = CreateAlignedImage(stitch, width_l, height_l, 8, VX_DF_IMAGE_RGB4_AMD, VX_MEMORY_TYPE_OPENCL)); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[level].DstPyrImgLaplacianRec = CreateAlignedImage(stitch, width_l, height_l, 8, VX_DF_IMAGE_RGB4_AMD, VX_MEMORY_TYPE_OPENCL)); } for (int level = 0; level < stitch->num_bands; level++) { stitch->pStitchMultiband[level].valid_array_offset = (vx_uint32)stitch->multibandBlendOffsetIntoBuffer[level]; } ERROR_CHECK_OBJECT_(stitch->blend_mask_image = vxCreateImage(stitch->context, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_U8)); } if (stitch->SEAM_FIND || stitch->EXPO_COMP == 1 || stitch->EXPO_COMP == 2) { ERROR_CHECK_OBJECT_(stitch->valid_mask_image = vxCreateImage(stitch->context, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras, VX_DF_IMAGE_U8)); } vx_status status = VX_FAILURE; if (!stitch->SETUP_LOAD_FILES_FOUND){ // initialize internal tables status = InitializeInternalTablesForCamera(stitch); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: InitializeInternalTablesForCamera() failed (%d)\n", status); return status; } if (stitch->SETUP_LOAD){ status = quickSetupDumpTables(stitch); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: quickSetupDumpTables() failed (%d)\n", status); return status; } } } else{ status = quickSetupLoadTables(stitch); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: AllocateInternalTablesForCamera: quickSetupLoadTables() failed (%d)\n", status); return status; } } if (!stitch->feature_enable_reinitialize) { // release internal buffers as they are not needed anymore if (stitch->validPixelCamMap) { delete[] stitch->validPixelCamMap; stitch->validPixelCamMap = nullptr; } if (stitch->paddedPixelCamMap) { delete[] stitch->paddedPixelCamMap; stitch->paddedPixelCamMap = nullptr; } if (stitch->camSrcMap) { delete[] stitch->camSrcMap; stitch->camSrcMap = nullptr; } if (stitch->overlapRectBuf) { delete[] stitch->overlapRectBuf; stitch->overlapRectBuf = nullptr; } if (stitch->camIndexTmpBuf) { delete[] stitch->camIndexTmpBuf; stitch->camIndexTmpBuf = nullptr; } if (stitch->camIndexBuf) { delete[] stitch->camIndexBuf; stitch->camIndexBuf = nullptr; } if (stitch->overlapMatrixBuf) { delete[] stitch->overlapMatrixBuf; stitch->overlapMatrixBuf = nullptr; } } return VX_SUCCESS; } /***************************************************************************************************************************************** functions to encode stitched output *****************************************************************************************************************************************/ static vx_status EncodeCreateImageFromROI(ls_context stitch) { vx_uint32 dst_tile_height = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_HEIGHT] / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y]); for (vx_uint32 i = 0; i < stitch->num_encode_sections; i++) { // create src & dst images from ROI's ERROR_CHECK_OBJECT_(stitch->encode_src_rgb_imgs[i] = vxCreateImageFromROI(stitch->Img_output_rgb, &stitch->src_encode_tile_rect[i])); // get the destination Image ID and create Img from ROI vx_uint32 outputTileID = stitch->dst_encode_tile_rect[i].start_y / dst_tile_height; stitch->dst_encode_tile_rect[i].start_y = stitch->dst_encode_tile_rect[i].start_y % dst_tile_height; stitch->dst_encode_tile_rect[i].end_y = stitch->dst_encode_tile_rect[i].end_y % dst_tile_height; ERROR_CHECK_OBJECT_(stitch->encode_dst_imgs[i] = vxCreateImageFromROI(stitch->encodetileOutput[outputTileID], &stitch->dst_encode_tile_rect[i])); // color covert the image ROI's ERROR_CHECK_OBJECT(stitch->encode_color_convert_nodes[i] = vxColorConvertNode(stitch->graphStitch, stitch->encode_src_rgb_imgs[i], stitch->encode_dst_imgs[i])); } return VX_SUCCESS; } static vx_status EncodeProcessImage(ls_context stitch) { // src tile dimesions vx_uint32 src_tile_width = (vx_uint32)(stitch->output_rgb_buffer_width / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X]); vx_uint32 src_tile_height = (vx_uint32)(stitch->output_rgb_buffer_height / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y]); vx_uint32 src_tile_overlap = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_src_tile_overlap]; // dst tile dimesions vx_uint32 dst_tile_width = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_WIDTH] / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X]); vx_uint32 dst_tile_height = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_HEIGHT] / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y]); // calculate encode regions vx_uint32 roi_img = 0; vx_uint32 src_tile_start_y = 0, dst_tile_start_y = 0; for (vx_uint32 j = 0; j < (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y]; j++){ vx_uint32 src_tile_start_x = 0, dst_tile_start_x = 0; for (vx_uint32 i = 0; i < (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X]; i++){ // source tile rectangle vx_int32 tstart_x = src_tile_start_x - src_tile_overlap, tend_x = src_tile_start_x + src_tile_width + src_tile_overlap; vx_int32 tstart_y = src_tile_start_y - src_tile_overlap; if (tstart_y < 0) { tstart_y = 0; } vx_int32 tend_y = src_tile_start_y + src_tile_height + src_tile_overlap; if (tend_y >(vx_int32)stitch->output_rgb_buffer_height) { tend_y = (vx_int32)stitch->output_rgb_buffer_height; } // destination tile rectangle vx_int32 output_tstart_x = dst_tile_start_x, output_tend_x = dst_tile_start_x + dst_tile_width; vx_int32 output_tstart_y = dst_tile_start_y, output_tend_y = dst_tile_start_y + dst_tile_height; // tile region warp around if (tstart_x < 0){ // overlap rectangle stitch->src_encode_tile_rect[roi_img].start_x = stitch->output_rgb_buffer_width - src_tile_overlap; stitch->src_encode_tile_rect[roi_img].end_x = stitch->output_rgb_buffer_width; stitch->src_encode_tile_rect[roi_img].start_y = tstart_y; stitch->src_encode_tile_rect[roi_img].end_y = tend_y; // output overlap rectangle stitch->dst_encode_tile_rect[roi_img].start_x = output_tstart_x; stitch->dst_encode_tile_rect[roi_img].end_x = output_tstart_x + src_tile_overlap; stitch->dst_encode_tile_rect[roi_img].start_y = output_tstart_y; stitch->dst_encode_tile_rect[roi_img].end_y = output_tstart_y + (tend_y - tstart_y); roi_img++; // image rectangle stitch->src_encode_tile_rect[roi_img].start_x = 0; stitch->src_encode_tile_rect[roi_img].end_x = tend_x; stitch->src_encode_tile_rect[roi_img].start_y = tstart_y; stitch->src_encode_tile_rect[roi_img].end_y = tend_y; // output image rectangle stitch->dst_encode_tile_rect[roi_img].start_x = output_tstart_x + src_tile_overlap; stitch->dst_encode_tile_rect[roi_img].end_x = stitch->dst_encode_tile_rect[roi_img].start_x + tend_x; stitch->dst_encode_tile_rect[roi_img].start_y = output_tstart_y; stitch->dst_encode_tile_rect[roi_img].end_y = output_tstart_y + (tend_y - tstart_y); roi_img++; } // tile region if (tstart_x >= 0 && tend_x <= (vx_int32)stitch->output_rgb_buffer_width){ // image rectangle stitch->src_encode_tile_rect[roi_img].start_x = tstart_x; stitch->src_encode_tile_rect[roi_img].end_x = tend_x; stitch->src_encode_tile_rect[roi_img].start_y = tstart_y; stitch->src_encode_tile_rect[roi_img].end_y = tend_y; // output image rectangle stitch->dst_encode_tile_rect[roi_img].start_x = output_tstart_x; stitch->dst_encode_tile_rect[roi_img].end_x = output_tend_x; stitch->dst_encode_tile_rect[roi_img].start_y = output_tstart_y; stitch->dst_encode_tile_rect[roi_img].end_y = output_tstart_y + (tend_y - tstart_y); roi_img++; } // tile region warp around if (tstart_x >= 0 && tend_x > (vx_int32)stitch->output_rgb_buffer_width){ // image rectangle stitch->src_encode_tile_rect[roi_img].start_x = tstart_x; stitch->src_encode_tile_rect[roi_img].end_x = stitch->output_rgb_buffer_width; stitch->src_encode_tile_rect[roi_img].start_y = tstart_y; stitch->src_encode_tile_rect[roi_img].end_y = tend_y; // output image rectangle stitch->dst_encode_tile_rect[roi_img].start_x = output_tstart_x; stitch->dst_encode_tile_rect[roi_img].end_x = output_tstart_x + (stitch->output_rgb_buffer_width - tstart_x); stitch->dst_encode_tile_rect[roi_img].start_y = output_tstart_y; stitch->dst_encode_tile_rect[roi_img].end_y = output_tstart_y + (tend_y - tstart_y); roi_img++; // overlap rectangle stitch->src_encode_tile_rect[roi_img].start_x = 0; stitch->src_encode_tile_rect[roi_img].end_x = src_tile_overlap; stitch->src_encode_tile_rect[roi_img].start_y = tstart_y; stitch->src_encode_tile_rect[roi_img].end_y = tend_y; // output image rectangle stitch->dst_encode_tile_rect[roi_img].start_x = output_tstart_x + (stitch->output_rgb_buffer_width - tstart_x); stitch->dst_encode_tile_rect[roi_img].end_x = stitch->dst_encode_tile_rect[roi_img].start_x + src_tile_overlap; stitch->dst_encode_tile_rect[roi_img].start_y = output_tstart_y; stitch->dst_encode_tile_rect[roi_img].end_y = output_tstart_y + (tend_y - tstart_y); roi_img++; } src_tile_start_x += src_tile_width; dst_tile_start_y += dst_tile_height; } src_tile_start_y += src_tile_height; } stitch->num_encode_sections = roi_img; return VX_SUCCESS; } //////////////////////////////////////////////////////////////////////////// // Stitch API implementation //! \brief Get version. LIVE_STITCH_API_ENTRY const char * VX_API_CALL lsGetVersion() { return LS_VERSION; } //! \brief Set callback for log messages. LIVE_STITCH_API_ENTRY void VX_API_CALL lsGlobalSetLogCallback(stitch_log_callback_f callback) { g_live_stitch_log_message_callback = callback; } //! \brief Set global attributes. Note that current global attributes will become default attributes for when a stitch context is created. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGlobalSetAttributes(vx_uint32 attr_offset, vx_uint32 attr_count, const vx_float32 * attr_ptr) { // make sure global attributes are reset to default if (!g_live_stitch_attr_initialized) ResetLiveStitchGlobalAttributes(); // bounding check if ((attr_offset + attr_count) > LIVE_STITCH_ATTR_MAX_COUNT) return VX_ERROR_INVALID_DIMENSION; // set global live_stitch_attr[] memcpy(&g_live_stitch_attr[attr_offset], attr_ptr, attr_count * sizeof(vx_float32)); return VX_SUCCESS; } //! \brief Get global attributes. Note that current global attributes will become default attributes for when a stitch context is created. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGlobalGetAttributes(vx_uint32 attr_offset, vx_uint32 attr_count, vx_float32 * attr_ptr) { // make sure global attributes are reset to default if (!g_live_stitch_attr_initialized) ResetLiveStitchGlobalAttributes(); // bounding check if ((attr_offset + attr_count) > LIVE_STITCH_ATTR_MAX_COUNT) return VX_ERROR_INVALID_DIMENSION; // get global live_stitch_attr[] memcpy(attr_ptr, &g_live_stitch_attr[attr_offset], attr_count * sizeof(vx_float32)); return VX_SUCCESS; } //! \brief Create stitch context. LIVE_STITCH_API_ENTRY ls_context VX_API_CALL lsCreateContext() { PROFILER_INITIALIZE(); // make sure global attributes are reset to default if (!g_live_stitch_attr_initialized) ResetLiveStitchGlobalAttributes(); ///////////////////////////////////////////////////////// // create stitch handle and initialize live_stitch_attr ls_context stitch = new ls_context_t; if (stitch) { memset(stitch, 0, sizeof(ls_context_t)); memcpy(stitch->live_stitch_attr, g_live_stitch_attr, sizeof(stitch->live_stitch_attr)); stitch->magic = LIVE_STITCH_MAGIC; } return stitch; } //! \brief Set context specific attributes. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetAttributes(ls_context stitch, vx_uint32 attr_offset, vx_uint32 attr_count, const vx_float32 * attr_ptr) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); // bounding check if ((attr_offset + attr_count) > LIVE_STITCH_ATTR_MAX_COUNT) return VX_ERROR_INVALID_DIMENSION; for (vx_uint32 attr = attr_offset; attr < (attr_offset + attr_count); attr++) { if (attr == LIVE_STITCH_ATTR_SEAM_THRESHOLD) { // update scalar of seafind k0 kernel stitch->scene_threshold_value = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_SEAM_THRESHOLD]; if (stitch->scene_threshold) { vx_status status = vxWriteScalarValue(stitch->scene_threshold, &stitch->scene_threshold_value); if (status != VX_SUCCESS) return status; } } else if (attr == LIVE_STITCH_ATTR_NOISE_FILTER_LAMBDA) { // update scalar of seafind k0 kernel stitch->noiseFilterLambda = (vx_float32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_NOISE_FILTER_LAMBDA]; if (stitch->filterLambda) { vx_status status = vxWriteScalarValue(stitch->filterLambda, &stitch->noiseFilterLambda); if (status != VX_SUCCESS) return status; } } else { // not all attributes are supported return VX_ERROR_NOT_SUPPORTED; } } // update live_stitch_attr to reflect recent changes memcpy(&stitch->live_stitch_attr[attr_offset], attr_ptr, attr_count * sizeof(vx_float32)); return VX_SUCCESS; } //! \brief Get context specific attributes. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetAttributes(ls_context stitch, vx_uint32 attr_offset, vx_uint32 attr_count, vx_float32 * attr_ptr) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); // bounding check if ((attr_offset + attr_count) > LIVE_STITCH_ATTR_MAX_COUNT) return VX_ERROR_INVALID_DIMENSION; // get live_stitch_attr memcpy(attr_ptr, &stitch->live_stitch_attr[attr_offset], attr_count * sizeof(vx_float32)); return VX_SUCCESS; } //! \brief Set stitch configuration. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOpenVXContext(ls_context stitch, vx_context openvx_context) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); if (stitch->context) { ls_printf("ERROR: lsSetOpenVXContext: OpenVX context already exists\n"); return VX_ERROR_NOT_SUPPORTED; } stitch->context = openvx_context; stitch->context_is_external = true; if (stitch->opencl_context) { ERROR_CHECK_STATUS_(vxSetContextAttribute(stitch->context, VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT, &stitch->opencl_context, sizeof(cl_context))); } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOpenCLContext(ls_context stitch, cl_context opencl_context) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); stitch->opencl_context = opencl_context; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetRigParams(ls_context stitch, const rig_params * par) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (stitch->initialized && !stitch->feature_enable_reinitialize) { ls_printf("ERROR: lsSetRigParams: lsReinitialize has been disabled\n"); return VX_ERROR_NOT_SUPPORTED; } memcpy(&stitch->rig_par, par, sizeof(stitch->rig_par)); // check and mark whether reinitialize is required if (stitch->initialized) { stitch->reinitialize_required = true; stitch->rig_params_updated = true; } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetCameraConfig(ls_context stitch, vx_uint32 num_camera_rows, vx_uint32 num_camera_columns, vx_df_image buffer_format, vx_uint32 buffer_width, vx_uint32 buffer_height) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); if (num_camera_rows * num_camera_columns > LIVE_STITCH_MAX_CAMERAS) { ls_printf("ERROR: this release supports upto %d cameras only\n", LIVE_STITCH_MAX_CAMERAS); return VX_ERROR_NOT_SUPPORTED; } if (buffer_format != VX_DF_IMAGE_UYVY && buffer_format != VX_DF_IMAGE_YUYV && buffer_format != VX_DF_IMAGE_RGB && buffer_format != VX_DF_IMAGE_NV12 && buffer_format != VX_DF_IMAGE_IYUV) { ls_printf("ERROR: lsSetCameraConfig: only UYVY/YUYV/RGB/NV12/IYUV buffer formats are allowed\n"); return VX_ERROR_INVALID_FORMAT; } // check num rows and columns if (num_camera_rows < 1 || num_camera_columns < 1 || (buffer_width % num_camera_columns) != 0 || (buffer_height % num_camera_rows) != 0) { ls_printf("ERROR: lsSetCameraConfig: dimensions are is not multiple of camera rows & columns\n"); return VX_ERROR_INVALID_DIMENSION; } // check that camera dimensions are multiples of 16x2 and width must be less than 8K if (((buffer_width / num_camera_columns) % 16) != 0 || ((buffer_height / num_camera_rows) % 2) != 0 || std::max(buffer_width, buffer_height / num_camera_rows) >= 8192) { ls_printf("ERROR: lsSetCameraConfig: camera dimensions are required to be multiple of 16x2 and width less than 8K\n"); return VX_ERROR_INVALID_DIMENSION; } // set configuration parameters stitch->num_cameras = num_camera_rows * num_camera_columns; stitch->num_camera_rows = num_camera_rows; stitch->num_camera_columns = num_camera_columns; stitch->camera_buffer_format = buffer_format; stitch->camera_buffer_width = buffer_width; stitch->camera_buffer_height = buffer_height; if (buffer_format != VX_DF_IMAGE_NV12 && buffer_format != VX_DF_IMAGE_IYUV){ stitch->camera_buffer_stride_in_bytes = buffer_width * (buffer_format == VX_DF_IMAGE_RGB ? 3 : 2); } else{ stitch->camera_buffer_stride_in_bytes = buffer_width; } ERROR_CHECK_ALLOC_(stitch->camera_par = new camera_params[stitch->num_cameras]()); stitch->camera_rgb_buffer_width = stitch->camera_buffer_width; stitch->camera_rgb_buffer_height = stitch->camera_buffer_height; // set default orientations for (vx_uint32 i = 0; i < stitch->num_cameras; i++) { stitch->camera_par[i].focal.yaw = -180.0f + 360.0f * (float)i / (float)stitch->num_cameras; } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOutputConfig(ls_context stitch, vx_df_image buffer_format, vx_uint32 buffer_width, vx_uint32 buffer_height) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); if (buffer_format != VX_DF_IMAGE_UYVY && buffer_format != VX_DF_IMAGE_YUYV && buffer_format != VX_DF_IMAGE_RGB && buffer_format != VX_DF_IMAGE_NV12 && buffer_format != VX_DF_IMAGE_IYUV) { ls_printf("ERROR: lsSetOutputConfig: only UYVY/YUYV/RGB/NV12/IYUV buffer formats are allowed\n"); return VX_ERROR_INVALID_FORMAT; } if (buffer_width != (buffer_height * 2)) { ls_printf("ERROR: lsSetOutputConfig: buffer_width should be 2 times buffer_height\n"); return VX_ERROR_INVALID_DIMENSION; } // check that dimensions are multiples of 16x2 if ((buffer_width % 16) != 0 || (buffer_height % 2) != 0) { ls_printf("ERROR: lsSetOutputConfig: output dimensions are required to be multiple of 16x2\n"); return VX_ERROR_INVALID_DIMENSION; } // set configuration parameters stitch->output_buffer_format = buffer_format; stitch->output_buffer_width = buffer_width; stitch->output_buffer_height = buffer_height; if (buffer_format != VX_DF_IMAGE_NV12 && buffer_format != VX_DF_IMAGE_IYUV){ stitch->output_buffer_stride_in_bytes = buffer_width * (buffer_format == VX_DF_IMAGE_RGB ? 3 : 2); } else{ stitch->output_buffer_stride_in_bytes = buffer_width; } stitch->output_rgb_buffer_width = stitch->output_buffer_width; stitch->output_rgb_buffer_height = stitch->output_buffer_height; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOverlayConfig(ls_context stitch, vx_uint32 num_overlay_rows, vx_uint32 num_overlay_columns, vx_df_image buffer_format, vx_uint32 buffer_width, vx_uint32 buffer_height) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); if (num_overlay_rows * num_overlay_columns > LIVE_STITCH_MAX_CAMERAS) { ls_printf("ERROR: this release supports upto %d cameras only\n", LIVE_STITCH_MAX_CAMERAS); return VX_ERROR_NOT_SUPPORTED; } if (buffer_format != VX_DF_IMAGE_RGBX) { ls_printf("ERROR: lsSetOverlayConfig: only RGBX buffer formats are allowed\n"); return VX_ERROR_INVALID_FORMAT; } // check num rows and columns if (num_overlay_rows < 1 || num_overlay_columns < 1 || (buffer_width % num_overlay_columns) != 0 || (buffer_height % num_overlay_rows) != 0) { ls_printf("ERROR: lsSetOverlayConfig: dimensions are is not multiple of overlay rows and columns\n"); return VX_ERROR_INVALID_DIMENSION; } // check that overlay dimensions are multiples of 16x2 and width less than 8K if (((buffer_width / num_overlay_columns) % 16) != 0 || ((buffer_height / num_overlay_rows) % 2) != 0 || std::max(buffer_width, buffer_height / num_overlay_columns) >= 8192) { ls_printf("ERROR: lsSetOverlayConfig: overlay dimensions are required to be multiple of 16x2 and width is less than 8K\n"); return VX_ERROR_INVALID_DIMENSION; } // set configuration parameters stitch->num_overlays = num_overlay_rows * num_overlay_columns; stitch->num_overlay_rows = num_overlay_rows; stitch->num_overlay_columns = num_overlay_columns; stitch->overlay_buffer_width = buffer_width; stitch->overlay_buffer_height = buffer_height; stitch->overlay_buffer_stride_in_bytes = buffer_width * 4; ERROR_CHECK_ALLOC_(stitch->overlay_par = new camera_params[stitch->num_overlays]()); // set default orientations stitch->overlay_par[0].focal.pitch = -90.0f; for (vx_uint32 i = 1; i < stitch->num_overlays; i++) { // set default overlay locations stitch->overlay_par[i].focal.pitch = -90.0f + 180.0f * (float)i / (float)(stitch->num_overlays-1); } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetCameraParams(ls_context stitch, vx_uint32 cam_index, const camera_params * par) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (cam_index >= stitch->num_cameras) { ls_printf("ERROR: lsSetCameraParams: invalid camera index (%d)\n", cam_index); return VX_ERROR_INVALID_VALUE; } if (stitch->initialized && !stitch->feature_enable_reinitialize) { ls_printf("ERROR: lsSetCameraParams: lsReinitialize has been disabled\n"); return VX_ERROR_NOT_SUPPORTED; } memcpy(&stitch->camera_par[cam_index], par, sizeof(camera_params)); // check and mark whether reinitialize is required if (stitch->initialized) { stitch->reinitialize_required = true; stitch->camera_params_updated = true; } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOverlayParams(ls_context stitch, vx_uint32 overlay_index, const camera_params * par) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (overlay_index >= stitch->num_overlays) { ls_printf("ERROR: lsSetOverlayParams: invalid overlay index (%d)\n", overlay_index); return VX_ERROR_INVALID_VALUE; } if (stitch->initialized && !stitch->feature_enable_reinitialize) { ls_printf("ERROR: lsSetOverlayParams: lsReinitialize has been disabled\n"); return VX_ERROR_NOT_SUPPORTED; } memcpy(&stitch->overlay_par[overlay_index], par, sizeof(camera_params)); // check and mark whether reinitialize is required if (stitch->initialized) { stitch->reinitialize_required = true; stitch->overlay_params_updated = true; } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetCameraBufferStride(ls_context stitch, vx_uint32 camera_buffer_stride_in_bytes) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); if ((camera_buffer_stride_in_bytes % 16) != 0) { ls_printf("ERROR: lsSetCameraBufferStride: stride has to be a multiple of 16\n"); return VX_ERROR_INVALID_DIMENSION; } stitch->camera_buffer_stride_in_bytes = camera_buffer_stride_in_bytes; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOutputBufferStride(ls_context stitch, vx_uint32 output_buffer_stride_in_bytes) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); if ((output_buffer_stride_in_bytes % 16) != 0) { ls_printf("ERROR: lsSetOutputBufferStride: stride has to be a multiple of 16\n"); return VX_ERROR_INVALID_DIMENSION; } stitch->output_buffer_stride_in_bytes = output_buffer_stride_in_bytes; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOverlayBufferStride(ls_context stitch, vx_uint32 overlay_buffer_stride_in_bytes) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); if ((overlay_buffer_stride_in_bytes % 16) != 0) { ls_printf("ERROR: lsSetOverlayBufferStride: stride has to be a multiple of 16\n"); return VX_ERROR_INVALID_DIMENSION; } stitch->overlay_buffer_stride_in_bytes = overlay_buffer_stride_in_bytes; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetCameraModule(ls_context stitch, const char * module, const char * kernelName, const char * kernelArguments) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); strncpy(stitch->loomio_camera.module, module, LOOMIO_MAX_LENGTH_MODULE_NAME-1); strncpy(stitch->loomio_camera.kernelName, kernelName, LOOMIO_MAX_LENGTH_KERNEL_NAME-1); strncpy(stitch->loomio_camera.kernelArguments, kernelArguments, LOOMIO_MAX_LENGTH_KERNEL_ARGUMENTS-1); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOutputModule(ls_context stitch, const char * module, const char * kernelName, const char * kernelArguments) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); strncpy(stitch->loomio_output.module, module, LOOMIO_MAX_LENGTH_MODULE_NAME-1); strncpy(stitch->loomio_output.kernelName, kernelName, LOOMIO_MAX_LENGTH_KERNEL_NAME-1); strncpy(stitch->loomio_output.kernelArguments, kernelArguments, LOOMIO_MAX_LENGTH_KERNEL_ARGUMENTS-1); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOverlayModule(ls_context stitch, const char * module, const char * kernelName, const char * kernelArguments) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); strncpy(stitch->loomio_overlay.module, module, LOOMIO_MAX_LENGTH_MODULE_NAME-1); strncpy(stitch->loomio_overlay.kernelName, kernelName, LOOMIO_MAX_LENGTH_KERNEL_NAME-1); strncpy(stitch->loomio_overlay.kernelArguments, kernelArguments, LOOMIO_MAX_LENGTH_KERNEL_ARGUMENTS-1); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetViewingModule(ls_context stitch, const char * module, const char * kernelName, const char * kernelArguments) { ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); strncpy(stitch->loomio_viewing.module, module, LOOMIO_MAX_LENGTH_MODULE_NAME - 1); strncpy(stitch->loomio_viewing.kernelName, kernelName, LOOMIO_MAX_LENGTH_KERNEL_NAME - 1); strncpy(stitch->loomio_viewing.kernelArguments, kernelArguments, LOOMIO_MAX_LENGTH_KERNEL_ARGUMENTS - 1); return VX_SUCCESS; } //! \brief initialize the stitch context. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsInitialize(ls_context stitch) { PROFILER_START(LoomSL, InitializeGraph); ERROR_CHECK_STATUS_(IsValidContextAndNotInitialized(stitch)); ///////////////////////////////////////////////////////// // pick default stitch mode and aux data length stitch->stitching_mode = stitching_mode_normal; if (stitch->live_stitch_attr[LIVE_STITCH_ATTR_STITCH_MODE] == (float)stitching_mode_quick_and_dirty) stitch->stitching_mode = stitching_mode_quick_and_dirty; if (stitch->live_stitch_attr[LIVE_STITCH_ATTR_ENABLE_REINITIALIZE] == 1.0f) stitch->feature_enable_reinitialize = true; stitch->loomioOutputAuxSelection = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_IO_OUTPUT_AUX_SELECTION]; stitch->loomioCameraAuxDataLength = std::min((vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_IO_CAMERA_AUX_DATA_SIZE], (vx_uint32)LOOMIO_MIN_AUX_DATA_CAPACITY); stitch->loomioOverlayAuxDataLength = std::min((vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_IO_OVERLAY_AUX_DATA_SIZE], (vx_uint32)LOOMIO_MIN_AUX_DATA_CAPACITY); stitch->loomioOutputAuxDataLength = std::min((vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_IO_OUTPUT_AUX_DATA_SIZE], (vx_uint32)LOOMIO_MIN_AUX_DATA_CAPACITY); ///////////////////////////////////////////////////////// // create and initialize OpenVX context and graphs if (!stitch->context) { stitch->context = vxCreateContext(); if (stitch->opencl_context) { ERROR_CHECK_STATUS_(vxSetContextAttribute(stitch->context, VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT, &stitch->opencl_context, sizeof(cl_context))); } } ERROR_CHECK_OBJECT_(stitch->context); vxRegisterLogCallback(stitch->context, log_callback, vx_false_e); ERROR_CHECK_STATUS_(vxPublishKernels(stitch->context)); ERROR_CHECK_OBJECT_(stitch->graphStitch = vxCreateGraph(stitch->context)); if (stitch->live_stitch_attr[LIVE_STITCH_ATTR_PROFILER] == 2.0f) { ERROR_CHECK_STATUS_(vxDirective((vx_reference)stitch->graphStitch, VX_DIRECTIVE_AMD_ENABLE_PROFILE_CAPTURE)); } // creating OpenVX image objects for input & output OpenCL buffers if (strlen(stitch->loomio_camera.kernelName) > 0) { // load OpenVX module (if specified) if (strlen(stitch->loomio_camera.module) > 0) { vx_status status = vxLoadKernels(stitch->context, stitch->loomio_camera.module); if (status != VX_SUCCESS) { ls_printf("ERROR: lsInitialize: vxLoadKernels(%s) failed (%d)\n", stitch->loomio_camera.module, status); return VX_ERROR_INVALID_PARAMETERS; } } // instantiate specified node into the graph ERROR_CHECK_OBJECT_(stitch->cameraMediaConfig = vxCreateScalar(stitch->context, VX_TYPE_STRING_AMD, stitch->loomio_camera.kernelArguments)); ERROR_CHECK_OBJECT_(stitch->Img_input = vxCreateVirtualImage(stitch->graphStitch, stitch->camera_buffer_width, stitch->camera_buffer_height, stitch->camera_buffer_format)); ERROR_CHECK_OBJECT_(stitch->loomioCameraAuxData = vxCreateArray(stitch->context, VX_TYPE_UINT8, stitch->loomioCameraAuxDataLength)); vx_reference params[] = { (vx_reference)stitch->cameraMediaConfig, (vx_reference)stitch->Img_input, (vx_reference)stitch->loomioCameraAuxData, }; ERROR_CHECK_OBJECT_(stitch->nodeLoomIoCamera = stitchCreateNode(stitch->graphStitch, stitch->loomio_camera.kernelName, params, dimof(params))); } else { // need image created from OpenCL handle if (stitch->camera_buffer_format == VX_DF_IMAGE_NV12 || stitch->camera_buffer_format == VX_DF_IMAGE_IYUV){ vx_imagepatch_addressing_t addr_in[3] = { 0, 0, 0 }; void *ptr[3] = { nullptr, nullptr, nullptr }; addr_in[0].dim_x = stitch->camera_buffer_width; addr_in[0].dim_y = stitch->camera_buffer_height; addr_in[0].stride_x = 1; addr_in[0].stride_y = stitch->camera_buffer_stride_in_bytes; if (stitch->camera_buffer_format == VX_DF_IMAGE_NV12){ addr_in[1].dim_x = stitch->camera_buffer_width; addr_in[1].dim_y = stitch->camera_buffer_height >> 1; addr_in[1].stride_x = 2; addr_in[1].stride_y = stitch->camera_buffer_stride_in_bytes; } else{ addr_in[1].dim_x = stitch->camera_buffer_width; addr_in[1].dim_y = stitch->camera_buffer_height; addr_in[1].stride_x = 1; addr_in[1].stride_y = stitch->camera_buffer_stride_in_bytes; addr_in[2].dim_x = stitch->camera_buffer_width; addr_in[2].dim_y = stitch->camera_buffer_height; addr_in[2].stride_x = 1; addr_in[2].stride_y = stitch->camera_buffer_stride_in_bytes; } ERROR_CHECK_OBJECT_(stitch->Img_input = vxCreateImageFromHandle(stitch->context, stitch->camera_buffer_format, &addr_in[0], ptr, VX_MEMORY_TYPE_OPENCL)); } else{ vx_imagepatch_addressing_t addr_in = { 0 }; void *ptr[1] = { nullptr }; addr_in.dim_x = stitch->camera_buffer_width; addr_in.dim_y = (stitch->camera_buffer_height); addr_in.stride_x = (stitch->camera_buffer_format == VX_DF_IMAGE_RGB) ? 3 : 2; addr_in.stride_y = stitch->camera_buffer_stride_in_bytes; if (addr_in.stride_y == 0) addr_in.stride_y = addr_in.stride_x * addr_in.dim_x; ERROR_CHECK_OBJECT_(stitch->Img_input = vxCreateImageFromHandle(stitch->context, stitch->camera_buffer_format, &addr_in, ptr, VX_MEMORY_TYPE_OPENCL)); } } // check attribute for fast init code stitch->USE_CPU_INIT = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_USE_CPU_FOR_INIT]; stitch->stitchInitData = nullptr; if (stitch->num_overlays > 0) { // create overlay image if (strlen(stitch->loomio_overlay.kernelName) > 0) { // load OpenVX module (if specified) if (strlen(stitch->loomio_overlay.module) > 0) { vx_status status = vxLoadKernels(stitch->context, stitch->loomio_overlay.module); if (status != VX_SUCCESS) { ls_printf("ERROR: lsInitialize: vxLoadKernels(%s) failed (%d)\n", stitch->loomio_overlay.module, status); return VX_ERROR_INVALID_PARAMETERS; } } // instantiate specified node into the graph ERROR_CHECK_OBJECT_(stitch->overlayMediaConfig = vxCreateScalar(stitch->context, VX_TYPE_STRING_AMD, stitch->loomio_overlay.kernelArguments)); ERROR_CHECK_OBJECT_(stitch->Img_overlay = vxCreateVirtualImage(stitch->graphStitch, stitch->overlay_buffer_width, stitch->overlay_buffer_height, VX_DF_IMAGE_RGBX)); ERROR_CHECK_OBJECT_(stitch->loomioOverlayAuxData = vxCreateArray(stitch->context, VX_TYPE_UINT8, stitch->loomioOverlayAuxDataLength)); vx_reference params[] = { (vx_reference)stitch->overlayMediaConfig, (vx_reference)stitch->Img_overlay, (vx_reference)stitch->loomioOverlayAuxData, }; ERROR_CHECK_OBJECT_(stitch->nodeLoomIoOverlay = stitchCreateNode(stitch->graphStitch, stitch->loomio_overlay.kernelName, params, dimof(params))); } else { // need image created from OpenCL handle vx_imagepatch_addressing_t addr_overlay = { 0 }; void *ptr_overlay[1] = { nullptr }; addr_overlay.dim_x = stitch->overlay_buffer_width; addr_overlay.dim_y = (stitch->overlay_buffer_height); addr_overlay.stride_x = 4; addr_overlay.stride_y = stitch->overlay_buffer_stride_in_bytes; if (addr_overlay.stride_y == 0) addr_overlay.stride_y = addr_overlay.stride_x * addr_overlay.dim_x; ERROR_CHECK_OBJECT_(stitch->Img_overlay = vxCreateImageFromHandle(stitch->context, VX_DF_IMAGE_RGBX, &addr_overlay, ptr_overlay, VX_MEMORY_TYPE_OPENCL)); } // create remap table object and image for overlay warp ERROR_CHECK_OBJECT_(stitch->overlay_remap = vxCreateRemap(stitch->context, stitch->overlay_buffer_width, stitch->overlay_buffer_height, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height)); ERROR_CHECK_OBJECT_(stitch->Img_overlay_rgb = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, VX_DF_IMAGE_RGB)); ERROR_CHECK_OBJECT_(stitch->Img_overlay_rgba = vxCreateVirtualImage(stitch->graphStitch, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, VX_DF_IMAGE_RGBX)); // initialize remap using lens model ERROR_CHECK_STATUS_(AllocateLensModelBuffersForOverlay(stitch)); ERROR_CHECK_STATUS_(InitializeInternalTablesForRemap(stitch, stitch->overlay_remap, stitch->num_overlays, stitch->num_overlay_columns, stitch->overlay_buffer_width / stitch->num_overlay_columns, stitch->overlay_buffer_height / stitch->num_overlay_rows, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->rig_par, stitch->overlay_par, stitch->overlaySrcMap, stitch->validPixelOverlayMap, stitch->overlayIndexTmpBuf, stitch->overlayIndexBuf)); if (!stitch->feature_enable_reinitialize) { if (stitch->overlaySrcMap) { delete[] stitch->overlaySrcMap; stitch->overlaySrcMap = nullptr; } if (stitch->validPixelOverlayMap) { delete[] stitch->validPixelOverlayMap; stitch->validPixelOverlayMap = nullptr; } if (stitch->overlayIndexTmpBuf) { delete[] stitch->overlayIndexTmpBuf; stitch->overlayIndexTmpBuf = nullptr; } if (stitch->overlayIndexBuf) { delete[] stitch->overlayIndexBuf; stitch->overlayIndexBuf = nullptr; } } } if (strlen(stitch->loomio_output.kernelName) > 0) { // load OpenVX module (if specified) if (strlen(stitch->loomio_output.module) > 0) { vx_status status = vxLoadKernels(stitch->context, stitch->loomio_output.module); if (status != VX_SUCCESS) { ls_printf("ERROR: lsInitialize: vxLoadKernels(%s) failed (%d)\n", stitch->loomio_output.module, status); return VX_ERROR_INVALID_PARAMETERS; } } // instantiate specified node into the graph stitch->output_encode_tiles = 1; ERROR_CHECK_OBJECT_(stitch->outputMediaConfig = vxCreateScalar(stitch->context, VX_TYPE_STRING_AMD, stitch->loomio_output.kernelArguments)); if ((stitch->output_buffer_format == VX_DF_IMAGE_NV12 || stitch->output_buffer_format == VX_DF_IMAGE_IYUV) && (stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X] != 1.0f || stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y] != 1.0f)){ // set buffer to encode tile width and height stitch->output_encode_tiles = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X] * stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y]); stitch->output_encode_buffer_width = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_WIDTH] / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X]); stitch->output_encode_buffer_height = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_HEIGHT] / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y] * stitch->output_encode_tiles); // create virtual image stitch->Img_output = vxCreateVirtualImage(stitch->graphStitch, stitch->output_encode_buffer_width, stitch->output_encode_buffer_height, stitch->output_buffer_format); } else{ stitch->Img_output = vxCreateVirtualImage(stitch->graphStitch, stitch->output_buffer_width, stitch->output_buffer_height, stitch->output_buffer_format); } ERROR_CHECK_OBJECT_(stitch->Img_output); vx_uint32 zero = 0; ERROR_CHECK_OBJECT_(stitch->loomioOutputAuxData = vxCreateArray(stitch->context, VX_TYPE_UINT8, stitch->loomioOutputAuxDataLength)); vx_array loomioOutputAuxDataSource = nullptr; if (stitch->loomioCameraAuxData && stitch->loomioOutputAuxSelection != 1) { loomioOutputAuxDataSource = stitch->loomioCameraAuxData; } else if (stitch->loomioOverlayAuxData && stitch->loomioOutputAuxSelection != 2) { loomioOutputAuxDataSource = stitch->loomioOverlayAuxData; } vx_reference params[] = { (vx_reference)stitch->outputMediaConfig, (vx_reference)stitch->Img_output, (vx_reference)loomioOutputAuxDataSource, (vx_reference)stitch->loomioOutputAuxData, }; ERROR_CHECK_OBJECT_(stitch->nodeLoomIoOutput = stitchCreateNode(stitch->graphStitch, stitch->loomio_output.kernelName, params, dimof(params))); } else { // need image created from OpenCL handle stitch->output_encode_tiles = 1; if (stitch->output_buffer_format == VX_DF_IMAGE_NV12 || stitch->output_buffer_format == VX_DF_IMAGE_IYUV) { vx_imagepatch_addressing_t addr_out[3] = { 0, 0, 0 }; void *ptr[3] = { nullptr, nullptr, nullptr }; // encode activated if (stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X] != 1.0f || stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y] != 1.0f){ // create the encoded tiled output stitch->output_encode_tiles = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X] * stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y]); stitch->output_encode_buffer_width = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_WIDTH] / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_X]); stitch->output_encode_buffer_height = (vx_uint32)(stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_HEIGHT] / stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_TILE_NUM_Y]) ; // create output buffer addr_out[0].dim_x = stitch->output_encode_buffer_width; addr_out[0].dim_y = stitch->output_encode_buffer_height; addr_out[0].stride_x = 1; addr_out[0].stride_y = (vx_int32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_OUTPUT_ENCODER_STRIDE_Y]; // assuing every tile has the same stride if (stitch->output_buffer_format == VX_DF_IMAGE_NV12){ addr_out[1].dim_x = stitch->output_encode_buffer_width; addr_out[1].dim_y = stitch->output_encode_buffer_height >> 1; addr_out[1].stride_x = 1; addr_out[1].stride_y = addr_out[0].stride_y; } else{ addr_out[1].dim_x = stitch->output_encode_buffer_width; addr_out[1].dim_y = stitch->output_encode_buffer_height; addr_out[1].stride_x = 1; addr_out[1].stride_y = addr_out[0].stride_y >> 1; addr_out[2].dim_x = stitch->output_encode_buffer_width; addr_out[2].dim_y = stitch->output_encode_buffer_height; addr_out[2].stride_x = 1; addr_out[2].stride_y = addr_out[0].stride_y >> 1; } for (vx_uint32 i = 0; i < stitch->output_encode_tiles; i++){ ERROR_CHECK_OBJECT_(stitch->encodetileOutput[i] = vxCreateImageFromHandle(stitch->context, stitch->output_buffer_format, &addr_out[0], ptr, VX_MEMORY_TYPE_OPENCL)); } } else{ // create output buffer addr_out[0].dim_x = stitch->output_rgb_buffer_width; addr_out[0].dim_y = stitch->output_rgb_buffer_height; addr_out[0].stride_x = 1; addr_out[0].stride_y = stitch->output_buffer_stride_in_bytes; if (stitch->output_buffer_format == VX_DF_IMAGE_NV12){ addr_out[1].dim_x = stitch->output_rgb_buffer_width; addr_out[1].dim_y = stitch->output_rgb_buffer_height >> 1; addr_out[1].stride_x = 1; addr_out[1].stride_y = stitch->output_buffer_stride_in_bytes; } else{ addr_out[1].dim_x = stitch->output_rgb_buffer_width; addr_out[1].dim_y = stitch->output_rgb_buffer_height; addr_out[1].stride_x = 1; addr_out[1].stride_y = stitch->output_buffer_stride_in_bytes; addr_out[2].dim_x = stitch->output_rgb_buffer_width; addr_out[2].dim_y = stitch->output_rgb_buffer_height; addr_out[2].stride_x = 1; addr_out[2].stride_y = stitch->output_buffer_stride_in_bytes; } ERROR_CHECK_OBJECT_(stitch->Img_output = vxCreateImageFromHandle(stitch->context, stitch->output_buffer_format, &addr_out[0], ptr, VX_MEMORY_TYPE_OPENCL)); } } else{ // create RGB/YUV buffer vx_imagepatch_addressing_t addr_out = { 0 }; void *ptr[1] = { nullptr }; addr_out.dim_x = stitch->output_buffer_width; addr_out.dim_y = stitch->output_buffer_height; addr_out.stride_x = (stitch->output_buffer_format == VX_DF_IMAGE_RGB) ? 3 : 2; addr_out.stride_y = stitch->output_buffer_stride_in_bytes; if (addr_out.stride_y == 0) addr_out.stride_y = addr_out.stride_x * addr_out.dim_x; ERROR_CHECK_OBJECT_(stitch->Img_output = vxCreateImageFromHandle(stitch->context, stitch->output_buffer_format, &addr_out, ptr, VX_MEMORY_TYPE_OPENCL)); } } if (stitch->output_encode_tiles > 4){ ls_printf("ERROR: lsInitialize: Max Encode Tiles supported is 4\n"); return VX_ERROR_INVALID_PARAMETERS;} // create temporary images when extra color conversion is needed if (stitch->camera_buffer_format != VX_DF_IMAGE_RGB) { ERROR_CHECK_OBJECT_(stitch->Img_input_rgb = vxCreateVirtualImage(stitch->graphStitch, stitch->camera_rgb_buffer_width, stitch->camera_rgb_buffer_height, VX_DF_IMAGE_RGB)); } if (stitch->output_buffer_format != VX_DF_IMAGE_RGB) { vx_uint32 output_img_width = stitch->output_buffer_width; vx_uint32 output_img_height = stitch->output_buffer_height; ERROR_CHECK_OBJECT_(stitch->Img_output_rgb = vxCreateImage(stitch->context, output_img_width, output_img_height, VX_DF_IMAGE_RGB)); } // process chroma key stitch->CHROMA_KEY = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY]; if (stitch->CHROMA_KEY){ // create chroma key RGB buffer vx_imagepatch_addressing_t addr_out = { 0 }; void *ptr[1] = { nullptr }; addr_out.dim_x = stitch->output_buffer_width; addr_out.dim_y = stitch->output_buffer_height; addr_out.stride_x = 3; addr_out.stride_y = stitch->output_buffer_width * 3; if (addr_out.stride_y == 0) addr_out.stride_y = addr_out.stride_x * addr_out.dim_x; ERROR_CHECK_OBJECT_(stitch->chroma_key_input_img = vxCreateImageFromHandle(stitch->context, VX_DF_IMAGE_RGB, &addr_out, ptr, VX_MEMORY_TYPE_OPENCL)); // create chroma key mask U8 buffer vx_uint32 output_img_width = stitch->output_buffer_width; vx_uint32 output_img_height = stitch->output_buffer_height; ERROR_CHECK_OBJECT_(stitch->chroma_key_mask_img = vxCreateVirtualImage(stitch->graphStitch, output_img_width, output_img_height, VX_DF_IMAGE_U8)); ERROR_CHECK_OBJECT_(stitch->chroma_key_input_RGB_img = vxCreateVirtualImage(stitch->graphStitch, output_img_width, output_img_height, VX_DF_IMAGE_RGB)); stitch->CHROMA_KEY_EED = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY_EED]; if (stitch->CHROMA_KEY_EED){ ERROR_CHECK_OBJECT_(stitch->chroma_key_dilate_mask_img = vxCreateVirtualImage(stitch->graphStitch, output_img_width, output_img_height, VX_DF_IMAGE_U8)); ERROR_CHECK_OBJECT_(stitch->chroma_key_erode_mask_img = vxCreateVirtualImage(stitch->graphStitch, output_img_width, output_img_height, VX_DF_IMAGE_U8)); } } //////////////////////////////////////////////////////////////////////// // build the input and output processing parts of stitch graph stitch->rgb_input = stitch->Img_input; if (stitch->camera_buffer_format != VX_DF_IMAGE_RGB) { // needs input color conversion if (stitch->camera_buffer_format == VX_DF_IMAGE_NV12 || stitch->camera_buffer_format == VX_DF_IMAGE_IYUV){ stitch->InputColorConvertNode = vxColorConvertNode(stitch->graphStitch, stitch->rgb_input, stitch->Img_input_rgb); } else{ stitch->InputColorConvertNode = stitchColorConvertNode(stitch->graphStitch, stitch->rgb_input, stitch->Img_input_rgb); } ERROR_CHECK_OBJECT_(stitch->InputColorConvertNode); stitch->rgb_input = stitch->Img_input_rgb; } // temporal filter for camera noise correction stitch->NOISE_FILTER = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_NOISE_FILTER]; if (stitch->NOISE_FILTER){ stitch->noiseFilterLambda = (vx_float32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_NOISE_FILTER_LAMBDA]; ERROR_CHECK_OBJECT_(stitch->filterLambda = vxCreateScalar(stitch->context, VX_TYPE_FLOAT32, &stitch->noiseFilterLambda)); ERROR_CHECK_OBJECT_(stitch->noiseFilterInput_image = vxCreateImage(stitch->context, stitch->camera_buffer_width, stitch->camera_buffer_height, VX_DF_IMAGE_RGB)); ERROR_CHECK_OBJECT_(stitch->noiseFilterImageDelay = vxCreateDelay(stitch->context, (vx_reference)stitch->noiseFilterInput_image, 2)); stitch->noiseFilterNode = stitchNoiseFilterNode(stitch->graphStitch, stitch->filterLambda, stitch->rgb_input, (vx_image)vxGetReferenceFromDelay(stitch->noiseFilterImageDelay, -1), (vx_image)vxGetReferenceFromDelay(stitch->noiseFilterImageDelay, 0)); ERROR_CHECK_OBJECT_(stitch->noiseFilterNode); stitch->rgb_input = (vx_image)vxGetReferenceFromDelay(stitch->noiseFilterImageDelay, 0); } stitch->rgb_output = stitch->Img_output; if (stitch->output_buffer_format != VX_DF_IMAGE_RGB) { // needs output color conversion if (stitch->output_buffer_format == VX_DF_IMAGE_NV12 || stitch->output_buffer_format == VX_DF_IMAGE_IYUV){ if (stitch->output_encode_tiles == 1){ stitch->OutputColorConvertNode = vxColorConvertNode(stitch->graphStitch, stitch->Img_output_rgb, stitch->rgb_output); ERROR_CHECK_OBJECT_(stitch->OutputColorConvertNode); } else{ // output needs to be encoded ERROR_CHECK_STATUS_(EncodeProcessImage(stitch)); ERROR_CHECK_STATUS_(EncodeCreateImageFromROI(stitch)); } } else{ stitch->OutputColorConvertNode = stitchColorConvertNode(stitch->graphStitch, stitch->Img_output_rgb, stitch->rgb_output); ERROR_CHECK_OBJECT_(stitch->OutputColorConvertNode); } stitch->rgb_output = stitch->Img_output_rgb; } if (stitch->CHROMA_KEY){ vx_uint32 ChromaKey_value = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY_VALUE]; vx_uint32 ChromaKey_Tol = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_CHROMA_KEY_TOL]; stitch->chromaKey_mask_generation_node = stitchChromaKeyMaskGeneratorNode(stitch->graphStitch, ChromaKey_value, ChromaKey_Tol, stitch->chroma_key_input_RGB_img, stitch->chroma_key_mask_img); ERROR_CHECK_OBJECT_(stitch->chromaKey_mask_generation_node); if (stitch->CHROMA_KEY_EED){ stitch->chromaKey_erode_node = vxErode3x3Node(stitch->graphStitch, stitch->chroma_key_mask_img, stitch->chroma_key_erode_mask_img); ERROR_CHECK_OBJECT_(stitch->chromaKey_erode_node); stitch->chromaKey_dilate_node = vxDilate3x3Node(stitch->graphStitch, stitch->chroma_key_erode_mask_img, stitch->chroma_key_dilate_mask_img); ERROR_CHECK_OBJECT_(stitch->chromaKey_dilate_node); stitch->chromaKey_merge_node = stitchChromaKeyMergeNode(stitch->graphStitch, stitch->chroma_key_input_RGB_img, stitch->chroma_key_input_img, stitch->chroma_key_dilate_mask_img, stitch->rgb_output); ERROR_CHECK_OBJECT_(stitch->chromaKey_merge_node); } else{ stitch->chromaKey_merge_node = stitchChromaKeyMergeNode(stitch->graphStitch, stitch->chroma_key_input_RGB_img, stitch->chroma_key_input_img, stitch->chroma_key_mask_img, stitch->rgb_output); ERROR_CHECK_OBJECT_(stitch->chromaKey_merge_node); } stitch->rgb_output = stitch->chroma_key_input_RGB_img; } if (stitch->Img_overlay) { // need add overlay ERROR_CHECK_OBJECT_(stitch->nodeOverlayRemap = vxRemapNode(stitch->graphStitch, stitch->Img_overlay, stitch->overlay_remap, VX_INTERPOLATION_TYPE_BILINEAR, stitch->Img_overlay_rgba)); ERROR_CHECK_OBJECT_(stitch->nodeOverlayBlend = stitchAlphaBlendNode(stitch->graphStitch, stitch->Img_overlay_rgb, stitch->Img_overlay_rgba, stitch->rgb_output)); stitch->rgb_output = stitch->Img_overlay_rgb; } if (strlen(stitch->loomio_viewing.kernelName) > 0) { // load OpenVX module (if specified) if (strlen(stitch->loomio_viewing.module) > 0) { vx_status status = vxLoadKernels(stitch->context, stitch->loomio_viewing.module); if (status != VX_SUCCESS) { ls_printf("ERROR: lsInitialize: vxLoadKernels(%s) failed (%d)\n", stitch->loomio_viewing.module, status); return VX_ERROR_INVALID_PARAMETERS; } } // instantiate specified node into the graph vx_uint32 zero = 0; ERROR_CHECK_OBJECT_(stitch->viewingMediaConfig = vxCreateScalar(stitch->context, VX_TYPE_STRING_AMD, stitch->loomio_viewing.kernelArguments)); ERROR_CHECK_OBJECT_(stitch->loomioViewingAuxData = vxCreateArray(stitch->context, VX_TYPE_UINT8, stitch->loomioOutputAuxDataLength)); vx_reference params[] = { (vx_reference)stitch->viewingMediaConfig, (vx_reference)stitch->rgb_output, (vx_reference)stitch->loomioCameraAuxData, (vx_reference)stitch->loomioViewingAuxData, }; ERROR_CHECK_OBJECT_(stitch->nodeLoomIoViewing = stitchCreateNode(stitch->graphStitch, stitch->loomio_viewing.kernelName, params, dimof(params))); } /*********************************************************************************************************************************** Quick Stitch Mode -> Simple stitch ************************************************************************************************************************************/ if (stitch->stitching_mode == stitching_mode_quick_and_dirty) { // create remap table object ERROR_CHECK_OBJECT_(stitch->camera_remap = vxCreateRemap(stitch->context, stitch->camera_rgb_buffer_width, stitch->camera_rgb_buffer_height, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height)); // initialize remap using lens model ERROR_CHECK_STATUS_(AllocateLensModelBuffersForCamera(stitch)); ERROR_CHECK_STATUS_(InitializeInternalTablesForRemap(stitch, stitch->camera_remap, stitch->num_cameras, stitch->num_camera_columns, stitch->camera_buffer_width / stitch->num_camera_columns, stitch->camera_buffer_height / stitch->num_camera_rows, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->rig_par, stitch->camera_par, stitch->camSrcMap, stitch->validPixelCamMap, stitch->camIndexTmpBuf, stitch->camIndexBuf)); if (!stitch->feature_enable_reinitialize) { if (stitch->camSrcMap) { delete[] stitch->camSrcMap; stitch->camSrcMap = nullptr; } if (stitch->validPixelCamMap) { delete[] stitch->validPixelCamMap; stitch->validPixelCamMap = nullptr; } if (stitch->camIndexTmpBuf) { delete[] stitch->camIndexTmpBuf; stitch->camIndexTmpBuf = nullptr; } if (stitch->camIndexBuf) { delete[] stitch->camIndexBuf; stitch->camIndexBuf = nullptr; } } //////////////////////////////////////////////////////////////////////// // create and verify graphStitch using simple remap kernel //////////////////////////////////////////////////////////////////////// ERROR_CHECK_OBJECT_(stitch->SimpleStitchRemapNode = vxRemapNode(stitch->graphStitch, stitch->rgb_input, stitch->camera_remap, VX_INTERPOLATION_TYPE_BILINEAR, stitch->rgb_output)); ERROR_CHECK_STATUS_(vxVerifyGraph(stitch->graphStitch)); ERROR_CHECK_STATUS_(SyncInternalTables(stitch)); } /*********************************************************************************************************************************** Normal Stitch Mode -> Full Stitch ************************************************************************************************************************************/ else if (stitch->stitching_mode == stitching_mode_normal) { //////////////////////////////////////////////////////////////////////// // get configuration from environment variables //////////////////////////////////////////////////////////////////////// if (stitch->num_cameras > 1) { stitch->EXPO_COMP = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP]; stitch->SEAM_FIND = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_SEAMFIND]; stitch->SEAM_REFRESH = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_SEAM_REFRESH]; stitch->SEAM_COST_SELECT = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_SEAM_COST_SELECT]; stitch->SEAM_FLAGS = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_SEAM_FLAGS]; stitch->scene_threshold_value = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_SEAM_THRESHOLD]; stitch->SEAM_FIND_TARGET = 0; stitch->MULTIBAND_BLEND = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND]; stitch->num_bands = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND_NUMBANDS]; if (stitch->num_bands < 2) { // general protection stitch->live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND] = 0.0f; stitch->live_stitch_attr[LIVE_STITCH_ATTR_MULTIBAND_NUMBANDS] = 0.0f; stitch->MULTIBAND_BLEND = 0; stitch->num_bands = 0; } if (stitch->MULTIBAND_BLEND){ // general protection for odd sized equirectangle vx_uint32 MAX_BAND = 10; // Max bands for multiband blend vx_uint32 MAX_BAND_ALLOWED = 0, half_width = stitch->output_rgb_buffer_width; for (vx_uint32 i = 0; i < MAX_BAND; i++){ if (half_width % 2 == 0){ half_width = half_width / 2; MAX_BAND_ALLOWED++; } else{ break; } } if ((vx_uint32)stitch->num_bands > MAX_BAND_ALLOWED){ stitch->num_bands = (vx_int32)MAX_BAND_ALLOWED; ls_printf("WARNING: Max allowed MULTIBAND BLEND bands for the set output equirectangle is %d\n", MAX_BAND_ALLOWED); } } stitch->EXPO_COMP_GAINW = 1; stitch->EXPO_COMP_GAINH = 1; stitch->EXPO_COMP_GAINC = (stitch->EXPO_COMP == 2) ? 3 : (stitch->EXPO_COMP == 4)? 12: 1; if (stitch->EXPO_COMP >= 3 ) { stitch->EXPO_COMP_GAINW = (vx_uint32)std::max(1.0f, stitch->live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_GAIN_IMG_W]); stitch->EXPO_COMP_GAINH = (vx_uint32)std::max(1.0f, stitch->live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_GAIN_IMG_H]); stitch->EXPO_COMP_GAINC = (vx_uint32)std::max(1.0f, stitch->live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_GAIN_IMG_C]); if (stitch->EXPO_COMP == 4) stitch->EXPO_COMP_GAINC = 12; // override the default value since kernel expects 12. } if (stitch->EXPO_COMP < 3) { stitch->alpha = (vx_float32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_ALPHA_VALUE]; stitch->beta = (vx_float32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_EXPCOMP_BETA_VALUE]; } // option to disable seam find with environment variable char value[256] = { 0 }; if (StitchGetEnvironmentVariable("LOOM_SEAM_FIND_DISABLE", value, sizeof(value))) { if (!strcmp(value, "1") && stitch->SEAM_FIND) { stitch->SEAM_FIND = 0; ls_printf("WARNING: SeamFind has been disabled using environment variable: LOOM_SEAM_FIND_DISABLE=1\n"); } } // quick setup files load stitch->SETUP_LOAD = (vx_uint32)stitch->live_stitch_attr[LIVE_STITCH_ATTR_SAVE_AND_LOAD_INIT]; stitch->SETUP_LOAD_FILES_FOUND = vx_false_e; if (stitch->MULTIBAND_BLEND || stitch->EXPO_COMP){ stitch->SETUP_LOAD = 0; } if (stitch->SETUP_LOAD){ vx_status status = quickSetupFilesLookup(stitch); if (status != VX_SUCCESS) { vxAddLogEntry((vx_reference)stitch->context, status, "ERROR: lsInitialize: quickSetupFilesLookup() failed (%d)\n", status); return status; } } } // allocate internal tables vx_status status = AllocateInternalTablesForCamera(stitch); if (status != VX_SUCCESS) return status; //////////////////////////////////////////////////////////////////////// // create and verify graphStitch using low-level kernels //////////////////////////////////////////////////////////////////////// // warping ERROR_CHECK_OBJECT_(stitch->WarpNode = stitchWarpNode(stitch->graphStitch, 1, stitch->num_cameras, stitch->ValidPixelEntry, stitch->WarpRemapEntry, stitch->rgb_input, stitch->RGBY1, stitch->warp_luma_image, stitch->num_camera_columns)); // exposure comp vx_image merge_input = stitch->RGBY1; vx_image merge_weight = stitch->weight_image; if (stitch->EXPO_COMP) { if (stitch->EXPO_COMP == 1) { ERROR_CHECK_OBJECT_(stitch->ExpcompComputeGainNode = stitchExposureCompCalcErrorFnNode(stitch->graphStitch, stitch->num_cameras, stitch->RGBY1, stitch->OverlapPixelEntry, stitch->valid_mask_image, stitch->A_matrix)); ERROR_CHECK_OBJECT_(stitch->ExpcompSolveGainNode = stitchExposureCompSolveForGainNode(stitch->graphStitch, stitch->alpha, stitch->beta, stitch->A_matrix, stitch->overlap_matrix, stitch->gain_array)); } else if (stitch->EXPO_COMP == 2) { ERROR_CHECK_OBJECT_(stitch->ExpcompComputeGainNode = stitchExposureCompCalcErrorFnRGBNode(stitch->graphStitch, stitch->num_cameras, stitch->RGBY1, stitch->OverlapPixelEntry, stitch->valid_mask_image, stitch->A_matrix)); ERROR_CHECK_OBJECT_(stitch->ExpcompSolveGainNode = stitchExposureCompSolveForGainNode(stitch->graphStitch, stitch->alpha, stitch->beta, stitch->A_matrix, stitch->overlap_matrix, stitch->gain_array)); } ERROR_CHECK_OBJECT_(stitch->ExpcompApplyGainNode = stitchExposureCompApplyGainNode(stitch->graphStitch, stitch->RGBY1, stitch->gain_array, stitch->valid_array, stitch->num_cameras, stitch->EXPO_COMP_GAINW, stitch->EXPO_COMP_GAINH, stitch->RGBY2)); // update merge input merge_input = stitch->RGBY2; } if (stitch->SEAM_FIND) { if (stitch->SEAM_REFRESH) { //SeamFind Step 1: Seam Refresh stitch->SeamfindStep1Node = stitchSeamFindSceneDetectNode(stitch->graphStitch, stitch->current_frame, stitch->scene_threshold, stitch->warp_luma_image, stitch->seamfind_info_array, stitch->seamfind_pref_array, stitch->seamfind_scene_array); ERROR_CHECK_OBJECT_(stitch->SeamfindStep1Node); } //SeamFind Step 2 - Cost Generation: 0:OpenVX Sobel 1:Optimized Sobel if (!stitch->SEAM_COST_SELECT) { vx_int32 zero = 0; vx_scalar shift; ERROR_CHECK_OBJECT_(shift = vxCreateScalar(stitch->context, VX_TYPE_INT32, &zero)); ERROR_CHECK_OBJECT_(stitch->SobelNode = vxSobel3x3Node(stitch->graphStitch, stitch->warp_luma_image, stitch->sobelx_image, stitch->sobely_image)); ERROR_CHECK_OBJECT_(stitch->MagnitudeNode = vxMagnitudeNode(stitch->graphStitch, stitch->sobelx_image, stitch->sobely_image, stitch->sobel_magnitude_s16_image)); ERROR_CHECK_OBJECT_(stitch->PhaseNode = vxPhaseNode(stitch->graphStitch, stitch->sobelx_image, stitch->sobely_image, stitch->sobel_phase_image)); ERROR_CHECK_OBJECT_(stitch->ConvertDepthNode = vxConvertDepthNode(stitch->graphStitch, stitch->sobel_magnitude_s16_image, stitch->sobel_magnitude_image, VX_CONVERT_POLICY_SATURATE, shift)); ERROR_CHECK_STATUS_(vxReleaseScalar(&shift)); } else { ERROR_CHECK_OBJECT_(stitch->SeamfindAnalyzeNode = stitchSeamFindAnalyzeNode(stitch->graphStitch, stitch->current_frame, stitch->seamfind_pref_array, stitch->seam_cost_enable)); ERROR_CHECK_OBJECT_(stitch->SeamfindStep2Node = stitchSeamFindCostGenerateNode(stitch->graphStitch, stitch->seam_cost_enable, stitch->warp_luma_image, stitch->sobel_magnitude_image, stitch->sobel_phase_image)); } //SeamFind Step 3 - Cost Accumulate stitch->SeamfindStep3Node = stitchSeamFindCostAccumulateNode(stitch->graphStitch, stitch->current_frame, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->sobel_magnitude_image, stitch->sobel_phase_image, stitch->valid_mask_image, stitch->seamfind_valid_array, stitch->seamfind_pref_array, stitch->seamfind_info_array, stitch->seamfind_accum_array); ERROR_CHECK_OBJECT_(stitch->SeamfindStep3Node); //SeamFind Step 4 - Path Trace stitch->SeamfindStep4Node = stitchSeamFindPathTraceNode(stitch->graphStitch, stitch->current_frame, stitch->weight_image, stitch->seamfind_info_array, stitch->seamfind_accum_array, stitch->seamfind_pref_array, stitch->seamfind_path_array); ERROR_CHECK_OBJECT_(stitch->SeamfindStep4Node); //SeamFind Step 5 - Set Weights stitch->SeamfindStep5Node = stitchSeamFindSetWeightsNode(stitch->graphStitch, stitch->current_frame, stitch->num_cameras, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, stitch->seamfind_weight_array, stitch->seamfind_path_array, stitch->seamfind_pref_array, stitch->seamfind_weight_image, stitch->SEAM_FLAGS); ERROR_CHECK_OBJECT_(stitch->SeamfindStep5Node); // update merge weight image merge_weight = stitch->seamfind_weight_image; } // create data objects and nodes for multiband blending if (stitch->MULTIBAND_BLEND){ // create Laplacian pyramids. for (int i = 1; i < stitch->num_bands; i++) { stitch->pStitchMultiband[i].WeightHSGNode = stitchMultiBandHalfScaleGaussianNode(stitch->graphStitch, stitch->num_cameras, stitch->pStitchMultiband[i].valid_array_offset, stitch->blend_offsets, stitch->pStitchMultiband[i - 1].WeightPyrImgGaussian, stitch->pStitchMultiband[i].WeightPyrImgGaussian); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[i].WeightHSGNode); stitch->pStitchMultiband[i].SourceHSGNode = stitchMultiBandHalfScaleGaussianNode(stitch->graphStitch, stitch->num_cameras, stitch->pStitchMultiband[i].valid_array_offset, stitch->blend_offsets, stitch->pStitchMultiband[i - 1].DstPyrImgGaussian, stitch->pStitchMultiband[i].DstPyrImgGaussian); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[i].SourceHSGNode); stitch->pStitchMultiband[i - 1].UpscaleSubtractNode = stitchMultiBandUpscaleGaussianSubtractNode(stitch->graphStitch, stitch->num_cameras, stitch->pStitchMultiband[i - 1].valid_array_offset, stitch->pStitchMultiband[i - 1].DstPyrImgGaussian, stitch->pStitchMultiband[i].DstPyrImgGaussian, stitch->blend_offsets, stitch->pStitchMultiband[i-1].WeightPyrImgGaussian, stitch->pStitchMultiband[i - 1].DstPyrImgLaplacian); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[i - 1].UpscaleSubtractNode); } // reconstruct Laplacian after blending with corresponding weights: for band = num_bands-1, laplacian and gaussian is the same int i = stitch->num_bands - 1; stitch->pStitchMultiband[i].BlendNode = stitchMultiBandMergeNode(stitch->graphStitch, stitch->num_cameras, stitch->pStitchMultiband[i].valid_array_offset, stitch->pStitchMultiband[i].DstPyrImgGaussian, stitch->pStitchMultiband[i].WeightPyrImgGaussian, stitch->blend_offsets, stitch->pStitchMultiband[i].DstPyrImgLaplacianRec); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[i].BlendNode); --i; for (; i > 0; --i){ stitch->pStitchMultiband[i].UpscaleAddNode = stitchMultiBandUpscaleGaussianAddNode(stitch->graphStitch, stitch->num_cameras, stitch->pStitchMultiband[i].valid_array_offset, stitch->pStitchMultiband[i].DstPyrImgLaplacian, stitch->pStitchMultiband[i + 1].DstPyrImgLaplacianRec, stitch->blend_offsets, stitch->pStitchMultiband[i].DstPyrImgLaplacianRec); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[i].UpscaleAddNode); } // for the lowest level stitch->pStitchMultiband[0].UpscaleAddNode = stitchMultiBandLaplacianReconstructNode(stitch->graphStitch, stitch->num_cameras, stitch->pStitchMultiband[0].valid_array_offset, stitch->pStitchMultiband[0].DstPyrImgLaplacian, stitch->pStitchMultiband[1].DstPyrImgLaplacianRec, stitch->blend_offsets, stitch->pStitchMultiband[0].DstPyrImgLaplacianRec); ERROR_CHECK_OBJECT_(stitch->pStitchMultiband[0].UpscaleAddNode); // update merge input and weight images merge_input = stitch->pStitchMultiband[0].DstPyrImgLaplacianRec; merge_weight = stitch->blend_mask_image; } // merge node ERROR_CHECK_OBJECT_(stitch->MergeNode = stitchMergeNode(stitch->graphStitch, stitch->cam_id_image, stitch->group1_image, stitch->group2_image, merge_input, merge_weight, stitch->rgb_output)); // verify the graph ERROR_CHECK_STATUS_(vxVerifyGraph(stitch->graphStitch)); ERROR_CHECK_STATUS_(SyncInternalTables(stitch)); } /*********************************************************************************************************************************** Other Modes ************************************************************************************************************************************/ else { vxAddLogEntry((vx_reference)stitch->context, VX_ERROR_NO_RESOURCES, "Other Stitching Modes are under development\nMode-1 = Quick Stitch Mode Available\nMode-2 = Normal Stitch Mode Available\n"); return VX_ERROR_NO_RESOURCES; } // mark that initialization is successful stitch->initialized = true; // debug: dump auxiliary data if (stitch->loomioCameraAuxData || stitch->loomioOverlayAuxData || stitch->loomioOutputAuxData || stitch->loomioViewingAuxData) { char fileName[1024] = { 0 }; if (StitchGetEnvironmentVariable("LOOMIO_AUX_DUMP", fileName, sizeof(fileName))) { stitch->loomioAuxDumpFile = fopen(fileName, "wb"); if (!stitch->loomioAuxDumpFile) { ls_printf("ERROR: unable to create: %s\n", fileName); if (stitch->loomioAuxDumpFile != NULL) fclose(stitch->loomioAuxDumpFile); return VX_FAILURE; } ls_printf("OK: dumping auxiliary data into %s\n", fileName); } } PROFILER_STOP(LoomSL, InitializeGraph); return VX_SUCCESS; } //! \brief initialize the stitch context. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsReinitialize(ls_context stitch) { PROFILER_START(LoomSL, ReinitializeGraph); if (!stitch->reinitialize_required) return VX_SUCCESS; ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (!stitch->feature_enable_reinitialize) { ls_printf("ERROR: lsReinitialize has been disabled\n"); return VX_ERROR_NOT_SUPPORTED; } if (stitch->scheduled) { ls_printf("ERROR: lsReinitialize: can't reinitialize when already scheduled\n"); return VX_ERROR_GRAPH_SCHEDULED; } if (stitch->rig_params_updated || stitch->camera_params_updated) { // Quick Initailize enabled if (stitch->stitchInitData && stitch->stitchInitData->graphInitialize){ ERROR_CHECK_STATUS_(setupQuickInitializeParams(stitch)); } // re-initialize tables for camera if (stitch->camera_remap){ ERROR_CHECK_STATUS_(InitializeInternalTablesForRemap(stitch, stitch->camera_remap, stitch->num_cameras, stitch->num_camera_columns, stitch->camera_buffer_width / stitch->num_camera_columns, stitch->camera_buffer_height / stitch->num_camera_rows, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->rig_par, stitch->camera_par, stitch->camSrcMap, stitch->validPixelCamMap, stitch->camIndexTmpBuf, stitch->camIndexBuf)); } else{ ERROR_CHECK_STATUS_(InitializeInternalTablesForCamera(stitch)); } ERROR_CHECK_STATUS_(SyncInternalTables(stitch)); } if (stitch->rig_params_updated || stitch->overlay_params_updated) { // re-initialize tables for overlay if (stitch->overlay_remap) { ERROR_CHECK_STATUS_(InitializeInternalTablesForRemap(stitch, stitch->overlay_remap, stitch->num_overlays, stitch->num_overlay_columns, stitch->overlay_buffer_width / stitch->num_overlay_columns, stitch->overlay_buffer_height / stitch->num_overlay_rows, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height, &stitch->rig_par, stitch->overlay_par, stitch->overlaySrcMap, stitch->validPixelOverlayMap, stitch->overlayIndexTmpBuf, stitch->overlayIndexBuf)); ERROR_CHECK_STATUS_(SyncInternalTables(stitch)); } } // clear flags stitch->reinitialize_required = false; stitch->rig_params_updated = false; stitch->camera_params_updated = false; stitch->overlay_params_updated = false; PROFILER_STOP(LoomSL, ReinitializeGraph); return VX_SUCCESS; } //! \brief Release stitch context. The ls_context will be reset to NULL. SHARED_PUBLIC vx_status VX_API_CALL lsReleaseContext(ls_context * pStitch) { if (!pStitch) { return VX_ERROR_INVALID_REFERENCE; } else { ls_context stitch = *pStitch; ERROR_CHECK_STATUS_(IsValidContext(stitch)); // graph profile dump if requested if (stitch->live_stitch_attr[LIVE_STITCH_ATTR_PROFILER]) { if (stitch->graphStitch) { ls_printf("> stitch graph profile\n"); char fileName[] = "stdout"; ERROR_CHECK_STATUS_(vxQueryGraph(stitch->graphStitch, VX_GRAPH_ATTRIBUTE_AMD_PERFORMANCE_INTERNAL_PROFILE, fileName, 0)); } } // release configurations if (stitch->camera_par) delete[] stitch->camera_par; if (stitch->overlay_par) delete[] stitch->overlay_par; // release image objects if (stitch->Img_input) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->Img_input)); if (stitch->Img_output) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->Img_output)); if (stitch->Img_input_rgb) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->Img_input_rgb)); if (stitch->Img_output_rgb) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->Img_output_rgb)); if (stitch->Img_overlay) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->Img_overlay)); if (stitch->Img_overlay_rgb) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->Img_overlay_rgb)); if (stitch->Img_overlay_rgba) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->Img_overlay_rgba)); if (stitch->RGBY1) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->RGBY1)); if (stitch->RGBY2) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->RGBY2)); if (stitch->weight_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->weight_image)); if (stitch->cam_id_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->cam_id_image)); if (stitch->group1_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->group1_image)); if (stitch->group2_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->group2_image)); if (stitch->valid_mask_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->valid_mask_image)); if (stitch->warp_luma_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->warp_luma_image)); if (stitch->sobel_magnitude_s16_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->sobel_magnitude_s16_image)); if (stitch->sobelx_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->sobelx_image)); if (stitch->sobely_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->sobely_image)); if (stitch->sobel_magnitude_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->sobel_magnitude_image)); if (stitch->sobel_phase_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->sobel_phase_image)); if (stitch->seamfind_weight_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->seamfind_weight_image)); if (stitch->blend_mask_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->blend_mask_image)); if (stitch->blend_offsets) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->blend_offsets)); if (stitch->chroma_key_input_img) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->chroma_key_input_img)); if (stitch->chroma_key_mask_img) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->chroma_key_mask_img)); if (stitch->chroma_key_dilate_mask_img) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->chroma_key_dilate_mask_img)); if (stitch->chroma_key_erode_mask_img) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->chroma_key_erode_mask_img)); if (stitch->chroma_key_input_RGB_img) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->chroma_key_input_RGB_img)); if (stitch->noiseFilterInput_image) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->noiseFilterInput_image)); // release scalar objects if (stitch->current_frame) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->current_frame)); if (stitch->scene_threshold) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->scene_threshold)); if (stitch->seam_cost_enable) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->seam_cost_enable)); if (stitch->filterLambda) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->filterLambda)); // release remap objects if (stitch->overlay_remap) ERROR_CHECK_STATUS_(vxReleaseRemap(&stitch->overlay_remap)); if (stitch->camera_remap) ERROR_CHECK_STATUS_(vxReleaseRemap(&stitch->camera_remap)); // release matrix if (stitch->overlap_matrix) ERROR_CHECK_STATUS_(vxReleaseMatrix(&stitch->overlap_matrix)); if (stitch->A_matrix) ERROR_CHECK_STATUS_(vxReleaseMatrix(&stitch->A_matrix)); if (stitch->A_matrix_initial_value) delete[] stitch->A_matrix_initial_value; // release arrays if (stitch->ValidPixelEntry) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->ValidPixelEntry)); if (stitch->WarpRemapEntry) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->WarpRemapEntry)); if (stitch->OverlapPixelEntry) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->OverlapPixelEntry)); if (stitch->valid_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->valid_array)); if (stitch->gain_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->gain_array)); if (stitch->overlap_rect_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->overlap_rect_array)); if (stitch->seamfind_valid_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->seamfind_valid_array)); if (stitch->seamfind_weight_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->seamfind_weight_array)); if (stitch->seamfind_accum_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->seamfind_accum_array)); if (stitch->seamfind_pref_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->seamfind_pref_array)); if (stitch->seamfind_path_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->seamfind_path_array)); if (stitch->seamfind_scene_array) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->seamfind_scene_array)); // release delay element if (stitch->noiseFilterImageDelay) ERROR_CHECK_STATUS_(vxReleaseDelay(&stitch->noiseFilterImageDelay)); // release node objects if (stitch->InputColorConvertNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->InputColorConvertNode)); if (stitch->SimpleStitchRemapNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SimpleStitchRemapNode)); if (stitch->OutputColorConvertNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->OutputColorConvertNode)); if (stitch->nodeOverlayRemap) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->nodeOverlayRemap)); if (stitch->nodeOverlayBlend) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->nodeOverlayBlend)); if (stitch->WarpNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->WarpNode)); if (stitch->ExpcompComputeGainNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->ExpcompComputeGainNode)); if (stitch->ExpcompSolveGainNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->ExpcompSolveGainNode)); if (stitch->ExpcompApplyGainNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->ExpcompApplyGainNode)); if (stitch->MergeNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->MergeNode)); if (stitch->SobelNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SobelNode)); if (stitch->MagnitudeNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->MagnitudeNode)); if (stitch->PhaseNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->PhaseNode)); if (stitch->ConvertDepthNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->ConvertDepthNode)); if (stitch->SeamfindStep1Node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SeamfindStep1Node)); if (stitch->SeamfindStep2Node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SeamfindStep2Node)); if (stitch->SeamfindStep3Node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SeamfindStep3Node)); if (stitch->SeamfindStep4Node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SeamfindStep4Node)); if (stitch->SeamfindStep5Node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SeamfindStep5Node)); if (stitch->SeamfindAnalyzeNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->SeamfindAnalyzeNode)); if (stitch->chromaKey_mask_generation_node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->chromaKey_mask_generation_node)); if (stitch->chromaKey_dilate_node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->chromaKey_dilate_node)); if (stitch->chromaKey_erode_node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->chromaKey_erode_node)); if (stitch->chromaKey_merge_node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->chromaKey_merge_node)); if (stitch->noiseFilterNode) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->noiseFilterNode)); if (stitch->MULTIBAND_BLEND && stitch->pStitchMultiband){ for (int i = 0; i < stitch->num_bands; i++){ if (stitch->pStitchMultiband[i].BlendNode)ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->pStitchMultiband[i].BlendNode)); if (stitch->pStitchMultiband[i].SourceHSGNode)ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->pStitchMultiband[i].SourceHSGNode)); if (stitch->pStitchMultiband[i].WeightHSGNode)ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->pStitchMultiband[i].WeightHSGNode)); if (stitch->pStitchMultiband[i].UpscaleSubtractNode)ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->pStitchMultiband[i].UpscaleSubtractNode)); if (stitch->pStitchMultiband[i].UpscaleAddNode)ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->pStitchMultiband[i].UpscaleAddNode)); if (stitch->pStitchMultiband[i].LaplacianReconNode)ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->pStitchMultiband[i].LaplacianReconNode)); if (stitch->pStitchMultiband[i].DstPyrImgGaussian) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->pStitchMultiband[i].DstPyrImgGaussian)); if (stitch->pStitchMultiband[i].WeightPyrImgGaussian) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->pStitchMultiband[i].WeightPyrImgGaussian)); if (stitch->pStitchMultiband[i].DstPyrImgLaplacian) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->pStitchMultiband[i].DstPyrImgLaplacian)); if (stitch->pStitchMultiband[i].DstPyrImgLaplacianRec) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->pStitchMultiband[i].DstPyrImgLaplacianRec)); } delete[] stitch->pStitchMultiband; delete[] stitch->multibandBlendOffsetIntoBuffer; } // release LoomIO objects if (stitch->cameraMediaConfig) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->cameraMediaConfig)); if (stitch->overlayMediaConfig) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->overlayMediaConfig)); if (stitch->outputMediaConfig) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->outputMediaConfig)); if (stitch->viewingMediaConfig) ERROR_CHECK_STATUS_(vxReleaseScalar(&stitch->viewingMediaConfig)); if (stitch->loomioCameraAuxData) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->loomioCameraAuxData)); if (stitch->loomioOverlayAuxData) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->loomioOverlayAuxData)); if (stitch->loomioOutputAuxData) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->loomioOutputAuxData)); if (stitch->loomioViewingAuxData) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->loomioViewingAuxData)); if (stitch->nodeLoomIoCamera) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->nodeLoomIoCamera)); if (stitch->nodeLoomIoOverlay) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->nodeLoomIoOverlay)); if (stitch->nodeLoomIoOutput) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->nodeLoomIoOutput)); if (stitch->nodeLoomIoViewing) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->nodeLoomIoViewing)); // release tiled image elements if (stitch->num_encode_sections > 1){ for (vx_uint32 i = 0; i < stitch->num_encode_sections; i++){ if (stitch->encode_src_rgb_imgs[i]) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->encode_src_rgb_imgs[i])); if (stitch->encode_dst_imgs[i]) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->encode_dst_imgs[i])); if (stitch->encode_color_convert_nodes[i]) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->encode_color_convert_nodes[i])); if (stitch->encodetileOutput[i])ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->encodetileOutput[i])); } } // release fast GPU initialize elements if (!stitch->USE_CPU_INIT){ if (stitch->stitchInitData){ if (stitch->stitchInitData->CameraParamsArr) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->stitchInitData->CameraParamsArr)); if (stitch->stitchInitData->CameraZBuffArr) ERROR_CHECK_STATUS_(vxReleaseArray(&stitch->stitchInitData->CameraZBuffArr)); if (stitch->stitchInitData->DefaultCamMap) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->stitchInitData->DefaultCamMap)); if (stitch->stitchInitData->ValidPixelMap) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->stitchInitData->ValidPixelMap)); if (stitch->stitchInitData->PaddedPixMap) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->stitchInitData->PaddedPixMap)); if (stitch->stitchInitData->SrcCoordMap) ERROR_CHECK_STATUS_(vxReleaseImage(&stitch->stitchInitData->SrcCoordMap)); if (stitch->stitchInitData->calc_warp_maps_node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->stitchInitData->calc_warp_maps_node)); if (stitch->stitchInitData->calc_default_idx_node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->stitchInitData->calc_default_idx_node)); if (stitch->stitchInitData->pad_dilate_node) ERROR_CHECK_STATUS_(vxReleaseNode(&stitch->stitchInitData->pad_dilate_node)); if (stitch->stitchInitData->graphInitialize) ERROR_CHECK_STATUS_(vxReleaseGraph(&stitch->stitchInitData->graphInitialize)); delete[] stitch->stitchInitData; stitch->stitchInitData = nullptr; } } // release internal buffers if (stitch->validPixelCamMap) { delete[] stitch->validPixelCamMap; stitch->validPixelCamMap = nullptr; } if (stitch->paddedPixelCamMap) { delete[] stitch->paddedPixelCamMap; stitch->paddedPixelCamMap = nullptr; } if (stitch->camSrcMap) { delete[] stitch->camSrcMap; stitch->camSrcMap = nullptr; } if (stitch->overlapRectBuf) { delete[] stitch->overlapRectBuf; stitch->overlapRectBuf = nullptr; } if (stitch->camIndexTmpBuf) { delete[] stitch->camIndexTmpBuf; stitch->camIndexTmpBuf = nullptr; } if (stitch->camIndexBuf) { delete[] stitch->camIndexBuf; stitch->camIndexBuf = nullptr; } if (stitch->overlapMatrixBuf) { delete[] stitch->overlapMatrixBuf; stitch->overlapMatrixBuf = nullptr; } if (stitch->overlaySrcMap) { delete[] stitch->overlaySrcMap; stitch->overlaySrcMap = nullptr; } if (stitch->validPixelOverlayMap) { delete[] stitch->validPixelOverlayMap; stitch->validPixelOverlayMap = nullptr; } if (stitch->overlayIndexTmpBuf) { delete[] stitch->overlayIndexTmpBuf; stitch->overlayIndexTmpBuf = nullptr; } if (stitch->overlayIndexBuf) { delete[] stitch->overlayIndexBuf; stitch->overlayIndexBuf = nullptr; } // debug aux dumps if (stitch->loomioAuxDumpFile) { fclose(stitch->loomioAuxDumpFile); } // clear the magic and destroy stitch->magic = ~LIVE_STITCH_MAGIC; //Graph & Context if (stitch->graphStitch) ERROR_CHECK_STATUS_(vxReleaseGraph(&stitch->graphStitch)); if (stitch->context && !stitch->context_is_external) ERROR_CHECK_STATUS_(vxReleaseContext(&stitch->context)); delete stitch; *pStitch = nullptr; } PROFILER_SHUTDOWN(); return VX_SUCCESS; } //! \brief Set OpenCL buffers // input_buffer - input opencl buffer with images from all cameras // overlay_buffer - overlay opencl buffer with all images // output_buffer - output opencl buffer for output equirectangular image // chromaKey_buffer - chroma key opencl buffer for equirectangular image // Use of nullptr will return the control of previously set buffer LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetCameraBuffer(ls_context stitch, cl_mem * input_buffer) { PROFILER_START(LoomSL, SetInputBuffer); ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); // check to make sure that LoomIO for camera is not active if (stitch->nodeLoomIoCamera) return VX_ERROR_NOT_ALLOCATED; // switch the user specified OpenCL buffer into image if (stitch->camera_buffer_format == VX_DF_IMAGE_NV12) { void * ptr_in[] = { input_buffer ? input_buffer[0] : nullptr, input_buffer ? input_buffer[1] : nullptr }; ERROR_CHECK_STATUS_(vxSwapImageHandle(stitch->Img_input, ptr_in, nullptr, 2)); } else { void * ptr_in[] = { input_buffer ? input_buffer[0] : nullptr }; ERROR_CHECK_STATUS_(vxSwapImageHandle(stitch->Img_input, ptr_in, nullptr, 1)); } PROFILER_STOP(LoomSL, SetInputBuffer); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOutputBuffer(ls_context stitch, cl_mem * output_buffer) { PROFILER_START(LoomSL, SetOutputBuffer); ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); // check to make sure that LoomIO for output is not active if (stitch->nodeLoomIoOutput) return VX_ERROR_NOT_ALLOCATED; // switch the user specified OpenCL buffer into image if (stitch->output_buffer_format == VX_DF_IMAGE_NV12) { if (stitch->output_encode_tiles > 1) { for (vx_uint32 i = 0; i < stitch->output_encode_tiles; i++){ void * ptr_out[] = { output_buffer ? output_buffer[(i * 2)] : nullptr, output_buffer ? output_buffer[(i * 2) + 1] : nullptr }; ERROR_CHECK_STATUS_(vxSwapImageHandle(stitch->encodetileOutput[i], ptr_out, nullptr, 2)); } } else { void * ptr_out[] = { output_buffer ? output_buffer[0] : nullptr, output_buffer ? output_buffer[1] : nullptr }; ERROR_CHECK_STATUS_(vxSwapImageHandle(stitch->Img_output, ptr_out, nullptr, 2)); } } else { void * ptr_out[] = { output_buffer ? output_buffer[0] : nullptr }; ERROR_CHECK_STATUS_(vxSwapImageHandle(stitch->Img_output, ptr_out, nullptr, 1)); } PROFILER_STOP(LoomSL, SetOutputBuffer); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetOverlayBuffer(ls_context stitch, cl_mem * overlay_buffer) { ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); // check to make sure that LoomIO for overlay is not active if (stitch->nodeLoomIoOverlay) return VX_ERROR_NOT_ALLOCATED; // switch the user specified OpenCL buffer into image void * ptr_overlay[] = { overlay_buffer ? overlay_buffer[0] : nullptr }; ERROR_CHECK_STATUS_(vxSwapImageHandle(stitch->Img_overlay, ptr_overlay, nullptr, 1)); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetChromaKeyBuffer(ls_context stitch, cl_mem * chromaKey_buffer) { ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (!stitch->CHROMA_KEY) return VX_ERROR_NOT_ALLOCATED; // switch the user specified OpenCL buffer into image void * ptr_chroma[] = { chromaKey_buffer ? chromaKey_buffer[0] : nullptr }; ERROR_CHECK_STATUS_(vxSwapImageHandle(stitch->chroma_key_input_img, ptr_chroma, nullptr, 1)); return VX_SUCCESS; } //! \brief Schedule next frame LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsScheduleFrame(ls_context stitch) { PROFILER_START(LoomSL, ScheduleGraph); ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (stitch->scheduled) { ls_printf("ERROR: lsScheduleFrame: already scheduled\n"); return VX_ERROR_GRAPH_SCHEDULED; } if (stitch->reinitialize_required) { ls_printf("ERROR: lsScheduleFrame: reinitialize required\n"); return VX_FAILURE; } // seamfind needs frame counter values to be incremented if (stitch->SEAM_FIND) { ERROR_CHECK_STATUS_(vxWriteScalarValue(stitch->current_frame, &stitch->current_frame_value)); stitch->current_frame_value++; } // exposure comp expects A_matrix to be initialized to ZERO on GPU if ((stitch->EXPO_COMP <= 2) && stitch->A_matrix) { ERROR_CHECK_STATUS_(vxWriteMatrix(stitch->A_matrix, stitch->A_matrix_initial_value)); ERROR_CHECK_STATUS_(vxDirective((vx_reference)stitch->A_matrix, VX_DIRECTIVE_AMD_COPY_TO_OPENCL)); } // age delay element if temporal noise filter activated if (stitch->NOISE_FILTER){ ERROR_CHECK_STATUS_(vxAgeDelay(stitch->noiseFilterImageDelay)); } // start the graph schedule ERROR_CHECK_STATUS_(vxScheduleGraph(stitch->graphStitch)); stitch->scheduled = true; PROFILER_STOP(LoomSL, ScheduleGraph); return VX_SUCCESS; } //! \brief Schedule next frame LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsWaitForCompletion(ls_context stitch) { PROFILER_START(LoomSL, WaitForCompletionGraph); ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (!stitch->scheduled) { ls_printf("ERROR: lsWaitForCompletion: not scheduled\n"); return VX_ERROR_GRAPH_SCHEDULED; } // wait for graph completion ERROR_CHECK_STATUS_(vxWaitGraph(stitch->graphStitch)); stitch->scheduled = false; // debug: dump auxiliary data if (stitch->loomioAuxDumpFile) { vx_array auxList[] = { stitch->loomioCameraAuxData, stitch->loomioOverlayAuxData, stitch->loomioOutputAuxData, stitch->loomioViewingAuxData }; for (size_t i = 0; i < sizeof(auxList) / sizeof(auxList[0]); i++) { if (auxList[i]) { vx_size numItems = 0; ERROR_CHECK_STATUS_(vxQueryArray(auxList[i], VX_ARRAY_NUMITEMS, &numItems, sizeof(numItems))); if (numItems > 0) { vx_map_id map_id = 0; vx_size stride = 0; char * ptr = nullptr; ERROR_CHECK_STATUS_(vxMapArrayRange(auxList[i], 0, numItems, &map_id, &stride, (void **)&ptr, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, VX_NOGAP_X)); fwrite(ptr, 1, numItems * stride, stitch->loomioAuxDumpFile); fflush(stitch->loomioAuxDumpFile); ERROR_CHECK_STATUS_(vxUnmapArrayRange(auxList[i], map_id)); } } } } PROFILER_STOP(LoomSL, WaitForCompletionGraph); return VX_SUCCESS; } //! \brief query functions. LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOpenVXContext(ls_context stitch, vx_context * openvx_context) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (!stitch->context) { stitch->context = vxCreateContext(); ERROR_CHECK_OBJECT_(stitch->context); if (stitch->opencl_context) { ERROR_CHECK_STATUS_(vxSetContextAttribute(stitch->context, VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT, &stitch->opencl_context, sizeof(cl_context))); } } *openvx_context = stitch->context; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOpenCLContext(ls_context stitch, cl_context * opencl_context) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (!stitch->opencl_context) { vx_context openvx_context = nullptr; vx_status status = lsGetOpenVXContext(stitch, &openvx_context); if (status) return status; status = vxQueryContext(openvx_context, VX_CONTEXT_ATTRIBUTE_AMD_OPENCL_CONTEXT, &stitch->opencl_context, sizeof(cl_context)); if (status) return status; } *opencl_context = stitch->opencl_context; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetRigParams(ls_context stitch, rig_params * par) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); memcpy(par, &stitch->rig_par, sizeof(rig_params)); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetCameraConfig(ls_context stitch, vx_uint32 * num_camera_rows, vx_uint32 * num_camera_columns, vx_df_image * buffer_format, vx_uint32 * buffer_width, vx_uint32 * buffer_height) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); *num_camera_rows = stitch->num_camera_rows; *num_camera_columns = stitch->num_camera_columns; *buffer_format = stitch->camera_buffer_format; *buffer_width = stitch->camera_buffer_width; *buffer_height = stitch->camera_buffer_height; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOutputConfig(ls_context stitch, vx_df_image * buffer_format, vx_uint32 * buffer_width, vx_uint32 * buffer_height) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); *buffer_format = stitch->output_buffer_format; *buffer_width = stitch->output_buffer_width; *buffer_height = stitch->output_buffer_height; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOverlayConfig(ls_context stitch, vx_uint32 * num_overlay_rows, vx_uint32 * num_overlay_columns, vx_df_image * buffer_format, vx_uint32 * buffer_width, vx_uint32 * buffer_height) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); *num_overlay_rows = stitch->num_overlay_rows; *num_overlay_columns = stitch->num_overlay_columns; *buffer_format = VX_DF_IMAGE_RGBX; *buffer_width = stitch->overlay_buffer_width; *buffer_height = stitch->overlay_buffer_height; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetCameraParams(ls_context stitch, vx_uint32 cam_index, camera_params * par) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (cam_index >= stitch->num_cameras) { ls_printf("ERROR: lsGetCameraParams: invalid camera index (%d)\n", cam_index); return VX_ERROR_INVALID_VALUE; } memcpy(par, &stitch->camera_par[cam_index], sizeof(camera_params)); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOverlayParams(ls_context stitch, vx_uint32 overlay_index, camera_params * par) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (overlay_index >= stitch->num_overlays) { ls_printf("ERROR: lsGetOverlayParams: invalid camera index (%d)\n", overlay_index); return VX_ERROR_INVALID_VALUE; } memcpy(par, &stitch->overlay_par[overlay_index], sizeof(camera_params)); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetCameraBufferStride(ls_context stitch, vx_uint32 * camera_buffer_stride_in_bytes) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); *camera_buffer_stride_in_bytes = stitch->camera_buffer_stride_in_bytes; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOutputBufferStride(ls_context stitch, vx_uint32 * output_buffer_stride_in_bytes) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); *output_buffer_stride_in_bytes = stitch->output_buffer_stride_in_bytes; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOverlayBufferStride(ls_context stitch, vx_uint32 * overlay_buffer_stride_in_bytes) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); *overlay_buffer_stride_in_bytes = stitch->overlay_buffer_stride_in_bytes; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetCameraModule(ls_context stitch, char * openvx_module, size_t openvx_module_size, char * kernelName, size_t kernelName_size, char * kernelArguments, size_t kernelArguments_size) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); strncpy(openvx_module, stitch->loomio_camera.module, openvx_module_size); strncpy(kernelName, stitch->loomio_camera.kernelName, kernelName_size); strncpy(kernelArguments, stitch->loomio_camera.kernelArguments, kernelArguments_size); openvx_module[openvx_module_size-1] = '\0'; kernelName[kernelName_size - 1] = '\0'; kernelArguments[kernelArguments_size - 1] = '\0'; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOutputModule(ls_context stitch, char * openvx_module, size_t openvx_module_size, char * kernelName, size_t kernelName_size, char * kernelArguments, size_t kernelArguments_size) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); strncpy(openvx_module, stitch->loomio_output.module, openvx_module_size); strncpy(kernelName, stitch->loomio_output.kernelName, kernelName_size); strncpy(kernelArguments, stitch->loomio_output.kernelArguments, kernelArguments_size); openvx_module[openvx_module_size - 1] = '\0'; kernelName[kernelName_size - 1] = '\0'; kernelArguments[kernelArguments_size - 1] = '\0'; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetOverlayModule(ls_context stitch, char * openvx_module, size_t openvx_module_size, char * kernelName, size_t kernelName_size, char * kernelArguments, size_t kernelArguments_size) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); strncpy(openvx_module, stitch->loomio_overlay.module, openvx_module_size); strncpy(kernelName, stitch->loomio_overlay.kernelName, kernelName_size); strncpy(kernelArguments, stitch->loomio_overlay.kernelArguments, kernelArguments_size); openvx_module[openvx_module_size - 1] = '\0'; kernelName[kernelName_size - 1] = '\0'; kernelArguments[kernelArguments_size - 1] = '\0'; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetViewingModule(ls_context stitch, char * openvx_module, size_t openvx_module_size, char * kernelName, size_t kernelName_size, char * kernelArguments, size_t kernelArguments_size) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); strncpy(openvx_module, stitch->loomio_viewing.module, openvx_module_size); strncpy(kernelName, stitch->loomio_viewing.kernelName, kernelName_size); strncpy(kernelArguments, stitch->loomio_viewing.kernelArguments, kernelArguments_size); openvx_module[openvx_module_size - 1] = '\0'; kernelName[kernelName_size - 1] = '\0'; kernelArguments[kernelArguments_size - 1] = '\0'; return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsExportConfiguration(ls_context stitch, const char * exportType, const char * fileName) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (!_stricmp(exportType, "loom_shell")) { FILE * fp = stdout; if (fileName) { fp = fopen(fileName, "w"); if (!fp) { ls_printf("ERROR: lsExportConfiguration: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } } fprintf(fp, "ls_context context;\n"); fprintf(fp, "context = lsCreateContext();\n"); for (vx_uint32 i = 0; i < stitch->num_cameras; i++) { camera_params camera_par = stitch->camera_par[i]; char lensType[64]; if (camera_par.lens.lens_type == ptgui_lens_rectilinear) strcpy(lensType, "ptgui_lens_rectilinear"); else if (camera_par.lens.lens_type == ptgui_lens_fisheye_ff) strcpy(lensType, "ptgui_lens_fisheye_ff"); else if (camera_par.lens.lens_type == ptgui_lens_fisheye_circ) strcpy(lensType, "ptgui_lens_fisheye_circ"); else if (camera_par.lens.lens_type == adobe_lens_rectilinear) strcpy(lensType, "adobe_lens_rectilinear"); else if (camera_par.lens.lens_type == adobe_lens_fisheye) strcpy(lensType, "adobe_lens_fisheye"); else { ls_printf("ERROR: lsExportConfiguration: loom_shell: (cam) lens_type=%d not supported\n", camera_par.lens.lens_type); return VX_ERROR_NOT_SUPPORTED; } fprintf(fp, "camera_params cam%02d_par = {{%8.3f,%8.3f,%8.3f,%.0f,%.0f,%.0f},{%.3f,%.1f,%.1f,%.3f,%.3f,%s,%f,%f,%f", i, camera_par.focal.yaw, camera_par.focal.pitch, camera_par.focal.roll, camera_par.focal.tx, camera_par.focal.ty, camera_par.focal.tz, camera_par.lens.hfov, camera_par.lens.haw, camera_par.lens.r_crop, camera_par.lens.du0, camera_par.lens.dv0, lensType, camera_par.lens.k1, camera_par.lens.k2, camera_par.lens.k3); vx_int32 lastNonZeroField = -1; for (vx_int32 i = 0; i < 7; i++) { if (camera_par.lens.reserved[i]) lastNonZeroField = i; } for (vx_int32 i = 0; i <= lastNonZeroField; i++) { fprintf(fp, ",%f", camera_par.lens.reserved[i]); } fprintf(fp, "}};\n"); } if (stitch->num_overlays > 0) { for (vx_uint32 i = 0; i < stitch->num_overlays; i++) { camera_params camera_par = stitch->overlay_par[i]; char lensType[64]; if (camera_par.lens.lens_type == ptgui_lens_rectilinear) strcpy(lensType, "ptgui_lens_rectilinear"); else if (camera_par.lens.lens_type == ptgui_lens_fisheye_ff) strcpy(lensType, "ptgui_lens_fisheye_ff"); else if (camera_par.lens.lens_type == ptgui_lens_fisheye_circ) strcpy(lensType, "ptgui_lens_fisheye_circ"); else if (camera_par.lens.lens_type == adobe_lens_rectilinear) strcpy(lensType, "adobe_lens_rectilinear"); else if (camera_par.lens.lens_type == adobe_lens_fisheye) strcpy(lensType, "adobe_lens_fisheye"); else { ls_printf("ERROR: lsExportConfiguration: loom_shell: (ovr) lens_type=%d not supported\n", camera_par.lens.lens_type); return VX_ERROR_NOT_SUPPORTED; } fprintf(fp, "camera_params ovr%02d_par = {{%8.3f,%8.3f,%8.3f,%.0f,%.0f,%.0f},{%.3f,%.1f,%.1f,%.3f,%.3f,%s,%f,%f,%f", i, camera_par.focal.yaw, camera_par.focal.pitch, camera_par.focal.roll, camera_par.focal.tx, camera_par.focal.ty, camera_par.focal.tz, camera_par.lens.hfov, camera_par.lens.haw, camera_par.lens.r_crop, camera_par.lens.du0, camera_par.lens.dv0, lensType, camera_par.lens.k1, camera_par.lens.k2, camera_par.lens.k3); vx_int32 lastNonZeroField = -1; for (vx_int32 i = 0; i < 7; i++) { if (camera_par.lens.reserved[i]) lastNonZeroField = i; } for (vx_int32 i = 0; i <= lastNonZeroField; i++) { fprintf(fp, ",%f", camera_par.lens.reserved[i]); } fprintf(fp, "}};\n"); } } char formatName[64]; if (stitch->output_buffer_format == VX_DF_IMAGE_RGB) strcpy(formatName, "VX_DF_IMAGE_RGB"); else if (stitch->output_buffer_format == VX_DF_IMAGE_UYVY) strcpy(formatName, "VX_DF_IMAGE_UYVY"); else if (stitch->output_buffer_format == VX_DF_IMAGE_YUYV) strcpy(formatName, "VX_DF_IMAGE_YUYV"); else { memcpy(formatName, &stitch->output_buffer_format, 4); formatName[4] = 0; } fprintf(fp, "lsSetOutputConfig(context,%s,%d,%d);\n", formatName, stitch->output_buffer_width, stitch->output_buffer_height); if (stitch->camera_buffer_format == VX_DF_IMAGE_RGB) strcpy(formatName, "VX_DF_IMAGE_RGB"); else if (stitch->camera_buffer_format == VX_DF_IMAGE_UYVY) strcpy(formatName, "VX_DF_IMAGE_UYVY"); else if (stitch->camera_buffer_format == VX_DF_IMAGE_YUYV) strcpy(formatName, "VX_DF_IMAGE_YUYV"); else { memcpy(formatName, &stitch->camera_buffer_format, 4); formatName[4] = 0; } fprintf(fp, "lsSetCameraConfig(context,%d,%d,%s,%d,%d);\n", stitch->num_camera_rows, stitch->num_camera_columns, formatName, stitch->camera_buffer_width, stitch->camera_buffer_height); for (vx_uint32 i = 0; i < stitch->num_cameras; i++) { camera_params camera_par = stitch->camera_par[i]; fprintf(fp, "lsSetCameraParams(context,%2d,&cam%02d_par);\n", i, i); } if (stitch->num_overlays > 0) { fprintf(fp, "lsSetOverlayConfig(context,%d,%d,VX_DF_IMAGE_RGBX,%d,%d);\n", stitch->num_overlay_rows, stitch->num_overlay_columns, stitch->overlay_buffer_width, stitch->overlay_buffer_height); for (vx_uint32 i = 0; i < stitch->num_overlays; i++) { camera_params camera_par = stitch->overlay_par[i]; fprintf(fp, "lsSetOverlayParams(context,%2d,&ovr%02d_par\n", i, i); } } fprintf(fp, "lsSetRigParams(context,{%.3f,%.3f,%.3f,%.3f});\n", stitch->rig_par.yaw, stitch->rig_par.pitch, stitch->rig_par.roll, stitch->rig_par.d); if (stitch->loomio_output.kernelName[0]) { fprintf(fp, "lsSetOutputModule(context,\"%s\",\"%s\",\"%s\");\n", stitch->loomio_output.module, stitch->loomio_output.kernelName, stitch->loomio_output.kernelArguments); } else if (stitch->output_buffer_stride_in_bytes) { fprintf(fp, "lsSetOutputBufferStride(context,%d);\n", stitch->output_buffer_stride_in_bytes); } if (stitch->loomio_camera.kernelName[0]) { fprintf(fp, "lsSetCameraModule(context,\"%s\",\"%s\",\"%s\");\n", stitch->loomio_camera.module, stitch->loomio_camera.kernelName, stitch->loomio_camera.kernelArguments); } else if (stitch->camera_buffer_stride_in_bytes) { fprintf(fp, "lsSetCameraBufferStride(context,%d);\n", stitch->camera_buffer_stride_in_bytes); } if (stitch->loomio_overlay.kernelName[0]) { fprintf(fp, "lsSetOverlayModule(context,\"%s\",\"%s\",\"%s\");\n", stitch->loomio_overlay.module, stitch->loomio_overlay.kernelName, stitch->loomio_overlay.kernelArguments); } else if (stitch->overlay_buffer_stride_in_bytes) { fprintf(fp, "lsSetOverlayBufferStride(context,%d);\n", stitch->overlay_buffer_stride_in_bytes); } if (stitch->loomio_viewing.kernelName[0]) { fprintf(fp, "lsSetViewingModule(context,\"%s\",\"%s\",\"%s\");\n", stitch->loomio_viewing.module, stitch->loomio_viewing.kernelName, stitch->loomio_viewing.kernelArguments); } if(fp != stdout) fclose(fp); } else if (!_strnicmp(exportType, "pts", 3)) { FILE * fp = stdout; if (fileName) { fp = fopen(fileName, "w"); if (!fp) { ls_printf("ERROR: lsExportConfiguration: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } } const char * camFileFormat = exportType[3] == ':' ? &exportType[4] : "CAM%02d.bmp"; bool gotCamFileList = strstr(camFileFormat, ",") ? true : false; if (stitch->num_cameras < 1) { ls_printf("ERROR: lsExportConfiguration: %s: no cameras detected in current configuration\n", exportType); return VX_ERROR_NOT_SUFFICIENT; } if (stitch->rig_par.d != 0.0f) { ls_printf("ERROR: lsExportConfiguration: %s: non-zero d field in rig_param is not supported\n", exportType); return VX_ERROR_NOT_SUPPORTED; } fprintf(fp, "# ptGui project file\n\n"); fprintf(fp, "p w%d h%d f2 v360 u0 n\"JPEG g0 q95\"\n", stitch->output_buffer_width, stitch->output_buffer_height); fprintf(fp, "m g0 i0\n\n"); fprintf(fp, "# input images:\n"); for (vx_uint32 i = 0; i < stitch->num_cameras; i++) { int lens_type = -1; if (stitch->camera_par[i].lens.lens_type == ptgui_lens_rectilinear) lens_type = 0; else if (stitch->camera_par[i].lens.lens_type == ptgui_lens_fisheye_ff) lens_type = 3; else if (stitch->camera_par[i].lens.lens_type == ptgui_lens_fisheye_circ) lens_type = 2; else { ls_printf("ERROR: lsExportConfiguration: %s: lens_type of camera#%d not supported\n", exportType, i); return VX_ERROR_NOT_SUPPORTED; } if (stitch->camera_par[i].focal.tx != 0.0f || stitch->camera_par[i].focal.ty != 0.0f || stitch->camera_par[i].focal.tz != 0.0f) { ls_printf("ERROR: lsExportConfiguration: %s: non-zero tx/ty/tz fields in camera#%d is not supported\n", exportType, i); return VX_ERROR_NOT_SUPPORTED; } // get camFileName from camFileFormat char camFileName[1024]; if (gotCamFileList) { strncpy(camFileName, camFileFormat, sizeof(camFileName)); char * p = strstr(camFileName, ","); if (p) *p = '\0'; const char * s = camFileFormat; while (*s && *s != ',') s++; if (*s == ',') camFileFormat = s + 1; } else { sprintf(camFileName, camFileFormat, i); } // add camera entry vx_uint32 width = stitch->camera_buffer_width / stitch->num_camera_columns; vx_uint32 height = stitch->camera_buffer_height / stitch->num_camera_rows; fprintf(fp, "#-imgfile %d %d \"%s\"\n", width, height, camFileName); vx_float32 d = stitch->camera_par[i].lens.du0; vx_float32 e = stitch->camera_par[i].lens.dv0; if ((stitch->camera_par[i].lens.haw > 0) && (fabsf(stitch->camera_par[i].lens.haw - width) >= 0.5f)) { vx_int32 left = 0, right = width, top = 0, bottom = height; // check reserved fields for hidden crop parameters from PtGui if (stitch->camera_par[i].lens.lens_type <= ptgui_lens_fisheye_circ && (stitch->camera_par[i].lens.reserved[3] != 0 || stitch->camera_par[i].lens.reserved[4] != 0 || stitch->camera_par[i].lens.reserved[5] != 0 || stitch->camera_par[i].lens.reserved[6] != 0)) { left = (vx_int32)stitch->camera_par[i].lens.reserved[3]; top = (vx_int32)stitch->camera_par[i].lens.reserved[4]; right = (vx_int32)stitch->camera_par[i].lens.reserved[5]; bottom = (vx_int32)stitch->camera_par[i].lens.reserved[6]; d -= 0.5f*(left + right - (vx_int32)width); e -= 0.5f*(top + bottom - (vx_int32)height); } else { // only use crop in horizontal direction left = (vx_int32)(floor(d) - 0.5f * stitch->camera_par[i].lens.haw); right = (vx_int32)(floor(d) + 0.5f * stitch->camera_par[i].lens.haw); d -= floorf(d); } fprintf(fp, "o f%d y%f r%f p%f v%f a%f b%f c%f d%f e%f g0 t0 C%d,%d,%d,%d\n", lens_type, stitch->camera_par[i].focal.yaw - stitch->rig_par.yaw, stitch->camera_par[i].focal.roll - stitch->rig_par.roll, stitch->camera_par[i].focal.pitch - stitch->rig_par.pitch, stitch->camera_par[i].lens.hfov, stitch->camera_par[i].lens.k1, stitch->camera_par[i].lens.k2, stitch->camera_par[i].lens.k3, d, e, left, right, top, bottom); } else { fprintf(fp, "o f%d y%f r%f p%f v%f a%f b%f c%f d%f e%f g0 t0\n", lens_type, stitch->camera_par[i].focal.yaw - stitch->rig_par.yaw, stitch->camera_par[i].focal.roll - stitch->rig_par.roll, stitch->camera_par[i].focal.pitch - stitch->rig_par.pitch, stitch->camera_par[i].lens.hfov * width / (stitch->camera_par[i].lens.haw > 0 ? stitch->camera_par[i].lens.haw : (float)width), stitch->camera_par[i].lens.k1, stitch->camera_par[i].lens.k2, stitch->camera_par[i].lens.k3, d, e); } } if(fp != stdout) fclose(fp); } else if (!_stricmp(exportType, "gdf")) { ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (_stricmp(fileName + strlen(fileName) - 4, ".gdf")) { ls_printf("ERROR: lsExportConfiguration: gdf: requires fileName extension to be .gdf\n"); return VX_ERROR_INVALID_PARAMETERS; } char fileNamePrefixForTables[1024] = { 0 }; strncpy(fileNamePrefixForTables, fileName, strlen(fileName) - 4); FILE * fp = fopen(fileName, "w"); if (!fp) { ls_printf("ERROR: lsExportConfiguration: unable to create: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } vx_node nodeObjList[] = { stitch->InputColorConvertNode, stitch->SimpleStitchRemapNode, stitch->OutputColorConvertNode, stitch->WarpNode, stitch->ExpcompComputeGainNode, stitch->ExpcompSolveGainNode, stitch->ExpcompApplyGainNode, stitch->MergeNode, stitch->SobelNode, stitch->MagnitudeNode, stitch->PhaseNode, stitch->ConvertDepthNode, stitch->SeamfindStep1Node, stitch->SeamfindStep2Node, stitch->SeamfindStep3Node, stitch->SeamfindStep4Node, stitch->SeamfindStep5Node, stitch->nodeOverlayRemap, stitch->nodeOverlayBlend, stitch->nodeLoomIoCamera, stitch->nodeLoomIoOverlay, stitch->nodeLoomIoOutput, stitch->nodeLoomIoViewing, }; const char * kernelNameList[] = { "com.amd.loomsl.color_convert", "org.khronos.openvx.remap", "com.amd.loomsl.color_convert", "com.amd.loomsl.warp", "com.amd.loomsl.expcomp_compute_gainmatrix", "com.amd.loomsl.expcomp_solvegains", "com.amd.loomsl.expcomp_applygains", "com.amd.loomsl.merge", "org.khronos.openvx.sobel_3x3", "org.khronos.openvx.magnitude", "org.khronos.openvx.phase", "org.khronos.openvx.convert_depth", "com.amd.loomsl.seamfind_scene_detect", "com.amd.loomsl.seamfind_cost_generate", "com.amd.loomsl.seamfind_cost_accumulate", "com.amd.loomsl.seamfind_path_trace", "com.amd.loomsl.seamfind_set_weights", "org.khronos.openvx.remap", "com.amd.loomsl.alpha_blend", stitch->loomio_camera.kernelName, stitch->loomio_overlay.kernelName, stitch->loomio_output.kernelName, stitch->loomio_viewing.kernelName, }; std::map nodeMap; for (vx_size i = 0; i < dimof(nodeObjList); i++) { if (nodeObjList[i]) { nodeMap[nodeObjList[i]] = kernelNameList[i]; } } if (stitch->MULTIBAND_BLEND){ for (int i = 1; i < stitch->num_bands; i++) { nodeMap[stitch->pStitchMultiband[i].WeightHSGNode] = "com.amd.loomsl.half_scale_gaussian"; nodeMap[stitch->pStitchMultiband[i].SourceHSGNode] = "com.amd.loomsl.half_scale_gaussian"; nodeMap[stitch->pStitchMultiband[i].UpscaleSubtractNode] = "com.amd.loomsl.upscale_gaussian_subtract"; } int i = stitch->num_bands - 1; nodeMap[stitch->pStitchMultiband[i].BlendNode] = "com.amd.loomsl.multiband_blend"; --i; for (; i > 0; --i){ nodeMap[stitch->pStitchMultiband[i].UpscaleAddNode] = "com.amd.loomsl.upscale_gaussian_add"; } nodeMap[stitch->pStitchMultiband[0].UpscaleAddNode] = "com.amd.loomsl.laplacian_reconstruct"; } std::map refSuffixList; std::map refIsForCpuUseOnly; for (auto it = nodeMap.begin(); it != nodeMap.end(); it++) { vx_node node = it->first; if (node) { vx_uint32 paramCount; ERROR_CHECK_STATUS_(vxQueryNode(node, VX_NODE_PARAMETERS, ¶mCount, sizeof(paramCount))); for (vx_uint32 paramIndex = 0; paramIndex < paramCount; paramIndex++) { vx_reference ref = avxGetNodeParamRef(node, paramIndex); if (vxGetStatus(ref) == VX_SUCCESS) { if (refSuffixList.find(ref) == refSuffixList.end()) { bool isIntermediateTmpData = false, isForCpuUseOnly = false; const char * fileNameSuffix = GetFileNameSuffix(stitch, ref, isIntermediateTmpData, isForCpuUseOnly); if (fileNameSuffix && !isIntermediateTmpData) { refSuffixList[ref] = fileNameSuffix; if (isForCpuUseOnly) { refIsForCpuUseOnly[ref] = true; } } } } } } } fprintf(fp, "import vx_loomsl\n"); std::map refNameList; if (stitch->stitching_mode == stitching_mode_normal) { fprintf(fp, "type WarpValidPixelEntryType userstruct:%d\n", (int)sizeof(StitchValidPixelEntry)); fprintf(fp, "type WarpRemapEntryType userstruct:%d\n", (int)sizeof(StitchWarpRemapEntry)); fprintf(fp, "data warpValidPixelTable = array:WarpValidPixelEntryType,%d\n", (int)stitch->table_sizes.warpTableSize); fprintf(fp, "data warpRemapTable = array:WarpRemapEntryType,%d\n", (int)stitch->table_sizes.warpTableSize); fprintf(fp, "data RGBY1 = image:%d,%d,RGBA\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); fprintf(fp, "data weight_image = image:%d,%d,U008\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); fprintf(fp, "data cam_id_image = image:%d,%d,U008\n", (stitch->output_rgb_buffer_width / 8), stitch->output_rgb_buffer_height); fprintf(fp, "data group1_image = image:%d,%d,U016\n", (stitch->output_rgb_buffer_width / 8), stitch->output_rgb_buffer_height); fprintf(fp, "data group2_image = image:%d,%d,U016\n", (stitch->output_rgb_buffer_width / 8), stitch->output_rgb_buffer_height); refNameList[(vx_reference)stitch->ValidPixelEntry] = "warpValidPixelTable"; refNameList[(vx_reference)stitch->WarpRemapEntry] = "warpRemapTable"; refNameList[(vx_reference)stitch->RGBY1] = "RGBY1"; refNameList[(vx_reference)stitch->weight_image] = "weight_image"; refNameList[(vx_reference)stitch->cam_id_image] = "cam_id_image"; refNameList[(vx_reference)stitch->group1_image] = "group1_image"; refNameList[(vx_reference)stitch->group2_image] = "group2_image"; if (stitch->EXPO_COMP) { fprintf(fp, "type ExpCompValidEntryType userstruct:%d\n", (int)sizeof(StitchOverlapPixelEntry)); fprintf(fp, "type ExpCompCalcEntryType userstruct:%d\n", (int)sizeof(StitchExpCompCalcEntry)); fprintf(fp, "data expCompValidTable = array:ExpCompValidEntryType,%d\n", (int)stitch->table_sizes.expCompValidTableSize); if (stitch->EXPO_COMP < 3) fprintf(fp, "data expCompCalcTable = array:ExpCompCalcEntryType,%d\n", (int)stitch->table_sizes.expCompOverlapTableSize); fprintf(fp, "data expCompGain = array:VX_TYPE_FLOAT32,%d\n", (int)stitch->num_cameras); fprintf(fp, "data expCompAMat = matrix:VX_TYPE_INT32,%d,%d\n", stitch->num_cameras, stitch->num_cameras); fprintf(fp, "data expCompCountMat = matrix:VX_TYPE_INT32,%d,%d\n", stitch->num_cameras, stitch->num_cameras); fprintf(fp, "data RGBY2 = image:%d,%d,RGBA\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); refNameList[(vx_reference)stitch->valid_array] = "expCompValidTable"; if (stitch->EXPO_COMP < 3) refNameList[(vx_reference)stitch->OverlapPixelEntry] = "expCompCalcTable"; refNameList[(vx_reference)stitch->gain_array] = "expCompGain"; refNameList[(vx_reference)stitch->A_matrix] = "expCompAMat"; refNameList[(vx_reference)stitch->overlap_matrix] = "expCompCountMat"; refNameList[(vx_reference)stitch->RGBY2] = "RGBY2"; } if (stitch->SEAM_FIND) { fprintf(fp, "type SeamFindValidEntryType userstruct:%d\n", (int)sizeof(StitchSeamFindValidEntry)); fprintf(fp, "type SeamFindWeightEntryType userstruct:%d\n", (int)sizeof(StitchSeamFindWeightEntry)); fprintf(fp, "type SeamFindAccumEntryType userstruct:%d\n", (int)sizeof(StitchSeamFindAccumEntry)); fprintf(fp, "type SeamFindPreferenceType userstruct:%d\n", (int)sizeof(StitchSeamFindPreference)); fprintf(fp, "type SeamFindInformationType userstruct:%d\n", (int)sizeof(StitchSeamFindInformation)); fprintf(fp, "type SeamFindPathEntryType userstruct:%d\n", (int)sizeof(StitchSeamFindPathEntry)); fprintf(fp, "data seamFindValid = array:SeamFindValidEntryType,%d\n", (int)stitch->table_sizes.seamFindValidTableSize); fprintf(fp, "data seamFindWeight = array:SeamFindWeightEntryType,%d\n", (int)stitch->table_sizes.seamFindWeightTableSize); fprintf(fp, "data seamFindAccum = array:SeamFindAccumEntryType,%d\n", (int)stitch->table_sizes.seamFindAccumTableSize); fprintf(fp, "data seamFindPref = array:SeamFindPreferenceType,%d\n", (int)stitch->table_sizes.seamFindPrefInfoTableSize); fprintf(fp, "data seamFindInfo = array:SeamFindInformationType,%d\n", (int)stitch->table_sizes.seamFindPrefInfoTableSize); fprintf(fp, "data seamFindPath = array:SeamFindPathEntryType,%d\n", (int)stitch->table_sizes.seamFindPathTableSize); fprintf(fp, "data warpLuma = virtual-image:%d,%d,U008\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); refNameList[(vx_reference)stitch->seamfind_valid_array] = "seamFindValid"; refNameList[(vx_reference)stitch->seamfind_weight_array] = "seamFindWeight"; refNameList[(vx_reference)stitch->seamfind_accum_array] = "seamFindAccum"; refNameList[(vx_reference)stitch->seamfind_pref_array] = "seamFindPref"; refNameList[(vx_reference)stitch->seamfind_info_array] = "seamFindInfo"; refNameList[(vx_reference)stitch->seamfind_path_array] = "seamFindPath"; refNameList[(vx_reference)stitch->warp_luma_image] = "warpLuma"; if (!stitch->SEAM_COST_SELECT) { fprintf(fp, "data seamFindSobelX = virtual-image:%d,%d,S016\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); fprintf(fp, "data seamFindSobelY = virtual-image:%d,%d,S016\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); fprintf(fp, "data seamFindMagS16 = virtual-image:%d,%d,S016\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); refNameList[(vx_reference)stitch->sobelx_image] = "seamFindSobelX"; refNameList[(vx_reference)stitch->sobely_image] = "seamFindSobelY"; refNameList[(vx_reference)stitch->sobel_magnitude_s16_image] = "seamFindMagS16"; } fprintf(fp, "data seamFindMag = virtual-image:%d,%d,U008\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); fprintf(fp, "data seamFindPhase = virtual-image:%d,%d,U008\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); fprintf(fp, "data seamFindWeightImage = image:%d,%d,U008\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); fprintf(fp, "data seamFindCurFrame = scalar:VX_TYPE_UINT32,%d\n", stitch->current_frame_value); refNameList[(vx_reference)stitch->sobel_magnitude_image] = "seamFindMag"; refNameList[(vx_reference)stitch->sobel_phase_image] = "seamFindPhase"; refNameList[(vx_reference)stitch->seamfind_weight_image] = "seamFindWeightImage"; refNameList[(vx_reference)stitch->current_frame] = "seamFindCurFrame"; if (stitch->SEAM_REFRESH) { fprintf(fp, "type SeamFindSceneEntryType userstruct:%d\n", (int)sizeof(StitchSeamFindSceneEntry)); fprintf(fp, "data seamFindSceneTable = array:SeamFindSceneEntryType,%d\n", (int)stitch->table_sizes.seamFindPrefInfoTableSize); fprintf(fp, "data seamFindSceneThreshold = scalar:VX_TYPE_UINT32,%d\n", stitch->scene_threshold_value); refNameList[(vx_reference)stitch->seamfind_scene_array] = "seamFindSceneTable"; refNameList[(vx_reference)stitch->scene_threshold] = "seamFindSceneThreshold"; } if (stitch->SEAM_COST_SELECT) { vx_uint32 cost_enable = 1; fprintf(fp, "data seamFindCost = scalar:VX_TYPE_UINT32,%d\n", cost_enable); refNameList[(vx_reference)stitch->seam_cost_enable] = "seamFindCost"; } } if (stitch->MULTIBAND_BLEND) { fprintf(fp, "type BlendValidEntryType userstruct:%d\n", (int)sizeof(StitchBlendValidEntry)); fprintf(fp, "data blendValidTable = array:BlendValidEntryType,%d\n", (int)stitch->table_sizes.blendOffsetTableSize); refNameList[(vx_reference)stitch->blend_offsets] = "blendValidTable"; } if (stitch->SEAM_FIND || stitch->EXPO_COMP) { fprintf(fp, "data validMaskImage = image:%d,%d,U008\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras); refNameList[(vx_reference)stitch->valid_mask_image] = "validMaskImage"; } } fprintf(fp, "data Img_input = image:%d,%d,%4.4s\n", stitch->camera_buffer_width, stitch->camera_buffer_height, (const char *)&stitch->camera_buffer_format); fprintf(fp, "data Img_output = image:%d,%d,%4.4s\n", stitch->output_buffer_width, stitch->output_buffer_height, (const char *)&stitch->output_buffer_format); refNameList[(vx_reference)stitch->Img_input] = "Img_input"; refNameList[(vx_reference)stitch->Img_output] = "Img_output"; if (stitch->overlay_remap) { fprintf(fp, "data Img_overlay = image:%d,%d,RGBA\n", stitch->overlay_buffer_width, stitch->overlay_buffer_height); fprintf(fp, "data Img_overlay_rgba = virtual-image:%d,%d,RGBA\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height); fprintf(fp, "data Img_overlay_rgb = virtual-image:%d,%d,RGB2\n", stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height); fprintf(fp, "data overlay_remap = remap:%d,%d,%d,%d\n", stitch->overlay_buffer_width, stitch->overlay_buffer_height, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height); refNameList[(vx_reference)stitch->Img_overlay] = "Img_overlay"; refNameList[(vx_reference)stitch->Img_overlay_rgba] = "Img_overlay_rgba"; refNameList[(vx_reference)stitch->Img_overlay_rgb] = "Img_overlay_rgb"; refNameList[(vx_reference)stitch->overlay_remap] = "overlay_remap"; } if (stitch->camera_remap) { fprintf(fp, "data camera_remap = remap:%d,%d,%d,%d\n", stitch->camera_rgb_buffer_width, stitch->camera_rgb_buffer_height, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height); refNameList[(vx_reference)stitch->camera_remap] = "camera_remap"; } int genImageCount = 0, genScalarCount = 0; for (auto it = nodeMap.begin(); it != nodeMap.end(); it++) { vx_node node = it->first; if (node) { vx_uint32 paramCount; ERROR_CHECK_STATUS_(vxQueryNode(node, VX_NODE_PARAMETERS, ¶mCount, sizeof(paramCount))); for (vx_uint32 paramIndex = 0; paramIndex < paramCount; paramIndex++) { vx_reference ref = avxGetNodeParamRef(node, paramIndex); if (vxGetStatus(ref) == VX_SUCCESS) { if (refNameList.find(ref) == refNameList.end()) { vx_enum type; ERROR_CHECK_STATUS_(vxQueryReference(ref, VX_REFERENCE_TYPE, &type, sizeof(type))); if (type == VX_TYPE_IMAGE) { vx_uint32 width, height; vx_df_image format; ERROR_CHECK_STATUS_(vxQueryImage((vx_image)ref, VX_IMAGE_WIDTH, &width, sizeof(width))); ERROR_CHECK_STATUS_(vxQueryImage((vx_image)ref, VX_IMAGE_HEIGHT, &height, sizeof(height))); ERROR_CHECK_STATUS_(vxQueryImage((vx_image)ref, VX_IMAGE_FORMAT, &format, sizeof(format))); char name[64]; sprintf(name, "img_%02d", genImageCount++); fprintf(fp, "data %s = image:%d,%d,%4.4s\n", name, width, height, (const char *)&format); refNameList[ref] = name; } else if (type == VX_TYPE_SCALAR) { vx_enum data_type; char value[1024] = { 0 }; ERROR_CHECK_STATUS_(vxQueryScalar((vx_scalar)ref, VX_SCALAR_TYPE, &data_type, sizeof(data_type))); ERROR_CHECK_STATUS_(vxReadScalarValue((vx_scalar)ref, value)); char name[64]; sprintf(name, "scalar_%02d", genScalarCount++); if (data_type == VX_TYPE_UINT32) fprintf(fp, "data %s = scalar:VX_TYPE_UINT32,%u\n", name, *(vx_uint32 *)value); else if (data_type == VX_TYPE_ENUM) fprintf(fp, "data %s = scalar:VX_TYPE_ENUM,0x%08x\n", name, *(vx_enum *)value); else if (data_type == VX_TYPE_INT32) fprintf(fp, "data %s = scalar:VX_TYPE_INT32,%d\n", name, *(vx_int32 *)value); else if (data_type == VX_TYPE_FLOAT32) fprintf(fp, "data %s = scalar:VX_TYPE_FLOAT32,%f\n", name, *(vx_float32 *)value); else if (data_type == VX_TYPE_STRING_AMD) fprintf(fp, "data %s = scalar:VX_TYPE_STRING_AMD,\"%s\"\n", name, value); else { ls_printf("ERROR: lsExportConfiguration: gdf: unsupported scalar data type found: %d\n", data_type); return VX_FAILURE; } refNameList[ref] = name; } else { ls_printf("ERROR: lsExportConfiguration: gdf: unsupported object type detected as arg#%d of node: %s\n", paramIndex, it->second.c_str()); return VX_FAILURE; } } } } } } for (auto it = refSuffixList.begin(); it != refSuffixList.end(); it++) { if (refNameList.find(it->first) == refNameList.end()) { vx_enum type; char name[64] = { 0 }; const char * suffix = it->second.c_str(); ERROR_CHECK_STATUS_(vxQueryReference(it->first, VX_REFERENCE_TYPE, &type, sizeof(type))); if (*suffix == '|') strcpy(name, suffix + 1); else { for (int i = 0; suffix[i]; i++) { name[i] = (suffix[i] == '.' || suffix[i] == '-') ? '_' : suffix[i]; } } refNameList[it->first] = name; if (type == VX_TYPE_IMAGE) { vx_uint32 width, height; vx_df_image format; ERROR_CHECK_STATUS_(vxQueryImage((vx_image)it->first, VX_IMAGE_WIDTH, &width, sizeof(width))); ERROR_CHECK_STATUS_(vxQueryImage((vx_image)it->first, VX_IMAGE_HEIGHT, &height, sizeof(height))); ERROR_CHECK_STATUS_(vxQueryImage((vx_image)it->first, VX_IMAGE_FORMAT, &format, sizeof(format))); fprintf(fp, "data %s = image:%d,%d,%4.4s\n", name, width, height, (const char *)&format); } else if (type == VX_TYPE_SCALAR) { vx_enum data_type; char value[1024] = { 0 }; ERROR_CHECK_STATUS_(vxQueryScalar((vx_scalar)it->first, VX_SCALAR_TYPE, &data_type, sizeof(data_type))); ERROR_CHECK_STATUS_(vxReadScalarValue((vx_scalar)it->first, value)); if (data_type == VX_TYPE_UINT32) fprintf(fp, "data %s = scalar:VX_TYPE_UINT32,%u\n", name, *(vx_uint32 *)value); else if (data_type == VX_TYPE_ENUM) fprintf(fp, "data %s = scalar:VX_TYPE_ENUM,0x%08x\n", name, *(vx_enum *)value); else if (data_type == VX_TYPE_INT32) fprintf(fp, "data %s = scalar:VX_TYPE_INT32,%d\n", name, *(vx_int32 *)value); else if (data_type == VX_TYPE_FLOAT32) fprintf(fp, "data %s = scalar:VX_TYPE_FLOAT32,%f\n", name, *(vx_float32 *)value); else if (data_type == VX_TYPE_STRING_AMD) fprintf(fp, "data %s = scalar:VX_TYPE_STRING_AMD,\"%s\"\n", name, value); else { ls_printf("ERROR: lsExportConfiguration: gdf: unsupported scalar data type found: %d\n", data_type); return VX_FAILURE; } } else { ls_printf("ERROR: lsExportConfiguration: gdf: internal error: one of the object type is not supported: %d\n", type); return VX_FAILURE; } } } fprintf(fp, "\n"); for (auto it = nodeMap.begin(); it != nodeMap.end(); it++) { vx_node node = it->first; if (node) { vx_uint32 paramCount; ERROR_CHECK_STATUS_(vxQueryNode(node, VX_NODE_PARAMETERS, ¶mCount, sizeof(paramCount))); fprintf(fp, "node %s", it->second.c_str()); for (vx_uint32 paramIndex = 0; paramIndex < paramCount; paramIndex++) { vx_reference ref = avxGetNodeParamRef(node, paramIndex); if (vxGetStatus(ref) == VX_SUCCESS) { if (refNameList.find(ref) == refNameList.end()) { vx_enum type; ERROR_CHECK_STATUS_(vxQueryReference(ref, VX_REFERENCE_TYPE, &type, sizeof(type))); if (type == VX_TYPE_SCALAR) { char value[1024]; ERROR_CHECK_STATUS_(vxReadScalarValue((vx_scalar)ref, value)); fprintf(fp, " !%d", *(int *)value); } else { ls_printf("ERROR: lsExportConfiguration: gdf: unsupported data object as arg#%d of node object: %s\n", paramIndex, it->second.c_str()); return VX_FAILURE; } } else { fprintf(fp, " %s", refNameList[ref].c_str()); } } else { fprintf(fp, " NULL"); } } fprintf(fp, "\n"); } } fprintf(fp, "\n"); for (auto it = refSuffixList.begin(); it != refSuffixList.end(); it++) { fprintf(fp, "init %s %s-%s\n", refNameList[it->first].c_str(), fileNamePrefixForTables, it->second.c_str()); } fprintf(fp, "read %s %s-camera-input.raw\n", refNameList[(vx_reference)stitch->Img_input].c_str(), fileNamePrefixForTables); if (stitch->Img_overlay) { fprintf(fp, "read %s %s-overlay-input.raw\n", refNameList[(vx_reference)stitch->Img_overlay].c_str(), fileNamePrefixForTables); } fprintf(fp, "write %s %s-stitch-output.raw\n", refNameList[(vx_reference)stitch->Img_output].c_str(), fileNamePrefixForTables); fprintf(fp, "\n"); for (auto it = refSuffixList.begin(); it != refSuffixList.end(); it++) { if (refIsForCpuUseOnly.find(it->first) == refIsForCpuUseOnly.end() || !refIsForCpuUseOnly[it->first]) { fprintf(fp, "directive %s VX_DIRECTIVE_AMD_COPY_TO_OPENCL\n", refNameList[it->first].c_str()); } } fclose(fp); ls_printf("OK: lsExportConfiguration: created %s\n", fileName); return DumpInternalTables(stitch, fileNamePrefixForTables, false); } else if (!_stricmp(exportType, "data")) { ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); return DumpInternalTables(stitch, fileName, true); } else { ls_printf("ERROR: lsExportConfiguration: unsupported exportType: %s\n", exportType); return VX_ERROR_NOT_SUPPORTED; } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsImportConfiguration(ls_context stitch, const char * importType, const char * fileName) { ERROR_CHECK_STATUS_(IsValidContext(stitch)); if (!_stricmp(importType, "pts")) { if (stitch->num_cameras < 1) { ls_printf("ERROR: lsImportConfiguration: %s: needs more than one camera in the configuration\n", importType); return VX_ERROR_NOT_SUFFICIENT; } vx_uint32 camIndex = 0; camera_lens_type lens_type = ptgui_lens_fisheye_ff; vx_float32 a = 0, b = 0, c = 0, d = 0, e = 0, yaw = 0, pitch = 0, roll = 0, hfov = 0; vx_uint32 width = stitch->camera_buffer_width / stitch->num_camera_columns; vx_uint32 height = stitch->camera_buffer_height / stitch->num_camera_rows; bool isDummy = false; FILE * fp = fopen(fileName, "rb"); if (!fp) { ls_printf("ERROR: lsImportConfiguration: unable to open: %s\n", fileName); if (fp != NULL) fclose(fp); return VX_FAILURE; } fseek(fp, 0L, SEEK_END); long fileSize = ftell(fp); fseek(fp, 0L, SEEK_SET); char * textBuf = new char[fileSize + 1]; ERROR_CHECK_FREAD_(fread(textBuf, 1, fileSize, fp),fileSize); fclose(fp); textBuf[fileSize] = 0; for (const char * text = textBuf; *text; ) { if (!strncmp(text, "#-dummyimage", 12)) { isDummy = true; } else if (*text == 'o') { bool cropSpecified = false; vx_int32 left = 0, top = 0, right = width, bottom = height; if (camIndex >= stitch->num_cameras) { ls_printf("ERROR: lsImportConfiguration: %s: PTS has more cameras than current configuration\n", importType); delete[] textBuf; return VX_ERROR_NOT_SUPPORTED; } while (*text && *text != '\n') { // skip till whitespace while (*text && *text != '\n' && *text != ' ' && *text != '\t') text++; while (*text && *text != '\n' && (*text == ' ' || *text == '\t')) text++; // process fields if (*text == 'f') { if (text[1] == '0') lens_type = ptgui_lens_rectilinear; else if (text[1] == '2') lens_type = ptgui_lens_fisheye_circ; else if (text[1] == '3') lens_type = ptgui_lens_fisheye_ff; else { ls_printf("ERROR: lsImportConfiguration: %s: lens_type f%c not supported\n", importType, text[1]); delete[] textBuf; return VX_ERROR_NOT_SUPPORTED; } } else if (*text == 'y') yaw = (float)atof(&text[1]); else if (*text == 'p') pitch = (float)atof(&text[1]); else if (*text == 'r') roll = (float)atof(&text[1]); else if (*text == 'v' && text[1] != '=') hfov = (float)atof(&text[1]); else if (*text == 'a' && text[1] != '=') a = (float)atof(&text[1]); else if (*text == 'b' && text[1] != '=') b = (float)atof(&text[1]); else if (*text == 'c' && text[1] != '=') c = (float)atof(&text[1]); else if (*text == 'd' && text[1] != '=') d = (float)atof(&text[1]); else if (*text == 'e' && text[1] != '=') e = (float)atof(&text[1]); else if (*text == 'C') { sscanf(&text[1], "%d,%d,%d,%d", &left, &right, &top, &bottom); cropSpecified = true; } } if (!isDummy) { camera_params * par = &stitch->camera_par[camIndex++]; par->focal.yaw = yaw; par->focal.pitch = pitch; par->focal.roll = roll; par->focal.tx = 0.0f; par->focal.ty = 0.0f; par->focal.tz = 0.0f; par->lens.lens_type = lens_type; par->lens.hfov = hfov; par->lens.k1 = a; par->lens.k2 = b; par->lens.k3 = c; par->lens.du0 = d; par->lens.dv0 = e; par->lens.haw = (float)width; if (cropSpecified) { par->lens.haw = (float)(right - left); par->lens.du0 += 0.5f*(left + right - (vx_int32)width); par->lens.dv0 += 0.5f*(top + bottom - (vx_int32)height); par->lens.r_crop = par->lens.haw * 0.5f; // save PtGui crop values in reserved fields par->lens.reserved[3] = (float)left; par->lens.reserved[4] = (float)top; par->lens.reserved[5] = (float)right; par->lens.reserved[6] = (float)bottom; } } isDummy = false; } // skip till end-of-line while (*text && *text != '\n') text++; if (*text == '\n') text++; } delete[] textBuf; if (camIndex != stitch->num_cameras) { ls_printf("ERROR: lsImportConfiguration: %s: could not import for all %d cameras (found %d)\n", importType, stitch->num_cameras, camIndex); return VX_ERROR_NOT_SUFFICIENT; } } else { ls_printf("ERROR: lsImportConfiguration: unsupported importType: %s\n", importType); return VX_ERROR_NOT_SUPPORTED; } return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetExpCompGains(ls_context stitch, size_t num_entries, vx_float32 * gains) { ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (!stitch->EXPO_COMP || !stitch->gain_array) return VX_ERROR_NOT_SUPPORTED; vx_size count; ERROR_CHECK_STATUS_(vxQueryArray(stitch->gain_array, VX_ARRAY_NUMITEMS, &count, sizeof(count))); if (num_entries != count) { ls_printf("ERROR: lsSetExpCompGains: expects num_entries to be %d: got %d\n", (vx_uint32)count, (vx_uint32)num_entries); return VX_ERROR_INVALID_PARAMETERS; } ERROR_CHECK_STATUS_(vxCopyArrayRange(stitch->gain_array, 0, num_entries, sizeof(vx_float32), gains, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsGetExpCompGains(ls_context stitch, size_t num_entries, vx_float32 * gains) { ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (!stitch->EXPO_COMP || !stitch->gain_array) return VX_ERROR_NOT_SUPPORTED; vx_size count; ERROR_CHECK_STATUS_(vxQueryArray(stitch->gain_array, VX_ARRAY_NUMITEMS, &count, sizeof(count))); if (num_entries != count) { ls_printf("ERROR: lsGetExpCompGains: expects num_entries to be %d: got %d\n", (vx_uint32)count, (vx_uint32)num_entries); return VX_ERROR_INVALID_PARAMETERS; } ERROR_CHECK_STATUS_(vxCopyArrayRange(stitch->gain_array, 0, num_entries, sizeof(vx_float32), gains, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); return VX_SUCCESS; } LIVE_STITCH_API_ENTRY vx_status VX_API_CALL lsSetBlendWeights(ls_context stitch, vx_uint8 * weights, size_t size) { ERROR_CHECK_STATUS_(IsValidContextAndInitialized(stitch)); if (stitch->SEAM_FIND || !stitch->weight_image) return VX_ERROR_NOT_SUPPORTED; if (size != (size_t)(stitch->output_rgb_buffer_width * stitch->output_rgb_buffer_height * stitch->num_cameras)) return VX_ERROR_INVALID_PARAMETERS; // copy weight image vx_rectangle_t rect = { 0, 0, stitch->output_rgb_buffer_width, stitch->output_rgb_buffer_height * stitch->num_cameras }; vx_imagepatch_addressing_t addr; addr.dim_x = rect.end_x; addr.dim_y = rect.end_y; addr.stride_x = 1; addr.stride_y = rect.end_x; ERROR_CHECK_STATUS_(vxCopyImagePatch(stitch->weight_image, &rect, 0, &addr, weights, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); return VX_SUCCESS; }