Quantcast
Channel: Intel Developer Zone Articles
Viewing all 533 articles
Browse latest View live

How to create video wall with MSDK sample_multi_transcode

$
0
0

1. Download and install MSDK samples

Download and install MSDK sample from https://software.intel.com/en-us/intel-media-server-studio/code-samples or https://software.intel.com/en-us/media-sdk/documentation/code-samples

2. Create par file for sample_multi_transcode for 4 sources

-i::h264 crowd_run_1080p.264 -vpp_comp_dst_x 0 -vpp_comp_dst_y 0 -vpp_comp_dst_w 960 -vpp_comp_dst_h 540     -join -o::sink
-i::h264 crowd_run_1080p.264 -vpp_comp_dst_x 960 -vpp_comp_dst_y 0 -vpp_comp_dst_w 960 -vpp_comp_dst_h 540   -join -o::sink
-i::h264 crowd_run_1080p.264 -vpp_comp_dst_x 0 -vpp_comp_dst_y 540 -vpp_comp_dst_w 960 -vpp_comp_dst_h 540   -join -o::sink
-i::h264 crowd_run_1080p.264 -vpp_comp_dst_x 960 -vpp_comp_dst_y 540 -vpp_comp_dst_w 960 -vpp_comp_dst_h 540 -join -o::sink
-vpp_comp_only 4 -join -i::source

3. About parameters use in sample_multi_transode

-o::sink   | Output of this session serves as input for all sessions using the -i::source.
-i::source | The session receives the output of the session using the -o::sink option at input.
-join      | Join the session to another session.

More information about parameters, please refer to readme-multi-transcode.pdf in the source code folder.

A script for performance test with MSDK samples

$
0
0

1. Introduce the script

When MSDK run on difference platform, performance test usually needed when do the evaluation. MSDK sample is very good tools to do the performance, it supports media classic pipeline: decode, VPP, and encode, also has useful information to calculate the performance like running time, frame number etc. When do performance test, we also need to need the resouces usage, including CPU, memory, GPU usage etc. So auto run script is better to handle this. Followings will introduce this such scripts.

2. Download the script from Github.

$ git clone https://github.com/zchrzhou/mdk-perf-script.git

highly recommend to read : https://github.com/zchrzhou/mdk-perf-script/blob/master/readme.txt

3. Features of MSDK performance script

  • Perl script, easy extend, auto collect performance data (FPS/GPU/CPU/MEM usage).
  • Batch run many test cases in order.
  • Loop run test cases for stress test.
  • Support MSDK sample_decode, sample_encode, sample_vpp, sample_multi_transcode
  • Multi-OS support, support both Windows and Linux.

4. How to use this tool

$ ./run.sh or ./main.pl
Welcome to Intel MediaSDK sample multiable process test tool.
Enjoy and good luck.
Performance test with Intel MSDK sample
Use example:
    main.pl [--test <item-1> --test <item-n>] [--all] [--loop n] [--start n1 --end n2]
    main.pl [--test A01 --test B1 --test C1] [--loop 2]
    main.pl [--start 1 --end 10] [--loop 2]
    main.pl [--test A01] [--loop -1]

    --loop:         loop run (-1 will run forever)
    --start|--end:  run with the range from --start to --end
                    refer to lib/config.pl -> %conf{"range_template"}
    --all:          for all test items in lib/config.pl -> %test_map
    --test:         test item, refter to lib/config.pl -> %test_map

    --input-dir:    set input file folder
    --output-dir:   set output file folder
    --sample-dir:   set sample binary folder

    --with-output:  save output of transcode
    --with-par:     only for transcode test
    --with-gpu:     only for linux
    --with-cpu-mem  only for linux

5. Configure your test cases

please modify config.pm to custom your tests.

$ vim lib/config.pm
### Test Map
##Transcode: ITEM => [channel-num, test-type, input-codec, input-file, output-codex, output-ext, head-args, tail-args]
##Decode:    ITEM => [channel-num, test-type, input-param, input-file, output-param, output-ext, head-args, tail-args]
##Encode:    ITEM => [channel-num, test-type, input-param, input-file, output-param, output-ext, head-args, tail-args]
##VPP:       ITEM => [channel-num, test-type, input-param, input-file, output-param, output-ext, head-args, tail-args]
our %test_map = ("A01" => [1,  "transcode",  "-i::h264", "1080p.h264", "-o::h264", "h264", "", "-hw -w 1920 -h 1080 -u 7 -b 6000"],"A02" => [2,  "transcode",  "-i::h264", "1080p.h264", "-o::h264", "h264", "", "-hw -w 1920 -h 1080 -u 7 -b 6000"],"B1"  => [5,  "transcode",  "-i::h264", "1080p.h264", "-o::h264", "h264", "", "-hw -w 1280 -h 720 -u 7 -b 2048"],"C5"  => [4,  "transcode",  "-i::mpeg2", "1080p.m2t", "-o::h264", "h264", "", "-hw -w 176  -h 144  -u 7 -b 80"  ],"D2"  => [6,  "decode", "-i", "JOY_1080.h264", "-o", "yuv",  "h264", "-hw" ],"D3"  => [2,  "decode", "-i", "JOY_1080.h264", "-r", "",     "h264", "-hw" ],"E2"  => [6,  "encode", "-i", "JOY_1080.yuv", "-o", "h264", "h264", "-hw -w 1920  -h 1080" ],"F1"  => [2,  "vpp", "-i", "JOY_1080.yuv", "-o", "yuv", "-lib hw", "-scc nv12 -dcc nv12 -sw 1920  -sh 1080 -dw 1280  -dh 720 -n 5" ],"V0"  => [16, "transcode",  "-i::h264", "1080p.h264", "-o::h264", "h264", "", "-hw -w 1920 -h 1080 -u 7 -b 15000"],"V1"  => [16, "transcode",  "-i::h264", "1080p.h264", "-o::h264", "h264", "", "-hw -w 1920 -h 1080 -u 7 -b 15000"],"V2"  => [16, "transcode",  "-i::h264", "1080p.h264", "-o::h264", "h264", "", "-hw -w 1920 -h 1080 -u 7 -b 15000"],
);

6. A demo for run this scripts

$ ./run.sh --test A02 --with-fps --with-cpu-mem --with-par --with-gpu
Welcome to Intel MediaSDK sample multiable process test tool.
Enjoy and good luck.
mkdir -p input
mkdir -p output/A02
rm -rf   output/A02/*
rm -f input/1080p.h264
cp -f /home/zhoujd/perf-script/stream/1080p.h264 input/1080p.h264
Start top by child process
Test --with-par is used
Start top by child process
/home/zhoujd/perf-script/binary/sample_multi_transcode  -par output/A02/multi-channel.par > output/A02/A02-with-par.log
libva info: VA-API version 0.99.0
libva info: va_getDriverName() returns 0
libva info: User requested driver 'iHD'
libva info: Trying to open /opt/intel/mediasdk/lib64/iHD_drv_video.so
libva info: Found init function __vaDriverInit_0_32
libva info: va_openDriver() returns 0
[sudo] password for zhoujd:
top process num: zhoujd   18207 18200  0 22:20 pts/5    00:00:00 /bin/bash /home/zhoujd/perf-script/tools/cpu_mem/top.sh 1 sample_m

gpu process num: zhoujd   18208 18200  0 22:20 pts/5    00:00:00 /bin/bash /home/zhoujd/perf-script/tools/gpu/metrics_monitor.sh

0-time: 4.21 sec
0-frames: 500
0-fps: 118.69
1-time: 4.21 sec
1-frames: 500
1-fps: 118.75
AVG FPS: 118.72
Num Stream: 2
CPU: 13.1 %
MEM: 46.86 MB
GPU: 58.00% 95.75% 0.00%
mv /home/zhoujd/perf-script/tools/cpu_mem/cpu_mem.txt output/A02
mv /home/zhoujd/perf-script/tools/gpu/gpu.log output/A02
Wait 2s ...
run finished

Explore Unity Technologies ML-Agents* Exclusively on Intel® Architecture

$
0
0

Abstract

This article describes how to install and run Unity Technologies ML-Agents* in CPU-only environments. It demonstrates how to:

  • Train and run the ML-Agents Balance Balls example on Windows* without CUDA* and cuDNN*.
  • Perform a TensorFlow* CMake build on Windows optimized for Intel® Advanced Vector Extensions 2 (Intel® AVX2).
  • Create a simple Amazon Web Services* (AWS) Ubuntu* Amazon Machine Image* environment from scratch without CUDA and cuDNN, build a “headless” version of Balance Balls for Linux*, and train it on AWS.

Introduction

Unity Technologies released their beta version of Machine Learning Agents* (ML-Agents*) in September 2017, offering an exciting introduction to reinforcement learning using their 3D game engine. According to Unity’s introductory blog, this open SDK will potentially benefit academic researchers, industry researchers interested in “training regimes for robotics, autonomous vehicle, and other industrial applications,” and game developers.

Unity’s ML-Agents SDK leverages TensorFlow* as the machine learning framework for training agents using a Proximal Policy Optimization (PPO) algorithm. There are several example projects included in the GitHub* download, as well as a Getting Started example and documentation on how to install and use the SDK.

One downside of the SDK for some developers is the implied dependencies on CUDA* and cuDNN* to get the ML-Agents environment up and running. As it turns out, it is possible to not only explore ML-Agents exclusively on a CPU, but also perform a custom build of TensorFlow on a Windows® 10 computer to include optimizations for Intel® architecture.

In this article we show you how to:

  • Train and run the ML-Agents Balance Balls (see Figure 1) example on Windows without CUDA and cuDNN.
  • Perform a TensorFlow CMake build on Windows* optimized for Intel® Advanced Vector Extensions 2 (Intel® AVX2).
  • Create a simple Amazon Web Services* (AWS) Ubuntu* Amazon Machine Image* (AMI) environment from scratch without CUDA and cuDNN, build a “headless” version of Balance Balls for Linux*, and train it on AWS.


Figure 1. Trained Balance Balls model running in Unity* software.

 

Target Audience

This article is intended for developers who have had some exposure to TensorFlow, Unity software, Python*, AWS, and machine learning concepts.

System Configurations

The following system configurations were used in the preparation of this article:

Windows Workstation

  • Intel® Xeon® processor E3-1240 v5
  • Microsoft Windows 10, version 1709

Linux Server (Training)

  • Intel® Xeon® Platinum 8180 processor @ 2.50 GHz
  • Ubuntu Server 16.04 LTS

AWS Cloud (Training)

  • Intel® Xeon® processor
  • Ubuntu Server 16.04 LTS AMI

In the section on training ML-Agents in the cloud we use a free-tier Ubuntu Server 16.04 AMI.

Install Common Windows Components

This section describes the installation of common software components required to get the ML-Agents environment up and running. The Unity ML-Agents documentation contains an Installation and Setup procedure that links to a webpage instructing the user to install CUDA and cuDNN. Although this is fine if your system already has a graphics processing unit (GPU) card that is compatible with CUDA and you don’t mind the extra effort, it is not a requirement. Either way, we encourage you to review the Unity ML-Agents documentation before proceeding. 

There are essentially three steps required to install the common software components:

  1. Download and install Unity 2017.1 or later from the package located here.
  2. Download the ML-Agents SDK from GitHub. Extract the files and move them to a project folder of your choice (for example, C:\ml-agents).
  3. Download and install the Anaconda* distribution for Python 3.6 version for Windows, located here.

Install Prebuilt TensorFlow*

This section follows the guidelines for installing TensorFlow on Windows with CPU support only. According to the TensorFlow website, “this version of TensorFlow is typically much easier to install (typically, in 5 or 10 minutes), so even if you have an NVIDIA* GPU, we recommend installing this version first.” Follow these steps to install prebuilt TensorFlow on your Windows 10 system:

  1. In the Start menu, click the Anaconda Prompt icon (see Figure 2) to open a new terminal.


    Figure 2. Windows* Start menu.

  2. Type the following commands at the prompt:

    > conda create -n tensorflow-cpu python=3.5
    > activate tensorflow-cpu
    > pip install --ignore-installed --upgrade tensorflow

  3. As specified in the TensorFlow documentation, ensure the installation worked correctly by starting Python and typing the following commands:

    > python
    >>> import tensorflow as tf
    >>> hello = tf.constant('Hello')
    >>> sess = tf.Session()
    >>> print (sess.run(hello))

  4. If everything worked correctly, 'Hello' should print to the terminal as shown in Figure 3.


    Figure 3. Python* test output.

    You may also notice a message like the one shown in Figure 3, stating “Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX AVX2.” This message may vary depending on the Intel® processor in your system; it indicates TensorFlow could run faster on your computer if you build it from sources, which we will do in the next section.

  5. To close Python, at the prompt, press CTRL+Z.
     
  6. Navigate to the python subdirectory of the ML-Agents repository you downloaded earlier, and then run the following command to install the other required dependencies:

    > pip install.

  7. Refer to the Building Unity Environment section of the “Getting Started with Balance Ball Example” tutorial to complete the ML-Agents tutorial.

Install TensorFlow from Sources

This section describes how to build an optimized version of TensorFlow on your Windows 10 system.

The TensorFlow website states, “We don't officially support building TensorFlow on Windows; however, you may try to build TensorFlow on Windows if you don't mind using the highly experimental Bazel on Windows or TensorFlow CMake build.” However, don’t let this discourage you. In this section we provide instructions on how to perform a CMake build on your Windows system.

The following TensorFlow build guidelines complement the Step-by-step Windows build instructions shown on GitHub. To get a more complete understanding of the build process, we encourage you to review the GitHub documentation before continuing. 

  1. Install Microsoft Visual Studio* 2015. Be sure to check the programming options as shown in Figure 4.


    Figure 4. Visual Studio* programming options.

  2. Download and install Git from here. Accept all default settings for the installation.
     
  3. Download and extract swigwin from here. Change folders to C:\swigwin-3.0.12 (note that the version number may be different on your system).
     
  4. Download and install CMake version 3.6 from here. During the installation, be sure to check the option Add CMake to the system path for all users.
     
  5. In the Start menu, click the Anaconda Prompt icon (see Figure 2) to open a new terminal. Type the following commands at the prompt:

    > conda create -n tensorflow-custom36 python=3.6
    > activate tensorflow-custom36

  6. Run the following command to set up the environment:

    > "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat"

    (Note: If vcvarsall.bat is not found, try following the instructions provided here.)
     
  7. Clone the TensorFlow repository and create a working directory for your build:

    cd /
    > git clone https://github.com/tensorflow/tensorflow.git
    > cd tensorflow\tensorflow\contrib\cmake
    > mkdir build
    > cd build

  8. Type the following commands (Note: Be sure to check the paths and library version shown below on your own system, as they may be different):

    > cmake .. -A x64 -DCMAKE_BUILD_TYPE=Release ^
    -DSWIG_EXECUTABLE=C:\swigwin-3.0.12/swig.exe ^
    -DPYTHON_EXECUTABLE=C:/Users/%USERNAME%/Anaconda3/python.exe ^
    -DPYTHON_LIBRARIES=C:/Users/%USERNAME%/Anaconda3/libs/python36.lib ^
    -Dtensorflow_WIN_CPU_SIMD_OPTIONS=/arch:AVX2

  9. Build the pip package, which will be created as a .whl file in the directory .\tf_python\dist (for example, C:\tensorflow\tensorflow\contrib\cmake\build\tf_python\dist\tensorflow-1.4.0-cp36-cp36m-win_amd64.whl).

    > C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild /p:Configuration=Release tf_python_build_pip_package.vcxproj

    (Note: Be sure to check the path to MSBuild on your own system as it may be different.)
     
  10. Install the newly created TensorFlow build by typing the following command:

    pip install C:\tensorflow\tensorflow\contrib\cmake\build\tf_python\dist\tensorflow-1.4.0-cp36-cp36m-win_amd64.whl

  11. As specified in the TensorFlow documentation, ensure the installation worked correctly by starting Python and typing the following commands:

    > python
    >>> import tensorflow as tf
    >>> hello = tf.constant('Hello')
    >>> sess = tf.Session()
    >>> print (sess.run(hello))

  12. If everything worked correctly, 'Hello' should print to the terminal. Also, we should not see any build optimization warnings like we saw in the previous section (see Figure 5).


    Figure 5. Python* test output.

  13. To close Python, at the prompt, press CTRL+Z.
     
  14. Navigate to the python subdirectory of the ML-Agents repository you downloaded earlier, and then run the following command to install the other required dependencies:

    > pip install .

  15. Refer to the Building Unity Environment section of the “Getting Started with Balance Ball Example” tutorial to complete the ML-Agents tutorial.

Train ML-Agents in the Cloud

The ML-Agents documentation provides a guide titled “Training on Amazon–Web Service” that contains instructions for setting up an EC2 instance on AWS for training ML-Agents. Although this guide states, “you will need an EC2 instance which contains the latest Nvidia* drivers, CUDA8, and cuDNN,” there is a simpler way to do cloud-based training without the GPU overhead.

In this section we perform the following steps:

  • Create an Ubuntu Server 16.04 AMI (free tier).
  • Install prerequisite applications on Windows for interacting with the cloud server.
  • Install Python and TensorFlow on the AMI.
  • Build a headless Linux version of the Balance Balls application on Windows.
  • Export the Python code in the PPO.ipynb Jupyter Notebook* to run as a stand-alone script in the Linux environment.
  • Copy the python directory from Windows to the Linux AMI.
  • Run a training session on AWS for the ML-Agents Balance Balls application.
  1. Create an account on AWS if you don’t already have one. You can follow the steps shown in this section with an AWS Free Tier account; however, we do not cover every detail of creating an account and configuring an AMI, because the website contains detailed information on how to do this.
  2. Create an Ubuntu Server 16.04 AMI. Figure 6 shows the machine instance we used for preparing this article.


    Figure 6. Linux* Server 16.04 LTS Amazon Machine Image*.

  3. Install PuTTY* and WinSCP* on your Windows workstation. Detailed instructions and links for installing these components, connecting to your Linux instance from Windows using PuTTY, and transferring files to your Linux instance using WinSCP are provided on the AWS website.
     
  4. Log in to the Linux Server AMI using PuTTY, and then type the following commands to install Python and TensorFlow:

    > sudo apt-get update
    > sudo apt-get install python3-pip python3-dev
    > pip3 install tensorflow
    > pip3 install image

    Note: The next steps assume you have already completed the ML-Agents Getting Started with Balance Ball Example tutorial. If not, be sure to complete these instructions and verify you can successfully train and run a model on your local Windows workstation before proceeding.
     
  5. Ensure your Unity software installation includes Linux Build Support. You need to explicitly specify this option during installation, or you can add it to an existing installation by running the Unity Download Assistant as shown in Figure 7.


    Figure 7. Unity* software Linux* build support.

  6. In Unity software, open File – Build Settings and make the following selections:
    • Target Platform: Linux
    • Architecture: x86_64
    • Headless Mode: Checked
  7. These settings are shown in Figure 8.


    Figure 8. Unity* software build settings for headless Linux operation.

  8. After clicking Build, create a unique name for the application and save it in the repository’s python folder (see Figure 9). In our example we named it Ball3DHeadless.x86_64 and will refer to it as such for the remainder of this article.


    Figure 9. Build Linux* application.

  9. In order to run through a complete training session on the Linux AMI we will export the Python code in the PPO.ipynb Jupyter Notebook so it can run as a stand-alone script in the Linux environment. To do this, follow these steps:

    - In the Start menu, to open a new terminal, click the Anaconda Prompt icon (Figure 2).
    - Navigate to the python folder, and then type Jupyter Notebook on the command line.
    - Open the PPO.ipynb notebook, and then click File – Download As – Python (.py). This will save a new file named “ppo.py” in the Downloads folder of your Windows computer.
    - Change the filename to “ppo-test.py” and then copy it to the python folder in your ML-Agents repository.
    - Open ppo-test.py in a text editor, and then change the env_name variable to “Ball3DHeadless”:
    - env_name = “Ball3DHeadless” # Name of the training environment file.
    - Save ppo-test.py, and then continue to the next step.

  10. Once the application has been built for the Linux environment and the test script has been generated, use WinSCP to copy the python folder from your ML-Agents repository to the Ubuntu AMI. (Details on transferring files to your Linux instance using WinSCP are provided on the AWS website.)
  11. In the PuTTY console, navigate to the python folder and run the following commands:

    > cd python
    > chmod +x Ball3DHeadless.x86_64
    > python3 ppo-test.py
    If everything went well you should see the training session start up as shown in Figure 10.


    Figure 10. Training session running on an Amazon Web Services* Linux* instance.

Summary

In the output shown in Figure 10, notice that the time (in seconds) is printed to the console after every model save. Code was added to the ppo-test.py script for this article in order to get a rough measure of the training time between model saves.

To instrument the code we made the following modifications to the Python script:

import numpy as np
import os
import tensorflow as tf
import time # New Code
.
.
.
trainer = Trainer(ppo_model, sess, info, is_continuous, use_observations, use_states)
timer_start = time.clock() # New Code
.
.
.
Save_model(sess, model_path=model_path, steps=steps, saver=saver)
print(“ %s seconds “ % (time.clock() – timer_start)) # New Code
timer_start = time.clock() # New Code
.
.
.

Using this informal performance metric, we found that the average difference in training time between a prebuilt TensorFlow GPU binary and prebuilt CPU-only binary on the Windows workstation was negligible. The training time for the custom CPU-only TensorFlow build was roughly 19 percent faster than the prebuilt CPU-only binary on the Windows workstation. When training was performed in the cloud, the AWS Ubuntu Server AMI performed roughly 29 percent faster than the custom TensorFlow build on Windows.

Cannot Find "stdint.h" after Upgrade to Visual Studio 2017

$
0
0

Problem Description

When running Visual Studio 2017 C++ compiler under Intel(R) C++ Compiler environment, or Visual Studio 2017 solution contains mixed projects with both Intel compiler and Visual Studio C++ compiler may encounter 

fatal error C1083: Cannot open include file: '../../vc/include/stdint.h': No such file or directory

Root Cause

In some header files of Intel C++ compiler, we need to include particular Microsoft VC++ header files by path. With Microsoft Visual Studio 2015 and older, we can use the relative path, like “../vc”. Starting from Microsoft Visual Studio 2017 the include directory name contains full VC Tools version number.

For example, the Visual Studio 2017 stdint.h is here:

c:/Program files (x86)/Microsoft Visual Studio/2017/Professional/VC/Tools/MSVC/14.10.24930/include/stdint.h

For Visual Studio 2015, it is here:

c:/Program files (x86)/Microsoft Visual Studio 14.0/VC/INCLUDE/stdint.h

Solution

Workaround is to define __MS_VC_INSTALL_PATH macro in command line (-D option), e.g.:

-D__MS_VC_INSTALL_PATH="c:/Program files (x86)/Microsoft Visual Studio/2017/Professional/VC/Tools/MSVC/14.10.24930" 

To resolve the issue still relies on Microsoft's support. Please see our registered an issue in Microsoft's forum:

https://visualstudio.uservoice.com/forums/121579-visual-studio-ide/suggestions/30930367-add-a-built-in-precompiled-macro-to-vc-that-poin

For users encountered this issue, you are encouraged to vote this idea from above link.

Intel® Facial Special Effects Filter

$
0
0

Intel® Facial Special Effects Filter allows camera pipeline to apply different adjustment effects to the video.

The following features for video adjustment are supported:

Face Special Effect Features

The Lip Color module takes YUV input data. With the facial landmark information fed into the module, the module identifies the lip area when there is a face within the input frame. For input frame with detected faces, the module further performs color modification for lip area with the users’ preference of level of adjustment input from the application. 

The Dark Circles block takes YUV input data. Facial landmark points and skin-tone likelihood are utilized to locate the under eye region for processing. Once identifying the regions, a content-adaptive blending with the users’ preference of level of adjustment input from the application is performed to blend the original YUV.

The Under Eye module takes YUV input data. Facial landmark points and skin-tone likelihood information are utilized jointly to locate the under eye regions for processing. 

The Aging module takes YUV input data. Facial landmark information, semi-circle regions of the detected face, and skin-tone likelihood map fed from the analytic module are utilized to locate the area around eyes for processing. Once identifying the target area, a process with the users’ preference of level of adjustment input from the application is operated on YUV values for all pixels within the area.

The Eye Size module takes YUV input data. With the facial landmark information fed into the module and the users’ preference of level of enlargement input from the application, the module internally derives the proper location within the face and the shape of the eyes users intend to have. 

The Face Shape module takes YUV input data. With the facial landmark information fed into the module and the users’ preference of level of face change-effect input from the application, the module internally derives the different shape version of the original face area and performs morphological warping to create the face special filters effect.

The Skin Foundation module takes YUV input data and blends the input with a user selected foundation color where the per-pixel skin-tone likelihood score serves as the blending factor here.

The Nose feature module takes YUV input data. With the facial landmark information fed into the module and the users’ preference of level of adjustment input from the application, the module internally derives the modified shape of the nose area and performs morphological warping to create the special effect.

The Cheekbone Color block takes YUV input data. Facial landmark and skin-tone likelihood information are utilized to locate the cheekbone regions for processing. Once identifying the regions, a content-adaptive blending with the users’ preference of level of adjustment input from the application is performed to blend the original YUV values and a pre-defined red color value for pixels within the cheekbone region.

Emotions Special Effects Feature

The Emotions module takes YUV input data. With the facial landmark information fed into the module and the users’ preference of level of adjustment input from the application, the module internally derives the modified shape of the mouth area and performs morphological warping to create the smiling face effect via changing the shape of users’ mouths.

Face Tone Special Effects Feature 

The Face Tone block takes YUV input data and adjusts all 3-channel information to produce a smooth version of the input. The skin-tone likelihood map fed from the analytic module with the users’ preference of level of adjustment input from the application is utilized to blend the input image and bilateral filtered image to produce the output smoothed image.

 

Control Panel

We provide a utility that can enable and adjust the strength of each feature. This utility is in the attachment FBContorl_20180208.7z

 

Sample Source Code

We provide DirectShow based and MFT0 based sample source code to demonstrate the usage. The two filter samples will be described as following. You are welcome to integrate this filter into your camera driver package if you're camera IHVs.

 

DirectShow based filter

DirectShow based filter is a combination of enumerated capture filter and custom source filter. Enumerated capture filter is referenced from Microsoft AmCap Sample while custom source filter implementation is referenced from Microsoft Push Source Filters Sample.

DirectShow based filter wrapping camera video input with picture enhancement

 

The Null Renderer filter is a renderer that discards every sample it receives, without displaying or rendering the sample data. Maybe we could think of it like /dev/null in Linux. (Null Renderer Filter)

 

DirectShow standard filter works as an interface to set configure (color format/resolution/FPS) to physical capture device. It exposes PIN_CATEGORY_CAPTURE for downstream to receive sample data. (DirectShow Video Capture Filters)

DirectShow standard filter design to grab sample data from upstream, it exposes both input and output pin. In virtual camera we connect its input pin to Capture Filter’s capture output pin, and connect its output pin to Null Filter. (Sample Grabber Filter)

Implement custom source filter by deriving from DirectShow CSource. (Custom Source Filter)

 

A module that performs Face Special Effects Filters via D3D11 interface VideoProcessorBlt and video processing extension. Support NV12 input/output, it’s not literally a DirectShow filter, but do the fface special effects function after CSC stage.

A module that performs color space conversion via D3D11 interface VideoProcessorBlt. Used to convert YUY2/I420 format into NV12 as FB stage feed-in. It’s not literally a DirectShow filter.

 

Build and Installation:

In the attachment Intel®_Facial_Special_Effects_Filter_dshow_20170810.7z

  1. Install Visual Studio 2015 and Windows 10 SDK (10.0.14393)
  2. Build Win32 baseclasses\Release\strmbase.lib via baseclasses\baseclasses.sln
  3. Build Win32 filters\vcam\Release\x86\vcam_x86.dll via filters\vcam\vcam.sln
  4. Copy and register vcam_x86.dll via amdin command "regsvr32.exe vcam_x86.dll"
  5. Download and install vc_redist.x86.exe from Visual C++ Redistributable for Visual Studio 2015 
  6. Run 32-bit desktop camera app and select virtual camera device "Face Effects Camera"
  7. Change registry keys under [HKEY_CURRENT_USER\SOFTWARE\Intel\Display\DXVA\Intel Dxva Virtual Camera] or run virtual_camera_face_effects_setting.reg
       [0]: default strength
       [1-100]: face special effect strength
       [101]: disable face special effect
  8. Check the face effects.

Uninstall: regsvr32.exe /u vcam_x86.dll

Capabilities for DirectShow based filter:

  1. Only support camera with MJPG or YUY2
  2. Color format: Filter outputs YUY2
  3. FPS: 60 fps
  4. Three available resolutions 1280x720, 640x480 and 640x360 *
  5. Not support rotation mode since DShow app isn’t available under Metro mode.
  6. Max face special effects to 8 human faces.
  7. Only support for DShow app, not support for MF-based app

* GPU can support to 1920x1080. This filter software could be modified to support 1080P.

MFT0 based filter

Windows 10 offers IHVs and system OEMs the ability to create video processing plug-ins in the form of a Media Foundation Transform (MFT), known as the camera driver MFT. The driver MFT is also referred to as MFT0 to indicate that it's the first MFT to operate in the source reader. We add face special effects for video processing based on Driver MFT Sample. We implement capture and preview pin driver MFT on multi-pin cameras. For more info about creating a driver MFT, see Creating a camera driver MFT.

Notice:

  1. Need to install camera driver before the following installation. If you install this MFT0 driver before installing camera driver, the filter could not be applied.
  2. If your camera has its proprietary MFT0 filter, this MFT0 filter will replace with it. Only one MTF0 will be effective.

Build and Installation:

In the attachment Intel®_Facial_Special_Effects_Filter_mft0_20170810.7z

  1. Install Visual Studio 2015 and Windows 10 SDK (10.0.14393)
  2. Build x64 Release\x64\IntelMft0_x64.dll via SampleMft0.sln
  3. Download and install vc_redist.x64.exe from Visual C++ Redistributable for Visual Studio 2015
  4. Run install_intel_mft0.bat with admin to install MFT0 as step mentioned in Installing and registering the driver MFT
  5. Run UWP (Metro mode) camera app.
  6. Change registry keys under [HKEY_LOCAL_MACHINE\SOFTWARE\Intel\Display\DXVA\Intel Dxva Virtual Camera] or run create_mft0_regkey_local_machine.reg
       [0]: default strength
       [1-100]: face special effect strength
       [101]: disable face special effect
  7. Check the face effects.

Uninstall: regsvr32 /u "C:\Program Files\Intel\Intel MFT0\IntelMft0_x64.dll"

Capabilities for MFT0 based filter:

  1. Only support camera with MJPG or YUY2
  2. Color format: MFT0 outputs NV12 (if camera support MJPG) or YUY2 (if camera support YUY2)
  3. FPS: 60 fps
  4. Max resolution 1280x720 defined in config.h *
  5. Support rotation mode 0, 90, 180 and 270 degree with cropping and black filler (1280x720 -> 1080x720)
  6. Max face special effects up to 8 human faces.
  7. Only for MF or UWP (Metro) app on Win10 RS1, supports both MF and DShow app on Win10 RS2 with DShow Bridge enabled

* GPU can support to 1920x1080. This filter software could be modified to support 1080P.

Try it via Installer

Notice:

  1. Need to install camera driver before the following installation. If you install this MFT0 driver before installing camera driver, the filter could not be applied.
  2. If your camera has its proprietary MFT0 filter, this MFT0 filter will replace with it. Only one MTF0 will be effective.

In the attachment Intel®_Facial_Special_Effects_Filter_Installer_20170427.7z

  1. Run Setup.exe, it will install DirectShow based filter and MFT0 based filter.
  2. Run 32-bit desktop camera app for DirectShow based or UWP (Metro mode) camera app for MFT0 based filter.
  3. Check the face effects.

System Requirements

  • OS: Windows 10 RS1+
  • Platform: Skylake+
  • Intel® Graphics Driver for Windows: 15.46+
  • Apps: Skype (Desktop mode) / PotPlayer (Desktop mode) / Camera (Metro mode)

 

One Door VR: The First Proof of Concept on Un-Tethered VR Using MSI* Backpack PC

$
0
0

Corey Warning and Will Lewis are the co-founders of Rose City Games*, an independent game studio in Portland, Oregon.

Rose City Games was recently awarded a development stipend and equipment budget to create a VR Backpack Early Innovation Project. The challenge was to come up with something that could only be possible with an un-tethered VR setup. In this article, you’ll find documentation about concepting the project, what we learned, and where we hope to take it in the future. Below is the introductory video for the project.


Figure 1. Watch the introductory video of the One Door VR project.

Inspirations Behind Project: One Door

Earlier this year, our team attended the Resident Evil Escape Room in Portland, Oregon. Being huge fans of that franchise, experiencing that world in a totally new medium was really exciting, and it got us thinking about what other experiences could cross over in a similar fashion.

At the time, we were also trying out as many VR experiences as we could get our hands on. When we heard about the opportunity to work on an un-tethered VR experience, we knew there had to be something interesting we could bring to the table.

We’re currently operating out of a co-working space with some friends working on a variety of VR projects. The WILD crew had some experience in merging real space and VR, so I asked Gabe Paez if he remembered any specific challenges he encountered during that project. “Doors” was his response, and I decided to chase after creating a “VR Escape Room” experience, with the idea of moving through doors as the core concept!

Overview

The scope of this project is to create a proof of concept VR application using the MSI* One VR Backpack. We’re attempting to create a unique experience that’s only possible using this hardware, specifically, an un-tethered setup.

Right away, we knew this project would require an installation, and because of this, we’re not considering this product for mass market. This will likely be interesting content for exhibitions such as GDC Alt.Ctrl, Unite*, VR LA, etc.

One Door Game Concept

Players will be in a completely virtual space, interacting with a physical door installation. They will be wearing the MSI One VR Backpack, with a single HTC Vive* controller, and an HTC Vive headset. Each level will contain a simple puzzle or action the player must complete. Once completed, the player will be able to open the door and physically step through to the next level. At that point, they will be presented with a new puzzle or action, and the game will progress in this fashion.


Figure 2. The proof of concept setup for One Door

The player can open the door at any time. However, if a puzzle or action is incomplete, they will see the same level/door on the other side of the installation. We’re considering using an HTC Vive Tracker for the actual door handle, so that we can easily track and calibrate where the player needs to grab.


Figure 3. One Door front view


Figure 4. One Door top view

Installation Specifics

  • The door will need to be very light weight.
  • We’ll need support beams to make sure the wall doesn’t tip over.
    • Sandbags on the bases will be important.
  • We should use brackets or something similar that allows assembling and disassembling the installation quickly, without sacrificing the integrity each time.
  • The HTC Vive lighthouses will need to be set higher than the wall in order to capture the entire play area.
    • We’ll need quality stands, and likely more sandbags.
  • We may need something like bean bag chairs to place around the support beams/lighthouses to ensure people don’t trip into anything.
    • Another consideration is having someone attending to the installation at all times.


Figure 5. One Door field setup inside the HTC* lighthouses

Our Build-Out

  • Mobile, free-standing door with handle and base
  • MSI One VR Backpack and off-site computer for development
    • Additional DisplayPort-to-HDMI cable required
    • Mouse/keyboard/monitor
    • OBS to capture video
  • 2 lighthouses
    • Stands
    • Adjustable grips to point lighthouses at an angle
    • Placed diagonally on each side of the door
  • 1 Vive Tracker
    • Gaffe tape to attach it to the door, ripped at the charging port
    • Extension cables and charging cables run to the tracker for charging downtime
  • 2 Vive controllers
    • We didn’t need them, but showing hand positioning was helpful for recording video
  • iPhone* to capture real-world video


Figure 6. Door with HTC Vive*

This project was very much VR development training for us in many ways. This was our first time working with a Vive, and implementing the additional physical build out for a new interactive experience created a bit of a learning curve. I feel like a majority of our hang-ups were typical of any VR developer, but of course we created some unique challenges for ourselves that we're happy to have experience with now. I would definitely recommend that VR developers thoughtfully explore the topics below and learn from our assumptions and processes before kicking off a project of their own.

Our First Time with HTC Vive*

We've played with the Vive a ton, but this was our first time developing for it. Setting up the general developer environment and Unity* plugins didn't take much time, but we had to think very strategically about how to develop and test more seamlessly past that point. Very commonly, it saved us an immense amount of time to have two people on site at a time: One person tending to Unity, while the other moved controllers and trackers, re-adjusted lighthouses, adjusted room scale, and acted as a second pair of eyes.


Figure 7. One Door VR development and testing

With regard to hardware specifically as well as our project needing to use a physical prop, we went back and forth on many choreographies for how lighthouses were able to track devices, and even had quite a bit of trouble with hooking up a monitor. Since the MSI One VR Backpack has one HDMI output and one DisplayPort input, we had to borrow (and later buy) a DisplayPort-to-HDMI converter to both develop the application and use the Vive headset simultaneously. Luckily, this didn't delay development for too long, and was a better solution than our initial workaround — attaching the HDMI output to an HDMI switcher that we already had, and flipping between our monitor/dev environment and the headset. Continuing with this process for the duration of the project would have been very unrealistic and a huge waste of time.

We were introduced to more new experiences during this project, like being able to remotely work from home and use Unity's Collaborate feature, exploring how awesome it was to experience VR without being tethered, and becoming very familiar with how quickly we’re able to kick off a VR project.

Budget

Almost directly paired with testing new equipment and working with a physical build-out, our budget was another challenge we had to overcome. The recommended list of equipment provided by Intel was not totally covered by the allotted funding, so we had to pick and choose a bare minimum for what we might be able to use in our project, then consider how leftovers could satisfy the hours put in by an experienced developer. Luckily, because of our connections in the local game developer community, we were able to work with one of our friends who's been interested in experimenting on a project like this for some time. Still, if we were to do this project from scratch, we would very likely scope it with a higher budget in mind, as at least two more trackers, converter cables, adjustable joints for the tops of lighthouse stands, and a few other small items would have been considered in our minimum requirements to complete this project on a tighter timeline with a more polished product in mind.

Location/Space

From a consumer standpoint, we know that room-scale VR is unrealistic for many, and we still ran into a few issues as we planned for and worked on this project. One of my biggest recommendations to other developers working in room-scale VR would be to buy a tape measure early and make sure you have space solely dedicated to your project for the entirety of its development. We share a co-working space with about 20 other local VR developers, artists, game makers, and web designers, so needing to push our build-out to the side of the room at the end of every dev session added to our overall setup time. It did give us a lot of practice with setup and familiarity with devices, but another interesting revelation was that we never would have been able to do this from any of our homes!

Unique Build-Out

Since our project involved a prop (a full-sized, free-standing door), we had to make obvious considerations around moving it, storing it, and occlusion for the lighthouses. When we think about taking our project beyond a prototype, there are so many more issues that become apparent. Thinking about how this project would likely continue in the future as a tech demo, festival/museum installation, or resume piece, we also had to consider that we would need to show it to more people than ourselves and direct supporters. With this comes an additional consideration: safety. We definitely cut corners to very quickly build a functional prototype, but thinking around polish and transportation readiness, we would definitely recommend spending more time and resources towards creating a safer experience catered to those unfamiliar with VR.

As we prototyped, we were able to remember to pick our feet up in order to not trip, slowly move forward to avoid bashing into an outcropping in the door, and find the door handle without any problem. What we've made serves as an excellent tech demo, but we would definitely take another pass at the door prop before considering it any sort of consumable, public product, or experience. To make transportation easier, we would also build the door differently so that we could disassemble it on the fly.

Moving Forward

We're confident in what we have as a technical demo for how easy, interesting, and liberating it can be to use the MSI One VR Backpack, and we're also very proud and excited of what we were able to learn and accomplish. So much so that we'd like to continue implementing simple puzzles, art, voiceover, and accessibility features to make it more presentable. After some additional testing and polish, we'd like to shop the prototype around, searching for a sponsor related to content and IP, VR tech, interactive installations, or trade shows so that we can share the project with a wider audience! Intel is a prime candidate for this collaboration, and we'd love to follow up after giving another round on the demo.

Thanks for letting us be a part of this!

Code Sample (Unity)

When using a peripheral as large as a door, the room choreography needs to be spot-on with regard to your lighthouse and tracker setup — particularly the tracker, which we affixed to our door to gauge its orientation at any given time (this mainly allowed us to tell whether the door was closed or open). We made a simple setup script to position the door, door frame, and door stand/stabilizers properly.

The Setup Helper is a simple tool that provides a solution for the position and rotation of the door and door frame relative to the Vive Tracker position. Setup Helper runs in Editor mode, allowing it to be updated without having to be in Play mode, but should be disabled after running the application to allow the door to swing independent of the frame in game. Multiple Setup Helpers can be created to position any other geometry that needs to be spaced relative to the door, like room walls, floors, room decor, etc. in order to avoid potential visual/collision-oriented gaps or clipping.

The Setup Helper hierarchy is shown above. The following applies to the areas highlighted in blue, including the tracker (attached to the door) and doorway.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[ExecuteInEditMode]
public class SetupHelper : MonoBehaviour {
	public bool setDoorFrameToTracker = false;
	public GameObject doorFrameGo;
	public Transform trackerTransform;
    public bool trackRotation = false;
	public Vector3 doorframeShift;//used to set the difference in placement to make it fit perfectly on the tracker position
	// Use this for initialization
	void Start () {

	}

	// Update is called once per frame
#if UNITY_EDITOR
	void Update () {
		if (setDoorFrameToTracker)
			SetDoorFrameToTracker();
	}
	void SetDoorFrameToTracker()
	{
		doorFrameGo.transform.position = trackerTransform.position + doorframeShift;
        if (trackRotation)
            doorFrameGo.transform.rotation = trackerTransform.parent.rotation;
	}
#endif

}

About the Authors

Corey Warning and Will Lewis are the co-founders of Rose City Games, an independent game studio in Portland, Oregon.

How to use the Intel® Advisor Collection Control APIs

$
0
0

Overview

Intel® Advisor collection can be sped up, and the size of samples reduced, by using the Instrumentation and Tracing Technology (ITT) APIs. These ITT APIs were supported in the Intel® Advisor survey collection since the product release but now, as from Intel® Advisor 2018, you can also use the APIs on Trip Counts and FLOP collection. This can make the Roofline analysis an option for larger and longer running applications.

In this article, we will show how to use the collection control APIs to command Intel® Advisor when to start and stop the collection of performance data during the execution of your target application.

Background

Intel® Advisor typically starts collecting data as from the moment the analysis is started. As such, Intel® Advisor may be collecting data for sections of the large codebase in which you may not have interest. With the collection control ITT APIs, you can choose which sections of your source code that Intel® Advisor should monitor and record performance data.

Usage example: Focus on a specific code section

The first step is to  wrap your source code of interest between resume and pause APIs methods and then start Intel Advisor in paused mode. When Intel Advisor hits the resume method, it will start collecting performance data and stop when it sees the pause method.

Below are a series of detailed steps with a small code-snippet to get you started:

  1. First, your C/C++ application needs to understand the ITT APIs. In your source code, include the "ittnotify.h" header file, located in the include directory where Intel Advisor has been installed. By default, the installation path on Windows is:
    C:\Program Files (x86)\IntelSWTools\Advisor 2018\include
    On Linux, the default path will be:
    /opt/intel/advisor_2018/include

    Note: The "ittnotify.h"header file contains all the ITT APIs templates that you can use for instrumentation.

    Include the path to the header file above so that your compiler knows where to find the library. In Microsoft Visual Studio for example, navigate to Property Pages>C/C++>General>Additional Include Directories

    intel-advisor-visual-studio-itt-notify

  2. Finally, link to the ITT library (libittnotify.lib) and recompile your application.In Visual Studio, navigate to the Linker settings (Property Pages>Linker>Input>Additional Include Directories) and add the path to the library. By default, on Windows, the path will be:
    C:\Program Files (x86)\IntelSWTools\Advisor 2018\lib64\libittnotify.lib
    On Linux, the default path is: /opt/intel/advisor_2018/. Then, you would configure your build scripts to include the path to the library and link to the libittnotify.a library by passing -littnotify to your compiler.
  3. Next, you need to start Intel Advisor in Paused mode. Look for the Play with a Pause symbol icon like the one below:

    Intel-advisor-start-paused-button

    In Intel Advisor, the Survey Analysis and the Trip Counts and FLOP Analysis support the collection control APIs.

Example:

#include "ittnotify.h"

int main(int argc, char* argv[])
{
        // Do initialization work here
        __itt_resume(); //Intel Advisor starts recording performance data
        for (int i=0;i<size;i++)
        {
               do_some_math();
        }
        __itt_pause(); // Intel Advisor stops recording performance data

        for (int i=0;i<size;i++)
        {
               do_some_other_math();
        }

       return 0;
}

In the scenario above, Intel Advisor will give you performance data for the loop containing the do_some_math() method and not the one containing the do_some_other_math() method. If you draw the roofline model for that analysis, you would see one dot on the graph, as opposed to two, if you were to run Intel Advisor without the collection control APIs.

Troubleshooting Visual Studio Command Prompt Integration Issue

$
0
0

Issue Description

Nmake and ifort are not recognized from a command window, however using Intel Fortran under Visual Studio works perfectly.

Troubleshooting

Follow below checklist to troubleshooting Visual Studio command environmental issues:

1. Verify whether ifort and nmake are installed correctly:

    For Visual Studio 2017, nmake is installed at:

    C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Tools\MSVC\14.10.25017\bin\HostX64\x64\nmake.exe

    Find this by running below commands from a system ifort or nmake setup correctly:

> where nmake
  > where ifort

    Also check whether the location is included from PATH environment:

> echo %PATH%

2. If nmake can be found, verify if VS setup script runs properly.
    Start a cmd window, and run Visual Studio setup script manually:

> "C:\Program Files (x86)\Microsoft Visual Studio\2017 \Professional\VC\Auxiliary\Build\vcvars64.bat"

    An expected output is as below

    vscmd_setup.png

3.If nmake cannot be found. It’s your Visual Studio installation is incomplete. Please try re-install Visual Studio and find instructions from below articles:
 
4.Got an error in step 2?
> "C:\Program Files (x86)\Microsoft Visual   Studio\2017\Professional\VC\Auxiliary\Build\vcvars64.bat"
  \Common was unexpected at this time.
If yes, try debug the setup script set VSCMD_DEBUG environment variable:
> set VSCMD_DEBUG=3
Run the setup script again and redirect the output to log file:
> "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Auxiliary\Build\vcvars64.bat"> setup.log 2>&1

5.If you got the same error as above, there are some references from Visual Studio community:

    The solution is to remove all quotes from PATH environment variable value.
 
6.If you got a different error, again get an expected output from any system that runs the script correctly and compare with your current one. This will help you locate which command in the setup script that triggers the error. 
    You may also consider to report such issue to Visual Studio community directly at

 


Accelerating Media, Video & Computer Vision Processing: Which Tool Do I Use?

$
0
0

Intel has a multitude of awesome software development tools, including ones for innovating and optimizing media applications, immersive video including 360° and virtual reality, graphics, integrating visual understanding, and more. But sometimes, it's hard to figure out just which development tool or tools are best for your particular needs and usages.

Below you'll find a few insights to help you get to the right Intel software tool faster for media and video solutions, so you can focus on the really fun stuff - like building new competitive products and solutions, improving media application performance or video streaming quality for devices from edge to cloud, or even transitioning to more efficient formats like HEVC. 


Intel® Media SDK

Developing for:

  • Intel® Core™ or Intel® Core™ M processors 
  • Select SKUs of Intel® Celeron™, Intel® Pentium® and Intel® Atom® processors with Intel® HD Graphics supporting Intel® Quick Sync Video
  • Client, mobile and embedded devices - desktop or mobile media applications
  • OS - Windows* and Embedded Linux*
  • An Open Source version is also available at Github under the MIT license 

Uses & Needs

  • Fast video playback, encode, processing, media formats conversion or video conferencing
  • Accelerated processing of RAW video or images
  • Screen capture
  • Audio decode & encode support
  • Used with smart cameras across drones, phones, editors/players, network video recorders, and connected cars
  • Supports HEVC, AVC, MPEG-2 and audio codecs

Free Download


intel media server studioIntel® Media Server Studio

Three editions are available:

  • FREE Community
  • Essentials
  • Professional

Developing for:

Format Support HEVC, AVC, MPEG-2 and MPEG-Audio

Uses & Needs

  • High-density and fast video decode, encode, transcode
  • Optimize performance of Media/GPU pipeline 
  • Enhanced graphics programmability or visual analytics (for use with OpenCL™ applications)
  • Low-level control over encode quality
  • Debug, analysis and performance/quality optimization tools
  • Speed ransition to real-time 4K HEVC
  • Need to measure visual quality (Video Quality Caliper)
  • Looking for an enterprise-grade telecine interlace reverser (Premium Telecine Interlace Reverser)
  • Audio codecs
  • Screen capture

 Free Download & Paid Edition Options 


Intel® Collaboration Suite for WebRTC

This Client SDK builds on top of the W3C standard WebRTC APIs to accelerate development of real-time communications (RTC), including broadcast, peer-to-peer, conference mode communications, and online gaming/VR streaming. 

Use with Andrioid*, web (JavaScript* built), iOS* and Windows* applications. 

Free Download

Intel® SDK for OpenCL™ Applications

Developing for:

General purpose GPU acceleration on select Intel® processors (see technical specifications). OpenCL primarily targets execution units. An increasing number of extensions are being added to Intel processors to make the benefits of Intel’s fixed function hardware blocks  accessible to OpenCL applications.

Free Download


Intel® Computer Vision SDK

Accelerate computer vision solutions:

  • Easily harness the performance of computer vision accelerators from Intel
  • Add your own custom kernels into your workload pipeline
  • Quickly deploy computer vision algorithms with deep-learning support using the included Deep Learning Deployment Toolkit Beta
  • Create OpenVX* workload graphs with the intuitive and easy-to-use Vision Algorithm Designer

Free Download


Altera® Software (now part of Intel) 
Video & Image Processing Suite MegaCore Functions (part of Intel® Quartus® Prime Software Suite IP Catalog)

Developing for:

  • All Altera FPGA families
  • Video and image processing applications, such as video surveillance, broadcast, video conferencing, medical and military imaging and automotive displays

Uses & Needs

  • For design, simulation, verification of hardware bit streams for FPGA devices
  • optimized building blocks for deinterlacing, color space conversion, alpha blending, scaling and more

 


 

 

OpenCL and the OpenCL logo are trademarks of Apple Inc. used by permission by Khronos.

Intel® Media SDK & Intel® Media Server Studio Historical Release Notes

$
0
0

Release Notes of Intel® Media SDK include important information, such as system requirements, what's new, feature table and known issues since the previous release. Below is the list of release notes from previous releases of different products to track new features and supported system requirements.

Intel Media SDK

Version/What's NewRelease DateRelease NotesPlatform Support
2017 R1Jun. 9, 2017WindowsSupports select SKUs of 6th & 7th generation
Intel® Core™ processors (codename Skylake & KabyLake)

Intel® Media Server Studio

Version/What's NewRelease DateRelease NotesPlatform Support
2017 R3Aug. 1, 2017Windows*|Linux*Supports select SKUs of 5th & 6th generation
Intel® Xeon® & Core™ processors (codename Broadwell & Skylake)
2017 R2Jan. 4, 2017Windows*|Linux*Supports select SKUs of 5th & 6th generation
Intel® Xeon® & Core™ processors (codename Broadwell & Skylake)
2017 R1Sept. 1, 2016Windows*|Linux*Supports select SKUs of 5th & 6th generation
Intel® Xeon® & Core™ processors (codename Broadwell & Skylake)
Professional 2016Feb. 18, 2016Windows*|Linux*Supports select SKUs of 4th & 5th generation
Intel® Xeon® & Core™ processors (codename Haswell & Broadwell)
2016Feb. 18, 2016Windows*|Linux*Supports select SKUs of 4th & 5th generation
Intel® Xeon® & Core™ processors (codename Haswell & Broadwell)
2015 R6July. 2, 2015Windows*/Linux*Supports select SKUs of 4th & 5th generation
Intel® Xeon® & Core™ processors (codename Haswell & Broadwell)

Intel Media SDK for Embedded Linux*

Version/What's NewRelease DateRelease NotesPlatform Support
2017 R1Aug. 25, 2017LinuxSupports select SKUs Intel® Atom™ processors (codename ApolloLake)

 

 

 

 

For latest documents, getting started guide and release notes, check Intel Media SDK getting start webpage. If you have any issue, connect with us at Intel media forum.

Dynamically linked IMSL* Fortran Numerical Library can't work with Intel® Parallel Studio XE 2018 for Windows Update 2

$
0
0

Version : Intel® Parallel Studio XE 2018 for Windows Update 2, Intel® Math Kernel Library (Intel® MKL) 2018 Update 2

Operating System : Windows*

Architecture: Intel 64 Only


Problem Description :

An application built by Intel Parallel Studio XE for Windows 2018 Update 2 and dynamically linked with IMSL* Fortran Numerical Library will fail to start with an error message like:


"The procedure entry point mkl_lapack_ao_zgeqrf could not be located in the dynamic link library C:\Program Files(x86)\VNI\imsl\fnl701\Intel64\lib\imslmkl_dll.dll. "


The cause of the error is that symbols removal in Intel MKL 2018 Update 2 breaks its backward compatibility with binaries dynamically linked with an old version of Intel MKL such as IMSL* Fortran Numerical Library.

Resolution Status:

It will be fixed in a future product update. When the fix is available, this article will be updated with the information.

There are three workarounds available to resolve the error:

  1. Link IMSL Fortran Numerical Library statically
  2. Link IMSL Fortran Numerical Library without making use of Intel® MKL, which may have some performance impact
  3. Use an older version of Intel MKL DLL such as Intel MKL 2018 update 1 by putting them into PATH setting at runtime 

Intel® Math Kernel Library (Intel® MKL) 2019 System Requirements

$
0
0

Operating System Requirements

The Intel MKL 2019 release supports the IA-32 and Intel® 64 architectures. For a complete explanation of these architecture names please read the following article:

Intel Architecture Platform Terminology for Development Tools

The lists below pertain only to the system requirements necessary to support developing applications with Intel MKL. Please review your compiler (gcc*, Microsoft* Visual Studio* or Intel® Compiler Pro) hardware and software system requirements, in the documentation provided with that product, to determine the minimum development system requirements necessary to support your compiler product.

Supported operating systems: 

  • Windows 10 (IA-32 / Intel® 64)
  • Windows 8.1* (IA-32 / Intel® 64)
  • Windows 7* SP1 (IA-32 / Intel® 64)
  • Windows HPC Server 2016 (Intel® 64)
  • Windows HPC Server 2012 (Intel® 64)
  • Windows HPC Server 2008 R2 (Intel® 64) 
  • Red Hat* Enterprise Linux* 6 (IA-32 / Intel® 64)
  • Red Hat* Enterprise Linux* 7 (IA-32 / Intel® 64)
  • Red Hat* Enterprise Linux* 7.5 (IA-32 / Intel® 64)
  • Red Hat Fedora* core 28 (IA-32 / Intel® 64)
  • Red Hat Fedora* core 27 (IA-32 / Intel® 64)
  • SUSE Linux Enterprise Server* 11 
  • SUSE Linux Enterprise Server* 12
  • SUSE Linux Enterprise Server* 15  ????
  • openSUSE* 13.2
  • CentOS 7.1
  • CentOS 7.2
  • Debian* 8 (IA-32 / Intel® 64)
  • Debian* 9 (IA-32 / Intel® 64)
  • Ubuntu* 16.04 LTS (IA-32/Intel® 64)
  • Ubuntu* 17.10 LTS (IA-32/Intel® 64)
  • Ubuntu* 18.04 LTS (IA-32/Intel® 64)
  • WindRiver Linux 8
  • WindRiver Linux 9
  • WindRiver Linux 10
  • Yocto 2.3
  • Yocto 2.4
  • Yocto 2.5
  • Yocto 2.6
  • macOS* 10.13 (Xcode 6.x) and macOS* 10.14 (Xcode 6.x) (Intel® 64)

         Note: Intel® MKL is expected to work on many more Linux distributions as well. Let us know if you have trouble with the distribution you use.

Supported C/C++ and Fortran compilers for Windows*:

  • Intel® Fortran Composer XE 2019 for Windows* OS
  • Intel® Fortran Composer XE 2018 for Windows* OS
  • Intel® Fortran Composer XE 2017 for Windows* OS
  • Intel® Visual Fortran Compiler 19.0 for Windows* OS
  • Intel® Visual Fortran Compiler 18.0 for Windows* OS
  • Intel® Visual Fortran Compiler 17.0 for Windows* OS
  • Intel® C++ Composer XE 2019 for Windows* OS
  • Intel® C++ Composer XE 2018 for Windows* OS
  • Intel® C++ Composer XE 2017 for Windows* OS
  • Intel® C++ Compiler 19.0 for Windows* OS
  • Intel® C++ Compiler 18.0 for Windows* OS
  • Intel® C++ Compiler 17.0 for Windows* OS
  • Microsoft Visual Studio* 2017 - help file and environment integration
  • Microsoft Visual Studio* 2015 - help file and environment integration
  • Microsoft Visual Studio* 2013 - help file and environment integration

Supported C/C++ and Fortran compilers for Linux*:

  • Intel® Fortran Composer XE 2019 for Linux* OS
  • Intel® Fortran Composer XE 2018 for Linux* OS
  • Intel® Fortran Composer XE 2017 for Linux* OS
  • Intel® Fortran Compiler 19.0 for Linux* OS
  • Intel® Fortran Compiler 18.0 for Linux* OS
  • Intel® Fortran Compiler 17.0 for Linux* OS
  • Intel® C++ Composer XE 2019 for Linux* OS
  • Intel® C++ Composer XE 2018 for Linux* OS
  • Intel® C++ Composer XE 2017 for Linux* OS
  • Intel® C++ Compiler 19.0 for Linux* OS
  • Intel® C++ Compiler 18.0 for Linux* OS
  • Intel® C++ Compiler 17.0 for Linux* OS
  • GNU Compiler Collection 4.4 and later
  • PGI* Compiler version 2018
  • PGI* Compiler version 2017

Note: Using the latest version of Intel® Manycore Platform Software Stack (Intel® MPSS is recommended on Intel MIC Architecture. It is available from the Intel® Software Development Products Registration Center at http://registrationcenter.intel.com as part of your Intel® Parallel Studio XE for Linux* registration

Supported C/C++ and Fortran compilers for OS X*:

  • Intel® Fortran Compiler 19.0 for macOS *
  • Intel® Fortran Compiler 18.0 for macOS *
  • Intel® Fortran Compiler 17.0 for macOS *
  • Intel® C++ Compiler 19.0 for macOS *
  • Intel® C++ Compiler 18.0 for macOS *
  • Intel® C++ Compiler 17.0 for macOS *
  • CLANG/LLVM Compiler 9.0
  • CLANG/LLVM Compiler 10.0

MPI implementations that Intel® MKL for Windows* OS has been validated against:

  • Intel® MPI Library Version 2019 (Intel® 64) (http://www.intel.com/go/mpi)
  • Intel® MPI Library Version 2018 (Intel® 64) (http://www.intel.com/go/mpi)
  • Intel® MPI Library Version 2017 (Intel® 64) (http://www.intel.com/go/mpi)
  • MPICH version 3.3  (http://www-unix.mcs.anl.gov/mpi/mpich)
  • MPICH version 2.14  (http://www-unix.mcs.anl.gov/mpi/mpich)
  • MS MPI, CCE or HPC 2012 on Intel® 64 (http://www.microsoft.com/downloads)

MPI implementations that Intel® MKL for Linux* OS has been validated against:

  • Intel® MPI Library Version 2019 (Intel® 64) (http://www.intel.com/go/mpi)
  • Intel® MPI Library Version 2018 (Intel® 64) (http://www.intel.com/go/mpi)
  • Intel® MPI Library Version 2017 (Intel® 64) (http://www.intel.com/go/mpi)
  • MPICH version 3.3  (http://www-unix.mcs.anl.gov/mpi/mpich)
  • MPICH version 3.1  (http://www-unix.mcs.anl.gov/mpi/mpich)
  • MPICH version 2.14  (http://www-unix.mcs.anl.gov/mpi/mpich)
  • Open MPI 1.8.x (Intel® 64) (http://www.open-mpi.org)

Note: Usage of MPI and linking instructions can be found in the Intel Math Kernel Library Developer Guide

Other tools supported for use with example source code:

  • uBLAS examples: Boost C++ library, version 1.x.x
  • JAVA examples: J2SE* SDK 1.4.2, JDK 5.0 and 6.0 from Sun Microsystems, Inc.

Note: Parts of Intel® MKL have FORTRAN interfaces and data structures, while other parts have C interfaces and C data structures. The Intel Math Kernel Library Developer Guide  contains advice on how to link to Intel® MKL with different compilers and from different programming languages.

Deprecation Notices :

  • Dropped support for all MPI IA-32 implementations
  • Red Hat Enterprise Linux* 5.0 support is dropped
  • Windows XP* is not supported Support for Windows XP has been removed
  • Windows Server 2003* and Windows Vista* not supported

 

Energy Analysis with Intel(R) System Studio 2019 Beta

$
0
0

Energy Analysis with Intel® System Studio 2019 Beta

 

Introduction to Energy Analysis

  • Energy Analysis: Using the energy analysis components allows you to collect sleep state, frequency and temperature data that lets you find the software that is causing unwanted power use. Intel® System Studio 2019 beta includes energy analysis solution that best fits your environment. Please refer Intel® Energy Anaylsis Help for Energy Analysis general workflow.

 

Methods for Energy Analysis

  1. Intel® SoC Watch: A low overhead command line tool for collecting power-related metrics on Windows*, Linux*, or Android* systems

 

  1. Eclipse* GUI: An Eclipse* plug-in provides GUI for collection and viewing of Intel SoC Watch data. This is a preview feature currently. You can find this in the Intel® System Studio GUI to create a project and run energy analysis on a Linux or Android target system. The results are generated in a *.swjson format and can be opened and visualized with Intel System Studio. Please refer here for the details.

[Figure 1. Eclipse* GUI for Energy Analysis ]

 

  1. Intel® VTune™ Amplifier for Systems: In addition to performance analysis, Intel® VTune™ Amplifier provides visualization for data imported from SoC Watch.  Please refer here for the details.

[Figure 2. Intel® VTune™ Amplifier Visualization for SoCWatch Results ]

 

What is new with Intel® SoCWatch v2.6.1 for Windows*

  • Added option to log console output to a file. Use option --log <filename> (short name -l) to log all console messages to a file.
  • Added explanatory note to reports containing the Unknown value. For -f hw-cpu-cstate and -f hw-cpu-pstate, CPU C-State and CPU P-State reports now include a note explaining the meaning of the Unknown value that may appear in these reports. The residency table note is: "Unknown" state occurs when the system enters a platform idle state (ACPI S3 or S4). The wakeup table note is: "Unknown" wakeups mean the CPU wakeup reason could not be attributed to a known cause.
  • Added driver version to the summary report header. Summary reports now include the version of the Intel SoC Watch driver used to collect the data in addition to the application version number.
  • Added Alt-S as a hot key alternative to Ctrl-C for Windows 10 Desktop OS.
  • Removed several OS-based features from the -f sys group. The OS-based features which had a comparable hardware data (os-cpu-cstate, os-cpu-pstate, os-gfx-cstate) were removed from the group sys. Processing the OS-based ETL trace data is very time consuming for longer collections and often users do not need these OS-based metrics since the hardware metrics are more accurate. Removing these from the commonly used sys group reduces post-processing time and file size. Both OS and hardware based metrics are still included in the cpu and gfx group names, or can be explicitly added to the command line using their individual feature names.
  • HWP reporting is no longer included in the hw-cpu-pstate feature. The -f hw-cpu-pstate feature now collects only Core P-state frequencies to allow finer-grained selection of which data to collect. Use the new feature -f hw-cpu-hwp to collect the HWP Guaranteed, Highest, Lowest,
  • Most-Efficient Performance summary reports. The HWP feature is still included in the sys, cpu, and cpu-pstate groups.

What is new with Intel® SoCWatch v2.6.1 for Linux* and Android*.

  • New features supported : hw-cpu-hwp to collect the HWP Guaranteed, Highest, Lowest, Most-Efficient Performance summary reports.
  • Command line changes : New option for logging console output to a file: --log <filename> (short name -l). The -f cpu-cstate feature name has become a group name. The individual metric name is -f hw-cpu-cstate and includes C-state at the Package, Module, and Core levels as appropriate for the platform. This aligns feature names across all operating systems. The -f gfx-cstate feature name has become a group name. The individual metric name is -f hw-gfx-cstate and reports C-state residencies for the graphics subsystem. This aligns feature names across all operating systems.
  • The driver version number has been added to the summary report header.
  • HWP reporting is no longer included in the hw-cpu-pstate feature. Use the new feature -f hw-cpu-hwp to collect the HWP Guaranteed, Highest, Lowest, Most-Efficient Performance summary reports. The HWP feature is still included in the sys, cpu, and cpupstate groups.
  • The -f cpu-pstate feature is now collected by sampling vs. event trace. The CPU P-state data was not being collected on platforms with the P-state driver installed because the Pstate trace events are not triggered when it is used. To avoid the loss of this data, CPU Pstate residency is now based on P-state (processor frequency) status registers being sampled during the collection. Since this is now sampled data, there is some loss in precision of the CPU P-state residency and the report format changes.
  • The --version option output has changed.

 

Viewing all 533 articles
Browse latest View live


<script src="https://jsc.adskeeper.com/r/s/rssing.com.1596347.js" async> </script>