├── .gitignore ├── LICENSE ├── README.md ├── SocialPreview.png ├── ico.ico ├── ico.png ├── ico.psd ├── jarkViewer.slnx ├── jarkViewer ├── .gitignore ├── file │ ├── MSYHMONO.ttf │ ├── home.png │ ├── mainRes.png │ ├── printerRes.png │ ├── settingRes.png │ └── tips.png ├── include │ ├── D2D1App.h │ ├── FileAssociationManager.h │ ├── ImageDatabase.h │ ├── LRU.h │ ├── SVGPreprocessor.h │ ├── Setting.h │ ├── TextDrawer.h │ ├── aom │ │ ├── aom.h │ │ ├── aom_codec.h │ │ ├── aom_decoder.h │ │ ├── aom_encoder.h │ │ ├── aom_external_partition.h │ │ ├── aom_frame_buffer.h │ │ ├── aom_image.h │ │ ├── aom_integer.h │ │ ├── aomcx.h │ │ └── aomdx.h │ ├── avif │ │ ├── avif.h │ │ └── avif_cxx.h │ ├── bzlib.h │ ├── channel.h │ ├── config.h │ ├── dav1d │ │ ├── common.h │ │ ├── data.h │ │ ├── dav1d.h │ │ ├── headers.h │ │ ├── picture.h │ │ └── version.h │ ├── exifParse.h │ ├── exiv2 │ │ ├── basicio.hpp │ │ ├── bmffimage.hpp │ │ ├── bmpimage.hpp │ │ ├── config.h │ │ ├── convert.hpp │ │ ├── cr2image.hpp │ │ ├── crwimage.hpp │ │ ├── datasets.hpp │ │ ├── easyaccess.hpp │ │ ├── epsimage.hpp │ │ ├── error.hpp │ │ ├── exif.hpp │ │ ├── exiv2.hpp │ │ ├── exiv2lib_export.h │ │ ├── exv_conf.h │ │ ├── futils.hpp │ │ ├── gifimage.hpp │ │ ├── image.hpp │ │ ├── image_types.hpp │ │ ├── iptc.hpp │ │ ├── jp2image.hpp │ │ ├── jpgimage.hpp │ │ ├── metadatum.hpp │ │ ├── mrwimage.hpp │ │ ├── orfimage.hpp │ │ ├── pgfimage.hpp │ │ ├── photoshop.hpp │ │ ├── pngimage.hpp │ │ ├── preview.hpp │ │ ├── properties.hpp │ │ ├── psdimage.hpp │ │ ├── rafimage.hpp │ │ ├── rw2image.hpp │ │ ├── slice.hpp │ │ ├── tags.hpp │ │ ├── tgaimage.hpp │ │ ├── tiffimage.hpp │ │ ├── types.hpp │ │ ├── value.hpp │ │ ├── version.hpp │ │ ├── webpimage.hpp │ │ ├── xmp_exiv2.hpp │ │ └── xmpsidecar.hpp │ ├── framework.h │ ├── jarkUtils.h │ ├── jxl │ │ ├── cms.h │ │ ├── cms_interface.h │ │ ├── codestream_header.h │ │ ├── color_encoding.h │ │ ├── compressed_icc.h │ │ ├── decode.h │ │ ├── decode_cxx.h │ │ ├── encode.h │ │ ├── encode_cxx.h │ │ ├── gain_map.h │ │ ├── jxl_cms_export.h │ │ ├── jxl_export.h │ │ ├── jxl_threads_export.h │ │ ├── memory_manager.h │ │ ├── parallel_runner.h │ │ ├── resizable_parallel_runner.h │ │ ├── resizable_parallel_runner_cxx.h │ │ ├── stats.h │ │ ├── thread_parallel_runner.h │ │ ├── thread_parallel_runner_cxx.h │ │ ├── types.h │ │ └── version.h │ ├── libbpg.h │ ├── libde265 │ │ ├── de265-version.h │ │ ├── de265.h │ │ └── en265.h │ ├── libheif │ │ ├── heif.h │ │ ├── heif_aux_images.h │ │ ├── heif_brands.h │ │ ├── heif_color.h │ │ ├── heif_context.h │ │ ├── heif_cxx.h │ │ ├── heif_decoding.h │ │ ├── heif_encoding.h │ │ ├── heif_entity_groups.h │ │ ├── heif_error.h │ │ ├── heif_image.h │ │ ├── heif_image_handle.h │ │ ├── heif_items.h │ │ ├── heif_library.h │ │ ├── heif_metadata.h │ │ ├── heif_plugin.h │ │ ├── heif_properties.h │ │ ├── heif_regions.h │ │ ├── heif_security.h │ │ ├── heif_sequences.h │ │ ├── heif_tai_timestamps.h │ │ ├── heif_tiling.h │ │ ├── heif_uncompressed.h │ │ └── heif_version.h │ ├── libraw │ │ ├── libraw.h │ │ ├── libraw_alloc.h │ │ ├── libraw_config.h │ │ ├── libraw_const.h │ │ ├── libraw_datastream.h │ │ ├── libraw_internal.h │ │ ├── libraw_types.h │ │ └── libraw_version.h │ ├── libwebp2 │ │ ├── imageio │ │ │ ├── anim_image_dec.h │ │ │ ├── file_format.h │ │ │ ├── image_dec.h │ │ │ ├── image_enc.h │ │ │ └── imageio_util.h │ │ └── src │ │ │ ├── common │ │ │ ├── av1_common.h │ │ │ ├── color_precision.h │ │ │ ├── constants.h │ │ │ ├── filters │ │ │ │ └── rstr_flt_params.h │ │ │ ├── global_params.h │ │ │ ├── header_enc_dec.h │ │ │ ├── integral.h │ │ │ ├── lossless │ │ │ │ └── color_cache.h │ │ │ ├── lossy │ │ │ │ ├── aom │ │ │ │ │ └── cdfs.inc │ │ │ │ ├── block.h │ │ │ │ ├── block_size.h │ │ │ │ ├── block_size_io.h │ │ │ │ ├── context.h │ │ │ │ ├── predictor.h │ │ │ │ ├── quant_mtx.h │ │ │ │ ├── residuals.h │ │ │ │ ├── residuals_aom.h │ │ │ │ ├── rnd_mtx.h │ │ │ │ ├── segment.h │ │ │ │ └── transforms.h │ │ │ ├── preview │ │ │ │ └── preview.h │ │ │ ├── progress_watcher.h │ │ │ ├── symbols.h │ │ │ └── vdebug.h │ │ │ ├── dec │ │ │ ├── filters │ │ │ │ ├── alpha_filter.h │ │ │ │ ├── block_map_filter.h │ │ │ │ ├── deblocking_filter.h │ │ │ │ ├── directional_filter.h │ │ │ │ ├── grain_filter.h │ │ │ │ ├── intertile_filter.h │ │ │ │ ├── intratile_filter.h │ │ │ │ └── restoration_filter.h │ │ │ ├── incr │ │ │ │ ├── decoder_context.h │ │ │ │ ├── decoder_info.h │ │ │ │ ├── decoder_skip.h │ │ │ │ └── decoder_state.h │ │ │ ├── lossless │ │ │ │ └── losslessi_dec.h │ │ │ ├── preview │ │ │ │ └── preview_dec.h │ │ │ ├── residuals_dec_aom.h │ │ │ ├── symbols_dec.h │ │ │ ├── tile_dec.h │ │ │ └── wp2_dec_i.h │ │ │ ├── dsp │ │ │ ├── dsp.h │ │ │ ├── dsp_x86.h │ │ │ ├── lossless │ │ │ │ ├── decl_dsp.h │ │ │ │ ├── dspl.h │ │ │ │ └── encl_dsp.h │ │ │ └── math.h │ │ │ ├── enc │ │ │ ├── analysis.h │ │ │ ├── anim │ │ │ │ └── anim_enc.h │ │ │ ├── block_enc.h │ │ │ ├── lossless │ │ │ │ ├── backward_references_enc.h │ │ │ │ ├── histogram_enc.h │ │ │ │ ├── losslessi_enc.h │ │ │ │ └── palette.h │ │ │ ├── partitioning │ │ │ │ ├── partition_score_func.h │ │ │ │ ├── partition_score_func_area.h │ │ │ │ ├── partition_score_func_block.h │ │ │ │ ├── partition_score_func_multi.h │ │ │ │ ├── partition_score_func_tile.h │ │ │ │ ├── partitioner.h │ │ │ │ ├── partitioner_area.h │ │ │ │ ├── partitioner_exhaustive.h │ │ │ │ ├── partitioner_multi.h │ │ │ │ ├── partitioner_split.h │ │ │ │ ├── partitioner_split_recurse.h │ │ │ │ └── partitioner_top_left.h │ │ │ ├── preview │ │ │ │ └── preview_enc.h │ │ │ ├── residuals_enc_aom.h │ │ │ ├── screen_content │ │ │ │ └── screen_enc.h │ │ │ ├── symbols_enc.h │ │ │ ├── tile_enc.h │ │ │ ├── trellis.h │ │ │ └── wp2_enc_i.h │ │ │ ├── utils │ │ │ ├── ans.h │ │ │ ├── ans_enc.h │ │ │ ├── ans_utils.h │ │ │ ├── context_switch.h │ │ │ ├── csp.h │ │ │ ├── data_source.h │ │ │ ├── data_source_context.h │ │ │ ├── data_source_stream.h │ │ │ ├── front_mgr.h │ │ │ ├── hash.h │ │ │ ├── hash_map.h │ │ │ ├── orientation.h │ │ │ ├── plane.h │ │ │ ├── quantizer.h │ │ │ ├── random.h │ │ │ ├── split_iterator.h │ │ │ ├── stats.h │ │ │ ├── thread_utils.h │ │ │ ├── utils.h │ │ │ ├── vector.h │ │ │ └── wiener.h │ │ │ └── wp2 │ │ │ ├── base.h │ │ │ ├── debug.h │ │ │ ├── decode.h │ │ │ ├── encode.h │ │ │ └── format_constants.h │ ├── libyuv.h │ ├── libyuv │ │ ├── basic_types.h │ │ ├── compare.h │ │ ├── compare_row.h │ │ ├── convert.h │ │ ├── convert_argb.h │ │ ├── convert_from.h │ │ ├── convert_from_argb.h │ │ ├── cpu_id.h │ │ ├── loongson_intrinsics.h │ │ ├── macros_msa.h │ │ ├── mjpeg_decoder.h │ │ ├── planar_functions.h │ │ ├── rotate.h │ │ ├── rotate_argb.h │ │ ├── rotate_row.h │ │ ├── row.h │ │ ├── scale.h │ │ ├── scale_argb.h │ │ ├── scale_rgb.h │ │ ├── scale_row.h │ │ ├── scale_uv.h │ │ ├── version.h │ │ └── video_common.h │ ├── lunasvg.h │ ├── minizip │ │ ├── crypt.h │ │ ├── ioapi.h │ │ ├── iowin32.h │ │ ├── mztools.h │ │ ├── unzip.h │ │ └── zip.h │ ├── opencv2 │ │ ├── aruco.hpp │ │ ├── aruco │ │ │ ├── aruco_calib.hpp │ │ │ └── charuco.hpp │ │ ├── bgsegm.hpp │ │ ├── bioinspired.hpp │ │ ├── bioinspired │ │ │ ├── bioinspired.hpp │ │ │ ├── retina.hpp │ │ │ ├── retinafasttonemapping.hpp │ │ │ └── transientareassegmentationmodule.hpp │ │ ├── calib3d.hpp │ │ ├── calib3d │ │ │ ├── calib3d.hpp │ │ │ └── calib3d_c.h │ │ ├── ccalib.hpp │ │ ├── ccalib │ │ │ ├── multicalib.hpp │ │ │ ├── omnidir.hpp │ │ │ └── randpattern.hpp │ │ ├── core.hpp │ │ ├── core │ │ │ ├── affine.hpp │ │ │ ├── async.hpp │ │ │ ├── base.hpp │ │ │ ├── bindings_utils.hpp │ │ │ ├── bufferpool.hpp │ │ │ ├── check.hpp │ │ │ ├── core.hpp │ │ │ ├── core_c.h │ │ │ ├── cuda.hpp │ │ │ ├── cuda.inl.hpp │ │ │ ├── cuda │ │ │ │ ├── block.hpp │ │ │ │ ├── border_interpolate.hpp │ │ │ │ ├── color.hpp │ │ │ │ ├── common.hpp │ │ │ │ ├── datamov_utils.hpp │ │ │ │ ├── detail │ │ │ │ │ ├── color_detail.hpp │ │ │ │ │ ├── reduce.hpp │ │ │ │ │ ├── reduce_key_val.hpp │ │ │ │ │ ├── transform_detail.hpp │ │ │ │ │ ├── type_traits_detail.hpp │ │ │ │ │ └── vec_distance_detail.hpp │ │ │ │ ├── dynamic_smem.hpp │ │ │ │ ├── emulation.hpp │ │ │ │ ├── filters.hpp │ │ │ │ ├── funcattrib.hpp │ │ │ │ ├── functional.hpp │ │ │ │ ├── limits.hpp │ │ │ │ ├── reduce.hpp │ │ │ │ ├── saturate_cast.hpp │ │ │ │ ├── scan.hpp │ │ │ │ ├── simd_functions.hpp │ │ │ │ ├── transform.hpp │ │ │ │ ├── type_traits.hpp │ │ │ │ ├── utility.hpp │ │ │ │ ├── vec_distance.hpp │ │ │ │ ├── vec_math.hpp │ │ │ │ ├── vec_traits.hpp │ │ │ │ ├── warp.hpp │ │ │ │ ├── warp_reduce.hpp │ │ │ │ └── warp_shuffle.hpp │ │ │ ├── cuda_stream_accessor.hpp │ │ │ ├── cuda_types.hpp │ │ │ ├── cv_cpu_dispatch.h │ │ │ ├── cv_cpu_helper.h │ │ │ ├── cvdef.h │ │ │ ├── cvstd.hpp │ │ │ ├── cvstd.inl.hpp │ │ │ ├── cvstd_wrapper.hpp │ │ │ ├── detail │ │ │ │ ├── async_promise.hpp │ │ │ │ ├── dispatch_helper.impl.hpp │ │ │ │ └── exception_ptr.hpp │ │ │ ├── directx.hpp │ │ │ ├── dualquaternion.hpp │ │ │ ├── dualquaternion.inl.hpp │ │ │ ├── eigen.hpp │ │ │ ├── fast_math.hpp │ │ │ ├── hal │ │ │ │ ├── hal.hpp │ │ │ │ ├── interface.h │ │ │ │ ├── intrin.hpp │ │ │ │ ├── intrin_avx.hpp │ │ │ │ ├── intrin_avx512.hpp │ │ │ │ ├── intrin_cpp.hpp │ │ │ │ ├── intrin_forward.hpp │ │ │ │ ├── intrin_lasx.hpp │ │ │ │ ├── intrin_legacy_ops.h │ │ │ │ ├── intrin_lsx.hpp │ │ │ │ ├── intrin_math.hpp │ │ │ │ ├── intrin_msa.hpp │ │ │ │ ├── intrin_neon.hpp │ │ │ │ ├── intrin_rvv071.hpp │ │ │ │ ├── intrin_rvv_scalable.hpp │ │ │ │ ├── intrin_sse.hpp │ │ │ │ ├── intrin_sse_em.hpp │ │ │ │ ├── intrin_vsx.hpp │ │ │ │ ├── intrin_wasm.hpp │ │ │ │ ├── msa_macros.h │ │ │ │ └── simd_utils.impl.hpp │ │ │ ├── mat.hpp │ │ │ ├── mat.inl.hpp │ │ │ ├── matx.hpp │ │ │ ├── matx.inl.hpp │ │ │ ├── neon_utils.hpp │ │ │ ├── ocl.hpp │ │ │ ├── ocl_genbase.hpp │ │ │ ├── opencl │ │ │ │ ├── ocl_defs.hpp │ │ │ │ ├── opencl_info.hpp │ │ │ │ ├── opencl_svm.hpp │ │ │ │ └── runtime │ │ │ │ │ ├── autogenerated │ │ │ │ │ ├── opencl_clblas.hpp │ │ │ │ │ ├── opencl_clfft.hpp │ │ │ │ │ ├── opencl_core.hpp │ │ │ │ │ ├── opencl_core_wrappers.hpp │ │ │ │ │ ├── opencl_gl.hpp │ │ │ │ │ └── opencl_gl_wrappers.hpp │ │ │ │ │ ├── opencl_clblas.hpp │ │ │ │ │ ├── opencl_clfft.hpp │ │ │ │ │ ├── opencl_core.hpp │ │ │ │ │ ├── opencl_core_wrappers.hpp │ │ │ │ │ ├── opencl_gl.hpp │ │ │ │ │ ├── opencl_gl_wrappers.hpp │ │ │ │ │ ├── opencl_svm_20.hpp │ │ │ │ │ ├── opencl_svm_definitions.hpp │ │ │ │ │ └── opencl_svm_hsa_extension.hpp │ │ │ ├── opengl.hpp │ │ │ ├── operations.hpp │ │ │ ├── optim.hpp │ │ │ ├── ovx.hpp │ │ │ ├── parallel │ │ │ │ ├── backend │ │ │ │ │ ├── parallel_for.openmp.hpp │ │ │ │ │ └── parallel_for.tbb.hpp │ │ │ │ └── parallel_backend.hpp │ │ │ ├── persistence.hpp │ │ │ ├── quaternion.hpp │ │ │ ├── quaternion.inl.hpp │ │ │ ├── saturate.hpp │ │ │ ├── simd_intrinsics.hpp │ │ │ ├── softfloat.hpp │ │ │ ├── sse_utils.hpp │ │ │ ├── traits.hpp │ │ │ ├── types.hpp │ │ │ ├── types_c.h │ │ │ ├── utility.hpp │ │ │ ├── utils │ │ │ │ ├── allocator_stats.hpp │ │ │ │ ├── allocator_stats.impl.hpp │ │ │ │ ├── filesystem.hpp │ │ │ │ ├── fp_control_utils.hpp │ │ │ │ ├── instrumentation.hpp │ │ │ │ ├── logger.defines.hpp │ │ │ │ ├── logger.hpp │ │ │ │ ├── logtag.hpp │ │ │ │ ├── tls.hpp │ │ │ │ └── trace.hpp │ │ │ ├── va_intel.hpp │ │ │ ├── version.hpp │ │ │ └── vsx_utils.hpp │ │ ├── cvconfig.h │ │ ├── datasets │ │ │ ├── ar_hmdb.hpp │ │ │ ├── ar_sports.hpp │ │ │ ├── dataset.hpp │ │ │ ├── fr_adience.hpp │ │ │ ├── fr_lfw.hpp │ │ │ ├── gr_chalearn.hpp │ │ │ ├── gr_skig.hpp │ │ │ ├── hpe_humaneva.hpp │ │ │ ├── hpe_parse.hpp │ │ │ ├── ir_affine.hpp │ │ │ ├── ir_robot.hpp │ │ │ ├── is_bsds.hpp │ │ │ ├── is_weizmann.hpp │ │ │ ├── msm_epfl.hpp │ │ │ ├── msm_middlebury.hpp │ │ │ ├── or_imagenet.hpp │ │ │ ├── or_mnist.hpp │ │ │ ├── or_pascal.hpp │ │ │ ├── or_sun.hpp │ │ │ ├── pd_caltech.hpp │ │ │ ├── pd_inria.hpp │ │ │ ├── slam_kitti.hpp │ │ │ ├── slam_tumindoor.hpp │ │ │ ├── sr_bsds.hpp │ │ │ ├── sr_div2k.hpp │ │ │ ├── sr_general100.hpp │ │ │ ├── tr_chars.hpp │ │ │ ├── tr_icdar.hpp │ │ │ ├── tr_svt.hpp │ │ │ ├── track_alov.hpp │ │ │ ├── track_vot.hpp │ │ │ └── util.hpp │ │ ├── dpm.hpp │ │ ├── face.hpp │ │ ├── face │ │ │ ├── bif.hpp │ │ │ ├── face_alignment.hpp │ │ │ ├── facemark.hpp │ │ │ ├── facemarkAAM.hpp │ │ │ ├── facemarkLBF.hpp │ │ │ ├── facemark_train.hpp │ │ │ ├── facerec.hpp │ │ │ ├── mace.hpp │ │ │ └── predict_collector.hpp │ │ ├── features2d.hpp │ │ ├── features2d │ │ │ ├── features2d.hpp │ │ │ └── hal │ │ │ │ └── interface.h │ │ ├── flann.hpp │ │ ├── flann │ │ │ ├── all_indices.h │ │ │ ├── allocator.h │ │ │ ├── any.h │ │ │ ├── autotuned_index.h │ │ │ ├── composite_index.h │ │ │ ├── config.h │ │ │ ├── defines.h │ │ │ ├── dist.h │ │ │ ├── dummy.h │ │ │ ├── dynamic_bitset.h │ │ │ ├── flann.hpp │ │ │ ├── flann_base.hpp │ │ │ ├── general.h │ │ │ ├── ground_truth.h │ │ │ ├── heap.h │ │ │ ├── hierarchical_clustering_index.h │ │ │ ├── index_testing.h │ │ │ ├── kdtree_index.h │ │ │ ├── kdtree_single_index.h │ │ │ ├── kmeans_index.h │ │ │ ├── linear_index.h │ │ │ ├── logger.h │ │ │ ├── lsh_index.h │ │ │ ├── lsh_table.h │ │ │ ├── matrix.h │ │ │ ├── miniflann.hpp │ │ │ ├── nn_index.h │ │ │ ├── object_factory.h │ │ │ ├── params.h │ │ │ ├── random.h │ │ │ ├── result_set.h │ │ │ ├── sampling.h │ │ │ ├── saving.h │ │ │ ├── simplex_downhill.h │ │ │ └── timer.h │ │ ├── fuzzy.hpp │ │ ├── fuzzy │ │ │ ├── fuzzy_F0_math.hpp │ │ │ ├── fuzzy_F1_math.hpp │ │ │ ├── fuzzy_image.hpp │ │ │ └── types.hpp │ │ ├── gapi.hpp │ │ ├── gapi │ │ │ ├── core.hpp │ │ │ ├── cpu │ │ │ │ ├── core.hpp │ │ │ │ ├── gcpukernel.hpp │ │ │ │ ├── imgproc.hpp │ │ │ │ ├── ot.hpp │ │ │ │ ├── stereo.hpp │ │ │ │ └── video.hpp │ │ │ ├── fluid │ │ │ │ ├── core.hpp │ │ │ │ ├── gfluidbuffer.hpp │ │ │ │ ├── gfluidkernel.hpp │ │ │ │ └── imgproc.hpp │ │ │ ├── garg.hpp │ │ │ ├── garray.hpp │ │ │ ├── gasync_context.hpp │ │ │ ├── gcall.hpp │ │ │ ├── gcommon.hpp │ │ │ ├── gcompiled.hpp │ │ │ ├── gcompiled_async.hpp │ │ │ ├── gcompoundkernel.hpp │ │ │ ├── gcomputation.hpp │ │ │ ├── gcomputation_async.hpp │ │ │ ├── gframe.hpp │ │ │ ├── gkernel.hpp │ │ │ ├── gmat.hpp │ │ │ ├── gmetaarg.hpp │ │ │ ├── gopaque.hpp │ │ │ ├── gproto.hpp │ │ │ ├── gpu │ │ │ │ ├── core.hpp │ │ │ │ ├── ggpukernel.hpp │ │ │ │ └── imgproc.hpp │ │ │ ├── gscalar.hpp │ │ │ ├── gstreaming.hpp │ │ │ ├── gtransform.hpp │ │ │ ├── gtype_traits.hpp │ │ │ ├── gtyped.hpp │ │ │ ├── imgproc.hpp │ │ │ ├── infer.hpp │ │ │ ├── infer │ │ │ │ ├── bindings_ie.hpp │ │ │ │ ├── bindings_onnx.hpp │ │ │ │ ├── bindings_ov.hpp │ │ │ │ ├── ie.hpp │ │ │ │ ├── onnx.hpp │ │ │ │ ├── ov.hpp │ │ │ │ └── parsers.hpp │ │ │ ├── media.hpp │ │ │ ├── oak │ │ │ │ ├── infer.hpp │ │ │ │ └── oak.hpp │ │ │ ├── ocl │ │ │ │ ├── core.hpp │ │ │ │ ├── goclkernel.hpp │ │ │ │ └── imgproc.hpp │ │ │ ├── opencv_includes.hpp │ │ │ ├── operators.hpp │ │ │ ├── ot.hpp │ │ │ ├── own │ │ │ │ ├── assert.hpp │ │ │ │ ├── convert.hpp │ │ │ │ ├── cvdefs.hpp │ │ │ │ ├── exports.hpp │ │ │ │ ├── mat.hpp │ │ │ │ ├── saturate.hpp │ │ │ │ ├── scalar.hpp │ │ │ │ └── types.hpp │ │ │ ├── plaidml │ │ │ │ ├── core.hpp │ │ │ │ ├── gplaidmlkernel.hpp │ │ │ │ └── plaidml.hpp │ │ │ ├── python │ │ │ │ └── python.hpp │ │ │ ├── render.hpp │ │ │ ├── render │ │ │ │ ├── render.hpp │ │ │ │ └── render_types.hpp │ │ │ ├── rmat.hpp │ │ │ ├── s11n.hpp │ │ │ ├── s11n │ │ │ │ └── base.hpp │ │ │ ├── stereo.hpp │ │ │ ├── streaming │ │ │ │ ├── cap.hpp │ │ │ │ ├── desync.hpp │ │ │ │ ├── format.hpp │ │ │ │ ├── gstreamer │ │ │ │ │ ├── gstreamerpipeline.hpp │ │ │ │ │ └── gstreamersource.hpp │ │ │ │ ├── meta.hpp │ │ │ │ ├── onevpl │ │ │ │ │ ├── accel_types.hpp │ │ │ │ │ ├── cfg_params.hpp │ │ │ │ │ ├── data_provider_interface.hpp │ │ │ │ │ ├── default.hpp │ │ │ │ │ ├── device_selector_interface.hpp │ │ │ │ │ └── source.hpp │ │ │ │ ├── queue_source.hpp │ │ │ │ ├── source.hpp │ │ │ │ └── sync.hpp │ │ │ ├── util │ │ │ │ ├── any.hpp │ │ │ │ ├── compiler_hints.hpp │ │ │ │ ├── copy_through_move.hpp │ │ │ │ ├── optional.hpp │ │ │ │ ├── throw.hpp │ │ │ │ ├── type_traits.hpp │ │ │ │ ├── util.hpp │ │ │ │ └── variant.hpp │ │ │ └── video.hpp │ │ ├── hfs.hpp │ │ ├── highgui.hpp │ │ ├── highgui │ │ │ ├── highgui.hpp │ │ │ └── highgui_c.h │ │ ├── img_hash.hpp │ │ ├── img_hash │ │ │ ├── average_hash.hpp │ │ │ ├── block_mean_hash.hpp │ │ │ ├── color_moment_hash.hpp │ │ │ ├── img_hash_base.hpp │ │ │ ├── marr_hildreth_hash.hpp │ │ │ ├── phash.hpp │ │ │ └── radial_variance_hash.hpp │ │ ├── imgcodecs.hpp │ │ ├── imgcodecs │ │ │ ├── imgcodecs.hpp │ │ │ ├── imgcodecs_c.h │ │ │ ├── ios.h │ │ │ ├── legacy │ │ │ │ └── constants_c.h │ │ │ └── macosx.h │ │ ├── imgproc.hpp │ │ ├── imgproc │ │ │ ├── bindings.hpp │ │ │ ├── detail │ │ │ │ ├── gcgraph.hpp │ │ │ │ └── legacy.hpp │ │ │ ├── hal │ │ │ │ ├── hal.hpp │ │ │ │ └── interface.h │ │ │ ├── imgproc.hpp │ │ │ ├── imgproc_c.h │ │ │ ├── segmentation.hpp │ │ │ └── types_c.h │ │ ├── intensity_transform.hpp │ │ ├── line_descriptor.hpp │ │ ├── line_descriptor │ │ │ └── descriptor.hpp │ │ ├── ml.hpp │ │ ├── ml │ │ │ ├── ml.hpp │ │ │ └── ml.inl.hpp │ │ ├── objdetect.hpp │ │ ├── objdetect │ │ │ ├── aruco_board.hpp │ │ │ ├── aruco_detector.hpp │ │ │ ├── aruco_dictionary.hpp │ │ │ ├── barcode.hpp │ │ │ ├── charuco_detector.hpp │ │ │ ├── detection_based_tracker.hpp │ │ │ ├── face.hpp │ │ │ ├── graphical_code_detector.hpp │ │ │ └── objdetect.hpp │ │ ├── opencv.hpp │ │ ├── opencv_modules.hpp │ │ ├── optflow.hpp │ │ ├── optflow │ │ │ ├── motempl.hpp │ │ │ ├── pcaflow.hpp │ │ │ ├── rlofflow.hpp │ │ │ └── sparse_matching_gpc.hpp │ │ ├── phase_unwrapping.hpp │ │ ├── phase_unwrapping │ │ │ ├── histogramphaseunwrapping.hpp │ │ │ └── phase_unwrapping.hpp │ │ ├── photo.hpp │ │ ├── photo │ │ │ ├── cuda.hpp │ │ │ ├── legacy │ │ │ │ └── constants_c.h │ │ │ └── photo.hpp │ │ ├── plot.hpp │ │ ├── quality.hpp │ │ ├── quality │ │ │ ├── quality_utils.hpp │ │ │ ├── qualitybase.hpp │ │ │ ├── qualitybrisque.hpp │ │ │ ├── qualitygmsd.hpp │ │ │ ├── qualitymse.hpp │ │ │ ├── qualitypsnr.hpp │ │ │ └── qualityssim.hpp │ │ ├── rapid.hpp │ │ ├── reg │ │ │ ├── map.hpp │ │ │ ├── mapaffine.hpp │ │ │ ├── mapper.hpp │ │ │ ├── mappergradaffine.hpp │ │ │ ├── mappergradeuclid.hpp │ │ │ ├── mappergradproj.hpp │ │ │ ├── mappergradshift.hpp │ │ │ ├── mappergradsimilar.hpp │ │ │ ├── mapperpyramid.hpp │ │ │ ├── mapprojec.hpp │ │ │ └── mapshift.hpp │ │ ├── rgbd.hpp │ │ ├── rgbd │ │ │ ├── colored_kinfu.hpp │ │ │ ├── depth.hpp │ │ │ ├── detail │ │ │ │ └── pose_graph.hpp │ │ │ ├── dynafu.hpp │ │ │ ├── intrinsics.hpp │ │ │ ├── kinfu.hpp │ │ │ ├── large_kinfu.hpp │ │ │ ├── linemod.hpp │ │ │ └── volume.hpp │ │ ├── saliency.hpp │ │ ├── saliency │ │ │ ├── saliencyBaseClasses.hpp │ │ │ └── saliencySpecializedClasses.hpp │ │ ├── shape.hpp │ │ ├── shape │ │ │ ├── emdL1.hpp │ │ │ ├── hist_cost.hpp │ │ │ ├── shape.hpp │ │ │ ├── shape_distance.hpp │ │ │ └── shape_transformer.hpp │ │ ├── signal.hpp │ │ ├── signal │ │ │ └── signal_resample.hpp │ │ ├── stereo.hpp │ │ ├── stereo │ │ │ ├── descriptor.hpp │ │ │ ├── quasi_dense_stereo.hpp │ │ │ └── stereo.hpp │ │ ├── stitching.hpp │ │ ├── stitching │ │ │ ├── detail │ │ │ │ ├── autocalib.hpp │ │ │ │ ├── blenders.hpp │ │ │ │ ├── camera.hpp │ │ │ │ ├── exposure_compensate.hpp │ │ │ │ ├── matchers.hpp │ │ │ │ ├── motion_estimators.hpp │ │ │ │ ├── seam_finders.hpp │ │ │ │ ├── timelapsers.hpp │ │ │ │ ├── util.hpp │ │ │ │ ├── util_inl.hpp │ │ │ │ ├── warpers.hpp │ │ │ │ └── warpers_inl.hpp │ │ │ └── warpers.hpp │ │ ├── structured_light.hpp │ │ ├── structured_light │ │ │ ├── graycodepattern.hpp │ │ │ ├── sinusoidalpattern.hpp │ │ │ └── structured_light.hpp │ │ ├── superres.hpp │ │ ├── superres │ │ │ └── optical_flow.hpp │ │ ├── surface_matching.hpp │ │ ├── surface_matching │ │ │ ├── icp.hpp │ │ │ ├── pose_3d.hpp │ │ │ ├── ppf_helpers.hpp │ │ │ ├── ppf_match_3d.hpp │ │ │ └── t_hash_int.hpp │ │ ├── tracking.hpp │ │ ├── tracking │ │ │ ├── feature.hpp │ │ │ ├── kalman_filters.hpp │ │ │ ├── onlineBoosting.hpp │ │ │ ├── tldDataset.hpp │ │ │ ├── tracking.hpp │ │ │ ├── tracking_by_matching.hpp │ │ │ ├── tracking_internals.hpp │ │ │ ├── tracking_legacy.hpp │ │ │ └── twist.hpp │ │ ├── video.hpp │ │ ├── video │ │ │ ├── background_segm.hpp │ │ │ ├── detail │ │ │ │ └── tracking.detail.hpp │ │ │ ├── legacy │ │ │ │ └── constants_c.h │ │ │ ├── tracking.hpp │ │ │ └── video.hpp │ │ ├── videoio.hpp │ │ ├── videoio │ │ │ ├── legacy │ │ │ │ └── constants_c.h │ │ │ ├── registry.hpp │ │ │ ├── videoio.hpp │ │ │ └── videoio_c.h │ │ ├── videostab.hpp │ │ ├── videostab │ │ │ ├── deblurring.hpp │ │ │ ├── fast_marching.hpp │ │ │ ├── fast_marching_inl.hpp │ │ │ ├── frame_source.hpp │ │ │ ├── global_motion.hpp │ │ │ ├── inpainting.hpp │ │ │ ├── log.hpp │ │ │ ├── motion_core.hpp │ │ │ ├── motion_stabilizing.hpp │ │ │ ├── optical_flow.hpp │ │ │ ├── outlier_rejection.hpp │ │ │ ├── ring_buffer.hpp │ │ │ ├── stabilizer.hpp │ │ │ └── wobble_suppression.hpp │ │ ├── world.hpp │ │ ├── xfeatures2d.hpp │ │ ├── xfeatures2d │ │ │ ├── cuda.hpp │ │ │ └── nonfree.hpp │ │ ├── ximgproc.hpp │ │ ├── ximgproc │ │ │ ├── brightedges.hpp │ │ │ ├── color_match.hpp │ │ │ ├── deriche_filter.hpp │ │ │ ├── disparity_filter.hpp │ │ │ ├── edge_drawing.hpp │ │ │ ├── edge_filter.hpp │ │ │ ├── edgeboxes.hpp │ │ │ ├── edgepreserving_filter.hpp │ │ │ ├── estimated_covariance.hpp │ │ │ ├── fast_hough_transform.hpp │ │ │ ├── fast_line_detector.hpp │ │ │ ├── find_ellipses.hpp │ │ │ ├── fourier_descriptors.hpp │ │ │ ├── lsc.hpp │ │ │ ├── paillou_filter.hpp │ │ │ ├── peilin.hpp │ │ │ ├── radon_transform.hpp │ │ │ ├── ridgefilter.hpp │ │ │ ├── run_length_morphology.hpp │ │ │ ├── scansegment.hpp │ │ │ ├── seeds.hpp │ │ │ ├── segmentation.hpp │ │ │ ├── slic.hpp │ │ │ ├── sparse_match_interpolator.hpp │ │ │ ├── structured_edge_detection.hpp │ │ │ └── weighted_median_filter.hpp │ │ ├── xobjdetect.hpp │ │ ├── xphoto.hpp │ │ └── xphoto │ │ │ ├── bm3d_image_denoising.hpp │ │ │ ├── dct_image_denoising.hpp │ │ │ ├── inpainting.hpp │ │ │ ├── oilpainting.hpp │ │ │ ├── tonemap.hpp │ │ │ └── white_balance.hpp │ ├── printer.h │ ├── psdsdk.h │ ├── psdsdk │ │ ├── Psd.h │ │ ├── PsdAllocator.h │ │ ├── PsdAlphaChannel.h │ │ ├── PsdAssert.h │ │ ├── PsdBitUtil.h │ │ ├── PsdBlendMode.h │ │ ├── PsdChannel.h │ │ ├── PsdChannelType.h │ │ ├── PsdColorMode.h │ │ ├── PsdColorModeDataSection.h │ │ ├── PsdCompilerMacros.h │ │ ├── PsdCompressionType.h │ │ ├── PsdDecompressRle.h │ │ ├── PsdDocument.h │ │ ├── PsdDocumentation.h │ │ ├── PsdEndianConversion.h │ │ ├── PsdExport.h │ │ ├── PsdExportChannel.h │ │ ├── PsdExportColorMode.h │ │ ├── PsdExportDocument.h │ │ ├── PsdExportLayer.h │ │ ├── PsdExportMetaDataAttribute.h │ │ ├── PsdFile.h │ │ ├── PsdFixedSizeString.h │ │ ├── PsdImageDataSection.h │ │ ├── PsdImageResourceType.h │ │ ├── PsdImageResourcesSection.h │ │ ├── PsdInterleave.h │ │ ├── PsdKey.h │ │ ├── PsdLayer.h │ │ ├── PsdLayerCanvasCopy.h │ │ ├── PsdLayerMask.h │ │ ├── PsdLayerMaskSection.h │ │ ├── PsdLayerType.h │ │ ├── PsdLog.h │ │ ├── PsdMallocAllocator.h │ │ ├── PsdMemoryUtil.h │ │ ├── PsdNamespace.h │ │ ├── PsdNativeFile.h │ │ ├── PsdNativeFile_Linux.h │ │ ├── PsdNativeFile_Mac.h │ │ ├── PsdParseColorModeDataSection.h │ │ ├── PsdParseDocument.h │ │ ├── PsdParseImageDataSection.h │ │ ├── PsdParseImageResourcesSection.h │ │ ├── PsdParseLayerMaskSection.h │ │ ├── PsdPch.h │ │ ├── PsdPlanarImage.h │ │ ├── PsdPlatform.h │ │ ├── PsdSection.h │ │ ├── PsdStringUtil.h │ │ ├── PsdSyncFileReader.h │ │ ├── PsdSyncFileUtil.h │ │ ├── PsdSyncFileWriter.h │ │ ├── PsdThumbnail.h │ │ ├── PsdTypes.h │ │ ├── PsdUnionCast.h │ │ ├── PsdVectorMask.h │ │ ├── Psdinttypes.h │ │ ├── Psdispod.h │ │ ├── Psdisunsigned.h │ │ ├── Psdminiz.h │ │ └── Psdstdint.h │ ├── qoi.h │ ├── stb_image.h │ ├── stb_image_write.h │ ├── stb_truetype.h │ ├── targetver.h │ ├── thorvg.h │ ├── thread_pool.h │ ├── thread_safe_queue.h │ ├── tinyxml2.h │ ├── videoDecoder.h │ ├── x265.h │ ├── x265_config.h │ ├── zconf.h │ └── zlib.h ├── jarkViewer.ico ├── jarkViewer.rc ├── jarkViewer.vcxproj ├── jarkViewer.vcxproj.filters ├── jarkViewer.vcxproj.user ├── lib │ └── Psd_MT.pdb ├── libavcodec │ ├── avcodec.h │ ├── bit_depth_template.h │ ├── bswapdsp.h │ ├── bytestream.h │ ├── cabac.cpp │ ├── cabac.h │ ├── cabac_functions.h │ ├── cabac_tablegen.h │ ├── get_bits.h │ ├── golomb.cpp │ ├── golomb.h │ ├── hevc.cpp │ ├── hevc.h │ ├── hevc_cabac.cpp │ ├── hevc_filter.cpp │ ├── hevc_mvs.cpp │ ├── hevc_ps.cpp │ ├── hevc_refs.cpp │ ├── hevc_sei.cpp │ ├── hevcdsp.cpp │ ├── hevcdsp.h │ ├── hevcdsp_template.h │ ├── hevcpred.cpp │ ├── hevcpred.h │ ├── hevcpred_template.h │ ├── internal.h │ ├── mathops.h │ ├── old_codec_ids.h │ ├── put_bits.h │ ├── rnd_avg.h │ ├── thread.h │ ├── utils.cpp │ ├── version.h │ ├── videodsp.cpp │ ├── videodsp.h │ └── videodsp_template.h ├── libavutil │ ├── adler32.h │ ├── aes.h │ ├── atomic.h │ ├── atomic_gcc.h │ ├── atomic_suncc.h │ ├── atomic_win32.h │ ├── attributes.h │ ├── audio_fifo.h │ ├── audioconvert.h │ ├── avassert.h │ ├── avconfig.h │ ├── avstring.h │ ├── avutil.h │ ├── base64.h │ ├── blowfish.h │ ├── bprint.h │ ├── bswap.h │ ├── buffer.cpp │ ├── buffer.h │ ├── buffer_internal.h │ ├── cast5.h │ ├── channel_layout.h │ ├── colorspace.h │ ├── common.h │ ├── cpu.h │ ├── cpu_internal.h │ ├── crc.h │ ├── des.h │ ├── dict.h │ ├── display.h │ ├── downmix_info.h │ ├── dynarray.h │ ├── error.h │ ├── eval.h │ ├── ffversion.h │ ├── fifo.h │ ├── file.h │ ├── fixed_dsp.h │ ├── float_dsp.h │ ├── frame.cpp │ ├── frame.h │ ├── hash.h │ ├── hmac.h │ ├── imgutils.h │ ├── integer.h │ ├── internal.h │ ├── intfloat.h │ ├── intmath.h │ ├── intreadwrite.h │ ├── lfg.h │ ├── libm.h │ ├── lls.h │ ├── log.h │ ├── log2_tab.cpp │ ├── lzo.h │ ├── macros.h │ ├── mathematics.h │ ├── md5.cpp │ ├── md5.h │ ├── mem.cpp │ ├── mem.h │ ├── motion_vector.h │ ├── murmur3.h │ ├── old_pix_fmts.h │ ├── opencl.h │ ├── opencl_internal.h │ ├── opt.h │ ├── parseutils.h │ ├── pca.h │ ├── pixdesc.cpp │ ├── pixdesc.h │ ├── pixelutils.h │ ├── pixfmt.h │ ├── qsort.h │ ├── random_seed.h │ ├── rational.h │ ├── rc4.h │ ├── replaygain.h │ ├── ripemd.h │ ├── samplefmt.h │ ├── sha.h │ ├── sha512.h │ ├── softfloat.h │ ├── stereo3d.h │ ├── threadmessage.h │ ├── time_avutil.h │ ├── time_internal.h │ ├── timecode.h │ ├── timer.h │ ├── timestamp.h │ ├── tree.h │ ├── version.h │ ├── x86_cpu.h │ ├── xga_font_data.h │ └── xtea.h ├── resource.h ├── small.ico └── src │ ├── D2D1App.cpp │ ├── ImageDatabase.cpp │ ├── TextDrawer.cpp │ ├── cpp.hint │ ├── exifParse.cpp │ ├── jarkUtils.cpp │ ├── jarkViewer.cpp │ ├── libbpg.cpp │ └── tinyxml2.cpp ├── preview.png └── printerPreview.png /.gitignore: -------------------------------------------------------------------------------- 1 | .vs 2 | x64 3 | /jarkViewer/jarkViewer.aps 4 | /jarkViewer/file/home.psd 5 | /jarkViewer/file/tips.psd 6 | /associate_images.bat 7 | /associate_images_uninstall.bat 8 | /donate.png 9 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 JARK006 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /SocialPreview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/SocialPreview.png -------------------------------------------------------------------------------- /ico.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/ico.ico -------------------------------------------------------------------------------- /ico.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/ico.png -------------------------------------------------------------------------------- /ico.psd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/ico.psd -------------------------------------------------------------------------------- /jarkViewer.slnx: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /jarkViewer/.gitignore: -------------------------------------------------------------------------------- 1 | *.aps 2 | x64 3 | lib/*.lib 4 | libopencv/*.lib 5 | libexiv2/*.lib 6 | libpng/*.lib 7 | libwebp2/*.lib 8 | libavif/*.lib 9 | libjxl/*.lib 10 | -------------------------------------------------------------------------------- /jarkViewer/file/MSYHMONO.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/file/MSYHMONO.ttf -------------------------------------------------------------------------------- /jarkViewer/file/home.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/file/home.png -------------------------------------------------------------------------------- /jarkViewer/file/mainRes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/file/mainRes.png -------------------------------------------------------------------------------- /jarkViewer/file/printerRes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/file/printerRes.png -------------------------------------------------------------------------------- /jarkViewer/file/settingRes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/file/settingRes.png -------------------------------------------------------------------------------- /jarkViewer/file/tips.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/file/tips.png -------------------------------------------------------------------------------- /jarkViewer/include/TextDrawer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "jarkUtils.h" 3 | 4 | // https://github.com/nothings/stb 5 | // 整个工程只能一个源文件定义 STB_TRUETYPE_IMPLEMENTATION， 其他地方只需include 6 | #include "stb_truetype.h" 7 | 8 | 9 | class TextDrawer { 10 | public: 11 | const uint32_t IDR_TTF_DEFAULT = IDR_MSYHMONO_TTF; 12 | std::vector> asciiCache; 13 | 14 | TextDrawer() {} 15 | ~TextDrawer() {} 16 | 17 | void setLineGap(float percent); 18 | void setSize(int newSize); 19 | 20 | // str : UTF-8 21 | void putText(cv::Mat& img, const int x, const int y, const char* str, const cv::Vec4b& color); 22 | 23 | //Rect {x, y, width, height} 24 | void putAlignCenter(cv::Mat& img, cv::Rect rect, const char* str, const cv::Vec4b& color); 25 | 26 | //Rect {x, y, width, height} 27 | void putAlignLeft(cv::Mat& img, cv::Rect rect, const char* str, const cv::Vec4b& color); 28 | 29 | private: 30 | bool hasInit = false; 31 | float scale = 0; 32 | float lineGapPercent = 0.1f; 33 | stbtt_fontinfo info{}; 34 | 35 | int fontSize = 16; 36 | 37 | vector wordBuff; 38 | vector fontFileBuffer; 39 | 40 | rcFileInfo rc; 41 | 42 | void Init(unsigned int idi, const wchar_t* type); 43 | int putWord(cv::Mat& img, int x, int y, const int codePoint, const cv::Vec4b& color); 44 | }; -------------------------------------------------------------------------------- /jarkViewer/include/avif/avif_cxx.h: -------------------------------------------------------------------------------- 1 | // Copyright 2023 Google LLC 2 | // SPDX-License-Identifier: BSD-2-Clause 3 | 4 | #ifndef AVIF_AVIF_CXX_H 5 | #define AVIF_AVIF_CXX_H 6 | 7 | #if !defined(__cplusplus) 8 | #error "This a C++ only header. Use avif/avif.h for C." 9 | #endif 10 | 11 | #include 12 | 13 | #include "avif/avif.h" 14 | 15 | namespace avif 16 | { 17 | 18 | // Struct to call the destroy functions in a unique_ptr. 19 | struct UniquePtrDeleter 20 | { 21 | void operator()(avifEncoder * encoder) const { avifEncoderDestroy(encoder); } 22 | void operator()(avifDecoder * decoder) const { avifDecoderDestroy(decoder); } 23 | void operator()(avifImage * image) const { avifImageDestroy(image); } 24 | void operator()(avifGainMap * gainMap) const { avifGainMapDestroy(gainMap); } 25 | }; 26 | 27 | // Use these unique_ptr to ensure the structs are automatically destroyed. 28 | using EncoderPtr = std::unique_ptr; 29 | using DecoderPtr = std::unique_ptr; 30 | using ImagePtr = std::unique_ptr; 31 | using GainMapPtr = std::unique_ptr; 32 | 33 | } // namespace avif 34 | 35 | #endif // AVIF_AVIF_CXX_H 36 | -------------------------------------------------------------------------------- /jarkViewer/include/exiv2/config.h: -------------------------------------------------------------------------------- 1 | // config.h 2 | 3 | #ifndef _CONFIG_H_ 4 | #define _CONFIG_H_ 5 | 6 | ///// Start of Visual Studio Support ///// 7 | #ifdef _MSC_VER 8 | 9 | #pragma warning(disable : 4996) // Disable warnings about 'deprecated' standard functions 10 | #pragma warning(disable : 4251) // Disable warnings from std templates about exporting interfaces 11 | 12 | #endif // _MSC_VER 13 | ///// End of Visual Studio Support ///// 14 | 15 | #include "exv_conf.h" 16 | //////////////////////////////////////// 17 | 18 | ///// Start of platform macros ///////// 19 | #if defined(__MINGW32__) || defined(__MINGW64__) 20 | #ifndef __MING__ 21 | #define __MING__ 1 22 | #endif 23 | #ifndef __MINGW__ 24 | #define __MINGW__ 1 25 | #endif 26 | #endif 27 | 28 | #ifndef __CYGWIN__ 29 | #if defined(__CYGWIN32__) || defined(__CYGWIN64__) 30 | #define __CYGWIN__ 1 31 | #endif 32 | #endif 33 | 34 | #ifndef __LITTLE_ENDIAN__ 35 | #if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) 36 | #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 37 | #define __LITTLE_ENDIAN__ 1 38 | #endif 39 | #endif 40 | #endif 41 | 42 | #ifndef __LITTLE_ENDIAN__ 43 | #if defined(_WIN32) || defined(__CYGWIN__) 44 | #define __LITTLE_ENDIAN__ 1 45 | #endif 46 | #endif 47 | 48 | /* 49 | If you're using Solaris and the Solaris Studio compiler 50 | you must -library=stdcxx4 along with these inclusions below 51 | */ 52 | #if defined(OS_SOLARIS) 53 | #include 54 | #include 55 | #include 56 | #if defined(__cplusplus) 57 | #include 58 | #include 59 | #endif 60 | #endif 61 | ///// End of platform macros ///////// 62 | 63 | ///// Path separator macros ///// 64 | #ifndef EXV_SEPARATOR_STR 65 | #if defined(_WIN32) 66 | #define EXV_SEPARATOR_STR "\\" 67 | #define EXV_SEPARATOR_CHR '\\' 68 | #else 69 | #define EXV_SEPARATOR_STR "/" 70 | #define EXV_SEPARATOR_CHR '/' 71 | #endif 72 | #endif 73 | ////////////////////////////////////// 74 | 75 | #endif // _CONFIG_H_ 76 | -------------------------------------------------------------------------------- /jarkViewer/include/exiv2/exiv2.hpp: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-2.0-or-later 2 | 3 | #ifndef EXIV2_HPP_ 4 | #define EXIV2_HPP_ 5 | 6 | // ***************************************************************************** 7 | // included header files 8 | #include "exiv2/basicio.hpp" 9 | #include "exiv2/bmffimage.hpp" 10 | #include "exiv2/bmpimage.hpp" 11 | #include "exiv2/config.h" 12 | #include "exiv2/convert.hpp" 13 | #include "exiv2/cr2image.hpp" 14 | #include "exiv2/crwimage.hpp" 15 | #include "exiv2/datasets.hpp" 16 | #include "exiv2/easyaccess.hpp" 17 | #include "exiv2/epsimage.hpp" 18 | #include "exiv2/error.hpp" 19 | #include "exiv2/exif.hpp" 20 | #include "exiv2/futils.hpp" 21 | #include "exiv2/gifimage.hpp" 22 | #ifdef EXV_ENABLE_WEBREADY 23 | #include "exiv2/http.hpp" 24 | #endif 25 | #include "exiv2/image.hpp" 26 | #include "exiv2/iptc.hpp" 27 | #include "exiv2/jp2image.hpp" 28 | #include "exiv2/jpgimage.hpp" 29 | #include "exiv2/metadatum.hpp" 30 | #include "exiv2/mrwimage.hpp" 31 | #include "exiv2/orfimage.hpp" 32 | #include "exiv2/pgfimage.hpp" 33 | #include "exiv2/photoshop.hpp" 34 | 35 | #ifdef EXV_HAVE_LIBZ 36 | #include "exiv2/pngimage.hpp" 37 | #endif 38 | 39 | #include "exiv2/preview.hpp" 40 | #include "exiv2/properties.hpp" 41 | #include "exiv2/psdimage.hpp" 42 | #include "exiv2/rafimage.hpp" 43 | #include "exiv2/rw2image.hpp" 44 | 45 | #include "exiv2/tags.hpp" 46 | #include "exiv2/tgaimage.hpp" 47 | #include "exiv2/tiffimage.hpp" 48 | #include "exiv2/types.hpp" 49 | #include "exiv2/value.hpp" 50 | #include "exiv2/version.hpp" 51 | #include "exiv2/xmp_exiv2.hpp" 52 | #include "exiv2/xmpsidecar.hpp" 53 | 54 | #endif // ifndef EXIV2_HPP_ 55 | -------------------------------------------------------------------------------- /jarkViewer/include/exiv2/exiv2lib_export.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef EXIV2API_H 3 | #define EXIV2API_H 4 | 5 | #ifdef exiv2lib_STATIC 6 | # define EXIV2API 7 | # define EXIV2LIB_NO_EXPORT 8 | #else 9 | # ifndef EXIV2API 10 | # ifdef exiv2lib_EXPORTS 11 | /* We are building this library */ 12 | # define EXIV2API 13 | # else 14 | /* We are using this library */ 15 | # define EXIV2API 16 | # endif 17 | # endif 18 | 19 | # ifndef EXIV2LIB_NO_EXPORT 20 | # define EXIV2LIB_NO_EXPORT 21 | # endif 22 | #endif 23 | 24 | #ifndef EXIV2LIB_DEPRECATED 25 | # define EXIV2LIB_DEPRECATED __declspec(deprecated) 26 | #endif 27 | 28 | #ifndef EXIV2LIB_DEPRECATED_EXPORT 29 | # define EXIV2LIB_DEPRECATED_EXPORT EXIV2API EXIV2LIB_DEPRECATED 30 | #endif 31 | 32 | #ifndef EXIV2LIB_DEPRECATED_NO_EXPORT 33 | # define EXIV2LIB_DEPRECATED_NO_EXPORT EXIV2LIB_NO_EXPORT EXIV2LIB_DEPRECATED 34 | #endif 35 | 36 | /* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */ 37 | #if 0 /* DEFINE_NO_DEPRECATED */ 38 | # ifndef EXIV2LIB_NO_DEPRECATED 39 | # define EXIV2LIB_NO_DEPRECATED 40 | # endif 41 | #endif 42 | 43 | #endif /* EXIV2API_H */ 44 | -------------------------------------------------------------------------------- /jarkViewer/include/exiv2/image_types.hpp: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-2.0-or-later 2 | 3 | #ifndef IMAGE_TYPES_H 4 | #define IMAGE_TYPES_H 5 | 6 | namespace Exiv2 { 7 | /// Supported Image Formats 8 | enum class ImageType { 9 | none, 10 | arw, 11 | asf, 12 | bigtiff, 13 | bmff, 14 | bmp, ///< Windows bitmap 15 | cr2, 16 | crw, 17 | dng, 18 | eps, 19 | exv, 20 | gif, ///< GIF 21 | jp2, ///< JPEG-2000 22 | jpeg, 23 | mrw, 24 | nef, 25 | orf, 26 | pef, 27 | png, 28 | pgf, 29 | psd, ///< Photoshop (PSD) 30 | raf, 31 | rw2, 32 | sr2, 33 | srw, 34 | tga, 35 | tiff, 36 | webp, 37 | xmp, ///< XMP sidecar files 38 | qtime, 39 | riff, 40 | mkv, 41 | }; 42 | } // namespace Exiv2 43 | 44 | #endif // IMAGE_TYPES_H 45 | -------------------------------------------------------------------------------- /jarkViewer/include/framework.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "targetver.h" 4 | #define WIN32_LEAN_AND_MEAN // 从 Windows 头文件中排除极少使用的内容 5 | // Windows 头文件 6 | #include 7 | // C 运行时头文件 8 | #include 9 | #include 10 | #include 11 | #include 12 | -------------------------------------------------------------------------------- /jarkViewer/include/jxl/cms.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) the JPEG XL Project Authors. All rights reserved. 2 | // 3 | // Use of this source code is governed by a BSD-style 4 | // license that can be found in the LICENSE file. 5 | 6 | #ifndef JXL_CMS_H_ 7 | #define JXL_CMS_H_ 8 | 9 | // ICC profiles and color space conversions. 10 | 11 | #include 12 | #include 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | JXL_CMS_EXPORT const JxlCmsInterface* JxlGetDefaultCms(); 19 | 20 | #ifdef __cplusplus 21 | } 22 | #endif 23 | 24 | #endif // JXL_CMS_H_ 25 | -------------------------------------------------------------------------------- /jarkViewer/include/jxl/jxl_cms_export.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef JXL_CMS_EXPORT_H 3 | #define JXL_CMS_EXPORT_H 4 | 5 | #ifdef JXL_CMS_STATIC_DEFINE 6 | # define JXL_CMS_EXPORT 7 | # define JXL_CMS_NO_EXPORT 8 | #else 9 | # ifndef JXL_CMS_EXPORT 10 | # ifdef jxl_cms_EXPORTS 11 | /* We are building this library */ 12 | # define JXL_CMS_EXPORT 13 | # else 14 | /* We are using this library */ 15 | # define JXL_CMS_EXPORT 16 | # endif 17 | # endif 18 | 19 | # ifndef JXL_CMS_NO_EXPORT 20 | # define JXL_CMS_NO_EXPORT 21 | # endif 22 | #endif 23 | 24 | #ifndef JXL_CMS_DEPRECATED 25 | # define JXL_CMS_DEPRECATED __declspec(deprecated) 26 | #endif 27 | 28 | #ifndef JXL_CMS_DEPRECATED_EXPORT 29 | # define JXL_CMS_DEPRECATED_EXPORT JXL_CMS_EXPORT JXL_CMS_DEPRECATED 30 | #endif 31 | 32 | #ifndef JXL_CMS_DEPRECATED_NO_EXPORT 33 | # define JXL_CMS_DEPRECATED_NO_EXPORT JXL_CMS_NO_EXPORT JXL_CMS_DEPRECATED 34 | #endif 35 | 36 | /* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */ 37 | #if 0 /* DEFINE_NO_DEPRECATED */ 38 | # ifndef JXL_CMS_NO_DEPRECATED 39 | # define JXL_CMS_NO_DEPRECATED 40 | # endif 41 | #endif 42 | 43 | #endif /* JXL_CMS_EXPORT_H */ 44 | -------------------------------------------------------------------------------- /jarkViewer/include/jxl/jxl_export.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef JXL_EXPORT_H 3 | #define JXL_EXPORT_H 4 | 5 | #if 1 6 | # define JXL_EXPORT 7 | # define JXL_NO_EXPORT 8 | #else 9 | # ifndef JXL_EXPORT 10 | # ifdef JXL_INTERNAL_LIBRARY_BUILD 11 | /* We are building this library */ 12 | # define JXL_EXPORT __declspec(dllexport) 13 | # else 14 | /* We are using this library */ 15 | # define JXL_EXPORT __declspec(dllimport) 16 | # endif 17 | # endif 18 | 19 | # ifndef JXL_NO_EXPORT 20 | # define JXL_NO_EXPORT 21 | # endif 22 | #endif 23 | 24 | #ifndef JXL_DEPRECATED 25 | # define JXL_DEPRECATED __declspec(deprecated) 26 | #endif 27 | 28 | #ifndef JXL_DEPRECATED_EXPORT 29 | # define JXL_DEPRECATED_EXPORT JXL_EXPORT JXL_DEPRECATED 30 | #endif 31 | 32 | #ifndef JXL_DEPRECATED_NO_EXPORT 33 | # define JXL_DEPRECATED_NO_EXPORT JXL_NO_EXPORT JXL_DEPRECATED 34 | #endif 35 | 36 | /* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */ 37 | #if 0 /* DEFINE_NO_DEPRECATED */ 38 | # ifndef JXL_NO_DEPRECATED 39 | # define JXL_NO_DEPRECATED 40 | # endif 41 | #endif 42 | 43 | #endif /* JXL_EXPORT_H */ 44 | -------------------------------------------------------------------------------- /jarkViewer/include/jxl/jxl_threads_export.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef JXL_THREADS_EXPORT_H 3 | #define JXL_THREADS_EXPORT_H 4 | 5 | #ifdef JXL_THREADS_STATIC_DEFINE 6 | # define JXL_THREADS_EXPORT 7 | # define JXL_THREADS_NO_EXPORT 8 | #else 9 | # ifndef JXL_THREADS_EXPORT 10 | # ifdef JXL_THREADS_INTERNAL_LIBRARY_BUILD 11 | /* We are building this library */ 12 | # define JXL_THREADS_EXPORT 13 | # else 14 | /* We are using this library */ 15 | # define JXL_THREADS_EXPORT 16 | # endif 17 | # endif 18 | 19 | # ifndef JXL_THREADS_NO_EXPORT 20 | # define JXL_THREADS_NO_EXPORT 21 | # endif 22 | #endif 23 | 24 | #ifndef JXL_THREADS_DEPRECATED 25 | # define JXL_THREADS_DEPRECATED __declspec(deprecated) 26 | #endif 27 | 28 | #ifndef JXL_THREADS_DEPRECATED_EXPORT 29 | # define JXL_THREADS_DEPRECATED_EXPORT JXL_THREADS_EXPORT JXL_THREADS_DEPRECATED 30 | #endif 31 | 32 | #ifndef JXL_THREADS_DEPRECATED_NO_EXPORT 33 | # define JXL_THREADS_DEPRECATED_NO_EXPORT JXL_THREADS_NO_EXPORT JXL_THREADS_DEPRECATED 34 | #endif 35 | 36 | /* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */ 37 | #if 0 /* DEFINE_NO_DEPRECATED */ 38 | # ifndef JXL_THREADS_NO_DEPRECATED 39 | # define JXL_THREADS_NO_DEPRECATED 40 | # endif 41 | #endif 42 | 43 | #endif /* JXL_THREADS_EXPORT_H */ 44 | -------------------------------------------------------------------------------- /jarkViewer/include/jxl/version.h: -------------------------------------------------------------------------------- 1 | /* Copyright (c) the JPEG XL Project Authors. All rights reserved. 2 | * 3 | * Use of this source code is governed by a BSD-style 4 | * license that can be found in the LICENSE file. 5 | */ 6 | 7 | /** @addtogroup libjxl_common 8 | * @{ 9 | * @file version.h 10 | * @brief libjxl version information 11 | */ 12 | 13 | #ifndef JXL_VERSION_H_ 14 | #define JXL_VERSION_H_ 15 | 16 | #define JPEGXL_MAJOR_VERSION 0 ///< JPEG XL Major version 17 | #define JPEGXL_MINOR_VERSION 11 ///< JPEG XL Minor version 18 | #define JPEGXL_PATCH_VERSION 1 ///< JPEG XL Patch version 19 | 20 | /** Can be used to conditionally compile code for a specific JXL version 21 | * @param[maj] major version 22 | * @param[min] minor version 23 | * 24 | * @code 25 | * #if JPEGXL_NUMERIC_VERSION < JPEGXL_COMPUTE_NUMERIC_VERSION(0,8,0) 26 | * // use old/deprecated api 27 | * #else 28 | * // use current api 29 | * #endif 30 | * @endcode 31 | */ 32 | #define JPEGXL_COMPUTE_NUMERIC_VERSION(major,minor,patch) (((major)<<24) | ((minor)<<16) | ((patch)<<8) | 0) 33 | 34 | /* Numeric representation of the version */ 35 | #define JPEGXL_NUMERIC_VERSION JPEGXL_COMPUTE_NUMERIC_VERSION(JPEGXL_MAJOR_VERSION, JPEGXL_MINOR_VERSION, JPEGXL_PATCH_VERSION) 36 | 37 | #endif /* JXL_VERSION_H_ */ 38 | 39 | /** @}*/ 40 | -------------------------------------------------------------------------------- /jarkViewer/include/libde265/de265-version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * H.265 video codec. 3 | * Copyright (c) 2013-2014 struktur AG, Dirk Farin 4 | * 5 | * This file is part of libde265. 6 | * 7 | * libde265 is free software: you can redistribute it and/or modify 8 | * it under the terms of the GNU Lesser General Public License as 9 | * published by the Free Software Foundation, either version 3 of 10 | * the License, or (at your option) any later version. 11 | * 12 | * libde265 is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | * GNU Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public License 18 | * along with libde265. If not, see . 19 | */ 20 | 21 | /* de265-version.h 22 | * 23 | * This file was generated by autoconf when libde265 was built. 24 | * 25 | * DO NOT EDIT THIS FILE. 26 | */ 27 | #ifndef LIBDE265_VERSION_H 28 | #define LIBDE265_VERSION_H 29 | 30 | /* Numeric representation of the version */ 31 | #define LIBDE265_NUMERIC_VERSION 0x01001500 32 | 33 | /* Version string */ 34 | #define LIBDE265_VERSION "1.0.15" 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /jarkViewer/include/libheif/heif.h: -------------------------------------------------------------------------------- 1 | /* 2 | * HEIF codec. 3 | * Copyright (c) 2017-2025 Dirk Farin 4 | * 5 | * This file is part of libheif. 6 | * 7 | * libheif is free software: you can redistribute it and/or modify 8 | * it under the terms of the GNU Lesser General Public License as 9 | * published by the Free Software Foundation, either version 3 of 10 | * the License, or (at your option) any later version. 11 | * 12 | * libheif is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | * GNU Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public License 18 | * along with libheif. If not, see . 19 | */ 20 | 21 | #ifndef LIBHEIF_HEIF_H 22 | #define LIBHEIF_HEIF_H 23 | 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | #include 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /jarkViewer/include/libheif/heif_version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * HEIF codec. 3 | * Copyright (c) 2017 Dirk Farin 4 | * 5 | * This file is part of libheif. 6 | * 7 | * libheif is free software: you can redistribute it and/or modify 8 | * it under the terms of the GNU Lesser General Public License as 9 | * published by the Free Software Foundation, either version 3 of 10 | * the License, or (at your option) any later version. 11 | * 12 | * libheif is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | * GNU Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public License 18 | * along with libheif. If not, see . 19 | */ 20 | 21 | /* heif_version.h 22 | * 23 | * This file was automatically generated when libheif was built. 24 | * 25 | * DO NOT EDIT THIS FILE. 26 | */ 27 | #ifndef LIBHEIF_HEIF_VERSION_H 28 | #define LIBHEIF_HEIF_VERSION_H 29 | 30 | /* Numeric representation of the version */ 31 | #define LIBHEIF_NUMERIC_VERSION ((1<<24) | (20<<16) | (1<<8) | 0) 32 | 33 | /* Version string */ 34 | #define LIBHEIF_VERSION "1.20.1" 35 | 36 | #define LIBHEIF_PLUGIN_DIRECTORY "" 37 | 38 | #endif // LIBHEIF_HEIF_VERSION_H 39 | -------------------------------------------------------------------------------- /jarkViewer/include/libraw/libraw_config.h: -------------------------------------------------------------------------------- 1 | /* -*- C++ -*- 2 | * File: libraw_version.h 3 | * Copyright 2008-2013 LibRaw LLC (info@libraw.org) 4 | * Created: Mon Sept 8, 2008 5 | * 6 | * LibRaw C++ interface 7 | * 8 | 9 | LibRaw is free software; you can redistribute it and/or modify 10 | it under the terms of the one of two licenses as you choose: 11 | 12 | 1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1 13 | (See the file LICENSE.LGPL provided in LibRaw distribution archive for details). 14 | 15 | 2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0 16 | (See the file LICENSE.CDDL provided in LibRaw distribution archive for details). 17 | 18 | */ 19 | 20 | #ifndef __LIBRAW_CONFIG_H 21 | #define __LIBRAW_CONFIG_H 22 | 23 | /* Define to 1 if LibRaw have been compiled with DNG deflate codec support */ 24 | #define LIBRAW_USE_DNGDEFLATECODEC 1 25 | 26 | /* Define to 1 if LibRaw have been compiled with DNG lossy codec support */ 27 | #define LIBRAW_USE_DNGLOSSYCODEC 1 28 | 29 | /* Define to 1 if LibRaw have been compiled with OpenMP support */ 30 | /* #undef LIBRAW_USE_OPENMP */ 31 | 32 | /* Define to 1 if LibRaw have been compiled with LCMS support */ 33 | #define LIBRAW_USE_LCMS 1 34 | 35 | /* Define to 1 if LibRaw have been compiled with RedCine codec support */ 36 | #define LIBRAW_USE_REDCINECODEC 1 37 | 38 | /* Define to 1 if LibRaw have been compiled with RawSpeed codec support */ 39 | /* #undef LIBRAW_USE_RAWSPEED */ 40 | 41 | /* Define to 1 if LibRaw have been compiled with debug message from dcraw */ 42 | /* #undef LIBRAW_USE_DCRAW_DEBUG */ 43 | 44 | /* Define to 1 if LibRaw have been compiled with Foveon X3F support */ 45 | /* #undef LIBRAW_USE_X3FTOOLS */ 46 | 47 | /* Define to 1 if LibRaw have been compiled with Raspberry Pi RAW support */ 48 | /* #undef LIBRAW_USE_6BY9RPI */ 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /jarkViewer/include/libwebp2/src/common/lossy/transforms.h: -------------------------------------------------------------------------------- 1 | // Copyright 2019 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // https://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | // ----------------------------------------------------------------------------- 15 | // 16 | // Transforms 17 | // 18 | #ifndef WP2_COMMON_LOSSY_TRANSFORMS_H_ 19 | #define WP2_COMMON_LOSSY_TRANSFORMS_H_ 20 | 21 | #include "src/dsp/dsp.h" 22 | 23 | namespace WP2 { 24 | 25 | // Transform pair for horizontal and vertical directions. 26 | enum TransformPair { 27 | kDctDct = 0, 28 | kAdstAdst, 29 | kDctAdst, 30 | kAdstDct, 31 | kIdentityDct, 32 | kDctIdentity, 33 | kIdentityIdentity, 34 | kNumTransformPairs, 35 | kUnknownTf = kNumTransformPairs // Transform cannot be deduced, signal it. 36 | }; 37 | 38 | // Transform for vertical and horizontal axes corresponding to each transform 39 | // pair. 40 | extern const WP2TransformType kTfX[kNumTransformPairs]; 41 | extern const WP2TransformType kTfY[kNumTransformPairs]; 42 | 43 | enum class TransformClass { kTwoD, kHorizontal, kVertical }; 44 | 45 | // Returns the class corresponding to the given transform. 46 | TransformClass GetTransformClass(TransformPair transform); 47 | 48 | } // namespace WP2 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /jarkViewer/include/libwebp2/src/dec/preview/preview_dec.h: -------------------------------------------------------------------------------- 1 | // Copyright 2019 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // https://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | // ----------------------------------------------------------------------------- 15 | // 16 | // Preview decoder 17 | // 18 | // Author: Yannis Guyon (yguyon@google.com) 19 | 20 | #ifndef WP2_DEC_PREVIEW_PREVIEW_DEC_H_ 21 | #define WP2_DEC_PREVIEW_PREVIEW_DEC_H_ 22 | 23 | #include 24 | 25 | #include "src/wp2/base.h" 26 | 27 | namespace WP2 { 28 | 29 | //------------------------------------------------------------------------------ 30 | 31 | // Decompresses the preview from 'data' and draws it to the 'output_buffer' 32 | // which must be previously allocated to the desired dimensions. 33 | WP2Status DecodePreview(const uint8_t* data, uint32_t data_size, 34 | ArgbBuffer* output_buffer); 35 | 36 | //------------------------------------------------------------------------------ 37 | 38 | } // namespace WP2 39 | 40 | #endif // WP2_DEC_PREVIEW_PREVIEW_DEC_H_ 41 | -------------------------------------------------------------------------------- /jarkViewer/include/libwebp2/src/enc/screen_content/screen_enc.h: -------------------------------------------------------------------------------- 1 | // Copyright 2020 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // https://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | // ----------------------------------------------------------------------------- 15 | // 16 | // Screen content encoding (e.g. screenshots) 17 | // 18 | // Author: Maryla (maryla@google.com) 19 | 20 | #ifndef WP2_ENC_ANIM_SCREEN_ENC_H_ 21 | #define WP2_ENC_ANIM_SCREEN_ENC_H_ 22 | 23 | #include "src/common/global_params.h" 24 | #include "src/enc/anim/anim_enc.h" 25 | #include "src/utils/plane.h" 26 | #include "src/utils/vector.h" 27 | #include "src/wp2/base.h" 28 | #include "src/wp2/encode.h" 29 | #include "src/wp2/format_constants.h" 30 | 31 | namespace WP2 { 32 | 33 | //------------------------------------------------------------------------------ 34 | 35 | // Encodes screen content as a mix of lossy and lossless, using a 0 second 36 | // animation with 2 frames. SLOW! 37 | WP2Status EncodeScreenContent( 38 | const ArgbBuffer& input, Writer* const output, 39 | const EncoderConfig& config = EncoderConfig::kDefault); 40 | 41 | // Visible for testing. 42 | WP2Status EncodeScreenContent( 43 | const ArgbBuffer& input, const Plane& is_lossy, uint32_t block_size, 44 | Writer* const output, 45 | const EncoderConfig& config = EncoderConfig::kDefault); 46 | 47 | //------------------------------------------------------------------------------ 48 | 49 | } // namespace WP2 50 | 51 | #endif // WP2_ENC_ANIM_SCREEN_ENC_H_ 52 | -------------------------------------------------------------------------------- /jarkViewer/include/libwebp2/src/utils/data_source_context.h: -------------------------------------------------------------------------------- 1 | // Copyright 2019 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // https://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | // ----------------------------------------------------------------------------- 15 | // 16 | // SuspendableDataSource definition. 17 | // 18 | // Author: Yannis Guyon (yguyon@google.com) 19 | 20 | #ifndef WP2_UTILS_DATA_SOURCE_CONTEXT_H_ 21 | #define WP2_UTILS_DATA_SOURCE_CONTEXT_H_ 22 | 23 | #include 24 | 25 | #include "src/utils/context_switch.h" 26 | #include "src/utils/data_source.h" 27 | 28 | #if defined(WP2_USE_CONTEXT_SWITCH) && (WP2_USE_CONTEXT_SWITCH > 0) 29 | 30 | namespace WP2 { 31 | 32 | // Data source that will suspend and wait for resuming when Fetch() is called 33 | // (occurs when TryGetNext() is missing data), if a LocalContext is set. 34 | class SuspendableDataSource : public ExternalDataSource { 35 | public: 36 | void SetContext(LocalContext* context); 37 | bool HasEnoughDataToResume() const; 38 | 39 | void Reset() override; 40 | 41 | private: 42 | bool Fetch(size_t num_requested_bytes) override; 43 | 44 | LocalContext* context_ = nullptr; 45 | size_t num_requested_bytes_ = 0; 46 | }; 47 | 48 | } // namespace WP2 49 | 50 | #endif // WP2_USE_CONTEXT_SWITCH 51 | 52 | #endif /* WP2_UTILS_DATA_SOURCE_CONTEXT_H_ */ 53 | -------------------------------------------------------------------------------- /jarkViewer/include/libyuv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2011 The LibYuv Project Authors. All rights reserved. 3 | * 4 | * Use of this source code is governed by a BSD-style license 5 | * that can be found in the LICENSE file in the root of the source 6 | * tree. An additional intellectual property rights grant can be found 7 | * in the file PATENTS. All contributing project authors may 8 | * be found in the AUTHORS file in the root of the source tree. 9 | */ 10 | 11 | #ifndef INCLUDE_LIBYUV_H_ 12 | #define INCLUDE_LIBYUV_H_ 13 | 14 | #include "libyuv/basic_types.h" 15 | #include "libyuv/compare.h" 16 | #include "libyuv/convert.h" 17 | #include "libyuv/convert_argb.h" 18 | #include "libyuv/convert_from.h" 19 | #include "libyuv/convert_from_argb.h" 20 | #include "libyuv/cpu_id.h" 21 | #include "libyuv/mjpeg_decoder.h" 22 | #include "libyuv/planar_functions.h" 23 | #include "libyuv/rotate.h" 24 | #include "libyuv/rotate_argb.h" 25 | #include "libyuv/row.h" 26 | #include "libyuv/scale.h" 27 | #include "libyuv/scale_argb.h" 28 | #include "libyuv/scale_row.h" 29 | #include "libyuv/scale_uv.h" 30 | #include "libyuv/version.h" 31 | #include "libyuv/video_common.h" 32 | 33 | #endif // INCLUDE_LIBYUV_H_ 34 | -------------------------------------------------------------------------------- /jarkViewer/include/libyuv/rotate_argb.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The LibYuv Project Authors. All rights reserved. 3 | * 4 | * Use of this source code is governed by a BSD-style license 5 | * that can be found in the LICENSE file in the root of the source 6 | * tree. An additional intellectual property rights grant can be found 7 | * in the file PATENTS. All contributing project authors may 8 | * be found in the AUTHORS file in the root of the source tree. 9 | */ 10 | 11 | #ifndef INCLUDE_LIBYUV_ROTATE_ARGB_H_ 12 | #define INCLUDE_LIBYUV_ROTATE_ARGB_H_ 13 | 14 | #include "libyuv/basic_types.h" 15 | #include "libyuv/rotate.h" // For RotationMode. 16 | 17 | #ifdef __cplusplus 18 | namespace libyuv { 19 | extern "C" { 20 | #endif 21 | 22 | // Rotate ARGB frame 23 | LIBYUV_API 24 | int ARGBRotate(const uint8_t* src_argb, 25 | int src_stride_argb, 26 | uint8_t* dst_argb, 27 | int dst_stride_argb, 28 | int src_width, 29 | int src_height, 30 | enum RotationMode mode); 31 | 32 | #ifdef __cplusplus 33 | } // extern "C" 34 | } // namespace libyuv 35 | #endif 36 | 37 | #endif // INCLUDE_LIBYUV_ROTATE_ARGB_H_ 38 | -------------------------------------------------------------------------------- /jarkViewer/include/libyuv/scale_rgb.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2022 The LibYuv Project Authors. All rights reserved. 3 | * 4 | * Use of this source code is governed by a BSD-style license 5 | * that can be found in the LICENSE file in the root of the source 6 | * tree. An additional intellectual property rights grant can be found 7 | * in the file PATENTS. All contributing project authors may 8 | * be found in the AUTHORS file in the root of the source tree. 9 | */ 10 | 11 | #ifndef INCLUDE_LIBYUV_SCALE_RGB_H_ 12 | #define INCLUDE_LIBYUV_SCALE_RGB_H_ 13 | 14 | #include "libyuv/basic_types.h" 15 | #include "libyuv/scale.h" // For FilterMode 16 | 17 | #ifdef __cplusplus 18 | namespace libyuv { 19 | extern "C" { 20 | #endif 21 | 22 | // RGB can be RAW, RGB24 or YUV24 23 | // RGB scales 24 bit images by converting a row at a time to ARGB 24 | // and using ARGB row functions to scale, then convert to RGB. 25 | // TODO(fbarchard): Allow input/output formats to be specified. 26 | LIBYUV_API 27 | int RGBScale(const uint8_t* src_rgb, 28 | int src_stride_rgb, 29 | int src_width, 30 | int src_height, 31 | uint8_t* dst_rgb, 32 | int dst_stride_rgb, 33 | int dst_width, 34 | int dst_height, 35 | enum FilterMode filtering); 36 | 37 | #ifdef __cplusplus 38 | } // extern "C" 39 | } // namespace libyuv 40 | #endif 41 | 42 | #endif // INCLUDE_LIBYUV_SCALE_UV_H_ 43 | -------------------------------------------------------------------------------- /jarkViewer/include/libyuv/scale_uv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2020 The LibYuv Project Authors. All rights reserved. 3 | * 4 | * Use of this source code is governed by a BSD-style license 5 | * that can be found in the LICENSE file in the root of the source 6 | * tree. An additional intellectual property rights grant can be found 7 | * in the file PATENTS. All contributing project authors may 8 | * be found in the AUTHORS file in the root of the source tree. 9 | */ 10 | 11 | #ifndef INCLUDE_LIBYUV_SCALE_UV_H_ 12 | #define INCLUDE_LIBYUV_SCALE_UV_H_ 13 | 14 | #include "libyuv/basic_types.h" 15 | #include "libyuv/scale.h" // For FilterMode 16 | 17 | #ifdef __cplusplus 18 | namespace libyuv { 19 | extern "C" { 20 | #endif 21 | 22 | LIBYUV_API 23 | int UVScale(const uint8_t* src_uv, 24 | int src_stride_uv, 25 | int src_width, 26 | int src_height, 27 | uint8_t* dst_uv, 28 | int dst_stride_uv, 29 | int dst_width, 30 | int dst_height, 31 | enum FilterMode filtering); 32 | 33 | // Scale a 16 bit UV image. 34 | // This function is currently incomplete, it can't handle all cases. 35 | LIBYUV_API 36 | int UVScale_16(const uint16_t* src_uv, 37 | int src_stride_uv, 38 | int src_width, 39 | int src_height, 40 | uint16_t* dst_uv, 41 | int dst_stride_uv, 42 | int dst_width, 43 | int dst_height, 44 | enum FilterMode filtering); 45 | 46 | #ifdef __cplusplus 47 | } // extern "C" 48 | } // namespace libyuv 49 | #endif 50 | 51 | #endif // INCLUDE_LIBYUV_SCALE_UV_H_ 52 | -------------------------------------------------------------------------------- /jarkViewer/include/libyuv/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The LibYuv Project Authors. All rights reserved. 3 | * 4 | * Use of this source code is governed by a BSD-style license 5 | * that can be found in the LICENSE file in the root of the source 6 | * tree. An additional intellectual property rights grant can be found 7 | * in the file PATENTS. All contributing project authors may 8 | * be found in the AUTHORS file in the root of the source tree. 9 | */ 10 | 11 | #ifndef INCLUDE_LIBYUV_VERSION_H_ 12 | #define INCLUDE_LIBYUV_VERSION_H_ 13 | 14 | #define LIBYUV_VERSION 1895 15 | 16 | #endif // INCLUDE_LIBYUV_VERSION_H_ 17 | -------------------------------------------------------------------------------- /jarkViewer/include/minizip/iowin32.h: -------------------------------------------------------------------------------- 1 | /* iowin32.h -- IO base function header for compress/uncompress .zip 2 | Version 1.1, February 14h, 2010 3 | part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) 4 | 5 | Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) 6 | 7 | Modifications for Zip64 support 8 | Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) 9 | 10 | For more info read MiniZip_info.txt 11 | 12 | */ 13 | 14 | #include 15 | 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | void fill_win32_filefunc(zlib_filefunc_def* pzlib_filefunc_def); 22 | void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def); 23 | void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def); 24 | void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | -------------------------------------------------------------------------------- /jarkViewer/include/minizip/mztools.h: -------------------------------------------------------------------------------- 1 | /* 2 | Additional tools for Minizip 3 | Code: Xavier Roche '2004 4 | License: Same as ZLIB (www.gzip.org) 5 | */ 6 | 7 | #ifndef _zip_tools_H 8 | #define _zip_tools_H 9 | 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | #ifndef _ZLIB_H 15 | #include "zlib.h" 16 | #endif 17 | 18 | #include "unzip.h" 19 | 20 | /* Repair a ZIP file (missing central directory) 21 | file: file to recover 22 | fileOut: output file after recovery 23 | fileOutTmp: temporary file name used for recovery 24 | */ 25 | extern int ZEXPORT unzRepair(const char* file, 26 | const char* fileOut, 27 | const char* fileOutTmp, 28 | uLong* nRecovered, 29 | uLong* bytesRecovered); 30 | 31 | 32 | #ifdef __cplusplus 33 | } 34 | #endif 35 | 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/bufferpool.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved. 6 | 7 | #ifndef OPENCV_CORE_BUFFER_POOL_HPP 8 | #define OPENCV_CORE_BUFFER_POOL_HPP 9 | 10 | #ifdef _MSC_VER 11 | #pragma warning(push) 12 | #pragma warning(disable: 4265) 13 | #endif 14 | 15 | namespace cv 16 | { 17 | 18 | //! @addtogroup core_opencl 19 | //! @{ 20 | 21 | class BufferPoolController 22 | { 23 | protected: 24 | ~BufferPoolController() { } 25 | public: 26 | virtual size_t getReservedSize() const = 0; 27 | virtual size_t getMaxReservedSize() const = 0; 28 | virtual void setMaxReservedSize(size_t size) = 0; 29 | virtual void freeAllReservedBuffers() = 0; 30 | }; 31 | 32 | //! @} 33 | 34 | } 35 | 36 | #ifdef _MSC_VER 37 | #pragma warning(pop) 38 | #endif 39 | 40 | #endif // OPENCV_CORE_BUFFER_POOL_HPP 41 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/detail/dispatch_helper.impl.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP 6 | #define OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP 7 | 8 | //! @cond IGNORED 9 | 10 | namespace cv { 11 | namespace detail { 12 | 13 | template class Functor, typename... Args> 14 | static inline void depthDispatch(const int depth, Args&&... args) 15 | { 16 | switch (depth) 17 | { 18 | case CV_8U: 19 | Functor{}(std::forward(args)...); 20 | break; 21 | case CV_8S: 22 | Functor{}(std::forward(args)...); 23 | break; 24 | case CV_16U: 25 | Functor{}(std::forward(args)...); 26 | break; 27 | case CV_16S: 28 | Functor{}(std::forward(args)...); 29 | break; 30 | case CV_32S: 31 | Functor{}(std::forward(args)...); 32 | break; 33 | case CV_32F: 34 | Functor{}(std::forward(args)...); 35 | break; 36 | case CV_64F: 37 | Functor{}(std::forward(args)...); 38 | break; 39 | case CV_16F: 40 | default: 41 | CV_Error(cv::Error::BadDepth, "Unsupported matrix type."); 42 | }; 43 | } 44 | 45 | }} 46 | 47 | //! @endcond 48 | 49 | #endif //OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP 50 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/detail/exception_ptr.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_CORE_DETAILS_EXCEPTION_PTR_H 6 | #define OPENCV_CORE_DETAILS_EXCEPTION_PTR_H 7 | 8 | #ifndef CV__EXCEPTION_PTR 9 | # if defined(__ANDROID__) && defined(ATOMIC_INT_LOCK_FREE) && ATOMIC_INT_LOCK_FREE < 2 10 | # define CV__EXCEPTION_PTR 0 // Not supported, details: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58938 11 | # else 12 | # define CV__EXCEPTION_PTR 1 13 | # endif 14 | #endif 15 | #ifndef CV__EXCEPTION_PTR 16 | # define CV__EXCEPTION_PTR 0 17 | #elif CV__EXCEPTION_PTR 18 | # include // std::exception_ptr 19 | #endif 20 | 21 | #endif // OPENCV_CORE_DETAILS_EXCEPTION_PTR_H 22 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/opencl/runtime/opencl_svm_definitions.hpp: -------------------------------------------------------------------------------- 1 | /* See LICENSE file in the root OpenCV directory */ 2 | 3 | #ifndef OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP 4 | #define OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP 5 | 6 | #if defined(HAVE_OPENCL_SVM) 7 | #if defined(CL_VERSION_2_0) 8 | 9 | // OpenCL 2.0 contains SVM definitions 10 | 11 | #else 12 | 13 | typedef cl_bitfield cl_device_svm_capabilities; 14 | typedef cl_bitfield cl_svm_mem_flags; 15 | typedef cl_uint cl_kernel_exec_info; 16 | 17 | // 18 | // TODO Add real values after OpenCL 2.0 release 19 | // 20 | 21 | #ifndef CL_DEVICE_SVM_CAPABILITIES 22 | #define CL_DEVICE_SVM_CAPABILITIES 0x1053 23 | 24 | #define CL_DEVICE_SVM_COARSE_GRAIN_BUFFER (1 << 0) 25 | #define CL_DEVICE_SVM_FINE_GRAIN_BUFFER (1 << 1) 26 | #define CL_DEVICE_SVM_FINE_GRAIN_SYSTEM (1 << 2) 27 | #define CL_DEVICE_SVM_ATOMICS (1 << 3) 28 | #endif 29 | 30 | #ifndef CL_MEM_SVM_FINE_GRAIN_BUFFER 31 | #define CL_MEM_SVM_FINE_GRAIN_BUFFER (1 << 10) 32 | #endif 33 | 34 | #ifndef CL_MEM_SVM_ATOMICS 35 | #define CL_MEM_SVM_ATOMICS (1 << 11) 36 | #endif 37 | 38 | 39 | #endif // CL_VERSION_2_0 40 | #endif // HAVE_OPENCL_SVM 41 | 42 | #endif // OPENCV_CORE_OCL_RUNTIME_OPENCL_SVM_DEFINITIONS_HPP 43 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/ovx.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | // Copyright (C) 2016, Intel Corporation, all rights reserved. 6 | // Third party copyrights are property of their respective owners. 7 | 8 | // OpenVX related definitions and declarations 9 | 10 | #pragma once 11 | #ifndef OPENCV_OVX_HPP 12 | #define OPENCV_OVX_HPP 13 | 14 | #include "cvdef.h" 15 | 16 | namespace cv 17 | { 18 | /// Check if use of OpenVX is possible 19 | CV_EXPORTS_W bool haveOpenVX(); 20 | 21 | /// Check if use of OpenVX is enabled 22 | CV_EXPORTS_W bool useOpenVX(); 23 | 24 | /// Enable/disable use of OpenVX 25 | CV_EXPORTS_W void setUseOpenVX(bool flag); 26 | } // namespace cv 27 | 28 | #endif // OPENCV_OVX_HPP 29 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/utils/allocator_stats.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_CORE_ALLOCATOR_STATS_HPP 6 | #define OPENCV_CORE_ALLOCATOR_STATS_HPP 7 | 8 | #include "../cvdef.h" 9 | 10 | namespace cv { namespace utils { 11 | 12 | class AllocatorStatisticsInterface 13 | { 14 | protected: 15 | AllocatorStatisticsInterface() {} 16 | virtual ~AllocatorStatisticsInterface() {} 17 | public: 18 | virtual uint64_t getCurrentUsage() const = 0; 19 | virtual uint64_t getTotalUsage() const = 0; 20 | virtual uint64_t getNumberOfAllocations() const = 0; 21 | virtual uint64_t getPeakUsage() const = 0; 22 | 23 | /** set peak usage = current usage */ 24 | virtual void resetPeakUsage() = 0; 25 | }; 26 | 27 | }} // namespace 28 | 29 | #endif // OPENCV_CORE_ALLOCATOR_STATS_HPP 30 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/utils/logger.defines.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_LOGGER_DEFINES_HPP 6 | #define OPENCV_LOGGER_DEFINES_HPP 7 | 8 | //! @addtogroup core_logging 9 | //! @{ 10 | 11 | // Supported logging levels and their semantic 12 | #define CV_LOG_LEVEL_SILENT 0 //!< for using in setLogLevel() call 13 | #define CV_LOG_LEVEL_FATAL 1 //!< Fatal (critical) error (unrecoverable internal error) 14 | #define CV_LOG_LEVEL_ERROR 2 //!< Error message 15 | #define CV_LOG_LEVEL_WARN 3 //!< Warning message 16 | #define CV_LOG_LEVEL_INFO 4 //!< Info message 17 | #define CV_LOG_LEVEL_DEBUG 5 //!< Debug message. Disabled in the "Release" build. 18 | #define CV_LOG_LEVEL_VERBOSE 6 //!< Verbose (trace) messages. Requires verbosity level. Disabled in the "Release" build. 19 | 20 | namespace cv { 21 | namespace utils { 22 | namespace logging { 23 | 24 | //! Supported logging levels and their semantic 25 | enum LogLevel { 26 | LOG_LEVEL_SILENT = 0, //!< for using in setLogVevel() call 27 | LOG_LEVEL_FATAL = 1, //!< Fatal (critical) error (unrecoverable internal error) 28 | LOG_LEVEL_ERROR = 2, //!< Error message 29 | LOG_LEVEL_WARNING = 3, //!< Warning message 30 | LOG_LEVEL_INFO = 4, //!< Info message 31 | LOG_LEVEL_DEBUG = 5, //!< Debug message. Disabled in the "Release" build. 32 | LOG_LEVEL_VERBOSE = 6, //!< Verbose (trace) messages. Requires verbosity level. Disabled in the "Release" build. 33 | #ifndef CV_DOXYGEN 34 | ENUM_LOG_LEVEL_FORCE_INT = INT_MAX 35 | #endif 36 | }; 37 | 38 | }}} // namespace 39 | 40 | //! @} 41 | 42 | #endif // OPENCV_LOGGER_DEFINES_HPP 43 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/utils/logtag.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_CORE_LOGTAG_HPP 6 | #define OPENCV_CORE_LOGTAG_HPP 7 | 8 | #include "opencv2/core/cvstd.hpp" 9 | #include "logger.defines.hpp" 10 | 11 | namespace cv { 12 | namespace utils { 13 | namespace logging { 14 | 15 | struct LogTag 16 | { 17 | const char* name; 18 | LogLevel level; 19 | 20 | inline LogTag(const char* _name, LogLevel _level) 21 | : name(_name) 22 | , level(_level) 23 | {} 24 | }; 25 | 26 | }}} 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/core/version.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_VERSION_HPP 6 | #define OPENCV_VERSION_HPP 7 | 8 | #define CV_VERSION_MAJOR 4 9 | #define CV_VERSION_MINOR 12 10 | #define CV_VERSION_REVISION 0 11 | #define CV_VERSION_STATUS "" 12 | 13 | #define CVAUX_STR_EXP(__A) #__A 14 | #define CVAUX_STR(__A) CVAUX_STR_EXP(__A) 15 | 16 | #define CVAUX_STRW_EXP(__A) L ## #__A 17 | #define CVAUX_STRW(__A) CVAUX_STRW_EXP(__A) 18 | 19 | #define CV_VERSION CVAUX_STR(CV_VERSION_MAJOR) "." CVAUX_STR(CV_VERSION_MINOR) "." CVAUX_STR(CV_VERSION_REVISION) CV_VERSION_STATUS 20 | 21 | /* old style version constants*/ 22 | #define CV_MAJOR_VERSION CV_VERSION_MAJOR 23 | #define CV_MINOR_VERSION CV_VERSION_MINOR 24 | #define CV_SUBMINOR_VERSION CV_VERSION_REVISION 25 | 26 | #endif // OPENCV_VERSION_HPP 27 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/datasets/sr_bsds.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_DATASETS_SR_BSDS_HPP 6 | #define OPENCV_DATASETS_SR_BSDS_HPP 7 | 8 | #include 9 | #include 10 | 11 | #include "opencv2/datasets/dataset.hpp" 12 | 13 | #include 14 | 15 | namespace cv 16 | { 17 | namespace datasets 18 | { 19 | 20 | //! @addtogroup datasets_sr 21 | //! @{ 22 | 23 | struct SR_bsdsObj : public Object 24 | { 25 | std::string imageName; 26 | }; 27 | 28 | class CV_EXPORTS SR_bsds : public Dataset 29 | { 30 | public: 31 | virtual void load(const std::string &path) CV_OVERRIDE = 0; 32 | 33 | static Ptr create(); 34 | }; 35 | 36 | //! @} 37 | 38 | } 39 | } 40 | 41 | #endif -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/datasets/sr_div2k.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_DATASETS_SR_DIV2K_HPP 6 | #define OPENCV_DATASETS_SR_DIV2K_HPP 7 | 8 | #include 9 | #include 10 | 11 | #include "opencv2/datasets/dataset.hpp" 12 | 13 | #include 14 | 15 | namespace cv 16 | { 17 | namespace datasets 18 | { 19 | 20 | //! @addtogroup datasets_sr 21 | //! @{ 22 | 23 | struct SR_div2kObj : public Object 24 | { 25 | std::string imageName; 26 | }; 27 | 28 | class CV_EXPORTS SR_div2k : public Dataset 29 | { 30 | public: 31 | virtual void load(const std::string &path) CV_OVERRIDE = 0; 32 | 33 | static Ptr create(); 34 | }; 35 | 36 | //! @} 37 | 38 | } 39 | } 40 | 41 | #endif -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/datasets/sr_general100.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_DATASETS_SR_GENERAL100_HPP 6 | #define OPENCV_DATASETS_SR_GENERAL100_HPP 7 | 8 | #include 9 | #include 10 | 11 | #include "opencv2/datasets/dataset.hpp" 12 | 13 | #include 14 | 15 | namespace cv 16 | { 17 | namespace datasets 18 | { 19 | 20 | //! @addtogroup datasets_sr 21 | //! @{ 22 | 23 | struct SR_general100Obj : public Object 24 | { 25 | std::string imageName; 26 | }; 27 | 28 | class CV_EXPORTS SR_general100 : public Dataset 29 | { 30 | public: 31 | virtual void load(const std::string &path) CV_OVERRIDE = 0; 32 | 33 | static Ptr create(); 34 | }; 35 | 36 | //! @} 37 | 38 | } 39 | } 40 | 41 | #endif -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/features2d/hal/interface.h: -------------------------------------------------------------------------------- 1 | #ifndef OPENCV_FEATURE2D_HAL_INTERFACE_H 2 | #define OPENCV_FEATURE2D_HAL_INTERFACE_H 3 | 4 | #include "opencv2/core/cvdef.h" 5 | //! @addtogroup features2d_hal_interface 6 | //! @{ 7 | 8 | //! @name Fast feature detector types 9 | //! @sa cv::FastFeatureDetector 10 | //! @{ 11 | #define CV_HAL_TYPE_5_8 0 12 | #define CV_HAL_TYPE_7_12 1 13 | #define CV_HAL_TYPE_9_16 2 14 | //! @} 15 | 16 | //! @name Key point 17 | //! @sa cv::KeyPoint 18 | //! @{ 19 | struct CV_EXPORTS cvhalKeyPoint 20 | { 21 | float x; 22 | float y; 23 | float size; 24 | float angle; 25 | float response; 26 | int octave; 27 | int class_id; 28 | }; 29 | //! @} 30 | 31 | //! @} 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/flann/config.h: -------------------------------------------------------------------------------- 1 | /*********************************************************************** 2 | * Software License Agreement (BSD License) 3 | * 4 | * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. 5 | * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 11 | * 1. Redistributions of source code must retain the above copyright 12 | * notice, this list of conditions and the following disclaimer. 13 | * 2. Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | *************************************************************************/ 28 | 29 | 30 | #ifndef OPENCV_FLANN_CONFIG_H_ 31 | #define OPENCV_FLANN_CONFIG_H_ 32 | 33 | //! @cond IGNORED 34 | 35 | #ifdef FLANN_VERSION_ 36 | #undef FLANN_VERSION_ 37 | #endif 38 | #define FLANN_VERSION_ "1.6.10" 39 | 40 | //! @endcond 41 | 42 | #endif /* OPENCV_FLANN_CONFIG_H_ */ 43 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/flann/dummy.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef OPENCV_FLANN_DUMMY_H_ 3 | #define OPENCV_FLANN_DUMMY_H_ 4 | 5 | //! @cond IGNORED 6 | 7 | namespace cvflann 8 | { 9 | 10 | CV_DEPRECATED inline void dummyfunc() {} 11 | 12 | } 13 | 14 | //! @endcond 15 | 16 | #endif /* OPENCV_FLANN_DUMMY_H_ */ 17 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018-2021 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_HPP 9 | #define OPENCV_GAPI_HPP 10 | 11 | #include 12 | 13 | /** \defgroup gapi_ref G-API framework 14 | @{ 15 | @defgroup gapi_main_classes G-API Main Classes 16 | @defgroup gapi_data_objects G-API Data Types 17 | @{ 18 | @defgroup gapi_meta_args G-API Metadata Descriptors 19 | @} 20 | @defgroup gapi_std_backends G-API Standard Backends 21 | @defgroup gapi_compile_args G-API Graph Compilation Arguments 22 | @defgroup gapi_serialization G-API Serialization functionality 23 | @} 24 | */ 25 | 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | 37 | // Include these files here to avoid cyclic dependency between 38 | // Desync & GKernel & GComputation & GStreamingCompiled. 39 | #include 40 | #include 41 | 42 | #endif // OPENCV_GAPI_HPP 43 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/cpu/core.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_CPU_CORE_API_HPP 9 | #define OPENCV_GAPI_CPU_CORE_API_HPP 10 | 11 | #include // GKernelPackage 12 | #include // GAPI_EXPORTS 13 | 14 | namespace cv { 15 | namespace gapi { 16 | namespace core { 17 | namespace cpu { 18 | 19 | GAPI_EXPORTS_W cv::GKernelPackage kernels(); 20 | 21 | } // namespace cpu 22 | } // namespace core 23 | } // namespace gapi 24 | } // namespace cv 25 | 26 | 27 | #endif // OPENCV_GAPI_CPU_CORE_API_HPP 28 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/cpu/imgproc.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_CPU_IMGPROC_API_HPP 9 | #define OPENCV_GAPI_CPU_IMGPROC_API_HPP 10 | 11 | #include // GAPI_EXPORTS 12 | #include // GKernelPackage 13 | 14 | namespace cv { 15 | namespace gapi { 16 | namespace imgproc { 17 | namespace cpu { 18 | 19 | GAPI_EXPORTS GKernelPackage kernels(); 20 | 21 | } // namespace cpu 22 | } // namespace imgproc 23 | } // namespace gapi 24 | } // namespace cv 25 | 26 | 27 | #endif // OPENCV_GAPI_CPU_IMGPROC_API_HPP 28 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/cpu/ot.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_CPU_OT_API_HPP 9 | #define OPENCV_GAPI_CPU_OT_API_HPP 10 | 11 | #include // GAPI_EXPORTS 12 | #include // GKernelPackage 13 | 14 | namespace cv { 15 | namespace gapi { 16 | /** 17 | * @brief This namespace contains G-API Operation Types for 18 | * VAS Object Tracking module functionality. 19 | */ 20 | namespace ot { 21 | namespace cpu { 22 | GAPI_EXPORTS_W GKernelPackage kernels(); 23 | } // namespace cpu 24 | } // namespace ot 25 | } // namespace gapi 26 | } // namespace cv 27 | 28 | 29 | #endif // OPENCV_GAPI_CPU_OT_API_HPP 30 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/cpu/stereo.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2021 Intel Corporation 6 | 7 | #ifndef OPENCV_GAPI_CPU_STEREO_API_HPP 8 | #define OPENCV_GAPI_CPU_STEREO_API_HPP 9 | 10 | #include // GKernelPackage 11 | 12 | namespace cv { 13 | namespace gapi { 14 | namespace calib3d { 15 | namespace cpu { 16 | 17 | GAPI_EXPORTS GKernelPackage kernels(); 18 | 19 | /** @brief Structure for the Stereo operation initialization parameters.*/ 20 | struct GAPI_EXPORTS StereoInitParam { 21 | StereoInitParam(int nD, int bS, double bL, double f): 22 | numDisparities(nD), blockSize(bS), baseline(bL), focus(f) {} 23 | 24 | StereoInitParam() = default; 25 | 26 | int numDisparities = 0; 27 | int blockSize = 21; 28 | double baseline = 63.5; 29 | double focus = 3.6; 30 | }; 31 | 32 | } // namespace cpu 33 | } // namespace calib3d 34 | } // namespace gapi 35 | 36 | namespace detail { 37 | 38 | template<> struct CompileArgTag { 39 | static const char* tag() { 40 | return "org.opencv.stereoInit"; 41 | } 42 | }; 43 | 44 | } // namespace detail 45 | } // namespace cv 46 | 47 | 48 | #endif // OPENCV_GAPI_CPU_STEREO_API_HPP 49 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/cpu/video.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2020 Intel Corporation 6 | 7 | #ifndef OPENCV_GAPI_CPU_VIDEO_API_HPP 8 | #define OPENCV_GAPI_CPU_VIDEO_API_HPP 9 | 10 | #include // GKernelPackage 11 | 12 | namespace cv { 13 | namespace gapi { 14 | namespace video { 15 | namespace cpu { 16 | 17 | GAPI_EXPORTS GKernelPackage kernels(); 18 | 19 | } // namespace cpu 20 | } // namespace video 21 | } // namespace gapi 22 | } // namespace cv 23 | 24 | 25 | #endif // OPENCV_GAPI_CPU_VIDEO_API_HPP 26 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/fluid/core.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_FLUID_CORE_HPP 9 | #define OPENCV_GAPI_FLUID_CORE_HPP 10 | 11 | #include // GKernelPackage 12 | #include // GAPI_EXPORTS 13 | 14 | namespace cv { namespace gapi { namespace core { namespace fluid { 15 | 16 | GAPI_EXPORTS_W cv::GKernelPackage kernels(); 17 | 18 | }}}} 19 | 20 | #endif // OPENCV_GAPI_FLUID_CORE_HPP 21 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/fluid/imgproc.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_FLUID_IMGPROC_HPP 9 | #define OPENCV_GAPI_FLUID_IMGPROC_HPP 10 | 11 | #include // GKernelPackage 12 | #include // GAPI_EXPORTS 13 | 14 | namespace cv { namespace gapi { namespace imgproc { namespace fluid { 15 | 16 | GAPI_EXPORTS_W GKernelPackage kernels(); 17 | 18 | }}}} 19 | 20 | #endif // OPENCV_GAPI_FLUID_IMGPROC_HPP 21 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/gpu/core.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_GPU_CORE_API_HPP 9 | #define OPENCV_GAPI_GPU_CORE_API_HPP 10 | /** @file 11 | * @deprecated Use instead. 12 | */ 13 | 14 | #include 15 | 16 | namespace cv { 17 | namespace gapi { 18 | namespace core { 19 | namespace gpu { 20 | using namespace ocl; 21 | } // namespace gpu 22 | } // namespace core 23 | } // namespace gapi 24 | } // namespace cv 25 | 26 | 27 | #endif // OPENCV_GAPI_GPU_CORE_API_HPP 28 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/gpu/ggpukernel.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_GGPUKERNEL_HPP 9 | #define OPENCV_GAPI_GGPUKERNEL_HPP 10 | /** @file 11 | * @deprecated Use instead. 12 | */ 13 | 14 | #include 15 | #define GAPI_GPU_KERNEL GAPI_OCL_KERNEL 16 | 17 | 18 | #endif // OPENCV_GAPI_GGPUKERNEL_HPP 19 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/gpu/imgproc.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_GPU_IMGPROC_API_HPP 9 | #define OPENCV_GAPI_GPU_IMGPROC_API_HPP 10 | /** @file 11 | * @deprecated Use instead. 12 | */ 13 | 14 | #include 15 | 16 | 17 | namespace cv { 18 | namespace gapi { 19 | namespace imgproc { 20 | namespace gpu { 21 | using namespace ocl; 22 | } // namespace gpu 23 | } // namespace imgproc 24 | } // namespace gapi 25 | } // namespace cv 26 | 27 | 28 | #endif // OPENCV_GAPI_GPU_IMGPROC_API_HPP 29 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/ocl/core.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_OCL_CORE_API_HPP 9 | #define OPENCV_GAPI_OCL_CORE_API_HPP 10 | 11 | #include // GAPI_EXPORTS 12 | #include // GKernelPackage 13 | 14 | namespace cv { 15 | namespace gapi { 16 | namespace core { 17 | namespace ocl { 18 | 19 | GAPI_EXPORTS_W cv::GKernelPackage kernels(); 20 | 21 | } // namespace ocl 22 | } // namespace core 23 | } // namespace gapi 24 | } // namespace cv 25 | 26 | 27 | #endif // OPENCV_GAPI_OCL_CORE_API_HPP 28 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/ocl/imgproc.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_OCL_IMGPROC_API_HPP 9 | #define OPENCV_GAPI_OCL_IMGPROC_API_HPP 10 | 11 | #include // GAPI_EXPORTS 12 | #include // GKernelPackage 13 | 14 | namespace cv { 15 | namespace gapi { 16 | namespace imgproc { 17 | namespace ocl { 18 | 19 | GAPI_EXPORTS GKernelPackage kernels(); 20 | 21 | } // namespace ocl 22 | } // namespace imgproc 23 | } // namespace gapi 24 | } // namespace cv 25 | 26 | 27 | #endif // OPENCV_GAPI_OCL_IMGPROC_API_HPP 28 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/opencv_includes.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | 3 | // It is subject to the license terms in the LICENSE file found in the top-level directory 4 | // of this distribution and at http://opencv.org/license.html. 5 | // 6 | // Copyright (C) 2018 Intel Corporation 7 | 8 | 9 | #ifndef OPENCV_GAPI_OPENCV_INCLUDES_HPP 10 | #define OPENCV_GAPI_OPENCV_INCLUDES_HPP 11 | 12 | #if !defined(GAPI_STANDALONE) 13 | # include 14 | # include 15 | # include 16 | # include 17 | #define GAPI_OWN_TYPES_LIST cv::gapi::own::Rect, \ 18 | cv::gapi::own::Size, \ 19 | cv::gapi::own::Point, \ 20 | cv::gapi::own::Point2f, \ 21 | cv::gapi::own::Scalar, \ 22 | cv::gapi::own::Mat 23 | #else // Without OpenCV 24 | # include 25 | # include // cv::gapi::own::Rect/Size/Point 26 | # include // cv::gapi::own::Scalar 27 | # include 28 | // replacement of cv's structures: 29 | namespace cv { 30 | using Rect = gapi::own::Rect; 31 | using Size = gapi::own::Size; 32 | using Point = gapi::own::Point; 33 | using Point2f = gapi::own::Point2f; 34 | using Point3f = gapi::own::Point3f; 35 | using Scalar = gapi::own::Scalar; 36 | using Mat = gapi::own::Mat; 37 | } // namespace cv 38 | #define GAPI_OWN_TYPES_LIST cv::gapi::own::VoidType 39 | 40 | #endif // !defined(GAPI_STANDALONE) 41 | 42 | #endif // OPENCV_GAPI_OPENCV_INCLUDES_HPP 43 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/own/assert.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018-2020 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_OWN_ASSERT_HPP 9 | #define OPENCV_GAPI_OWN_ASSERT_HPP 10 | 11 | #include 12 | 13 | #define GAPI_DbgAssertNoOp(expr) { \ 14 | constexpr bool _assert_tmp = false && (expr); \ 15 | cv::util::suppress_unused_warning(_assert_tmp); \ 16 | } 17 | 18 | #if !defined(GAPI_STANDALONE) 19 | #include 20 | #define GAPI_Assert CV_Assert 21 | 22 | #if !defined(NDEBUG) || defined(CV_STATIC_ANALYSIS) 23 | # define GAPI_DbgAssert CV_DbgAssert 24 | #else 25 | # define GAPI_DbgAssert(expr) GAPI_DbgAssertNoOp(expr) 26 | #endif 27 | 28 | #define GAPI_Error(msg) CV_Error(cv::Error::StsError, msg) 29 | 30 | #else 31 | #include 32 | #include 33 | #include 34 | 35 | namespace detail 36 | { 37 | [[noreturn]] inline void assert_abort(const char* str, int line, const char* file, const char* func) 38 | { 39 | std::stringstream ss; 40 | ss << file << ":" << line << ": Assertion " << str << " in function " << func << " failed\n"; 41 | cv::util::throw_error(std::logic_error(ss.str())); 42 | } 43 | } 44 | 45 | #define GAPI_Assert(expr) \ 46 | { if (!(expr)) ::detail::assert_abort(#expr, __LINE__, __FILE__, __func__); } 47 | 48 | #ifdef NDEBUG 49 | # define GAPI_DbgAssert(expr) GAPI_DbgAssertNoOp(expr) 50 | #else 51 | # define GAPI_DbgAssert(expr) GAPI_Assert(expr) 52 | #endif 53 | 54 | #define GAPI_Error(msg) { \ 55 | ::detail::assert_abort(msg, __LINE__, __FILE__, __func__); \ 56 | } 57 | 58 | #endif // GAPI_STANDALONE 59 | 60 | #endif // OPENCV_GAPI_OWN_ASSERT_HPP 61 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/own/convert.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_OWN_CONVERT_HPP 9 | #define OPENCV_GAPI_OWN_CONVERT_HPP 10 | 11 | #if !defined(GAPI_STANDALONE) 12 | 13 | #include 14 | #include 15 | 16 | namespace cv 17 | { 18 | template 19 | std::vector to_own(const cv::MatSize &sz) { 20 | std::vector result(sz.dims()); 21 | for (int i = 0; i < sz.dims(); i++) { 22 | // Note: cv::MatSize is not iterable 23 | result[i] = static_cast(sz[i]); 24 | } 25 | return result; 26 | } 27 | 28 | cv::gapi::own::Mat to_own(Mat&&) = delete; 29 | 30 | inline cv::gapi::own::Mat to_own(Mat const& m) { 31 | return (m.dims == 2) 32 | ? cv::gapi::own::Mat{m.rows, m.cols, m.type(), m.data, m.step} 33 | : cv::gapi::own::Mat{to_own(m.size), m.type(), m.data}; 34 | } 35 | 36 | namespace gapi 37 | { 38 | namespace own 39 | { 40 | 41 | inline cv::Mat to_ocv(Mat const& m) { 42 | return m.dims.empty() 43 | ? cv::Mat{m.rows, m.cols, m.type(), m.data, m.step} 44 | : cv::Mat{m.dims, m.type(), m.data}; 45 | } 46 | 47 | cv::Mat to_ocv(Mat&&) = delete; 48 | 49 | } // namespace own 50 | } // namespace gapi 51 | } // namespace cv 52 | 53 | #endif // !defined(GAPI_STANDALONE) 54 | 55 | #endif // OPENCV_GAPI_OWN_CONVERT_HPP 56 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/own/exports.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_OWN_TYPES_HPP 9 | #define OPENCV_GAPI_OWN_TYPES_HPP 10 | 11 | # if defined(__OPENCV_BUILD) 12 | # include 13 | # define GAPI_EXPORTS CV_EXPORTS 14 | /* special informative macros for wrapper generators */ 15 | # define GAPI_PROP CV_PROP 16 | # define GAPI_PROP_RW CV_PROP_RW 17 | # define GAPI_WRAP CV_WRAP 18 | # define GAPI_EXPORTS_W_SIMPLE CV_EXPORTS_W_SIMPLE 19 | # define GAPI_EXPORTS_W CV_EXPORTS_W 20 | # else 21 | # define GAPI_PROP 22 | # define GAPI_PROP_RW 23 | # define GAPI_WRAP 24 | # define GAPI_EXPORTS 25 | # define GAPI_EXPORTS_W_SIMPLE 26 | # define GAPI_EXPORTS_W 27 | 28 | #if 0 // Note: the following version currently is not needed for non-OpenCV build 29 | # if defined _WIN32 30 | # define GAPI_EXPORTS __declspec(dllexport) 31 | # elif defined __GNUC__ && __GNUC__ >= 4 32 | # define GAPI_EXPORTS __attribute__ ((visibility ("default"))) 33 | # endif 34 | 35 | # ifndef GAPI_EXPORTS 36 | # define GAPI_EXPORTS 37 | # endif 38 | #endif 39 | 40 | # endif 41 | 42 | #endif // OPENCV_GAPI_OWN_TYPES_HPP 43 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/own/scalar.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_GAPI_OWN_SCALAR_HPP 9 | #define OPENCV_GAPI_GAPI_OWN_SCALAR_HPP 10 | 11 | #include 12 | 13 | namespace cv 14 | { 15 | namespace gapi 16 | { 17 | namespace own 18 | { 19 | 20 | class GAPI_EXPORTS Scalar 21 | { 22 | public: 23 | Scalar() = default; 24 | explicit Scalar(double v0) { val[0] = v0; } 25 | Scalar(double v0, double v1, double v2 = 0, double v3 = 0) 26 | : val{v0, v1, v2, v3} 27 | { 28 | } 29 | 30 | const double& operator[](int i) const { return val[i]; } 31 | double& operator[](int i) { return val[i]; } 32 | 33 | static Scalar all(double v0) { return Scalar(v0, v0, v0, v0); } 34 | 35 | double val[4] = {0}; 36 | }; 37 | 38 | inline bool operator==(const Scalar& lhs, const Scalar& rhs) 39 | { 40 | return std::equal(std::begin(lhs.val), std::end(lhs.val), std::begin(rhs.val)); 41 | } 42 | 43 | } // namespace own 44 | } // namespace gapi 45 | } // namespace cv 46 | 47 | #endif // OPENCV_GAPI_GAPI_OWN_SCALAR_HPP 48 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/plaidml/core.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2019 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_PLAIDML_CORE_HPP 9 | #define OPENCV_GAPI_PLAIDML_CORE_HPP 10 | 11 | #include // GKernelPackage 12 | #include // GAPI_EXPORTS 13 | 14 | namespace cv { namespace gapi { namespace core { namespace plaidml { 15 | 16 | GAPI_EXPORTS cv::GKernelPackage kernels(); 17 | 18 | }}}} 19 | 20 | #endif // OPENCV_GAPI_PLAIDML_CORE_HPP 21 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/plaidml/plaidml.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2019 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_PLAIDML_PLAIDML_HPP 9 | #define OPENCV_GAPI_PLAIDML_PLAIDML_HPP 10 | 11 | #include 12 | #include // CompileArgTag 13 | 14 | namespace cv 15 | { 16 | namespace gapi 17 | { 18 | 19 | /** 20 | * @brief This namespace contains G-API PlaidML backend functions, 21 | * structures, and symbols. 22 | */ 23 | namespace plaidml 24 | { 25 | 26 | /** \addtogroup gapi_compile_args 27 | * @{ 28 | */ 29 | /** 30 | * @brief This structure represents the basic parameters for the experimental 31 | * PlaidML backend. 32 | */ 33 | struct config 34 | { 35 | std::string dev_id; //!< Device ID. Refer to PlaidML documentation for details. 36 | std::string trg_id; //!< Target ID. Refer to PlaidML documentation for details. 37 | }; 38 | /** @} gapi_compile_args */ 39 | 40 | } // namespace plaidml 41 | } // namespace gapi 42 | 43 | namespace detail 44 | { 45 | template<> struct CompileArgTag 46 | { 47 | static const char* tag() { return "gapi.plaidml.config"; } 48 | }; 49 | } // namespace detail 50 | 51 | } // namespace cv 52 | 53 | #endif // OPENCV_GAPI_PLAIDML_PLAIDML_HPP 54 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/render.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2019 Intel Corporation 6 | 7 | #ifndef OPENCV_GAPI_RENDER_ROOT_HPP 8 | #define OPENCV_GAPI_RENDER_ROOT_HPP 9 | 10 | // This file is just a shortcut to render/render.hpp 11 | 12 | #include 13 | 14 | #endif // OPENCV_GAPI_RENDER_ROOT_HPP 15 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/streaming/onevpl/default.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2022 Intel Corporation 6 | 7 | #ifndef OPENCV_GAPI_STREAMING_ONEVPL_UTILS_HPP 8 | #define OPENCV_GAPI_STREAMING_ONEVPL_UTILS_HPP 9 | 10 | #include // GAPI_EXPORTS 11 | #include 12 | #include 13 | 14 | namespace cv { 15 | namespace gapi { 16 | namespace wip { 17 | namespace onevpl { 18 | 19 | /** 20 | * @brief Provides default device selector based on config. 21 | */ 22 | GAPI_EXPORTS std::shared_ptr getDefaultDeviceSelector(const std::vector& cfg_params); 23 | 24 | } // namespace onevpl 25 | } // namespace wip 26 | } // namespace gapi 27 | } // namespace cv 28 | 29 | #endif // OPENCV_GAPI_STREAMING_ONEVPL_UTILS_HPP 30 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/streaming/sync.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2021 Intel Corporation 6 | 7 | #ifndef OPENCV_GAPI_STREAMING_SYNC_HPP 8 | #define OPENCV_GAPI_STREAMING_SYNC_HPP 9 | 10 | namespace cv { 11 | namespace gapi { 12 | namespace streaming { 13 | 14 | enum class sync_policy { 15 | dont_sync, 16 | drop 17 | }; 18 | 19 | } // namespace streaming 20 | } // namespace gapi 21 | 22 | namespace detail { 23 | template<> struct CompileArgTag { 24 | static const char* tag() { return "gapi.streaming.sync_policy"; } 25 | }; 26 | 27 | } // namespace detail 28 | } // namespace cv 29 | 30 | #endif // OPENCV_GAPI_STREAMING_SYNC_HPP 31 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/util/compiler_hints.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | #ifndef OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP 8 | #define OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP 9 | 10 | namespace cv 11 | { 12 | namespace util 13 | { 14 | //! Utility template function to prevent "unused" warnings by various compilers. 15 | template void suppress_unused_warning( const T& ) {} 16 | } // namespace util 17 | } // namespace cv 18 | 19 | #endif /* OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP */ 20 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/util/copy_through_move.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2020 Intel Corporation 6 | 7 | #ifndef OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP 8 | #define OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP 9 | 10 | #include //decay_t 11 | 12 | namespace cv 13 | { 14 | namespace util 15 | { 16 | //This is a tool to move initialize captures of a lambda in C++11 17 | template 18 | struct copy_through_move_t{ 19 | T value; 20 | const T& get() const {return value;} 21 | T& get() {return value;} 22 | copy_through_move_t(T&& g) : value(std::move(g)) {} 23 | copy_through_move_t(copy_through_move_t&&) = default; 24 | copy_through_move_t(copy_through_move_t const& lhs) : copy_through_move_t(std::move(const_cast(lhs))) {} 25 | }; 26 | 27 | template 28 | copy_through_move_t> copy_through_move(T&& t){ 29 | return std::forward(t); 30 | } 31 | } // namespace util 32 | } // namespace cv 33 | 34 | #endif /* OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP */ 35 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/util/throw.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2018 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_UTIL_THROW_HPP 9 | #define OPENCV_GAPI_UTIL_THROW_HPP 10 | 11 | #include // std::forward 12 | 13 | #if !defined(__EXCEPTIONS) 14 | #include 15 | #include 16 | #endif 17 | 18 | namespace cv 19 | { 20 | namespace util 21 | { 22 | template 23 | [[noreturn]] void throw_error(ExceptionType &&e) 24 | { 25 | #if defined(__EXCEPTIONS) || defined(_CPPUNWIND) 26 | throw std::forward(e); 27 | #else 28 | fprintf(stderr, "An exception thrown! %s\n" , e.what()); 29 | fflush(stderr); 30 | abort(); 31 | #endif 32 | } 33 | } // namespace util 34 | } // namespace cv 35 | 36 | #endif // OPENCV_GAPI_UTIL_THROW_HPP 37 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/gapi/util/type_traits.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | // 5 | // Copyright (C) 2020 Intel Corporation 6 | 7 | 8 | #ifndef OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP 9 | #define OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP 10 | 11 | #include 12 | 13 | namespace cv 14 | { 15 | namespace util 16 | { 17 | //these are C++14 parts of type_traits : 18 | template< bool B, class T = void > 19 | using enable_if_t = typename std::enable_if::type; 20 | 21 | template 22 | using decay_t = typename std::decay::type; 23 | 24 | //this is not part of C++14 but still, of pretty common usage 25 | template 26 | using are_different_t = enable_if_t< !std::is_same, decay_t>::value, V>; 27 | 28 | } // namespace cv 29 | } // namespace util 30 | 31 | #endif // OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP 32 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/img_hash/average_hash.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_AVERAGE_HASH_HPP 6 | #define OPENCV_AVERAGE_HASH_HPP 7 | 8 | #include "img_hash_base.hpp" 9 | 10 | namespace cv { 11 | namespace img_hash { 12 | 13 | //! @addtogroup img_hash 14 | //! @{ 15 | 16 | /** @brief Computes average hash value of the input image 17 | 18 | This is a fast image hashing algorithm, but only work on simple case. For more details, please 19 | refer to @cite lookslikeit 20 | */ 21 | class CV_EXPORTS_W AverageHash : public ImgHashBase 22 | { 23 | public: 24 | CV_WRAP static Ptr create(); 25 | protected: 26 | AverageHash() {} 27 | }; 28 | 29 | /** @brief Calculates img_hash::AverageHash in one call 30 | @param inputArr input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1. 31 | @param outputArr Hash value of input, it will contain 16 hex decimal number, return type is CV_8U 32 | */ 33 | CV_EXPORTS_W void averageHash(cv::InputArray inputArr, cv::OutputArray outputArr); 34 | 35 | //! @} 36 | 37 | }} // cv::img_hash:: 38 | 39 | #endif // OPENCV_AVERAGE_HASH_HPP 40 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/img_hash/block_mean_hash.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_BLOCK_MEAN_HASH_HPP 6 | #define OPENCV_BLOCK_MEAN_HASH_HPP 7 | 8 | #include "img_hash_base.hpp" 9 | 10 | namespace cv { 11 | namespace img_hash { 12 | 13 | //! @addtogroup img_hash 14 | //! @{ 15 | 16 | enum BlockMeanHashMode 17 | { 18 | BLOCK_MEAN_HASH_MODE_0 = 0, //!< use fewer block and generate 16*16/8 uchar hash value 19 | BLOCK_MEAN_HASH_MODE_1 = 1, //!< use block blocks(step sizes/2), generate 31*31/8 + 1 uchar hash value 20 | }; 21 | 22 | /** @brief Image hash based on block mean. 23 | 24 | See @cite zauner2010implementation for details. 25 | */ 26 | class CV_EXPORTS_W BlockMeanHash : public ImgHashBase 27 | { 28 | public: 29 | /** @brief Create BlockMeanHash object 30 | @param mode the mode 31 | */ 32 | CV_WRAP void setMode(int mode); 33 | CV_WRAP std::vector getMean() const; 34 | CV_WRAP static Ptr create(int mode = BLOCK_MEAN_HASH_MODE_0); 35 | protected: 36 | BlockMeanHash() {} 37 | }; 38 | 39 | /** @brief Computes block mean hash of the input image 40 | @param inputArr input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1. 41 | @param outputArr Hash value of input, it will contain 16 hex decimal number, return type is CV_8U 42 | @param mode the mode 43 | */ 44 | CV_EXPORTS_W void blockMeanHash(cv::InputArray inputArr, 45 | cv::OutputArray outputArr, 46 | int mode = BLOCK_MEAN_HASH_MODE_0); 47 | 48 | //! @} 49 | 50 | }} // cv::img_hash:: 51 | 52 | #endif // OPENCV_BLOCK_MEAN_HASH_HPP 53 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/img_hash/color_moment_hash.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_COLOR_MOMENT_HASH_HPP 6 | #define OPENCV_COLOR_MOMENT_HASH_HPP 7 | 8 | #include "img_hash_base.hpp" 9 | 10 | namespace cv { 11 | namespace img_hash { 12 | 13 | //! @addtogroup img_hash 14 | //! @{ 15 | 16 | /** @brief Image hash based on color moments. 17 | 18 | See @cite tang2012perceptual for details. 19 | */ 20 | class CV_EXPORTS_W ColorMomentHash : public ImgHashBase 21 | { 22 | public: 23 | CV_WRAP static Ptr create(); 24 | protected: 25 | ColorMomentHash() {} 26 | }; 27 | 28 | /** @brief Computes color moment hash of the input, the algorithm 29 | is come from the paper "Perceptual Hashing for Color Images 30 | Using Invariant Moments" 31 | @param inputArr input image want to compute hash value, 32 | type should be CV_8UC4, CV_8UC3 or CV_8UC1. 33 | @param outputArr 42 hash values with type CV_64F(double) 34 | */ 35 | CV_EXPORTS_W void colorMomentHash(cv::InputArray inputArr, cv::OutputArray outputArr); 36 | 37 | //! @} 38 | 39 | }} // cv::img_hash:: 40 | 41 | #endif // OPENCV_COLOR_MOMENT_HASH_HPP 42 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/img_hash/img_hash_base.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_IMG_HASH_BASE_HPP 6 | #define OPENCV_IMG_HASH_BASE_HPP 7 | 8 | #include "opencv2/core.hpp" 9 | 10 | namespace cv { 11 | namespace img_hash { 12 | 13 | //! @addtogroup img_hash 14 | //! @{ 15 | 16 | /** @brief The base class for image hash algorithms 17 | */ 18 | class CV_EXPORTS_W ImgHashBase : public Algorithm 19 | { 20 | public: 21 | class ImgHashImpl; 22 | 23 | ~ImgHashBase(); 24 | /** @brief Computes hash of the input image 25 | @param inputArr input image want to compute hash value 26 | @param outputArr hash of the image 27 | */ 28 | CV_WRAP void compute(cv::InputArray inputArr, cv::OutputArray outputArr); 29 | /** @brief Compare the hash value between inOne and inTwo 30 | @param hashOne Hash value one 31 | @param hashTwo Hash value two 32 | @return value indicate similarity between inOne and inTwo, the meaning 33 | of the value vary from algorithms to algorithms 34 | */ 35 | CV_WRAP double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const; 36 | protected: 37 | ImgHashBase(); 38 | protected: 39 | Ptr pImpl; 40 | }; 41 | 42 | //! @} 43 | 44 | } } // cv::img_hash:: 45 | 46 | #endif // OPENCV_IMG_HASH_BASE_HPP 47 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/img_hash/phash.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_PHASH_HPP 6 | #define OPENCV_PHASH_HPP 7 | 8 | #include "img_hash_base.hpp" 9 | 10 | namespace cv { 11 | namespace img_hash { 12 | 13 | //! @addtogroup img_hash 14 | //! @{ 15 | 16 | /** @brief pHash 17 | 18 | Slower than average_hash, but tolerant of minor modifications 19 | 20 | This algorithm can combat more variation than averageHash, for more details please refer to @cite lookslikeit 21 | */ 22 | class CV_EXPORTS_W PHash : public ImgHashBase 23 | { 24 | public: 25 | CV_WRAP static Ptr create(); 26 | protected: 27 | PHash() {} 28 | }; 29 | 30 | /** @brief Computes pHash value of the input image 31 | @param inputArr input image want to compute hash value, 32 | type should be CV_8UC4, CV_8UC3, CV_8UC1. 33 | @param outputArr Hash value of input, it will contain 8 uchar value 34 | */ 35 | CV_EXPORTS_W void pHash(cv::InputArray inputArr, cv::OutputArray outputArr); 36 | 37 | //! @} 38 | 39 | } } // cv::img_hash:: 40 | 41 | #endif // OPENCV_PHASH_HPP 42 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/img_hash/radial_variance_hash.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_RADIAL_VARIANCE_HASH_HPP 6 | #define OPENCV_RADIAL_VARIANCE_HASH_HPP 7 | 8 | #include "img_hash_base.hpp" 9 | 10 | namespace cv { 11 | namespace img_hash { 12 | 13 | //! @addtogroup img_hash 14 | //! @{ 15 | 16 | 17 | /** @brief Image hash based on Radon transform. 18 | 19 | See @cite tang2012perceptual for details. 20 | */ 21 | class CV_EXPORTS_W RadialVarianceHash : public ImgHashBase 22 | { 23 | public: 24 | CV_WRAP static Ptr create(double sigma = 1, int numOfAngleLine = 180); 25 | 26 | CV_WRAP int getNumOfAngleLine() const; 27 | CV_WRAP double getSigma() const; 28 | 29 | CV_WRAP void setNumOfAngleLine(int value); 30 | CV_WRAP void setSigma(double value); 31 | 32 | // internals 33 | std::vector getFeatures(); 34 | cv::Mat getHash(); 35 | Mat getPixPerLine(Mat const &input); 36 | Mat getProjection(); 37 | protected: 38 | RadialVarianceHash() {} 39 | }; 40 | 41 | /** @brief Computes radial variance hash of the input image 42 | @param inputArr input image want to compute hash value, 43 | type should be CV_8UC4, CV_8UC3, CV_8UC1. 44 | @param outputArr Hash value of input 45 | @param sigma Gaussian kernel standard deviation 46 | @param numOfAngleLine The number of angles to consider 47 | */ 48 | CV_EXPORTS_W void radialVarianceHash(cv::InputArray inputArr, 49 | cv::OutputArray outputArr, 50 | double sigma = 1, 51 | int numOfAngleLine = 180); 52 | 53 | 54 | //! @} 55 | 56 | }} // cv::img_hash:: 57 | 58 | #endif // OPENCV_RADIAL_VARIANCE_HASH_HPP 59 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/imgcodecs/imgcodecs_c.h: -------------------------------------------------------------------------------- 1 | #error "This header with legacy C API declarations has been removed from OpenCV. Legacy constants are available from legacy/constants_c.h file." 2 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/imgcodecs/macosx.h: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #if !defined(__APPLE__) || !defined(__MACH__) 6 | #error This header should be used in macOS ObjC/Swift projects. 7 | #endif 8 | 9 | #import 10 | #include "opencv2/core.hpp" 11 | 12 | //! @addtogroup imgcodecs_macosx 13 | //! @{ 14 | 15 | CV_EXPORTS CGImageRef MatToCGImage(const cv::Mat& image) CF_RETURNS_RETAINED; 16 | CV_EXPORTS void CGImageToMat(const CGImageRef image, cv::Mat& m, bool alphaExist = false); 17 | CV_EXPORTS NSImage* MatToNSImage(const cv::Mat& image); 18 | CV_EXPORTS void NSImageToMat(const NSImage* image, cv::Mat& m, bool alphaExist = false); 19 | 20 | //! @} 21 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/imgproc/detail/legacy.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html 4 | 5 | #ifndef OPENCV_IMGPROC_DETAIL_LEGACY_HPP 6 | #define OPENCV_IMGPROC_DETAIL_LEGACY_HPP 7 | 8 | #include "opencv2/imgproc.hpp" 9 | 10 | namespace cv { 11 | 12 | #ifdef __OPENCV_BUILD 13 | 14 | CV_EXPORTS void findContours_legacy(InputArray _image, 15 | OutputArrayOfArrays _contours, 16 | OutputArray _hierarchy, 17 | int mode, 18 | int method, 19 | Point offset = Point()); 20 | CV_EXPORTS void findContours_legacy(InputArray image, 21 | OutputArrayOfArrays contours, 22 | int mode, 23 | int method, 24 | Point offset = Point()); 25 | 26 | CV_EXPORTS float EMD_legacy( InputArray _signature1, InputArray _signature2, 27 | int distType, InputArray _cost, 28 | float* lowerBound, OutputArray _flow ); 29 | 30 | CV_EXPORTS float wrapperEMD_legacy(InputArray _signature1, InputArray _signature2, 31 | int distType, InputArray _cost, 32 | Ptr lowerBound, OutputArray _flow); 33 | 34 | #endif 35 | 36 | } // namespace cv 37 | 38 | #endif // OPENCV_IMGPROC_DETAIL_LEGACY_HPP 39 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/imgproc/hal/interface.h: -------------------------------------------------------------------------------- 1 | #ifndef OPENCV_IMGPROC_HAL_INTERFACE_H 2 | #define OPENCV_IMGPROC_HAL_INTERFACE_H 3 | 4 | //! @addtogroup imgproc_hal_interface 5 | //! @{ 6 | 7 | //! @name Interpolation modes 8 | //! @sa cv::InterpolationFlags 9 | //! @{ 10 | #define CV_HAL_INTER_NEAREST 0 11 | #define CV_HAL_INTER_LINEAR 1 12 | #define CV_HAL_INTER_CUBIC 2 13 | #define CV_HAL_INTER_AREA 3 14 | #define CV_HAL_INTER_LANCZOS4 4 15 | #define CV_HAL_INTER_LINEAR_EXACT 5 16 | #define CV_HAL_INTER_NEAREST_EXACT 6 17 | #define CV_HAL_INTER_MAX 7 18 | #define CV_HAL_WARP_FILL_OUTLIERS 8 19 | #define CV_HAL_WARP_INVERSE_MAP 16 20 | #define CV_HAL_WARP_RELATIVE_MAP 32 21 | //! @} 22 | 23 | //! @name Morphology operations 24 | //! @sa cv::MorphTypes 25 | //! @{ 26 | #define CV_HAL_MORPH_ERODE 0 27 | #define CV_HAL_MORPH_DILATE 1 28 | //! @} 29 | 30 | //! @name Threshold types 31 | //! @sa cv::ThresholdTypes 32 | //! @{ 33 | #define CV_HAL_THRESH_BINARY 0 34 | #define CV_HAL_THRESH_BINARY_INV 1 35 | #define CV_HAL_THRESH_TRUNC 2 36 | #define CV_HAL_THRESH_TOZERO 3 37 | #define CV_HAL_THRESH_TOZERO_INV 4 38 | #define CV_HAL_THRESH_MASK 7 39 | #define CV_HAL_THRESH_OTSU 8 40 | #define CV_HAL_THRESH_TRIANGLE 16 41 | //! @} 42 | 43 | //! @name Adaptive threshold algorithm 44 | //! @sa cv::AdaptiveThresholdTypes 45 | //! @{ 46 | #define CV_HAL_ADAPTIVE_THRESH_MEAN_C 0 47 | #define CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C 1 48 | //! @} 49 | 50 | //! @} 51 | 52 | #endif 53 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/opencv_modules.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * ** File generated automatically, do not modify ** 3 | * 4 | * This file defines the list of modules available in current build configuration 5 | * 6 | * 7 | */ 8 | 9 | // This definition means that OpenCV is built with enabled non-free code. 10 | // For example, patented algorithms for non-profit/non-commercial use only. 11 | #define OPENCV_ENABLE_NONFREE 12 | 13 | #define HAVE_OPENCV_BGSEGM 14 | #define HAVE_OPENCV_BIOINSPIRED 15 | #define HAVE_OPENCV_CALIB3D 16 | #define HAVE_OPENCV_CCALIB 17 | #define HAVE_OPENCV_CORE 18 | #define HAVE_OPENCV_DATASETS 19 | #define HAVE_OPENCV_FEATURES2D 20 | #define HAVE_OPENCV_FLANN 21 | #define HAVE_OPENCV_FUZZY 22 | #define HAVE_OPENCV_GAPI 23 | #define HAVE_OPENCV_HFS 24 | #define HAVE_OPENCV_HIGHGUI 25 | #define HAVE_OPENCV_IMG_HASH 26 | #define HAVE_OPENCV_IMGCODECS 27 | #define HAVE_OPENCV_IMGPROC 28 | #define HAVE_OPENCV_INTENSITY_TRANSFORM 29 | #define HAVE_OPENCV_LINE_DESCRIPTOR 30 | #define HAVE_OPENCV_ML 31 | #define HAVE_OPENCV_OPTFLOW 32 | #define HAVE_OPENCV_PHASE_UNWRAPPING 33 | #define HAVE_OPENCV_PHOTO 34 | #define HAVE_OPENCV_PLOT 35 | #define HAVE_OPENCV_QUALITY 36 | #define HAVE_OPENCV_RAPID 37 | #define HAVE_OPENCV_REG 38 | #define HAVE_OPENCV_RGBD 39 | #define HAVE_OPENCV_SALIENCY 40 | #define HAVE_OPENCV_SHAPE 41 | #define HAVE_OPENCV_SIGNAL 42 | #define HAVE_OPENCV_STEREO 43 | #define HAVE_OPENCV_STITCHING 44 | #define HAVE_OPENCV_STRUCTURED_LIGHT 45 | #define HAVE_OPENCV_SUPERRES 46 | #define HAVE_OPENCV_SURFACE_MATCHING 47 | #define HAVE_OPENCV_TRACKING 48 | #define HAVE_OPENCV_VIDEO 49 | #define HAVE_OPENCV_VIDEOIO 50 | #define HAVE_OPENCV_VIDEOSTAB 51 | #define HAVE_OPENCV_WORLD 52 | #define HAVE_OPENCV_XFEATURES2D 53 | #define HAVE_OPENCV_XIMGPROC 54 | #define HAVE_OPENCV_XPHOTO 55 | 56 | 57 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/photo/legacy/constants_c.h: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_PHOTO_LEGACY_CONSTANTS_H 6 | #define OPENCV_PHOTO_LEGACY_CONSTANTS_H 7 | 8 | enum InpaintingModes 9 | { 10 | CV_INPAINT_NS =0, 11 | CV_INPAINT_TELEA =1 12 | }; 13 | 14 | #endif // OPENCV_PHOTO_LEGACY_CONSTANTS_H 15 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/quality.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_QUALITY_HPP 6 | #define OPENCV_QUALITY_HPP 7 | 8 | #include "quality/qualitybase.hpp" 9 | #include "quality/qualitymse.hpp" 10 | #include "quality/qualitypsnr.hpp" 11 | #include "quality/qualityssim.hpp" 12 | #include "quality/qualitygmsd.hpp" 13 | #include "quality/qualitybrisque.hpp" 14 | 15 | #endif -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/rgbd.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html 4 | 5 | // This code is also subject to the license terms in the LICENSE_KinectFusion.md file found in this module's directory 6 | 7 | // This code is also subject to the license terms in the LICENSE_WillowGarage.md file found in this module's directory 8 | 9 | #ifndef __OPENCV_RGBD_HPP__ 10 | #define __OPENCV_RGBD_HPP__ 11 | 12 | #include "opencv2/rgbd/linemod.hpp" 13 | #include "opencv2/rgbd/depth.hpp" 14 | #include "opencv2/rgbd/kinfu.hpp" 15 | #include "opencv2/rgbd/dynafu.hpp" 16 | #include "opencv2/rgbd/large_kinfu.hpp" 17 | #include "opencv2/rgbd/detail/pose_graph.hpp" 18 | #include "opencv2/rgbd/colored_kinfu.hpp" 19 | 20 | 21 | /** @defgroup rgbd RGB-Depth Processing 22 | 23 | @ref kinfu_icp 24 | */ 25 | 26 | #endif 27 | 28 | /* End of file. */ 29 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/signal.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html 4 | #ifndef OPENCV_SIGNAL_HPP 5 | #define OPENCV_SIGNAL_HPP 6 | 7 | /** 8 | * @defgroup signal Signal Processing 9 | * @{ 10 | * This module includes signal processing algorithms. 11 | * @} 12 | */ 13 | 14 | #include "opencv2/core.hpp" 15 | #include "opencv2/signal/signal_resample.hpp" 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/signal/signal_resample.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html 4 | #ifndef OPENCV_SIGNAL_SIGNAL_RESAMPLE_HPP 5 | #define OPENCV_SIGNAL_SIGNAL_RESAMPLE_HPP 6 | 7 | #include 8 | 9 | namespace cv { 10 | namespace signal { 11 | 12 | //! @addtogroup signal 13 | //! @{ 14 | 15 | /** @brief Signal resampling 16 | * 17 | * @param[in] inputSignal Array with input signal. 18 | * @param[out] outSignal Array with output signal 19 | * @param[in] inFreq Input signal frequency. 20 | * @param[in] outFreq Output signal frequency. 21 | * Signal resampling implemented a cubic interpolation function and a filtering function based on Kaiser window and Bessel function, used to construct a FIR filter. 22 | * Result is similar to `scipy.signal.resample`. 23 | 24 | Detail: https://en.wikipedia.org/wiki/Sample-rate_conversion 25 | */ 26 | CV_EXPORTS_W void resampleSignal(InputArray inputSignal, OutputArray outSignal, const int inFreq, const int outFreq); 27 | 28 | //! @} 29 | 30 | } 31 | } 32 | #endif 33 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/tracking/twist.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OPENCV_TWIST_HPP 2 | #define OPENCV_TWIST_HPP 3 | 4 | #include "opencv2/core.hpp" 5 | 6 | namespace cv 7 | { 8 | namespace detail 9 | { 10 | inline namespace tracking 11 | { 12 | //! @addtogroup tracking_detail 13 | //! @{ 14 | 15 | /** 16 | * @brief Compute the camera twist from a set of 2D pixel locations, their 17 | * velocities, depth values and intrinsic parameters of the camera. The pixel 18 | * velocities are usually obtained from optical flow algorithms, both dense and 19 | * sparse flow can be used to compute the flow between images and \p duv computed by 20 | * dividing the flow by the time interval between the images. 21 | * 22 | * @param uv 2xN matrix of 2D pixel locations 23 | * @param duv 2Nx1 matrix of 2D pixel velocities 24 | * @param depths 1xN matrix of depth values 25 | * @param K 3x3 camera intrinsic matrix 26 | * 27 | * @return cv::Vec6d 6x1 camera twist 28 | */ 29 | CV_EXPORTS cv::Vec6d computeTwist(const cv::Mat& uv, const cv::Mat& duv, const cv::Mat& depths, 30 | const cv::Mat& K); 31 | 32 | /** 33 | * @brief Compute the interaction matrix ( @cite Hutchinson1996ATO @cite chaumette:inria-00350283 34 | * @cite chaumette:inria-00350638 ) for a set of 2D pixels. This is usually 35 | * used in visual servoing applications to command a robot to move at desired pixel 36 | * locations/velocities. By inverting this matrix, one can estimate camera spatial 37 | * velocity i.e., the twist. 38 | * 39 | * @param uv 2xN matrix of 2D pixel locations 40 | * @param depths 1xN matrix of depth values 41 | * @param K 3x3 camera intrinsic matrix 42 | * @param J 2Nx6 interaction matrix 43 | * 44 | */ 45 | CV_EXPORTS void computeInteractionMatrix(const cv::Mat& uv, const cv::Mat& depths, const cv::Mat& K, 46 | cv::Mat& J); 47 | 48 | //! @} 49 | 50 | } // namespace tracking 51 | } // namespace detail 52 | } // namespace cv 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/video/legacy/constants_c.h: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef OPENCV_VIDEO_LEGACY_CONSTANTS_H 6 | #define OPENCV_VIDEO_LEGACY_CONSTANTS_H 7 | 8 | enum 9 | { 10 | CV_LKFLOW_PYR_A_READY = 1, 11 | CV_LKFLOW_PYR_B_READY = 2, 12 | CV_LKFLOW_INITIAL_GUESSES = 4, 13 | CV_LKFLOW_GET_MIN_EIGENVALS = 8 14 | }; 15 | 16 | #endif // OPENCV_VIDEO_LEGACY_CONSTANTS_H 17 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/ximgproc/edgepreserving_filter.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef __OPENCV_EDGEPRESERVINGFILTER_HPP__ 6 | #define __OPENCV_EDGEPRESERVINGFILTER_HPP__ 7 | 8 | #include 9 | 10 | namespace cv { namespace ximgproc { 11 | 12 | //! @addtogroup ximgproc 13 | //! @{ 14 | 15 | /** 16 | * @brief Smoothes an image using the Edge-Preserving filter. 17 | * 18 | * The function smoothes Gaussian noise as well as salt & pepper noise. 19 | * For more details about this implementation, please see 20 | * [ReiWoe18] Reich, S. and Wörgötter, F. and Dellen, B. (2018). A Real-Time Edge-Preserving Denoising Filter. Proceedings of the 13th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP): Visapp, 85-94, 4. DOI: 10.5220/0006509000850094. 21 | * 22 | * @param src Source 8-bit 3-channel image. 23 | * @param dst Destination image of the same size and type as src. 24 | * @param d Diameter of each pixel neighborhood that is used during filtering. Must be greater or equal 3. 25 | * @param threshold Threshold, which distinguishes between noise, outliers, and data. 26 | */ 27 | CV_EXPORTS_W void edgePreservingFilter( InputArray src, OutputArray dst, int d, double threshold ); 28 | 29 | //! @} 30 | 31 | }} // namespace 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/ximgproc/find_ellipses.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef __OPENCV_FIND_ELLIPSES_HPP__ 6 | #define __OPENCV_FIND_ELLIPSES_HPP__ 7 | 8 | #include 9 | 10 | namespace cv { 11 | namespace ximgproc { 12 | 13 | //! @addtogroup ximgproc 14 | //! @{ 15 | 16 | /** 17 | @brief Finds ellipses fastly in an image using projective invariant pruning. 18 | * 19 | * The function detects ellipses in images using projective invariant pruning. 20 | * For more details about this implementation, please see @cite jia2017fast 21 | * Jia, Qi et al, (2017). 22 | * A Fast Ellipse Detector using Projective Invariant Pruning. IEEE Transactions on Image Processing. 23 | * 24 | @param image input image, could be gray or color. 25 | @param ellipses output vector of found ellipses. each vector is encoded as five float $x, y, a, b, radius, score$. 26 | @param scoreThreshold float, the threshold of ellipse score. 27 | @param reliabilityThreshold float, the threshold of reliability. 28 | @param centerDistanceThreshold float, the threshold of center distance. 29 | */ 30 | CV_EXPORTS_W void findEllipses( 31 | InputArray image, OutputArray ellipses, 32 | float scoreThreshold = 0.7f, float reliabilityThreshold = 0.5f, 33 | float centerDistanceThreshold = 0.05f 34 | ); 35 | //! @} ximgproc 36 | } 37 | } 38 | #endif -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/ximgproc/peilin.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef __OPENCV_PEILIN_HPP__ 6 | #define __OPENCV_PEILIN_HPP__ 7 | 8 | #include 9 | 10 | namespace cv { namespace ximgproc { 11 | 12 | //! @addtogroup ximgproc 13 | //! @{ 14 | 15 | /** 16 | * @brief Calculates an affine transformation that normalize given image using Pei&Lin Normalization. 17 | * 18 | * Assume given image \f$I=T(\bar{I})\f$ where \f$\bar{I}\f$ is a normalized image and \f$T\f$ is an affine transformation distorting this image by translation, rotation, scaling and skew. 19 | * The function returns an affine transformation matrix corresponding to the transformation \f$T^{-1}\f$ described in [PeiLin95]. 20 | * For more details about this implementation, please see 21 | * [PeiLin95] Soo-Chang Pei and Chao-Nan Lin. Image normalization for pattern recognition. Image and Vision Computing, Vol. 13, N.10, pp. 711-723, 1995. 22 | * 23 | * @param I Given transformed image. 24 | * @return Transformation matrix corresponding to inversed image transformation 25 | */ 26 | CV_EXPORTS Matx23d PeiLinNormalization ( InputArray I ); 27 | /** @overload */ 28 | CV_EXPORTS_W void PeiLinNormalization ( InputArray I, OutputArray T ); 29 | 30 | //! @} 31 | 32 | }} // namespace 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/ximgproc/radon_transform.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | #ifndef __OPENCV_RADON_TRANSFORM_HPP__ 6 | #define __OPENCV_RADON_TRANSFORM_HPP__ 7 | 8 | #include "opencv2/core.hpp" 9 | #include "opencv2/imgproc.hpp" 10 | 11 | namespace cv { namespace ximgproc { 12 | /** 13 | * @brief Calculate Radon Transform of an image. 14 | * @param src The source (input) image. 15 | * @param dst The destination image, result of transformation. 16 | * @param theta Angle resolution of the transform in degrees. 17 | * @param start_angle Start angle of the transform in degrees. 18 | * @param end_angle End angle of the transform in degrees. 19 | * @param crop Crop the source image into a circle. 20 | * @param norm Normalize the output Mat to grayscale and convert type to CV_8U 21 | * 22 | * This function calculates the Radon Transform of a given image in any range. 23 | * See https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf for detail. 24 | * If the input type is CV_8U, the output will be CV_32S. 25 | * If the input type is CV_32F or CV_64F, the output will be CV_64F 26 | * The output size will be num_of_integral x src_diagonal_length. 27 | * If crop is selected, the input image will be crop into square then circle, 28 | * and output size will be num_of_integral x min_edge. 29 | * 30 | */ 31 | CV_EXPORTS_W void RadonTransform(InputArray src, 32 | OutputArray dst, 33 | double theta = 1, 34 | double start_angle = 0, 35 | double end_angle = 180, 36 | bool crop = false, 37 | bool norm = false); 38 | } } 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /jarkViewer/include/opencv2/xphoto/oilpainting.hpp: -------------------------------------------------------------------------------- 1 | // This file is part of OpenCV project. 2 | // It is subject to the license terms in the LICENSE file found in the top-level directory 3 | // of this distribution and at http://opencv.org/license.html. 4 | 5 | 6 | #ifndef __OPENCV_OIL_PAINTING_HPP__ 7 | #define __OPENCV_OIL_PAINTING_HPP__ 8 | 9 | #include 10 | #include 11 | 12 | namespace cv 13 | { 14 | namespace xphoto 15 | { 16 | 17 | //! @addtogroup xphoto 18 | //! @{ 19 | 20 | /** @brief oilPainting 21 | See the book @cite Holzmann1988 for details. 22 | @param src Input three-channel or one channel image (either CV_8UC3 or CV_8UC1) 23 | @param dst Output image of the same size and type as src. 24 | @param size neighbouring size is 2-size+1 25 | @param dynRatio image is divided by dynRatio before histogram processing 26 | @param code color space conversion code(see ColorConversionCodes). Histogram will used only first plane 27 | */ 28 | CV_EXPORTS_W void oilPainting(InputArray src, OutputArray dst, int size, int dynRatio, int code); 29 | /** @brief oilPainting 30 | See the book @cite Holzmann1988 for details. 31 | @param src Input three-channel or one channel image (either CV_8UC3 or CV_8UC1) 32 | @param dst Output image of the same size and type as src. 33 | @param size neighbouring size is 2-size+1 34 | @param dynRatio image is divided by dynRatio before histogram processing 35 | */ 36 | CV_EXPORTS_W void oilPainting(InputArray src, OutputArray dst, int size, int dynRatio); 37 | //! @} 38 | } 39 | } 40 | 41 | #endif // __OPENCV_OIL_PAINTING_HPP__ 42 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // the main include that always needs to be included in every translation unit that uses the PSD library 3 | #include "psdsdk/Psd.h" 4 | 5 | // for convenience reasons, we directly include the platform header from the PSD library. 6 | // we could have just included as well, but that is unnecessarily big, and triggers lots of warnings. 7 | #include "psdsdk/PsdPlatform.h" 8 | 9 | // in the sample, we use the provided malloc allocator for all memory allocations. likewise, we also use the provided 10 | // native file interface. 11 | // in your code, feel free to use whatever allocator you have lying around. 12 | #include "psdsdk/PsdMallocAllocator.h" 13 | #include "psdsdk/PsdNativeFile.h" 14 | 15 | #include "psdsdk/PsdDocument.h" 16 | #include "psdsdk/PsdColorMode.h" 17 | #include "psdsdk/PsdLayer.h" 18 | #include "psdsdk/PsdChannel.h" 19 | #include "psdsdk/PsdChannelType.h" 20 | #include "psdsdk/PsdLayerMask.h" 21 | #include "psdsdk/PsdVectorMask.h" 22 | #include "psdsdk/PsdLayerMaskSection.h" 23 | #include "psdsdk/PsdImageDataSection.h" 24 | #include "psdsdk/PsdImageResourcesSection.h" 25 | #include "psdsdk/PsdParseDocument.h" 26 | #include "psdsdk/PsdParseLayerMaskSection.h" 27 | #include "psdsdk/PsdParseImageDataSection.h" 28 | #include "psdsdk/PsdParseImageResourcesSection.h" 29 | #include "psdsdk/PsdLayerCanvasCopy.h" 30 | #include "psdsdk/PsdInterleave.h" 31 | #include "psdsdk/PsdPlanarImage.h" 32 | #include "psdsdk/PsdExport.h" 33 | #include "psdsdk/PsdExportDocument.h" 34 | #include "psdsdk/PsdParseColorModeDataSection.h" 35 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/Psd.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | // This header file contains the bare minimum of includes needed by every translation unit that uses the PSD library. 8 | #include "PsdPch.h" 9 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdAllocator.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Interfaces 10 | /// \ingroup Allocators 11 | /// \brief Base class for all memory allocators. 12 | /// \details Memory allocators are used throughout the library to ensure full control over all allocations. This allows 13 | /// using custom allocators for better performance, a smaller memory footprint, and for adding extra debugging and/or tracking 14 | /// features. 15 | /// \sa MallocAllocator 16 | class Allocator 17 | { 18 | public: 19 | /// Empty destructor. 20 | virtual ~Allocator(void); 21 | 22 | /// Allocates \a size bytes with a given \a alignment. The alignment must be a power-of-two. 23 | void* Allocate(size_t size, size_t alignment); 24 | 25 | /// Frees an allocation. 26 | void Free(void* ptr); 27 | 28 | private: 29 | virtual void* DoAllocate(size_t size, size_t alignment) PSD_ABSTRACT; 30 | virtual void DoFree(void* ptr) PSD_ABSTRACT; 31 | }; 32 | 33 | PSD_NAMESPACE_END 34 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdAlphaChannel.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "PsdFixedSizeString.h" 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | /// \ingroup Types 12 | /// \class AlphaChannel 13 | /// \brief A struct representing an alpha channel as stored in the image resources section. 14 | /// \remark Note that the image data for alpha channels is stored in the image data section. 15 | /// \sa ImageResourcesSection 16 | struct AlphaChannel 17 | { 18 | struct Mode 19 | { 20 | enum Enum 21 | { 22 | ALPHA = 0, ///< The channel stores alpha data. 23 | INVERTED_ALPHA = 1, ///< The channel stores inverted alpha data. 24 | SPOT = 2 ///< The channel stores spot color data. 25 | }; 26 | }; 27 | 28 | util::FixedSizeString asciiName; ///< The channel's ASCII name. 29 | uint16_t colorSpace; ///< The color space the colors are stored in. 30 | uint16_t color[4]; ///< 16-bit color data with 0 being black and 65535 being white (assuming RGBA). 31 | uint16_t opacity; ///< The channel's opacity in the range [0, 100]. 32 | uint8_t mode; ///< The channel's mode, one of AlphaChannel::Mode. 33 | }; 34 | 35 | PSD_NAMESPACE_END 36 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdBitUtil.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "Psdisunsigned.h" 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | /// \ingroup Util 12 | /// \namespace bitUtil 13 | /// \brief Provides bit manipulation routines. 14 | namespace bitUtil 15 | { 16 | /// Returns whether a given number is a power-of-two. 17 | template 18 | inline bool IsPowerOfTwo(T x); 19 | 20 | /// Rounds a number up to the next multiple of a power-of-two. 21 | template 22 | inline T RoundUpToMultiple(T numToRound, T multipleOf); 23 | 24 | /// Rounds a number down to the next multiple of a power-of-two. 25 | template 26 | inline T RoundDownToMultiple(T numToRound, T multipleOf); 27 | } 28 | 29 | #include "PsdBitUtil.inl" 30 | 31 | PSD_NAMESPACE_END 32 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdBlendMode.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \namespace blendMode 11 | /// \brief A namespace holding all blend modes known by Photoshop. 12 | namespace blendMode 13 | { 14 | enum Enum 15 | { 16 | PASS_THROUGH, ///< Key = "pass" 17 | NORMAL, ///< Key = "norm" 18 | DISSOLVE, ///< Key = "diss" 19 | DARKEN, ///< Key = "dark" 20 | MULTIPLY, ///< Key = "mul " 21 | COLOR_BURN, ///< Key = "idiv" 22 | LINEAR_BURN, ///< Key = "lbrn" 23 | DARKER_COLOR, ///< Key = "dkCl" 24 | LIGHTEN, ///< Key = "lite" 25 | SCREEN, ///< Key = "scrn" 26 | COLOR_DODGE, ///< Key = "div " 27 | LINEAR_DODGE, ///< Key = "lddg" 28 | LIGHTER_COLOR, ///< Key = "lgCl" 29 | OVERLAY, ///< Key = "over" 30 | SOFT_LIGHT, ///< Key = "sLit" 31 | HARD_LIGHT, ///< Key = "hLit" 32 | VIVID_LIGHT, ///< Key = "vLit" 33 | LINEAR_LIGHT, ///< Key = "lLit" 34 | PIN_LIGHT, ///< Key = "pLit" 35 | HARD_MIX, ///< Key = "hMix" 36 | DIFFERENCE, ///< Key = "diff" 37 | EXCLUSION, ///< Key = "smud" 38 | SUBTRACT, ///< Key = "fsub" 39 | DIVIDE, ///< Key = "fdiv" 40 | HUE, ///< Key = "hue " 41 | SATURATION, ///< Key = "sat " 42 | COLOR, ///< Key = "colr" 43 | LUMINOSITY, ///< Key = "lum " 44 | 45 | UNKNOWN 46 | }; 47 | 48 | /// Converts a given \a key to the corresponding \ref blendMode::Enum. 49 | Enum KeyToEnum(uint32_t key); 50 | 51 | /// Converts any of the \ref blendMode::Enum values into a string literal. 52 | const char* ToString(Enum value); 53 | } 54 | 55 | PSD_NAMESPACE_END 56 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdChannel.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class Channel 11 | /// \brief A struct representing a channel as stored in the layers of the Layer Mask section. 12 | /// \sa Layer 13 | struct Channel 14 | { 15 | uint64_t fileOffset; ///< The offset from the start of the file where the channel's data is stored. 16 | uint32_t size; ///< The size of the channel data to be read from the file. 17 | void* data; ///< Planar data the size of the layer the channel belongs to. Data is only valid if the type member indicates so. 18 | int16_t type; ///< One of the \ref channelType constants denoting the type of data. 19 | }; 20 | 21 | PSD_NAMESPACE_END 22 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdChannelType.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \namespace channelType 11 | /// \brief A namespace holding constants to distinguish between the types of data a channel can hold. 12 | namespace channelType 13 | { 14 | enum Enum 15 | { 16 | INVALID = 32767, ///< Internal value. Used to denote that a channel no longer holds valid data. 17 | 18 | R = 0, ///< Type denoting the R channel, not necessarily the first in a RGB Color Mode document. 19 | G = 1, ///< Type denoting the G channel, not necessarily the second in a RGB Color Mode document. 20 | B = 2, ///< Type denoting the B channel, not necessarily the third in a RGB Color Mode document. 21 | 22 | TRANSPARENCY_MASK = -1, ///< The layer's channel data is a transparency mask. 23 | LAYER_OR_VECTOR_MASK = -2, ///< The layer's channel data is either a layer or vector mask. 24 | LAYER_MASK = -3 ///< The layer's channel data is a layer mask. 25 | }; 26 | } 27 | 28 | PSD_NAMESPACE_END 29 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdColorMode.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \namespace colorMode 11 | /// \brief A namespace holding all color modes known by Photoshop. 12 | namespace colorMode 13 | { 14 | enum Enum 15 | { 16 | BITMAP = 0, 17 | GRAYSCALE = 1, 18 | INDEXED = 2, 19 | RGB = 3, 20 | CMYK = 4, 21 | MULTICHANNEL = 7, 22 | DUOTONE = 8, 23 | LAB = 9 24 | }; 25 | 26 | /// Converts any of the \ref colorMode::Enum values into a string literal. 27 | const char* ToString(unsigned int value); 28 | } 29 | 30 | PSD_NAMESPACE_END 31 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdColorModeDataSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Sections 10 | /// \class ColorModeDataSection 11 | /// \brief A struct representing the information extracted from the Color Mode Data section. 12 | struct ColorModeDataSection 13 | { 14 | uint8_t* colorData; 15 | uint32_t sizeOfColorData; 16 | }; 17 | 18 | PSD_NAMESPACE_END 19 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdCompressionType.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \namespace compressionType 11 | /// \brief A namespace holding compression types known by Photoshop. 12 | namespace compressionType 13 | { 14 | enum Enum 15 | { 16 | RAW = 0, ///< Raw data. 17 | RLE = 1, ///< RLE-compressed data (using the PackBits algorithm). 18 | ZIP = 2, ///< ZIP-compressed data. 19 | ZIP_WITH_PREDICTION = 3 ///< ZIP-compressed data with prediction (delta-encoding). 20 | }; 21 | } 22 | 23 | PSD_NAMESPACE_END 24 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdDecompressRle.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | namespace imageUtil 10 | { 11 | /// \ingroup ImageUtil 12 | /// Decompresses a block of RLE encoded data using the PackBits (http://en.wikipedia.org/wiki/PackBits) algorithm. 13 | void DecompressRle(const uint8_t* PSD_RESTRICT src, unsigned int srcSize, uint8_t* PSD_RESTRICT dest, unsigned int size); 14 | 15 | /// \ingroup ImageUtil 16 | /// Compresses a block of data to RLE encoded data using the PackBits (http://en.wikipedia.org/wiki/PackBits) algorithm. 17 | /// \a dest must hold \a size * 2 bytes. 18 | unsigned int CompressRle(const uint8_t* PSD_RESTRICT src, uint8_t* PSD_RESTRICT dest, unsigned int size); 19 | } 20 | 21 | PSD_NAMESPACE_END 22 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdDocument.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "PsdSection.h" 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | /// \ingroup Types 12 | /// \class Document 13 | /// \brief A struct storing the document-wide information and sections contained in a .PSD file. 14 | /// \sa Section 15 | struct Document 16 | { 17 | unsigned int width; ///< The width of the document. 18 | unsigned int height; ///< The height of the document. 19 | unsigned int channelCount; ///< The number of channels stored in the document, including any additional alpha channels. 20 | unsigned int bitsPerChannel; ///< The bits per channel (8, 16 or 32). 21 | unsigned int colorMode; ///< The color mode the document is stored in, can be any of \ref colorMode::Enum. 22 | 23 | Section colorModeDataSection; ///< Color mode data section. 24 | Section imageResourcesSection; ///< Image Resources section. 25 | Section layerMaskInfoSection; ///< Layer Mask Info section. 26 | Section imageDataSection; ///< Image Data section. 27 | }; 28 | 29 | PSD_NAMESPACE_END 30 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdEndianConversion.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | /// \ingroup Util 12 | /// \namespace endianUtil 13 | /// \brief Provides endian conversion routines. 14 | namespace endianUtil 15 | { 16 | /// Converts from big-endian to native-endian, and returns the converted value. 17 | template 18 | PSD_INLINE T BigEndianToNative(T value); 19 | 20 | /// Converts from little-endian to native-endian, and returns the converted value. 21 | template 22 | PSD_INLINE T LittleEndianToNative(T value); 23 | 24 | /// Converts from native-endian to big-endian, and returns the converted value. 25 | template 26 | PSD_INLINE T NativeToBigEndian(T value); 27 | 28 | /// Converts from native-endian to little-endian, and returns the converted value. 29 | template 30 | PSD_INLINE T NativeToLittleEndian(T value); 31 | } 32 | 33 | #include "PsdEndianConversion.inl" 34 | 35 | PSD_NAMESPACE_END 36 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdExportChannel.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \namespace exportChannel 11 | /// \brief A namespace denoting a channel that is exported to the Layer Mask section. 12 | namespace exportChannel 13 | { 14 | enum Enum 15 | { 16 | // supported in Grayscale documents 17 | GRAY, 18 | 19 | // supported in RGB documents 20 | RED, 21 | GREEN, 22 | BLUE, 23 | 24 | // supported in all documents 25 | ALPHA 26 | }; 27 | } 28 | 29 | PSD_NAMESPACE_END 30 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdExportColorMode.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \namespace exportColorMode 11 | /// \brief A namespace denoting a color mode used for exporting a PSD document. Enumerator values denote the number of channels in the document as well as the PSD mode identifier. 12 | /// \sa colorMode 13 | namespace exportColorMode 14 | { 15 | enum Enum 16 | { 17 | GRAYSCALE = 1, 18 | RGB = 3 19 | }; 20 | } 21 | 22 | PSD_NAMESPACE_END 23 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdExportDocument.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "PsdExportColorMode.h" 7 | #include "PsdExportMetaDataAttribute.h" 8 | #include "PsdExportLayer.h" 9 | #include "PsdAlphaChannel.h" 10 | 11 | 12 | PSD_NAMESPACE_BEGIN 13 | 14 | struct Thumbnail; 15 | 16 | /// \ingroup Types 17 | /// \class ExportDocument 18 | /// \brief A struct representing a document to be exported. 19 | struct ExportDocument 20 | { 21 | static const unsigned int MAX_ATTRIBUTE_COUNT = 128u; 22 | static const unsigned int MAX_LAYER_COUNT = 128u; 23 | static const unsigned int MAX_ALPHA_CHANNEL_COUNT = 128u; 24 | 25 | uint32_t width; 26 | uint32_t height; 27 | uint16_t bitsPerChannel; 28 | exportColorMode::Enum colorMode; 29 | 30 | ExportMetaDataAttribute attributes[MAX_ATTRIBUTE_COUNT]; 31 | unsigned int attributeCount; 32 | 33 | ExportLayer layers[MAX_LAYER_COUNT]; 34 | uint16_t layerCount; 35 | 36 | void* mergedImageData[3u]; 37 | 38 | AlphaChannel alphaChannels[MAX_ALPHA_CHANNEL_COUNT]; 39 | uint16_t alphaChannelCount; 40 | void* alphaChannelData[MAX_ALPHA_CHANNEL_COUNT]; 41 | 42 | uint8_t* iccProfile; 43 | uint32_t sizeOfICCProfile; 44 | 45 | uint8_t* exifData; 46 | uint32_t sizeOfExifData; 47 | 48 | Thumbnail* thumbnail; 49 | }; 50 | 51 | PSD_NAMESPACE_END 52 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdExportLayer.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class ExportLayer 11 | /// \brief A struct representing a layer as exported to the Layer Mask section. 12 | struct ExportLayer 13 | { 14 | // the SDK currently supports R, G, B, A 15 | static const unsigned int MAX_CHANNEL_COUNT = 4u; 16 | 17 | int32_t top; 18 | int32_t left; 19 | int32_t bottom; 20 | int32_t right; 21 | char* name; 22 | 23 | void* channelData[MAX_CHANNEL_COUNT]; 24 | uint32_t channelSize[MAX_CHANNEL_COUNT]; 25 | uint16_t channelCompression[MAX_CHANNEL_COUNT]; 26 | }; 27 | 28 | PSD_NAMESPACE_END 29 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdExportMetaDataAttribute.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class ExportMetaDataAttribute 11 | /// \brief A struct representing a meta data attribute as exported to the image resources section. 12 | struct ExportMetaDataAttribute 13 | { 14 | char* name; 15 | char* value; 16 | }; 17 | 18 | PSD_NAMESPACE_END 19 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdImageDataSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct PlanarImage; 10 | 11 | 12 | /// \ingroup Sections 13 | /// \class ImageDataSection 14 | /// \brief A struct representing the information extracted from the Image Data section. 15 | /// \sa PlanarImage 16 | struct ImageDataSection 17 | { 18 | PlanarImage* images; ///< An array of planar images, having imageCount entries. 19 | unsigned int imageCount; ///< The number of planar images stored in the array. 20 | }; 21 | 22 | PSD_NAMESPACE_END 23 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdImageResourcesSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct AlphaChannel; 10 | struct Thumbnail; 11 | 12 | 13 | /// \ingroup Sections 14 | /// \class ImageResourcesSection 15 | /// \brief A struct representing the information extracted from the Image Resources section. 16 | /// \sa AlphaChannel 17 | struct ImageResourcesSection 18 | { 19 | AlphaChannel* alphaChannels; ///< An array of alpha channels, having alphaChannelCount entries. 20 | unsigned int alphaChannelCount; ///< The number of alpha channels stored in the array. 21 | 22 | uint8_t* iccProfile; ///< Raw data of the ICC profile. 23 | uint32_t sizeOfICCProfile; 24 | 25 | uint8_t* exifData; ///< Raw EXIF data. 26 | uint32_t sizeOfExifData; 27 | 28 | bool containsRealMergedData; ///< Whether the PSD contains real merged data. 29 | 30 | char* xmpMetadata; ///< Raw XMP metadata. 31 | 32 | Thumbnail* thumbnail; ///< JPEG thumbnail. 33 | }; 34 | 35 | PSD_NAMESPACE_END 36 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdKey.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | namespace util 10 | { 11 | /// \ingroup Util 12 | /// \class Key 13 | /// \brief Helper template used to produce a 32-bit value out of 4 characters for comparison purposes. 14 | /// \details Many parts of a .PSD file store a 4-character string for identification purposes, e.g. a valid .PSD file 15 | /// always starts with the character sequence "8BPS". This helper template can be used to build a 32-bit value that 16 | /// can be compared against the big-endian signature read from the .PSD file. 17 | /// \code 18 | /// // read the signature from a file, and convert the big-endian value to native endianness 19 | /// const uint32_t signature = util::ReadFromFileBE(reader); 20 | /// 21 | /// // check if the signature matches "8BPS" by using the util::Key helper template 22 | /// if (signature == util::Key<'8', 'B', 'P', 'S'>::VALUE) 23 | /// ... 24 | /// \endcode 25 | /// \remark Note that util::Key::VALUE is a compile-time constant, and can therefore be used in other template expressions, 26 | /// switch cases, etc. 27 | template 28 | struct Key 29 | { 30 | static const uint32_t VALUE = 31 | ((static_cast(a) << 24u) | 32 | (static_cast(b) << 16u) | 33 | (static_cast(c) << 8u) | 34 | (static_cast(d))); 35 | }; 36 | 37 | template const uint32_t Key::VALUE; 38 | } 39 | 40 | PSD_NAMESPACE_END 41 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdLayerCanvasCopy.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | namespace imageUtil 10 | { 11 | /// \ingroup ImageUtil 12 | /// Copies 8-bit planar layer data to a canvas. Only the parts overlapping the canvas will be copied to it. 13 | void CopyLayerData(const uint8_t* PSD_RESTRICT layerData, uint8_t* PSD_RESTRICT canvasData, int layerLeft, int layerTop, int layerRight, int layerBottom, unsigned int canvasWidth, unsigned int canvasHeight); 14 | 15 | /// \ingroup ImageUtil 16 | /// Copies 16-bit planar layer data to a canvas. Only the parts overlapping the canvas will be copied to it. 17 | void CopyLayerData(const uint16_t* PSD_RESTRICT layerData, uint16_t* PSD_RESTRICT canvasData, int layerLeft, int layerTop, int layerRight, int layerBottom, unsigned int canvasWidth, unsigned int canvasHeight); 18 | 19 | /// \ingroup ImageUtil 20 | /// Copies 32-bit planar layer data to a canvas. Only the parts overlapping the canvas will be copied to it. 21 | void CopyLayerData(const float32_t* PSD_RESTRICT layerData, float32_t* PSD_RESTRICT canvasData, int layerLeft, int layerTop, int layerRight, int layerBottom, unsigned int canvasWidth, unsigned int canvasHeight); 22 | } 23 | 24 | PSD_NAMESPACE_END 25 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdLayerMask.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class LayerMask 11 | /// \brief A struct representing a layer mask as stored in the layers of the Layer Mask section. 12 | /// \sa Layer VectorMask 13 | struct LayerMask 14 | { 15 | int32_t top; ///< Top coordinate of the rectangle that encloses the mask. 16 | int32_t left; ///< Left coordinate of the rectangle that encloses the mask. 17 | int32_t bottom; ///< Bottom coordinate of the rectangle that encloses the mask. 18 | int32_t right; ///< Right coordinate of the rectangle that encloses the mask. 19 | 20 | uint64_t fileOffset; ///< The offset from the start of the file where the channel's data is stored. 21 | 22 | void* data; ///< Planar data, having a size of (right-left)*(bottom-top)*bytesPerPixel. 23 | 24 | float64_t feather; ///< The mask's feather value. 25 | uint8_t density; ///< The mask's density value. 26 | uint8_t defaultColor; ///< The mask's default color regions outside the enclosing rectangle. 27 | }; 28 | 29 | PSD_NAMESPACE_END 30 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdLayerMaskSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct Layer; 10 | 11 | 12 | /// \ingroup Sections 13 | /// \class LayerMaskSection 14 | /// \brief A struct representing the information extracted from the Layer Mask section. 15 | /// \sa Layer 16 | struct LayerMaskSection 17 | { 18 | Layer* layers; ///< An array of layers, having layerCount entries. 19 | unsigned int layerCount; ///< The number of layers stored in the array. 20 | 21 | uint16_t overlayColorSpace; ///< The color space of the overlay (undocumented, not used yet). 22 | uint16_t opacity; ///< The global opacity level (0 = transparent, 100 = opaque, not used yet). 23 | uint8_t kind; ///< The global kind of layer (not used yet). 24 | 25 | bool hasTransparencyMask; ///< Whether the layer data contains a transparency mask or not. 26 | }; 27 | 28 | PSD_NAMESPACE_END 29 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdLayerType.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \namespace layerType 11 | /// \brief A namespace holding layer types known by Photoshop. 12 | namespace layerType 13 | { 14 | enum Enum 15 | { 16 | ANY = 0, ///< Any other type of layer. 17 | OPEN_FOLDER = 1, ///< Open folder. 18 | CLOSED_FOLDER = 2, ///< Closed folder. 19 | SECTION_DIVIDER = 3 ///< Bounding section divider, hidden in the UI. 20 | }; 21 | } 22 | 23 | PSD_NAMESPACE_END 24 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdMallocAllocator.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "PsdAllocator.h" 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | /// \ingroup Allocators 12 | /// \brief Simple allocator implementation that uses malloc and free internally. 13 | /// \sa Allocator 14 | class MallocAllocator : public Allocator 15 | { 16 | private: 17 | virtual void* DoAllocate(size_t size, size_t alignment) PSD_OVERRIDE; 18 | virtual void DoFree(void* ptr) PSD_OVERRIDE; 19 | }; 20 | 21 | PSD_NAMESPACE_END 22 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdMemoryUtil.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "PsdAllocator.h" 7 | #include "Psdispod.h" 8 | #include "PsdAssert.h" 9 | 10 | 11 | PSD_NAMESPACE_BEGIN 12 | 13 | /// \ingroup Util 14 | /// \namespace memoryUtil 15 | /// \brief Provides memory allocation utilities. 16 | namespace memoryUtil 17 | { 18 | /// Allocates memory for an instance of type T, using T's default alignment. 19 | template 20 | inline T* Allocate(Allocator* allocator); 21 | 22 | /// Allocates memory for \a count instances of type T, using T's default alignment. 23 | /// \remark Note that this does not call any constructors, and hence only works for POD types. 24 | template 25 | inline T* AllocateArray(Allocator* allocator, size_t count); 26 | 27 | /// Frees memory previously allocated with \a allocator, and nullifies \a ptr. 28 | template 29 | inline void Free(Allocator* allocator, T*& ptr); 30 | 31 | /// Frees an array previously allocated with \a allocator, and nullifies \a ptr. 32 | /// \remark Note that this does not call any destructors, and hence only works for POD types. 33 | template 34 | inline void FreeArray(Allocator* allocator, T*& ptr); 35 | } 36 | 37 | #include "PsdMemoryUtil.inl" 38 | 39 | PSD_NAMESPACE_END 40 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdNamespace.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | /// \def PSD_NAMESPACE_NAME 8 | /// \ingroup Platform 9 | /// \brief Macro used to configure the name of the PSD library namespace. 10 | #define PSD_NAMESPACE_NAME psd 11 | 12 | 13 | /// \def PSD_NAMESPACE 14 | /// \ingroup Platform 15 | /// \brief Macro used to refer to a symbol in the PSD library namespace. 16 | /// \sa PSD_USING_NAMESPACE 17 | #define PSD_NAMESPACE PSD_NAMESPACE_NAME 18 | 19 | 20 | /// \def PSD_NAMESPACE_BEGIN 21 | /// \ingroup Platform 22 | /// \brief Macro used to open a namespace in the PSD library. 23 | /// \sa PSD_NAMESPACE_END 24 | #define PSD_NAMESPACE_BEGIN namespace PSD_NAMESPACE_NAME { 25 | 26 | 27 | /// \def PSD_NAMESPACE_END 28 | /// \ingroup Platform 29 | /// \brief Macro used to close a namespace previously opened with \ref PSD_NAMESPACE_BEGIN. 30 | /// \sa PSD_NAMESPACE_BEGIN 31 | #define PSD_NAMESPACE_END } 32 | 33 | 34 | /// \def PSD_USING_NAMESPACE 35 | /// \ingroup Platfrom 36 | /// \brief Macro used to make the PSD library namespace available in a translation unit. 37 | /// \sa PSD_NAMESPACE 38 | #define PSD_USING_NAMESPACE using namespace PSD_NAMESPACE_NAME 39 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdNativeFile.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "PsdFile.h" 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | /// \ingroup Files 12 | /// \brief Simple file implementation that uses Windows' native file functions internally. 13 | /// \sa File 14 | class NativeFile : public File 15 | { 16 | public: 17 | /// Constructor. 18 | explicit NativeFile(Allocator* allocator); 19 | 20 | private: 21 | virtual bool DoOpenRead(const wchar_t* filename) PSD_OVERRIDE; 22 | virtual bool DoOpenWrite(const wchar_t* filename) PSD_OVERRIDE; 23 | virtual bool DoClose(void) PSD_OVERRIDE; 24 | 25 | virtual File::ReadOperation DoRead(void* buffer, uint32_t count, uint64_t position) PSD_OVERRIDE; 26 | virtual bool DoWaitForRead(File::ReadOperation& operation) PSD_OVERRIDE; 27 | 28 | virtual File::WriteOperation DoWrite(const void* buffer, uint32_t count, uint64_t position) PSD_OVERRIDE; 29 | virtual bool DoWaitForWrite(File::WriteOperation& operation) PSD_OVERRIDE; 30 | 31 | virtual uint64_t DoGetSize(void) const PSD_OVERRIDE; 32 | 33 | // internally, this is a HANDLE, but we don't want to include Windows.h just for that 34 | void* m_file; 35 | }; 36 | 37 | PSD_NAMESPACE_END 38 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdNativeFile_Linux.h: -------------------------------------------------------------------------------- 1 | //Linux 2 | #pragma once 3 | 4 | #include "PsdPch.h" 5 | #include "PsdAllocator.h" 6 | #include "PsdFile.h" 7 | #include "PsdNamespace.h" 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | /// \ingroup Files 12 | /// \brief Simple file implementation that uses Posix asio internally. 13 | /// \sa File 14 | class NativeFile : public File 15 | { 16 | public: 17 | /// Constructor. 18 | explicit NativeFile(Allocator* allocator); 19 | 20 | private: 21 | virtual bool DoOpenRead(const wchar_t* filename) PSD_OVERRIDE; 22 | virtual bool DoOpenWrite(const wchar_t* filename) PSD_OVERRIDE; 23 | virtual bool DoClose(void) PSD_OVERRIDE; 24 | 25 | virtual File::ReadOperation DoRead(void* buffer, uint32_t count, uint64_t position) PSD_OVERRIDE; 26 | virtual bool DoWaitForRead(File::ReadOperation& operation) PSD_OVERRIDE; 27 | 28 | virtual File::WriteOperation DoWrite(const void* buffer, uint32_t count, uint64_t position) PSD_OVERRIDE; 29 | virtual bool DoWaitForWrite(File::WriteOperation& operation) PSD_OVERRIDE; 30 | 31 | virtual uint64_t DoGetSize(void) const PSD_OVERRIDE; 32 | 33 | int m_fd; 34 | }; 35 | 36 | 37 | PSD_NAMESPACE_END 38 | 39 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdNativeFile_Mac.h: -------------------------------------------------------------------------------- 1 | // 2 | // PsdNativeFile_Mac.cpp 3 | // Contributed to psd_sdk 4 | // 5 | // Created by Oluseyi Sonaiya on 3/29/20. 6 | // Copyright © 2020 Oluseyi Sonaiya. All rights reserved. 7 | // 8 | // psd_sdk Copyright 2011-2020, Molecular Matters GmbH 9 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 10 | 11 | #pragma once 12 | 13 | #include 14 | #include "PsdFile.h" 15 | 16 | 17 | PSD_NAMESPACE_BEGIN 18 | 19 | /// \ingroup Files 20 | /// \brief Simple file implementation that uses Windows' native file functions internally. 21 | /// \sa File 22 | class NativeFile : public File 23 | { 24 | public: 25 | /// Constructor. 26 | explicit NativeFile(Allocator* allocator); 27 | 28 | private: 29 | virtual bool DoOpenRead(const wchar_t* filename) PSD_OVERRIDE; 30 | virtual bool DoOpenWrite(const wchar_t* filename) PSD_OVERRIDE; 31 | virtual bool DoClose(void) PSD_OVERRIDE; 32 | 33 | virtual File::ReadOperation DoRead(void* buffer, uint32_t count, uint64_t position) PSD_OVERRIDE; 34 | virtual bool DoWaitForRead(File::ReadOperation& operation) PSD_OVERRIDE; 35 | 36 | virtual File::WriteOperation DoWrite(const void* buffer, uint32_t count, uint64_t position) PSD_OVERRIDE; 37 | virtual bool DoWaitForWrite(File::WriteOperation& operation) PSD_OVERRIDE; 38 | 39 | virtual uint64_t DoGetSize(void) const PSD_OVERRIDE; 40 | 41 | dispatch_fd_t m_fileDescriptor; 42 | }; 43 | 44 | PSD_NAMESPACE_END 45 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdParseColorModeDataSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct Document; 10 | class File; 11 | class Allocator; 12 | struct ColorModeDataSection; 13 | 14 | 15 | /// \ingroup Parser 16 | /// Parses the color mode data section in the document, and returns a newly created instance that needs to be freed 17 | /// by a call to \ref DestroyColorModeDataSection. 18 | /// \remark This function does not yet parse meaningful data. 19 | ColorModeDataSection* ParseColorModeDataSection(const Document* document, File* file, Allocator* allocator); 20 | 21 | /// \ingroup Parser 22 | /// Destroys and nullifies the given \a section previously created by a call to \ref ParseColorModeDataSection. 23 | void DestroyColorModeDataSection(ColorModeDataSection*& section, Allocator* allocator); 24 | 25 | PSD_NAMESPACE_END 26 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdParseDocument.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct Document; 10 | class File; 11 | class Allocator; 12 | 13 | 14 | /// \ingroup Parser 15 | /// Parses only the header and section offsets, and returns a newly created document that needs to be freed 16 | /// by a call to \ref DestroyDocument. 17 | Document* CreateDocument(File* file, Allocator* allocator); 18 | 19 | /// \ingroup Parser 20 | /// Destroys and nullifies the given \a document previously created by a call to \ref CreateDocument. 21 | void DestroyDocument(Document*& document, Allocator* allocator); 22 | 23 | PSD_NAMESPACE_END 24 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdParseImageDataSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct Document; 10 | class File; 11 | class Allocator; 12 | struct ImageDataSection; 13 | 14 | 15 | /// \ingroup Parser 16 | /// Parses the image data section in the document, and returns a newly created instance that needs to be freed 17 | /// by a call to \ref DestroyImageDataSection. 18 | /// \remark It is valid to parse different sections of a document (e.g. using \ref ParseImageResourcesSection, \ref ParseImageDataSection, 19 | /// or \ref ParseLayerMaskSection) in parallel from different threads. 20 | ImageDataSection* ParseImageDataSection(const Document* document, File* file, Allocator* allocator); 21 | 22 | /// \ingroup Parser 23 | /// Destroys and nullifies the given \a section previously created by a call to \ref ParseImageDataSection. 24 | void DestroyImageDataSection(ImageDataSection*& section, Allocator* allocator); 25 | 26 | PSD_NAMESPACE_END 27 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdParseImageResourcesSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct Document; 10 | class File; 11 | class Allocator; 12 | struct ImageResourcesSection; 13 | 14 | 15 | /// \ingroup Parser 16 | /// Parses the image resources section in the document, and returns a newly created instance that needs to be freed 17 | /// by a call to \ref DestroyImageResourcesSection. 18 | /// \remark It is valid to parse different sections of a document (e.g. using \ref ParseImageResourcesSection, \ref ParseImageDataSection, 19 | /// or \ref ParseLayerMaskSection) in parallel from different threads. 20 | ImageResourcesSection* ParseImageResourcesSection(const Document* document, File* file, Allocator* allocator); 21 | 22 | /// \ingroup Parser 23 | /// Destroys and nullifies the given \a section previously created by a call to \ref ParseImageResourcesSection. 24 | void DestroyImageResourcesSection(ImageResourcesSection*& section, Allocator* allocator); 25 | 26 | PSD_NAMESPACE_END 27 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdParseLayerMaskSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | struct Document; 10 | class File; 11 | class Allocator; 12 | struct Layer; 13 | struct LayerMaskSection; 14 | 15 | 16 | /// \ingroup Parser 17 | /// Parses the layer mask section in the document, and returns a newly created instance that needs to be freed 18 | /// by a call to \ref DestroyLayerMaskSection. This function does not extract layer data yet, that has to be done 19 | /// by a call to \ref ExtractLayer for each layer. 20 | /// \remark It is valid to parse different sections of a document (e.g. using \ref ParseImageResourcesSection, \ref ParseImageDataSection, 21 | /// or \ref ParseLayerMaskSection) in parallel from different threads. 22 | LayerMaskSection* ParseLayerMaskSection(const Document* document, File* file, Allocator* allocator); 23 | 24 | /// \ingroup Parser 25 | /// Extracts data for a given \a layer. 26 | /// \remark It is valid and suggested to extract the data of individual layers from multiple threads in parallel. 27 | void ExtractLayer(const Document* document, File* file, Allocator* allocator, Layer* layer); 28 | 29 | /// \ingroup Parser 30 | /// Destroys and nullifies the given \a section previously created by a call to \ref ParseLayerMaskSection. 31 | void DestroyLayerMaskSection(LayerMaskSection*& section, Allocator* allocator); 32 | 33 | PSD_NAMESPACE_END 34 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdPlanarImage.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class PlanarImage 11 | /// \brief A struct representing a planar image as stored in the Image Data section. 12 | /// \sa ImageDataSection 13 | struct PlanarImage 14 | { 15 | void* data; ///< Planar data the size of the document's canvas. 16 | }; 17 | 18 | PSD_NAMESPACE_END 19 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdPlatform.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | // enable strict type checking for Windows headers 8 | #ifndef STRICT 9 | # define STRICT 10 | #endif 11 | 12 | // exclude rarely used Windows stuff 13 | #define WIN32_LEAN_AND_MEAN 14 | #define WIN32_EXTRA_LEAN 15 | #define VC_EXTRALEAN 16 | 17 | // prevent Windows from polluting the global namespace with too many things 18 | #define NOGDICAPMASKS 19 | #define NOWINDOWSTATION 20 | #define NOVIRTUALKEYCODES 21 | #define NOWINMESSAGES 22 | #define NOWINSTYLES 23 | #define NOSYSMETRICS 24 | #define NOMENUS 25 | #define NOICONS 26 | #define NOKEYSTATES 27 | #define NOSYSCOMMANDS 28 | #define NORASTEROPS 29 | #define NOSHOWWINDOW 30 | #define OEMRESOURCE 31 | #define NOATOM 32 | #define NOCLIPBOARD 33 | #define NOCOLOR 34 | #define NOCTLMGR 35 | #define NODRAWTEXT 36 | #define NOGDI 37 | #define NOKERNEL 38 | #define NOUSER 39 | #define NONLS 40 | #define NOMB 41 | #define NOMEMMGR 42 | #define NOMETAFILE 43 | #define NOMINMAX 44 | #define NOMSG 45 | #define NOOPENFILE 46 | #define NOSCROLL 47 | #define NOSERVICE 48 | #define NOSOUND 49 | #define NOTEXTMETRIC 50 | #define NOWH 51 | #define NOWINOFFSETS 52 | #define NOCOMM 53 | #define NOKANJI 54 | #define NOHELP 55 | #define NOMCX 56 | #define NOPROFILER 57 | #define NOIME 58 | #define NODEFERWINDOWPOS 59 | #define NOMCX 60 | 61 | 62 | #if PSD_USE_MSVC 63 | // the main Windows header 64 | PSD_PUSH_WARNING_LEVEL(0) 65 | #include 66 | PSD_POP_WARNING_LEVEL 67 | #endif 68 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdSection.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class Section 11 | /// \brief A struct storing data for any section in a .PSD file. 12 | struct Section 13 | { 14 | uint64_t offset; ///< The offset from the start of the file where this section is stored. 15 | uint32_t length; ///< The length of the section. 16 | }; 17 | 18 | PSD_NAMESPACE_END 19 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdStringUtil.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "PsdNamespace.h" 4 | #include "PsdAllocator.h" 5 | 6 | PSD_NAMESPACE_BEGIN 7 | 8 | namespace stringUtil 9 | { 10 | /// 11 | /// \brief Convert wchar_t * to char * 12 | /// 13 | /// \param ws The wide string 14 | /// \param alloc The mem allocator 15 | /// \return char* nullptr on error 16 | /// 17 | char *ConvertWString(const wchar_t* ws, Allocator* alloc); 18 | } 19 | 20 | PSD_NAMESPACE_END 21 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdSyncFileReader.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | class File; 10 | 11 | 12 | /// \ingroup Files 13 | /// \brief Synchronous file wrapper using an arbitrary \ref File implementation for sequential reads. 14 | /// \details In certain situations, working with synchronous read operations is much easier than having to deal with a number 15 | /// of asynchronous reads, keeping track of individual read operations. This is especially true when parsing a file sequentially, 16 | /// where different read operations depend on previous ones. 17 | /// \sa File 18 | class SyncFileReader 19 | { 20 | public: 21 | /// Constructor initializing the internal read position to zero. 22 | /// \remark The given \a file must already be open. 23 | explicit SyncFileReader(File* file); 24 | 25 | /// Reads \a count bytes into \a buffer synchronously, incrementing the internal read position. 26 | void Read(void* buffer, uint32_t count); 27 | 28 | /// Skips \a count bytes. 29 | void Skip(uint64_t count); 30 | 31 | /// Sets the internal read position for the next call to Read(). 32 | void SetPosition(uint64_t position); 33 | 34 | /// Returns the internal read position. 35 | uint64_t GetPosition(void) const; 36 | 37 | private: 38 | File* m_file; 39 | uint64_t m_position; 40 | }; 41 | 42 | PSD_NAMESPACE_END 43 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdSyncFileUtil.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include "PsdEndianConversion.h" 7 | #include "PsdSyncFileReader.h" 8 | #include "PsdSyncFileWriter.h" 9 | 10 | 11 | PSD_NAMESPACE_BEGIN 12 | 13 | /// \ingroup Util 14 | /// \namespace fileUtil 15 | /// \brief Provides file reading utilities. 16 | namespace fileUtil 17 | { 18 | /// Reads built-in data types from a file. 19 | template 20 | inline T ReadFromFile(SyncFileReader& reader); 21 | 22 | /// Reads built-in data types from a file, assuming they are stored as big-endian data. 23 | /// The read value is automatically converted to the native endianness. 24 | template 25 | inline T ReadFromFileBE(SyncFileReader& reader); 26 | 27 | /// Writes built-in data types to a file. 28 | template 29 | inline void WriteToFile(SyncFileWriter& writer, const T& data); 30 | 31 | /// Writes built-in data types to a file, assuming they are to be stored as big-endian data. 32 | /// The write value is automatically converted to the native endianness. 33 | template 34 | inline void WriteToFileBE(SyncFileWriter& writer, const T& data); 35 | } 36 | 37 | #include "PsdSyncFileUtil.inl" 38 | 39 | PSD_NAMESPACE_END 40 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdSyncFileWriter.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | class File; 10 | 11 | 12 | /// \ingroup Files 13 | /// \brief Synchronous file wrapper using an arbitrary \ref File implementation for sequential writes. 14 | /// \details In certain situations, working with synchronous write operations is much easier than having to deal with a number 15 | /// of asynchronous writes, keeping track of individual write operations. This is especially true when e.g. writing header information. 16 | /// \sa File 17 | class SyncFileWriter 18 | { 19 | public: 20 | /// Constructor initializing the internal write position to zero. 21 | /// \remark The given \a file must already be open. 22 | explicit SyncFileWriter(File* file); 23 | 24 | /// Writes \a count bytes from \a buffer synchronously, incrementing the internal write position. 25 | void Write(const void* buffer, uint32_t count); 26 | 27 | /// Returns the internal write position. 28 | uint64_t GetPosition(void) const; 29 | 30 | private: 31 | File* m_file; 32 | uint64_t m_position; 33 | }; 34 | 35 | PSD_NAMESPACE_END 36 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdThumbnail.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class Thumbnail 11 | /// \brief A struct representing a thumbnail as stored in the image resources section. 12 | /// \sa ImageResourcesSection 13 | struct Thumbnail 14 | { 15 | uint32_t width; 16 | uint32_t height; 17 | uint32_t binaryJpegSize; 18 | uint8_t* binaryJpeg; 19 | }; 20 | 21 | PSD_NAMESPACE_END 22 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdTypes.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | #include "Psdstdint.h" 8 | 9 | 10 | /// \ingroup Platform 11 | /// \brief Defines a standard 32-bit floating-point type. 12 | typedef float float32_t; 13 | 14 | 15 | /// \ingroup Platform 16 | /// \brief Defines a standard 64-bit floating-point type. 17 | typedef double float64_t; 18 | 19 | 20 | static_assert(sizeof(uint8_t) == 1, "sizeof(uint8_t) is not 1 byte"); 21 | static_assert(sizeof(int8_t) == 1, "sizeof(int8_t) is not 1 byte"); 22 | 23 | static_assert(sizeof(uint16_t) == 2, "sizeof(uint16_t) is not 2 bytes"); 24 | static_assert(sizeof(int16_t) == 2, "sizeof(int16_t) is not 2 bytes"); 25 | 26 | static_assert(sizeof(uint32_t) == 4, "sizeof(uint32_t) is not 4 bytes"); 27 | static_assert(sizeof(int32_t) == 4, "sizeof(int32_t) is not 4 bytes"); 28 | 29 | static_assert(sizeof(uint64_t) == 8, "sizeof(uint64_t) is not 8 bytes"); 30 | static_assert(sizeof(int64_t) == 8, "sizeof(int64_t) is not 8 bytes"); 31 | 32 | static_assert(sizeof(float32_t) == 4, "sizeof(float32_t) is not 4 bytes"); 33 | static_assert(sizeof(float64_t) == 8, "sizeof(float64_t) is not 8 bytes"); 34 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdUnionCast.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | namespace util 10 | { 11 | /// \ingroup Util 12 | /// \brief Casts from one type into another via a union. 13 | /// \details This type of cast is similar to a reinterpret_cast, but never violates the strict aliasing rule, and should 14 | /// therefore be used e.g. when trying to treat one type of data as a different, non-compatible one. 15 | /// \code 16 | /// float f = 1.0f; 17 | /// uint32_t bits = union_cast(f); 18 | /// \endcode 19 | /// \remark Both types must have the same size. 20 | template 21 | PSD_INLINE TO union_cast(FROM from); 22 | } 23 | 24 | #include "PsdUnionCast.inl" 25 | 26 | PSD_NAMESPACE_END 27 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/PsdVectorMask.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_NAMESPACE_BEGIN 8 | 9 | /// \ingroup Types 10 | /// \class VectorMask 11 | /// \brief A struct representing a vector mask as stored in the layers of the Layer Mask section. 12 | /// \sa Layer LayerMask 13 | struct VectorMask 14 | { 15 | int32_t top; ///< Top coordinate of the rectangle that encloses the mask. 16 | int32_t left; ///< Left coordinate of the rectangle that encloses the mask. 17 | int32_t bottom; ///< Bottom coordinate of the rectangle that encloses the mask. 18 | int32_t right; ///< Right coordinate of the rectangle that encloses the mask. 19 | 20 | uint64_t fileOffset; ///< The offset from the start of the file where the channel's data is stored. 21 | 22 | void* data; ///< Planar data, having a size of (right-left)*(bottom-top)*bytesPerPixel. 23 | 24 | float64_t feather; ///< The mask's feather value. 25 | uint8_t density; ///< The mask's density value. 26 | uint8_t defaultColor; ///< The mask's default color regions outside the enclosing rectangle. 27 | }; 28 | 29 | PSD_NAMESPACE_END 30 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/Psdinttypes.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | #if PSD_USE_MSVC && PSD_USE_MSVC_VER <= 2012 8 | // VS2008, VS2010 and VS2012 don't provide inttypes.h 9 | #define PRIu64 "I64u" 10 | #define PRId64 "I64d" 11 | #else 12 | #include 13 | #endif 14 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/Psdispod.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | namespace util 12 | { 13 | /// \ingroup Util 14 | /// \brief Wrapper around std::is_pod, because it is not supported by all compilers. 15 | template 16 | struct IsPod 17 | { 18 | #if PSD_USE_MSVC && PSD_USE_MSVC_VER <= 2008 19 | static const bool value = std::tr1::is_pod::value; 20 | #else 21 | static const bool value = std::is_pod::value; 22 | #endif 23 | }; 24 | 25 | template const bool IsPod::value; 26 | } 27 | 28 | PSD_NAMESPACE_END 29 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/Psdisunsigned.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | 9 | PSD_NAMESPACE_BEGIN 10 | 11 | namespace util 12 | { 13 | /// \ingroup Util 14 | /// \brief Wrapper around std::is_unsigned, because it is not supported by all compilers. 15 | template 16 | struct IsUnsigned 17 | { 18 | #if PSD_USE_MSVC && PSD_USE_MSVC_VER <= 2008 19 | static const bool value = std::tr1::is_unsigned::value; 20 | #else 21 | static const bool value = std::is_unsigned::value; 22 | #endif 23 | }; 24 | 25 | template const bool IsUnsigned::value; 26 | } 27 | 28 | PSD_NAMESPACE_END 29 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/Psdminiz.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | PSD_PUSH_WARNING_LEVEL(0) 8 | #define MINIZ_HEADER_FILE_ONLY 9 | #include "Psdminiz.c" 10 | #undef MINIZ_HEADER_FILE_ONLY 11 | PSD_POP_WARNING_LEVEL 12 | -------------------------------------------------------------------------------- /jarkViewer/include/psdsdk/Psdstdint.h: -------------------------------------------------------------------------------- 1 | // Copyright 2011-2020, Molecular Matters GmbH 2 | // See LICENSE.txt for licensing details (2-clause BSD License: https://opensource.org/licenses/BSD-2-Clause) 3 | 4 | #pragma once 5 | 6 | 7 | // Pull in standard 8-bit, 16-bit, 32-bit and 64-bit types. 8 | #if PSD_USE_MSVC && PSD_USE_MSVC_VER <= 2008 9 | // VS2008 does not ship with the stdint.h header. 10 | typedef signed __int8 int8_t; 11 | typedef signed __int16 int16_t; 12 | typedef signed __int32 int32_t; 13 | typedef unsigned __int8 uint8_t; 14 | typedef unsigned __int16 uint16_t; 15 | typedef unsigned __int32 uint32_t; 16 | typedef signed __int64 int64_t; 17 | typedef unsigned __int64 uint64_t; 18 | 19 | #ifndef SIZE_MAX 20 | #ifdef _WIN64 21 | #define SIZE_MAX _UI64_MAX 22 | #else 23 | #define SIZE_MAX _UI32_MAX 24 | #endif 25 | #endif 26 | #else 27 | PSD_PUSH_WARNING_LEVEL(0) 28 | #include 29 | #if defined(__APPLE__) 30 | #include 31 | #endif 32 | PSD_POP_WARNING_LEVEL 33 | #endif 34 | -------------------------------------------------------------------------------- /jarkViewer/include/targetver.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // // 包含 SDKDDKVer.h 可定义可用的最高版本的 Windows 平台。 4 | // 如果希望为之前的 Windows 平台构建应用程序，在包含 SDKDDKVer.h 之前请先包含 WinSDKVer.h 并 5 | // 将 _WIN32_WINNT 宏设置为想要支持的平台。 6 | #include 7 | -------------------------------------------------------------------------------- /jarkViewer/include/x265_config.h: -------------------------------------------------------------------------------- 1 | /***************************************************************************** 2 | * Copyright (C) 2013-2020 MulticoreWare, Inc 3 | * 4 | * Authors: Steve Borho 5 | * 6 | * This program is free software; you can redistribute it and/or modify 7 | * it under the terms of the GNU General Public License as published by 8 | * the Free Software Foundation; either version 2 of the License, or 9 | * (at your option) any later version. 10 | * 11 | * This program is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | * GNU General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU General Public License 17 | * along with this program; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA. 19 | * 20 | * This program is also available under a commercial proprietary license. 21 | * For more information, contact us at license @ x265.com. 22 | *****************************************************************************/ 23 | 24 | #ifndef X265_CONFIG_H 25 | #define X265_CONFIG_H 26 | 27 | /* Defines generated at build time */ 28 | 29 | /* Incremented each time public API is changed, X265_BUILD is used as 30 | * the shared library SONAME on platforms which support it. It also 31 | * prevents linking against a different version of the static lib */ 32 | #define X265_BUILD 209 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /jarkViewer/jarkViewer.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/jarkViewer.ico -------------------------------------------------------------------------------- /jarkViewer/jarkViewer.rc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/jarkViewer.rc -------------------------------------------------------------------------------- /jarkViewer/jarkViewer.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | "D:\Downloads\test\10.ico" 5 | WindowsLocalDebugger 6 | 7 | 8 | "D:\Downloads\test\10.ico" 9 | WindowsLocalDebugger 10 | 11 | -------------------------------------------------------------------------------- /jarkViewer/lib/Psd_MT.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/lib/Psd_MT.pdb -------------------------------------------------------------------------------- /jarkViewer/libavcodec/bswapdsp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVCODEC_BSWAP_BUF_H 20 | #define AVCODEC_BSWAP_BUF_H 21 | 22 | #include 23 | 24 | typedef struct BswapDSPContext { 25 | void (*bswap_buf)(uint32_t *dst, const uint32_t *src, int w); 26 | void (*bswap16_buf)(uint16_t *dst, const uint16_t *src, int len); 27 | } BswapDSPContext; 28 | 29 | void ff_bswapdsp_init(BswapDSPContext *c); 30 | void ff_bswapdsp_init_x86(BswapDSPContext *c); 31 | 32 | #endif /* AVCODEC_BSWAP_BUF_H */ 33 | -------------------------------------------------------------------------------- /jarkViewer/libavcodec/hevcpred.h: -------------------------------------------------------------------------------- 1 | /* 2 | * HEVC video Decoder 3 | * 4 | * Copyright (C) 2012 - 2013 Guillaume Martres 5 | * 6 | * This file is part of FFmpeg. 7 | * 8 | * FFmpeg is free software; you can redistribute it and/or 9 | * modify it under the terms of the GNU Lesser General Public 10 | * License as published by the Free Software Foundation; either 11 | * version 2.1 of the License, or (at your option) any later version. 12 | * 13 | * FFmpeg is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 | * Lesser General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public 19 | * License along with FFmpeg; if not, write to the Free Software 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 | */ 22 | 23 | #ifndef AVCODEC_HEVCPRED_H 24 | #define AVCODEC_HEVCPRED_H 25 | 26 | #include 27 | #include 28 | 29 | struct HEVCContext; 30 | 31 | typedef struct HEVCPredContext { 32 | void (*intra_pred[4])(struct HEVCContext *s, int x0, int y0, int c_idx); 33 | 34 | void (*pred_planar[4])(uint8_t *src, const uint8_t *top, 35 | const uint8_t *left, ptrdiff_t stride); 36 | void (*pred_dc)(uint8_t *src, const uint8_t *top, const uint8_t *left, 37 | ptrdiff_t stride, int log2_size, int c_idx); 38 | void (*pred_angular[4])(uint8_t *src, const uint8_t *top, 39 | const uint8_t *left, ptrdiff_t stride, 40 | int c_idx, int mode, 41 | int disable_intra_boundary_filter BIT_DEPTH_PARAM); 42 | } HEVCPredContext; 43 | 44 | void ff_hevc_pred_init(HEVCPredContext *hpc, int bit_depth); 45 | 46 | #endif /* AVCODEC_HEVCPRED_H */ 47 | -------------------------------------------------------------------------------- /jarkViewer/libavcodec/rnd_avg.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2001-2003 BERO 3 | * Copyright (c) 2011 Oskar Arvidsson 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVCODEC_RND_AVG_H 23 | #define AVCODEC_RND_AVG_H 24 | 25 | #include 26 | #include 27 | 28 | #define BYTE_VEC32(c) ((c) * 0x01010101UL) 29 | #define BYTE_VEC64(c) ((c) * 0x0001000100010001UL) 30 | 31 | static inline uint32_t rnd_avg32(uint32_t a, uint32_t b) 32 | { 33 | return (a | b) - (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1); 34 | } 35 | 36 | static inline uint32_t no_rnd_avg32(uint32_t a, uint32_t b) 37 | { 38 | return (a & b) + (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1); 39 | } 40 | 41 | static inline uint64_t rnd_avg64(uint64_t a, uint64_t b) 42 | { 43 | return (a | b) - (((a ^ b) & ~BYTE_VEC64(0x01)) >> 1); 44 | } 45 | 46 | static inline uint64_t no_rnd_avg64(uint64_t a, uint64_t b) 47 | { 48 | return (a & b) + (((a ^ b) & ~BYTE_VEC64(0x01)) >> 1); 49 | } 50 | 51 | #endif /* AVCODEC_RND_AVG_H */ 52 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/adler32.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2006 Mans Rullgard 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_ADLER32_H 22 | #define AVUTIL_ADLER32_H 23 | 24 | #include 25 | #include "attributes.h" 26 | 27 | /** 28 | * @file 29 | * Public header for libavutil Adler32 hasher 30 | * 31 | * @defgroup lavu_adler32 Adler32 32 | * @ingroup lavu_crypto 33 | * @{ 34 | */ 35 | 36 | /** 37 | * Calculate the Adler32 checksum of a buffer. 38 | * 39 | * Passing the return value to a subsequent av_adler32_update() call 40 | * allows the checksum of multiple buffers to be calculated as though 41 | * they were concatenated. 42 | * 43 | * @param adler initial checksum value 44 | * @param buf pointer to input buffer 45 | * @param len size of input buffer 46 | * @return updated checksum 47 | */ 48 | unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf, 49 | unsigned int len) av_pure; 50 | 51 | /** 52 | * @} 53 | */ 54 | 55 | #endif /* AVUTIL_ADLER32_H */ 56 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/atomic_suncc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * This file is part of FFmpeg. 4 | * 5 | * FFmpeg is free software; you can redistribute it and/or 6 | * modify it under the terms of the GNU Lesser General Public 7 | * License as published by the Free Software Foundation; either 8 | * version 2.1 of the License, or (at your option) any later version. 9 | * 10 | * FFmpeg is distributed in the hope that it will be useful, 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 | * Lesser General Public License for more details. 14 | * 15 | * You should have received a copy of the GNU Lesser General Public 16 | * License along with FFmpeg; if not, write to the Free Software 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 | */ 19 | 20 | #ifndef AVUTIL_ATOMIC_SUNCC_H 21 | #define AVUTIL_ATOMIC_SUNCC_H 22 | 23 | #include 24 | #include 25 | 26 | #include "atomic.h" 27 | 28 | #define avpriv_atomic_int_get atomic_int_get_suncc 29 | static inline int atomic_int_get_suncc(volatile int *ptr) 30 | { 31 | __machine_rw_barrier(); 32 | return *ptr; 33 | } 34 | 35 | #define avpriv_atomic_int_set atomic_int_set_suncc 36 | static inline void atomic_int_set_suncc(volatile int *ptr, int val) 37 | { 38 | *ptr = val; 39 | __machine_rw_barrier(); 40 | } 41 | 42 | #define avpriv_atomic_int_add_and_fetch atomic_int_add_and_fetch_suncc 43 | static inline int atomic_int_add_and_fetch_suncc(volatile int *ptr, int inc) 44 | { 45 | return atomic_add_int_nv(ptr, inc); 46 | } 47 | 48 | #define avpriv_atomic_ptr_cas atomic_ptr_cas_suncc 49 | static inline void *atomic_ptr_cas_suncc(void * volatile *ptr, 50 | void *oldval, void *newval) 51 | { 52 | return atomic_cas_ptr(ptr, oldval, newval); 53 | } 54 | 55 | #endif /* AVUTIL_ATOMIC_SUNCC_H */ 56 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/atomic_win32.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2012 Ronald S. Bultje 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_ATOMIC_WIN32_H 22 | #define AVUTIL_ATOMIC_WIN32_H 23 | 24 | #include 25 | 26 | #define avpriv_atomic_int_get atomic_int_get_win32 27 | static inline int atomic_int_get_win32(volatile int *ptr) 28 | { 29 | MemoryBarrier(); 30 | return *ptr; 31 | } 32 | 33 | #define avpriv_atomic_int_set atomic_int_set_win32 34 | static inline void atomic_int_set_win32(volatile int *ptr, int val) 35 | { 36 | *ptr = val; 37 | MemoryBarrier(); 38 | } 39 | 40 | #define avpriv_atomic_int_add_and_fetch atomic_int_add_and_fetch_win32 41 | static inline int atomic_int_add_and_fetch_win32(volatile int *ptr, int inc) 42 | { 43 | return inc + InterlockedExchangeAdd((LONG*)ptr, (LONG)inc); 44 | } 45 | 46 | #define avpriv_atomic_ptr_cas atomic_ptr_cas_win32 47 | static inline void *atomic_ptr_cas_win32(void * volatile *ptr, 48 | void *oldval, void *newval) 49 | { 50 | return InterlockedCompareExchangePointer(ptr, newval, oldval); 51 | } 52 | 53 | #endif /* AVUTIL_ATOMIC_WIN32_H */ 54 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/audioconvert.h: -------------------------------------------------------------------------------- 1 | 2 | #include "version.h" 3 | 4 | #if FF_API_AUDIOCONVERT 5 | #include "channel_layout.h" 6 | #endif 7 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/avconfig.h: -------------------------------------------------------------------------------- 1 | /* Generated by ffconf */ 2 | #ifndef AVUTIL_AVCONFIG_H 3 | #define AVUTIL_AVCONFIG_H 4 | #define AV_HAVE_BIGENDIAN 0 5 | #define AV_HAVE_FAST_UNALIGNED 0 6 | #define AV_HAVE_INCOMPATIBLE_LIBAV_ABI 0 7 | #endif /* AVUTIL_AVCONFIG_H */ 8 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/cpu_internal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVUTIL_CPU_INTERNAL_H 20 | #define AVUTIL_CPU_INTERNAL_H 21 | 22 | #include "cpu.h" 23 | 24 | #define CPUEXT_SUFFIX(flags, suffix, cpuext) \ 25 | (HAVE_ ## cpuext ## suffix && ((flags) & AV_CPU_FLAG_ ## cpuext)) 26 | 27 | #define CPUEXT(flags, cpuext) CPUEXT_SUFFIX(flags, , cpuext) 28 | 29 | int ff_get_cpu_flags_aarch64(void); 30 | int ff_get_cpu_flags_arm(void); 31 | int ff_get_cpu_flags_ppc(void); 32 | int ff_get_cpu_flags_x86(void); 33 | 34 | #endif /* AVUTIL_CPU_INTERNAL_H */ 35 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/ffversion.h: -------------------------------------------------------------------------------- 1 | #ifndef AVUTIL_FFVERSION_H 2 | #define AVUTIL_FFVERSION_H 3 | #define FFMPEG_VERSION "N-67732-g530eb6a" 4 | #endif /* AVUTIL_FFVERSION_H */ 5 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/log2_tab.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2003-2012 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #include 22 | 23 | const uint8_t ff_log2_tab[256]={ 24 | 0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, 25 | 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 26 | 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 27 | 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 28 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 29 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 30 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 31 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 32 | }; 33 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/macros.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | /** 20 | * @file 21 | * @ingroup lavu 22 | * Utility Preprocessor macros 23 | */ 24 | 25 | #ifndef AVUTIL_MACROS_H 26 | #define AVUTIL_MACROS_H 27 | 28 | /** 29 | * @addtogroup preproc_misc Preprocessor String Macros 30 | * 31 | * String manipulation macros 32 | * 33 | * @{ 34 | */ 35 | 36 | #define AV_STRINGIFY(s) AV_TOSTRING(s) 37 | #define AV_TOSTRING(s) #s 38 | 39 | #define AV_GLUE(a, b) a ## b 40 | #define AV_JOIN(a, b) AV_GLUE(a, b) 41 | 42 | /** 43 | * @} 44 | */ 45 | 46 | #define AV_PRAGMA(s) _Pragma(#s) 47 | 48 | #endif /* AVUTIL_MACROS_H */ 49 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/motion_vector.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVUTIL_MOTION_VECTOR_H 20 | #define AVUTIL_MOTION_VECTOR_H 21 | 22 | #include 23 | 24 | typedef struct AVMotionVector { 25 | /** 26 | * Where the current macroblock comes from; negative value when it comes 27 | * from the past, positive value when it comes from the future. 28 | * XXX: set exact relative ref frame reference instead of a +/- 1 "direction". 29 | */ 30 | int32_t source; 31 | /** 32 | * Width and height of the block. 33 | */ 34 | uint8_t w, h; 35 | /** 36 | * Absolute source position. Can be outside the frame area. 37 | */ 38 | int16_t src_x, src_y; 39 | /** 40 | * Absolute destination position. Can be outside the frame area. 41 | */ 42 | int16_t dst_x, dst_y; 43 | /** 44 | * Extra flag information. 45 | * Currently unused. 46 | */ 47 | uint64_t flags; 48 | } AVMotionVector; 49 | 50 | #endif /* AVUTIL_MOTION_VECTOR_H */ 51 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/murmur3.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2013 Reimar Döffinger 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_MURMUR3_H 22 | #define AVUTIL_MURMUR3_H 23 | 24 | #include 25 | 26 | struct AVMurMur3 *av_murmur3_alloc(void); 27 | void av_murmur3_init_seeded(struct AVMurMur3 *c, uint64_t seed); 28 | void av_murmur3_init(struct AVMurMur3 *c); 29 | void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len); 30 | void av_murmur3_final(struct AVMurMur3 *c, uint8_t dst[16]); 31 | 32 | #endif /* AVUTIL_MURMUR3_H */ 33 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/opencl_internal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2012 Peng Gao 3 | * Copyright (C) 2012 Li Cao 4 | * Copyright (C) 2012 Wei Gao 5 | * 6 | * This file is part of FFmpeg. 7 | * 8 | * FFmpeg is free software; you can redistribute it and/or 9 | * modify it under the terms of the GNU Lesser General Public 10 | * License as published by the Free Software Foundation; either 11 | * version 2.1 of the License, or (at your option) any later version. 12 | * 13 | * FFmpeg is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 | * Lesser General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public 19 | * License along with FFmpeg; if not, write to the Free Software 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 | */ 22 | 23 | #include "opencl.h" 24 | 25 | #define FF_OPENCL_PARAM_INFO(a) ((void*)(&(a))), (sizeof(a)) 26 | 27 | typedef struct { 28 | cl_kernel kernel; 29 | int param_num; 30 | void *ctx; 31 | } FFOpenclParam; 32 | 33 | int avpriv_opencl_set_parameter(FFOpenclParam *opencl_param, ...); 34 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/pca.h: -------------------------------------------------------------------------------- 1 | /* 2 | * principal component analysis (PCA) 3 | * Copyright (c) 2004 Michael Niedermayer 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | /** 23 | * @file 24 | * principal component analysis (PCA) 25 | */ 26 | 27 | #ifndef AVUTIL_PCA_H 28 | #define AVUTIL_PCA_H 29 | 30 | struct PCA *ff_pca_init(int n); 31 | void ff_pca_free(struct PCA *pca); 32 | void ff_pca_add(struct PCA *pca, const double *v); 33 | int ff_pca(struct PCA *pca, double *eigenvector, double *eigenvalue); 34 | 35 | #endif /* AVUTIL_PCA_H */ 36 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/random_seed.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2009 Baptiste Coudurier 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_RANDOM_SEED_H 22 | #define AVUTIL_RANDOM_SEED_H 23 | 24 | #include 25 | /** 26 | * @addtogroup lavu_crypto 27 | * @{ 28 | */ 29 | 30 | /** 31 | * Get a seed to use in conjunction with random functions. 32 | * This function tries to provide a good seed at a best effort bases. 33 | * Its possible to call this function multiple times if more bits are needed. 34 | * It can be quite slow, which is why it should only be used as seed for a faster 35 | * PRNG. The quality of the seed depends on the platform. 36 | */ 37 | uint32_t av_get_random_seed(void); 38 | 39 | /** 40 | * @} 41 | */ 42 | 43 | #endif /* AVUTIL_RANDOM_SEED_H */ 44 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/rc4.h: -------------------------------------------------------------------------------- 1 | /* 2 | * RC4 encryption/decryption/pseudo-random number generator 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_RC4_H 22 | #define AVUTIL_RC4_H 23 | 24 | #include 25 | 26 | struct AVRC4 { 27 | uint8_t state[256]; 28 | int x, y; 29 | }; 30 | 31 | /** 32 | * @brief Initializes an AVRC4 context. 33 | * 34 | * @param key_bits must be a multiple of 8 35 | * @param decrypt 0 for encryption, 1 for decryption, currently has no effect 36 | */ 37 | int av_rc4_init(struct AVRC4 *d, const uint8_t *key, int key_bits, int decrypt); 38 | 39 | /** 40 | * @brief Encrypts / decrypts using the RC4 algorithm. 41 | * 42 | * @param count number of bytes 43 | * @param dst destination array, can be equal to src 44 | * @param src source array, can be equal to dst, may be NULL 45 | * @param iv not (yet) used for RC4, should be NULL 46 | * @param decrypt 0 for encryption, 1 for decryption, not (yet) used 47 | */ 48 | void av_rc4_crypt(struct AVRC4 *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); 49 | 50 | #endif /* AVUTIL_RC4_H */ 51 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/replaygain.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * This file is part of FFmpeg. 4 | * 5 | * FFmpeg is free software; you can redistribute it and/or 6 | * modify it under the terms of the GNU Lesser General Public 7 | * License as published by the Free Software Foundation; either 8 | * version 2.1 of the License, or (at your option) any later version. 9 | * 10 | * FFmpeg is distributed in the hope that it will be useful, 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 | * Lesser General Public License for more details. 14 | * 15 | * You should have received a copy of the GNU Lesser General Public 16 | * License along with FFmpeg; if not, write to the Free Software 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 | */ 19 | 20 | #ifndef AVUTIL_REPLAYGAIN_H 21 | #define AVUTIL_REPLAYGAIN_H 22 | 23 | #include 24 | 25 | /** 26 | * ReplayGain information (see 27 | * http://wiki.hydrogenaudio.org/index.php?title=ReplayGain_1.0_specification). 28 | * The size of this struct is a part of the public ABI. 29 | */ 30 | typedef struct AVReplayGain { 31 | /** 32 | * Track replay gain in microbels (divide by 100000 to get the value in dB). 33 | * Should be set to INT32_MIN when unknown. 34 | */ 35 | int32_t track_gain; 36 | /** 37 | * Peak track amplitude, with 100000 representing full scale (but values 38 | * may overflow). 0 when unknown. 39 | */ 40 | uint32_t track_peak; 41 | /** 42 | * Same as track_gain, but for the whole album. 43 | */ 44 | int32_t album_gain; 45 | /** 46 | * Same as track_peak, but for the whole album, 47 | */ 48 | uint32_t album_peak; 49 | } AVReplayGain; 50 | 51 | #endif /* AVUTIL_REPLAYGAIN_H */ 52 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/time_avutil.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2000-2003 Fabrice Bellard 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_TIME_H 22 | #define AVUTIL_TIME_H 23 | 24 | #include 25 | 26 | /** 27 | * Get the current time in microseconds. 28 | */ 29 | int64_t av_gettime(void); 30 | 31 | /** 32 | * Get the current time in microseconds since some unspecified starting point. 33 | * On platforms that support it, the time comes from a monotonic clock 34 | * This property makes this time source ideal for measuring relative time. 35 | * The returned values may not be monotonic on platforms where a monotonic 36 | * clock is not available. 37 | */ 38 | int64_t av_gettime_relative(void); 39 | 40 | /** 41 | * Indicates with a boolean result if the av_gettime_relative() time source 42 | * is monotonic. 43 | */ 44 | int av_gettime_relative_is_monotonic(void); 45 | 46 | /** 47 | * Sleep for a period of time. Although the duration is expressed in 48 | * microseconds, the actual delay may be rounded to the precision of the 49 | * system timer. 50 | * 51 | * @param usec Number of microseconds to sleep. 52 | * @return zero on success or (negative) error code. 53 | */ 54 | int av_usleep(unsigned usec); 55 | 56 | #endif /* AVUTIL_TIME_H */ 57 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/time_internal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVUTIL_TIME_INTERNAL_H 20 | #define AVUTIL_TIME_INTERNAL_H 21 | 22 | #include 23 | #include "config.h" 24 | 25 | #if !HAVE_GMTIME_R && !defined(gmtime_r) 26 | static inline struct tm *gmtime_r(const time_t* clock, struct tm *result) 27 | { 28 | struct tm *ptr = gmtime(clock); 29 | if (!ptr) 30 | return NULL; 31 | *result = *ptr; 32 | return result; 33 | } 34 | #endif 35 | 36 | #if !HAVE_LOCALTIME_R && !defined(localtime_r) 37 | static inline struct tm *localtime_r(const time_t* clock, struct tm *result) 38 | { 39 | struct tm *ptr = localtime(clock); 40 | if (!ptr) 41 | return NULL; 42 | *result = *ptr; 43 | return result; 44 | } 45 | #endif 46 | 47 | #endif /* AVUTIL_TIME_INTERNAL_H */ 48 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/x86_cpu.h: -------------------------------------------------------------------------------- 1 | #include "libavutil/x86/asm.h" 2 | -------------------------------------------------------------------------------- /jarkViewer/libavutil/xga_font_data.h: -------------------------------------------------------------------------------- 1 | /* 2 | * CGA/EGA/VGA ROM font data 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | /** 22 | * @file 23 | * CGA/EGA/VGA ROM font data 24 | */ 25 | 26 | #ifndef AVUTIL_XGA_FONT_DATA_H 27 | #define AVUTIL_XGA_FONT_DATA_H 28 | 29 | #include 30 | #include "internal.h" 31 | 32 | extern av_export const uint8_t avpriv_cga_font[2048]; 33 | extern av_export const uint8_t avpriv_vga16_font[4096]; 34 | 35 | #endif /* AVUTIL_XGA_FONT_DATA_H */ 36 | -------------------------------------------------------------------------------- /jarkViewer/resource.h: -------------------------------------------------------------------------------- 1 | #define IDC_MYICON 2 2 | #define IDD_JARKVIEWER_DIALOG 102 3 | #define IDS_APP_TITLE 103 4 | #define IDM_ABOUT 104 5 | #define IDI_JARKVIEWER 107 6 | #define IDI_SMALL 108 7 | #define IDC_JARKVIEWER 109 8 | #define IDR_MAINFRAME 128 9 | #define IDR_ACCELERATOR1 134 10 | #define IDB_PNG_TIPS 136 11 | #define IDB_PNG_HOME 137 12 | #define IDR_MSYHMONO_TTF 138 13 | #define IDB_PNG_SETTING_RES 139 14 | #define IDB_PNG_MAIN_RES 140 15 | #define IDB_PNG_PRINTER_RES 141 16 | #define IDC_STATIC -1 17 | 18 | // Next default values for new objects 19 | // 20 | #ifdef APSTUDIO_INVOKED 21 | #ifndef APSTUDIO_READONLY_SYMBOLS 22 | #define _APS_NO_MFC 1 23 | #define _APS_NEXT_RESOURCE_VALUE 142 24 | #define _APS_NEXT_COMMAND_VALUE 32772 25 | #define _APS_NEXT_CONTROL_VALUE 1000 26 | #define _APS_NEXT_SYMED_VALUE 110 27 | #endif 28 | #endif 29 | -------------------------------------------------------------------------------- /jarkViewer/small.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/jarkViewer/small.ico -------------------------------------------------------------------------------- /jarkViewer/src/cpp.hint: -------------------------------------------------------------------------------- 1 | // 提示文件帮助 Visual Studio IDE 解释 Visual C++ 标识符, 2 | // 如函数和宏的名称。 3 | // 有关详细信息，请参见 https://go.microsoft.com/fwlink/?linkid=865984 4 | #define NULL 5 | #define MB_ICONERROR 6 | -------------------------------------------------------------------------------- /preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/preview.png -------------------------------------------------------------------------------- /printerPreview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jark006/JarkViewer/6188cd9df774ac47b9ad7ef6d2e269b5acd3e0ac/printerPreview.png --------------------------------------------------------------------------------