From 5308224addefe398e55f54f714188ed9a89c1104 Mon Sep 17 00:00:00 2001
From: linxie47 <lin.xie@intel.com>
Date: Tue, 17 Dec 2024 12:00:02 +0800
Subject: [PATCH] Refine build (#26)

* Use a simple and clear build script

* Add CodeQL and using the new build script

* Exclude some directories

* refine the documents

* Further refine the readme
---
 .github/workflows/codeql.yml   | 102 +++++++++++
 README.md                      | 136 +++++++++------
 build.sh                       | 176 +++++++++++++++++++
 build_ivsr.sh                  | 308 ---------------------------------
 docs/docker_image_build.md     |  22 ++-
 docs/figs/logo.bmp             | Bin 135054 -> 0 bytes
 docs/figs/logo.png             | Bin 0 -> 7168 bytes
 docs/generic_manual_build.md   |  16 +-
 docs/quick_try_manual_build.md |  10 +-
 ivsr_setupvar.sh               |  31 ----
 10 files changed, 391 insertions(+), 410 deletions(-)
 create mode 100644 .github/workflows/codeql.yml
 create mode 100755 build.sh
 delete mode 100755 build_ivsr.sh
 delete mode 100644 docs/figs/logo.bmp
 create mode 100644 docs/figs/logo.png
 delete mode 100755 ivsr_setupvar.sh

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 0000000..54bf2d6
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,102 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+    paths-ignore:
+      - '**/*.md'
+      - '**/*.txt'
+  schedule:
+    - cron: '19 6 * * 0'
+
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ${{ matrix.runner-os }}
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        runner-os: [ 'ubuntu-22.04' ]
+        language: [c-cpp]
+        build-mode: [manual]
+        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+    - name: 'Harden Runner'
+      uses: step-security/harden-runner@17d0e2bd7d51742c71671bd19fa12bdc9d40a3d6 # v2.8.1
+      with:
+        egress-policy: audit
+
+    - name: Checkout repository
+      #uses: actions/checkout@v4
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #4.2.2
+
+    - name: Check disk space
+      run: df -h
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      #uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@b611370bb5703a7efb587f9d136a52ea24c5c38c # v3.25.11
+      with:
+        languages: ${{ matrix.language }}
+        # Passing a config that excludes specific directories
+        config: |
+          paths-ignore:
+            - ivsr_ffmpeg_plugin/ffmpeg
+            - ivsr_ov/based_on_openvino_2022.3/openvino
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    - name: Git config
+      run: |
+        git config --global user.email "you@example.com"
+        git config --global user.name "Your Name"
+
+    - name: Build
+      run: |
+          chmod a+x ./build.sh
+          ./build.sh --ov_version 2024.5
+          echo 'build ivsr completed!'
+
+    - name: Perform CodeQL Analysis
+      #uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@b611370bb5703a7efb587f9d136a52ea24c5c38c # v3.25.11
+      with:
+        category: "/language:${{matrix.language}}"
diff --git a/README.md b/README.md
index 48a8542..448c3c5 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 <!-- ![logo](./docs/figs/iVSR.png) -->
 <div align=center>
-<img src="./docs/figs/logo.bmp" width = 20% height = 20% />
+<img src="./docs/figs/logo.png" width = 20% height = 20% />
 </div>
 
 <div align=center>
@@ -8,7 +8,7 @@
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/OpenVisualCloud/iVSR/badge)](https://api.securityscorecards.dev/projects/github.com/OpenVisualCloud/iVSR)
 [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/9795/badge)](https://bestpractices.coreinfrastructure.org/projects/9795)
 [![Dependency Review](https://github.com/OpenVisualCloud/iVSR/actions/workflows/dependency-review.yml/badge.svg)](https://github.com/OpenVisualCloud/iVSR/actions/workflows/dependency-review.yml)
-[![CodeQL](https://github.com/OpenVisualCloud/iVSR/actions/workflows/codeql.yml/badge.svg)](https://github.com/OpenVisualCloud/iVSR/actions/workflows/codeql.yml)<br>
+[![CodeQL](https://github.com/OpenVisualCloud/iVSR/actions/workflows/codeql.yml/badge.svg)](https://github.com/OpenVisualCloud/iVSR/actions/workflows/codeql.yml)  
 [![License](https://img.shields.io/badge/license-BSD_3_Clause-stable.svg)](https://github.com/OpenVisualCloud/iVSR/blob/master/LICENSE.md)
 [![Contributions](https://img.shields.io/badge/contributions-welcome-blue.svg)](https://github.com/OpenVisualCloud/iVSR/wiki)
 [![Ubuntu-DockerFile-Build](https://github.com/OpenVisualCloud/iVSR/actions/workflows/ubuntu-build-docker.yml/badge.svg)](https://github.com/OpenVisualCloud/iVSR/actions/workflows/ubuntu-build-docker.yml)
@@ -33,11 +33,9 @@
 5. [License](#5-license)
 # 1. Overview of iVSR
 ## 1.1 What is iVSR
-iVSR aims to facilitate AI media processing with exceptional quality and performance on Intel's hardware.
+iVSR facilitates AI media processing with exceptional quality and performance on Intel hardware.
 
-iVSR offers a patch-based, heterogeneous, multi-GPU, and multi-algorithm solution, 
-harnessing the full capabilities of Intel's CPUs and GPUs. 
-And iVSR is adaptable for deployment on a single device, a distributed system, cloud infrastructure, edge cloud, or K8S environment.
+iVSR offers a patch-based, heterogeneous, multi-GPU, and multi-algorithm solution, harnessing the full capabilities of Intel CPUs and GPUs. It is adaptable for deployment on a single device, a distributed system, cloud infrastructure, edge cloud, or K8S environment.
 
 <!-- ![overview](./docs/figs/iVSR.png) -->
 <div align=center>
@@ -46,10 +44,10 @@ And iVSR is adaptable for deployment on a single device, a distributed system, c
 
 ## 1.2 Why is iVSR needed
 
-- Simple APIs are provided, ensuring that any changes to the OpenVINO API remain hidden.
-- A patch-based solution is offered to facilitate inference on hardware with limited memory capacity. This is particularly useful for super-resolution of high-resolution input videos, such as 4K.
+- Simple APIs ensure that any changes to the OpenVINO API remain hidden.
+- A patch-based solution facilitates inference on hardware with limited memory capacity, particularly useful for super-resolution of high-resolution input videos, such as 4K.
 - The iVSR SDK includes features to safeguard AI models created by Intel, which contain Intel IP.
-- The iVSR SDK is versatile and can support a wide range of AI media processing algorithms.
+- The iVSR SDK is versatile and supports a wide range of AI media processing algorithms.
 - For specific algorithms, performance optimization can be executed to better align with customer requirements.
 
 ## 1.3 iVSR Components
@@ -57,62 +55,89 @@ This repository or package includes the following major components:
 
 ### 1.3.1 iVSR SDK
 The iVSR SDK is a middleware library that supports various AI video processing filters. It is designed to accommodate different AI inference backends, although currently, it only supports OpenVINO.<br>
-For a detailed introduction to the iVSR SDK API, please refer to [this introduction](./ivsr_sdk/README.md#api-introduction).We've also included a `vsr_sample` as a demonstration of its usage.<br>
+For a detailed introduction to the iVSR SDK API, please refer to [this introduction](./ivsr_sdk/README.md#api-introduction).
+
+We've also included a `vsr_sample` as a demonstration of its usage.
 
-### 1.3.2 iVSR FFmpeg plugin
 In order to support the widely-used media processing solution FFmpeg, we've provided an iVSR SDK plugin to simplify integration.<br>
-This plugin is integrated into FFmpeg's [`dnn_processing` filter](https://ffmpeg.org/ffmpeg-filters.html#dnn_005fprocessing-1) in the libavfilter library, serving as a new `ivsr` backend to this filter. Please note that the patches provided in this project are specifically for FFmpeg n6.1.<br>
+This plugin is integrated into FFmpeg's `dnn_processing` filter in the [FFmpeg documentation](https://ffmpeg.org/ffmpeg-filters.html#dnn_005fprocessing-1) in the libavfilter library, serving as a new `ivsr` backend to this filter. Please note that the patches provided in this project are specifically for FFmpeg n6.1.<br>
 
 ### 1.3.3 OpenVINO patches and extension
 In [this folder](./ivsr_ov/based_on_openvino_2022.3/patches), you'll find patches for OpenVINO that enable the Enhanced BasicVSR model. These patches utilize OpenVINO's [Custom OpenVINO™ Operations](https://docs.openvino.ai/latest/openvino_docs_Extensibility_UG_add_openvino_ops.html) feature, which allows users to support models with custom operations not inherently supported by OpenVINO.<br>
 These patches are specifically for OpenVINO 2022.3, meaning the Enhanced BasicVSR model will only work on OpenVINO 2022.3 with these patches applied.<br>
 
-
 ## 1.4 Capabilities of iVSR
-Currently, iVSR offers two AI media processing functionalities: Video Super Resolution (VSR), and Smart Video Processing (SVP) for bandwidth optimization. Both functionalities can be run on Intel CPUs and Intel GPUs (including Flex170, Arc770) via OpenVINO and FFmpeg.
-
+Currently, iVSR offers two AI media processing functionalities: Video Super Resolution (VSR) and Smart Video Processing (SVP) for bandwidth optimization. Both functionalities can be run on Intel CPUs and Intel GPUs (including Flex170, Arc770) via OpenVINO and FFmpeg.
 
 ### 1.4.1 Video Super Resolution (VSR)
-Video Super Resolution (VSR) is a technique extensively employed in the AI media enhancement domain to upscale low-resolution videos to high-resolution. iVSR supports `Enhanced BasicVSR`, `Enhanced EDSR`, `TSENet`, and has the capability to be extended to support additional models.
+Video Super Resolution (VSR) is a technique extensively employed in the AI media enhancement domain to upscale low-resolution videos to high-resolution. iVSR supports `Enhanced BasicVSR`, `Enhanced EDSR`, and `TSENet`. It also has the capability to be extended to support additional models.
 
 - #### i. Enhanced BasicVSR
   `BasicVSR` is a publicly available AI-based VSR algorithm. For more details on the public `BasicVSR`, please refer to this [paper](https://arxiv.org/pdf/2012.02181.pdf).<br><br>
-  We have improved the public model to attain superior visual quality and reduced computational complexity,  named `Enhanced BasicVSR`. The performance of the `Enhanced BasicVSR` model inference has also been optimized for Intel GPUs. Please note that this optimization is specific to OpenVINO 2022.3. Therefore, the Enhanced BasicVSR model only works with OpenVINO 2022.3 with the applied patches.<br><br>
-  The input shape of this model is `[1, (channels)3, (frames)3, H, W]`, and the output shape is `[1, (channels)3, (frames)3, 2xH, 2xW]`.
+  We have improved the public model to attain superior visual quality and reduced computational complexity. This improved model is named `Enhanced BasicVSR`. The performance of the `Enhanced BasicVSR` model inference has also been optimized for Intel GPUs. Please note that this optimization is specific to OpenVINO 2022.3. Therefore, the Enhanced BasicVSR model only works with OpenVINO 2022.3 with the applied patches.<br><br>
+  The input shape of this model and the output shape are:
+  ```plaintext
+  Input shape: [1, (channels)3, (frames)3, H, W]
+  Output shape: [1, (channels)3, (frames)3, 2xH, 2xW]
+  ```
 
 - #### ii. Enhanced EDSR
   `EDSR` is another publicly available AI-based single image SR algorithm. For more details on the public EDSR, please refer to this [paper](https://arxiv.org/pdf/1707.02921.pdf)<br><br>
-  We have improved the public `EDSR` model to reduce the computational complexity by over 79% compared to Enhanced BasicVSR, while maintaining similar visual quality, named `Enhanced EDSR`.<br><br>
-  The input shape of this model is `[1, (channels)3, H, W]`, and the output shape is `[1, (channels)3, 2xH, 2xW]`.
+  We have improved the public `EDSR` model to reduce the computational complexity by over 79% compared to Enhanced BasicVSR. This improvement maintains similar visual quality and is named `Enhanced EDSR`.<br><br>
+  The input shape of this model and the output shape are:
+  ```plaintext
+  Input shape: [1, (channels)3, H, W]
+  Output shape: [1, (channels)3, 2xH, 2xW]
+  ```
 
 - #### iii. TSENet
   `TSENet` is one multi-frame SR algorithm derived from [ETDS](https://github.com/ECNUSR/ETDS).<br><br>
   We provide a preview version of the feature to support this model in the SDK and its plugin. Please contact your Intel representative to obtain the model package.<br><br>
-  The input shape of this model is `[1, (channels * frames)9, H, W]`, and the output shape is `[1, (channels)3, 2xH, 2xW]`. For each inference, the input data is the `(n-1)th`, `(n)th`, and `(n+1)th` frames combined. The output data is the `(N)th` frame. For the first frame, the input data is `1st`, `1st`, `2nd` frames combined. For the last frame, the input data is the `(n-1)th`, `(n)th`, `(n)th` frames combined.<br>
+  The input shape of this model and the output shape are:
+  ```plaintext
+  Input shape: [1, (channels * frames)9, H, W]
+  Output shape: [1, (channels)3, 2xH, 2xW]
+  ```
+  For each inference, the input data is the `(n-1)th`, `(n)th`, and `(n+1)th` frames combined. The output data is the `(N)th` frame. For the first frame, the input data is `1st`, `1st`, `2nd` frames combined. For the last frame, the input data is the `(n-1)th`, `(n)th`, `(n)th` frames combined.
 
 ### 1.4.2. Smart Video Processing (SVP)
-`SVP` is an AI-based video prefilter that enhances the perceptual rate-distortion in video encoding. With `SVP`, the encoded video streams maintain the same visual quality while reducing bandwidth.<br>
+`SVP` is an AI-based video prefilter that enhances perceptual rate-distortion in video encoding. With `SVP`, encoded video streams maintain the same visual quality while reducing bandwidth usage.<br>
+
+Two SVP model variants are provided:
 
-Two SVP model variances are provided. `SVP-Basic` model is one efficiency-oriented designed model, it preserves fidelity while reducing the encoded bitrate. Modifications to images/video by SVP-Basic pre-processing cannot be perceived by human eyes while they can be measured by no to minor BD-rates degradation if it’s measured by SSIM or MS-SSIM metrics. SVP-Basic model is adaptive to almost all video scenarios, including live sport, live gaming, livestream sales, VOD, video conference, video surveillance, and 5G video ring.<br>
-`SVP-SE` model is designed for subjective video quality preservation with up to 50% bitrate saving. It targets human eyes plausible enhancement, reduces complex details like human-eyes insensitive patterns and noise; hence it can’t be evaluated by popular full-reference visual quality metrics including PSNR/SSIM/VMAF/etc. It improves the visibility and quality of visuals, making them more vivid and appealing to viewers, so it’s widely used in various industries, including entertainment, media and advertising, to enhance the visual experience and attract audience attention.<br><br>
-The input and output shape are `[1, (channels)3, H, W]` for RGB based model and `[1, (channels)1, H, W]` for Y based model.<br>
+- **SVP-Basic**: This model is designed for efficiency, preserving fidelity while reducing the encoded bitrate. Modifications made by SVP-Basic are imperceptible to the human eye but can be measured by minor BD-rate degradation when evaluated using SSIM or MS-SSIM metrics. SVP-Basic is adaptable to various video scenarios, including live sports, gaming, livestream sales, VOD, video conferencing, video surveillance, and 5G video streaming.<br>
+
+- **SVP-SE**: This model focuses on subjective video quality preservation, achieving up to 50% bitrate savings. It enhances visuals by reducing complex details and noise that are less perceptible to human eyes. As a result, it cannot be evaluated by traditional full-reference visual quality metrics like PSNR, SSIM, or VMAF. SVP-SE improves the visibility and quality of visuals, making them more vivid and appealing, which is beneficial in industries such as entertainment, media, and advertising.<br>
+
+The input and output shapes are:
+- RGB based model: 
+  ```plaintext
+  Input shape: [1, (channels)3, H, W]
+  Output shape: [1, (channels)3, H, W]
+  ```
+- Y based model:
+  ```plaintext
+  Input shape: [1, (channels)1, H, W]
+  Output shape: [1, (channels)1, H, W]
+  ```
+<br>
 
 # 2. Setup iVSR env on linux
 The software was validated on:
 - Intel Xeon hardware platform
-- (Optional) Intel Data Center GPU Flex 170(*aka* ATS-M1 150W)
-- Host OS: Linux based OS (Ubuntu 22.04 or Rocky Linux 9.3)
-- Docker OS: Ubuntu 22.04 or Rocky Linux 9.3
-- OpenVINO: [2022.3](https://github.com/openvinotoolkit/openvino/tree/2022.3.0) or [2023.2](https://github.com/openvinotoolkit/openvino/tree/2023.2.0) or [2024.5](https://github.com/openvinotoolkit/openvino/tree/2024.5.0)
+- (Optional) Intel® Data Center GPU Flex 170(*aka* ATS-M1 150W)
+- Host OS: Linux-based OS (Ubuntu 22.04 or Rocky Linux 9.3)
+- Docker-based OS: Ubuntu 22.04 or Rocky Linux 9.3
+- OpenVINO: [2022.3](https://github.com/openvinotoolkit/openvino/tree/2022.3.0), [2023.2](https://github.com/openvinotoolkit/openvino/tree/2023.2.0), or [2024.5](https://github.com/openvinotoolkit/openvino/tree/2024.5.0)
 - FFmpeg: [n6.1](https://github.com/FFmpeg/FFmpeg/tree/n6.1)
 
-Building iVSR requires the installation of the GPU driver(optional), OpenCV, OpenVINO, and FFmpeg.<br>
+Building iVSR requires the installation of the GPU driver (optional), OpenCV, OpenVINO, and FFmpeg.  
 We provide **three** ways to install requirements and build iVSR SDK & iVSR FFmpeg plugin:<br>
 1. [Install dependencies and build iVSR manually](#22-install-dependencies-and-build-ivsr-manually)<br>
 2. [Install dependencies and build iVSR by scripts](#23-install-dependencies-and-build-ivsr-by-scripts)<br>
 3. [Install dependencies and build iVSR by Dockerfile](#24-install-dependencies-and-build-ivsr-by-dockerfile)<br>
 
-Note that to run inference on a **GPU**, it is necessary to have **kernel packages** installed on the bare metal system beforehand. See [Install GPU kernel packages ](#21-optional-install-gpu-kernel-packages) for details.<br>
+Note that to run inference on a **GPU**, it is necessary to have **kernel packages** installed on the bare metal system beforehand. See [Install GPU kernel packages](#21-optional-install-gpu-kernel-packages) for details.<br>
 
 ## 2.1 (Optional) Install GPU kernel packages
 Refer to this [instruction](https://dgpu-docs.intel.com/driver/installation.html#ubuntu-package-installation) for the installation guide on Ubuntu. GPU runtime driver/packages are also installed in script and dockerfile provided.
@@ -120,48 +145,49 @@ Refer to this [instruction](https://dgpu-docs.intel.com/driver/installation.html
 ## 2.2 Install dependencies and build iVSR manually
 
 Here are two guides for your reference:<br>
-One is generic in case you are familiar with Intel® devices and have experience in Intel® developed software before, which you can follow the official steps to build OpenCV and OpenVINO by source code. You can get it from: [Generic manual building guide](docs/generic_manual_build.md#generic-manual-build-steps-for-ffmpeg--ivsr-plugin-software)<br>
-Another option is a tutorial for absolute beginners to try to build the project following every step in the guide based on a clean Ubuntu OS installed machine. [Quick manual building guide](docs/quick_try_manual_build.md#manual-build-steps-for-ffmpeg--ivsr-plugin-software-on-ubuntu)
+1. **Generic Manual Building Guide**: If you are familiar with Intel® devices and have experience with Intel® developed software, follow the official steps to build OpenCV and OpenVINO from source code. Refer to the [Generic manual building guide](docs/generic_manual_build.md#generic-manual-build-steps-for-ffmpeg--ivsr-plugin-software).<br>
+2. **Quick Manual Building Guide**: For absolute beginners, this tutorial provides step-by-step instructions to build the project on a clean Ubuntu OS. Refer to the [Quick manual building guide](docs/quick_try_manual_build.md#manual-build-steps-for-ffmpeg--ivsr-plugin-software-on-ubuntu).<br>
+
+## 2.3 Install dependencies and build iVSR using scripts
+We provide a `build.sh` script to facilitate building the entire project from source on a clean Ubuntu 22.04-based Linux machine.
 
-## 2.3 Install dependencies and build iVSR by scripts
-We provide shell scripts `build_ivsr.sh` and `ivsr_setupvar.sh` to assist in building the dependencies from source code and setting up the environment from scratch.<br>
 ```bash
-#ivsr environment building
-chmod a+x ./build_ivsr.sh
-sudo ./build_ivsr.sh --enable_ov_patch <true/false> --enable_compile_ffmpeg true --ov_version <2022.3|2023.2|2024.5>
-#environment variables setting
-source ./ivsr_setupvar.sh --ov_version <2022.3|2023.2|2024.5>
+chmod a+x ./build.sh
+./build.sh --ov_version [2022.3|2023.2|2024.5]
 ```
-The scripts accept the following input parameters:<br>
-- `enable_ov_patch`: Determines whether to enable OpenVINO patches, which are necessary to run the Enhanced BasicVSR model.<br>
-- `enable_compile_ffmpeg`: Determines whether to compile FFmpeg. Set this to `false` if you're only using the iVSR SDK sample.<br>
-- `ov_version`: Specifies the OpenVINO version. iVSR supports `2022.3`, `2023.2` and `2024.5`. Note that running the Enhanced BasicVSR model requires `2022.3`.<br>
 
-Feel free to modify and update these scripts as per your requirements. For new released OpenVINO version, please follow the [manual build](#22-install-dependencies-and-build-ivsr-manually) guide.<br>
+The script accepts the following parameter:
+- `ov_version`: Specifies the OpenVINO version. iVSR supports `2022.3`, `2023.2`, and `2024.5`. Note that running the Enhanced BasicVSR model requires `2022.3`.
 
+After the build is complete, set the environment variables. For OpenVINO 2022.3:
 
-## 2.4 Install dependencies and build iVSR by Dockerfile
-Dockerfiles are also provided to expedite the environment setup process. Follow the guide to build the docker image and run the application in the docker containers: [Docker image build guide](docs/docker_image_build.md#docker-image-build-guide).<br>
+```bash
+source <workspace>/ivsr_ov/based_on_openvino_2022.3/openvino/install/setupvars.sh
+```
+
+For other OpenVINO versions installed via official packages, manual environment setup is not required.
+
+Once the build is successfully completed, refer to [section 3.2](#32-run-with-ffmpeg) for instructions on using the FFmpeg command line to run the pipelines. Feel free to modify and update these scripts as needed. For newly released OpenVINO versions, please follow the [manual build](#22-install-dependencies-and-build-ivsr-manually) guide.
+
+## 2.4 Install dependencies and build iVSR using Dockerfile
+To simplify the environment setup, Dockerfiles are provided. Follow the [Docker image build guide](docs/docker_image_build.md#docker-image-build-guide) to build the Docker image and run the application in Docker containers.
 
 # 3. How to use iVSR
-Both `vsr_sample` and FFmpeg integration are provided to run inference on the iVSR SDK. Execute the following commands to setup the env before executing them. <br>
+You can run inference on the iVSR SDK using either the `vsr_sample` or the `ffmpeg` integrated with the iVSR plugin. Before running them, set up the environment with the following commands:
 ```bash
 source <OpenVINO installation dir>/install/setupvars.sh
 export LD_LIBRARY_PATH=<Package dir>/ivsr_sdk/lib:<OpenCV installation folder>/install/lib:$LD_LIBRARY_PATH
 ```
-Please note that the current solution is of `pre-production` quality.<br>
-
+Note that the current solution is of `pre-production` quality.
 
 ## 3.1 Run with iVSR SDK sample
-`vsr_sample` has been developed using the iVSR SDK and OpenCV. For guidance on how to run inference with it, please refer to this [section](./ivsr_sdk/README.md#vsr-sample).<br>
+The `vsr_sample` is developed using the iVSR SDK and OpenCV. For detailed instructions on running inference with it, refer to this [section](./ivsr_sdk/README.md#vsr-sample).
 
 ## 3.2 Run with FFmpeg
-Once the FFmpeg plugin patches have been applied and FFmpeg has been built, you can refer to [the FFmpeg cmd line samples](ivsr_ffmpeg_plugin/README.md#how-to-run-inference-with-ffmpeg-plugin) for instructions on how to run inference with FFmpeg.<br>
+After applying the FFmpeg plugin patches and building FFmpeg, refer to [the FFmpeg command line samples](ivsr_ffmpeg_plugin/README.md#how-to-run-inference-with-ffmpeg-plugin) for instructions on running inference with FFmpeg.
 
 # 4. Model files
-Only models in OpenVINO IR format is supported by iVSR. Please reach out to your Intel representative to obtain the model files which are not included in the package.<br>
-
+iVSR supports only models in OpenVINO IR format. Contact your Intel representative to obtain the model files, as they are not included in the repo.
 
 # 5. License
 iVSR is licensed under the BSD 3-clause license. See [LICENSE](LICENSE.md) for details.
-
diff --git a/build.sh b/build.sh
new file mode 100755
index 0000000..f783c99
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,176 @@
+#!/bin/bash
+
+set -e
+
+base_dir=$(pwd)
+ov_version=2022.3
+
+# Function to display usage information
+usage() {
+    echo "Usage: $0  --ov_version [2022.3|2023.2|2024.5]"
+    exit 1
+}
+
+prepare_dependencies() {
+  echo "Preparing dependencies..."
+  sudo apt-get install -y --no-install-recommends \
+    curl ca-certificates gpg-agent software-properties-common
+  
+  sudo apt-get install -y --no-install-recommends --fix-missing \
+    autoconf \
+    automake \
+    build-essential \
+    apt-utils cmake cython3 flex bison gcc g++ git make patch pkg-config wget \
+    libdrm-dev libudev-dev libtool libusb-1.0-0-dev xz-utils ocl-icd-opencl-dev opencl-headers \
+    apt-utils gpg-agent software-properties-common wget python3-dev libpython3-dev python3-pip
+}
+
+config_git_users() {
+  if [ -z "$(git config --global user.name)" ]; then
+      git config --global user.name "no name"
+  fi
+
+  if [ -z "$(git config --global user.email)" ]; then
+      git config --global user.email "noname@example.com"
+  fi
+}
+
+install_openvino_from_source() {
+  echo "Start building OpenVINO"
+
+  ov_repo=https://github.com/openvinotoolkit/openvino.git
+  ov_branch=${ov_version}.0
+  ivsr_ov_dir=${base_dir}/ivsr_ov/based_on_openvino_${ov_version}/openvino
+  if [ ! -d "${ivsr_ov_dir}" ]; then
+    git clone --depth 1 --branch ${ov_branch} ${ov_repo} ${ivsr_ov_dir}
+    git config --global --add safe.directory ${ivsr_ov_dir}
+  fi
+  cd ${ivsr_ov_dir}
+  git submodule update --init --recursive
+
+  ## applying ov22.3 patches to enable Enhanced BasicVSR model
+  for patch_file in $(find ../patches -iname "*.patch" | sort -n);do
+      echo "Applying: ${patch_file}"
+      git am --whitespace=fix ${patch_file}
+  done
+
+  mkdir -p build && cd build && \
+  cmake \
+    -DCMAKE_INSTALL_PREFIX=${PWD}/../install \
+    -DENABLE_INTEL_CPU=ON \
+    -DENABLE_CLDNN=ON \
+    -DENABLE_INTEL_GPU=ON \
+    -DENABLE_ONEDNN_FOR_GPU=OFF \
+    -DENABLE_INTEL_GNA=OFF \
+    -DENABLE_INTEL_MYRIAD_COMMON=OFF \
+    -DENABLE_INTEL_MYRIAD=OFF \
+    -DENABLE_PYTHON=ON \
+    -DENABLE_OPENCV=ON \
+    -DENABLE_SAMPLES=ON \
+    -DENABLE_CPPLINT=OFF \
+    -DTREAT_WARNING_AS_ERROR=OFF \
+    -DENABLE_TESTS=OFF \
+    -DENABLE_GAPI_TESTS=OFF \
+    -DENABLE_BEH_TESTS=OFF \
+    -DENABLE_FUNCTIONAL_TESTS=OFF \
+    -DENABLE_OV_CORE_UNIT_TESTS=OFF \
+    -DENABLE_OV_CORE_BACKEND_UNIT_TESTS=OFF \
+    -DENABLE_DEBUG_CAPS=ON \
+    -DENABLE_GPU_DEBUG_CAPS=ON \
+    -DENABLE_CPU_DEBUG_CAPS=ON \
+    -DCMAKE_BUILD_TYPE=Release \
+    .. && \
+  make -j $(nproc --all) && \
+  make install
+  echo "Build OpenVINO finished."
+    
+  source ${PWD}/../install/setupvars.sh
+}
+
+build_install_ivsr_sdk() {
+  echo "Building and installing iVSR SDK..."
+
+  ivsr_sdk_dir=${base_dir}/ivsr_sdk/
+  cd ${ivsr_sdk_dir}
+  mkdir -p build && cd build && cmake \
+    -DENABLE_LOG=OFF -DENABLE_PERF=OFF -DENABLE_THREADPROCESS=ON \
+    -DCMAKE_BUILD_TYPE=Release .. && \
+  make -j $(nproc --all)
+  sudo make install
+  echo "Build ivsr sdk finished."
+}
+
+build_ffmpeg() {
+  echo "Building FFMPEG with specific libraries support..."
+  sudo -E apt-get update && \
+    DEBIAN_FRONTEND=noninteractive sudo apt-get install -y --no-install-recommends \
+    ca-certificates tar g++ wget pkg-config nasm yasm libglib2.0-dev flex bison gobject-introspection libgirepository1.0-dev \
+    python3-dev libx11-dev libxv-dev libxt-dev libasound2-dev libpango1.0-dev libtheora-dev libvisual-0.4-dev libgl1-mesa-dev \
+    libcurl4-gnutls-dev librtmp-dev mjpegtools libx264-dev libx265-dev libde265-dev libva-dev libtbb-dev
+  
+  # Add commands to build FFMPEG from source
+  ffmpeg_dir=$base_dir/ivsr_ffmpeg_plugin/ffmpeg
+  ffmpeg_repo=https://github.com/FFmpeg/FFmpeg.git
+
+  if [ ! -d "${ffmpeg_dir}" ]; then
+    git clone --depth 1 --branch n6.1 ${ffmpeg_repo} ${ffmpeg_dir}
+    git config --global --add safe.directory ${ffmpeg_dir}
+  fi
+
+  # Apply patches
+  cd ${ffmpeg_dir} && cp -rf $base_dir/ivsr_ffmpeg_plugin/patches/*.patch .
+  git am --whitespace=fix *.patch
+
+  ./configure \
+      --enable-gpl \
+      --enable-nonfree \
+      --disable-static \
+      --disable-doc \
+      --enable-shared \
+      --enable-version3 \
+      --enable-libivsr \
+      --enable-libx264 \
+      --enable-libx265
+
+  make -j$(nproc)
+  sudo make install
+  sudo ldconfig
+}
+
+install_openvino_from_apt() {
+  echo "Installing OpenVINO from apt..."
+  local version=$1
+
+  wget -qO - https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | sudo apt-key add -
+
+  echo "deb https://apt.repos.intel.com/openvino/2023 ubuntu22 main" | sudo tee /etc/apt/sources.list.d/intel-openvino-2023.list
+  echo "deb https://apt.repos.intel.com/openvino/2024 ubuntu22 main" | sudo tee /etc/apt/sources.list.d/intel-openvino-2024.list
+
+  sudo -E apt-get update && \
+    DEBIAN_FRONTEND=noninteractive sudo -E apt-get install -y openvino-$version.0
+}
+
+main() {
+  while [ "$1" != "" ]; do
+    case $1 in
+      --ov_version ) shift
+                     ov_version=$1
+                     ;;
+      * ) usage
+          exit 1
+    esac
+    shift
+  done
+
+  prepare_dependencies
+  config_git_users
+  if [ "$ov_version" = "2022.3" ]; then
+    install_openvino_from_source
+  else
+    install_openvino_from_apt "$ov_version" 
+  fi
+  build_install_ivsr_sdk
+  build_ffmpeg
+}
+
+main "$@"
\ No newline at end of file
diff --git a/build_ivsr.sh b/build_ivsr.sh
deleted file mode 100755
index 4efde04..0000000
--- a/build_ivsr.sh
+++ /dev/null
@@ -1,308 +0,0 @@
-#!/bin/bash
-set -e
-
-PROJECTDIR=${PWD}
-# Function to display usage information
-usage() {
-    echo "Usage: $0  --enable_ov_patch [true|false]
-                        --enable_compile_ffmpeg [true|false]
-                        --ov_version [2022.3|2023.2|2024.5]"
-    exit 1
-}
-
-
-
-# Initialize variables
-ENABLE_OV_PATCH="false"
-ENABLE_COMPILE_FFMPEG="true"
-OV_VERSION="2022.3"
-
-
-
-# Parse command line arguments
-while [ $# -gt 0 ]; do
-  case "$1" in
-    --enable_ov_patch)
-      shift
-      ENABLE_OV_PATCH=$(echo "$1" | tr '[:upper:]' '[:lower:]')
-      if [ "$ENABLE_OV_PATCH" != "true" ] && [ "$ENABLE_OV_PATCH" != "false" ]; then
-        usage
-        exit 1
-      fi
-      ;;
-    --enable_compile_ffmpeg)
-      shift
-      ENABLE_COMPILE_FFMPEG=$(echo "$1" | tr '[:upper:]' '[:lower:]')
-      if [ "$ENABLE_COMPILE_FFMPEG" != "true" ] && [ "$ENABLE_COMPILE_FFMPEG" != "false" ]; then
-        usage
-        exit 1
-      fi
-      ;;
-    --ov_version)
-        shift
-        if [ "$1" = "2022.3" ] || [ "$1" = "2023.2" ] || [ "$1" = "2024.5" ]; then
-          OV_VERSION=$1
-        else
-          usage
-          exit 1
-        fi
-        ;;
-    *)
-      # If the flag doesn't match any known option, display usage message
-      usage
-      ;;
-  esac
-  shift # Move to the next argument
-done
-
-if [ "$OV_VERSION" != "2022.3" ]; then
-    ENABLE_OV_PATCH="false"
-    echo "There is no openvino patches for openvino $OV_VERSION, will ignore the setting of ENABLE_OV_PATCH"
-fi
-
-
-
-# 1.Install pre-requisites
-apt-get update && DEBIAN_FRONTEND=noninteractive && apt-get install -y --no-install-recommends --fix-missing \
-        build-essential \
-        ca-certificates \
-        curl \
-        cmake \
-        cython3 \
-        flex \
-        bison \
-        gcc \
-        g++ \
-        git \
-        libdrm-dev \
-        libudev-dev \
-        libtool \
-        libusb-1.0-0-dev \
-        make \
-        patch \
-        patchelf \
-        pkg-config \
-        xz-utils \
-        ocl-icd-opencl-dev \
-        opencl-headers \
-        apt-utils \
-        gpg-agent \
-        software-properties-common \
-        wget \
-        python3-dev libpython3-dev python3-pip
-
-apt-get clean
-pip --no-cache-dir install --upgrade pip==23.0 setuptools==65.5.0
-pip install numpy==1.23.5
-
-
-
-# 2.Build and Install opencv
-echo "Start building OpenCV"
-OPENCV_REPO=https://github.com/opencv/opencv/archive/4.5.3-openvino-2021.4.2.tar.gz
-cd ${PROJECTDIR}/.. && wget -qO - ${OPENCV_REPO} | tar xz
-OPENCV_BASE=${PROJECTDIR}/../opencv-4.5.3-openvino-2021.4.2
-cd ${OPENCV_BASE}  && mkdir -p build && mkdir -p install && cd build
-  cmake \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_INSTALL_PREFIX=${OPENCV_BASE}/install \
-    -DCMAKE_INSTALL_LIBDIR=lib \
-    -DOPENCV_GENERATE_PKGCONFIG=ON \
-    -DBUILD_DOCS=OFF \
-    -DBUILD_EXAMPLES=OFF \
-    -DBUILD_PERF_TESTS=OFF \
-    -DBUILD_TESTS=OFF \
-    -DWITH_OPENEXR=OFF \
-    -DWITH_OPENJPEG=OFF \
-    -DWITH_GSTREAMER=OFF \
-    -DWITH_JASPER=OFF \
-    -DWITH_FFMPEG=OFF \
-    -DPYTHON3_EXECUTABLE=/usr/bin/python3 \
-    ..
-  make -j "$(nproc)"
-  make install
-cd ${OPENCV_BASE}/install/bin && bash ./setup_vars_opencv4.sh
-echo "Build OpenCV finished."
-
-
-
-# 3.install GPU runtime drivers
-## 3.1 Add the online network repository of intel graphics.
-rm -f /usr/share/keyrings/intel-graphics.gpg
-no_proxy=$no_proxy wget -qO - https://repositories.intel.com/graphics/intel-graphics.key | gpg --dearmor --output /usr/share/keyrings/intel-graphics.gpg
-echo 'deb [arch=amd64 signed-by=/usr/share/keyrings/intel-graphics.gpg] https://repositories.intel.com/graphics/ubuntu jammy flex' | \
-    tee  /etc/apt/sources.list.d/intel.gpu.jammy.list
-
-## 3.2-1 BKC for OV2022.3
-if [ "$OV_VERSION" = "2022.3" ]; then
-    apt-get update
-    # repository to install Intel(R) GPU drivers
-    xargs apt-get install -y --no-install-recommends --fix-missing < ${PROJECTDIR}/ivsr_sdk/dgpu_umd_stable_555_0124.txt
-    apt-get install -y vainfo clinfo
-    apt-get clean
-fi
-
-## 3.2-2 BKC for other OV versions
-if [ "$OV_VERSION" != "2022.3" ]; then
-  apt-get update
-  apt-get install -y vainfo clinfo
-  apt-get install -y --no-install-recommends ocl-icd-libopencl1
-  apt-get clean
-  #hadolint ignore=DL3003
-  mkdir /tmp/gpu_deps && cd /tmp/gpu_deps
-  curl -L -O https://github.com/intel/compute-runtime/releases/download/23.05.25593.11/libigdgmm12_22.3.0_amd64.deb
-  curl -L -O https://github.com/intel/intel-graphics-compiler/releases/download/igc-1.0.13700.14/intel-igc-core_1.0.13700.14_amd64.deb
-  curl -L -O https://github.com/intel/intel-graphics-compiler/releases/download/igc-1.0.13700.14/intel-igc-opencl_1.0.13700.14_amd64.deb
-  curl -L -O https://github.com/intel/compute-runtime/releases/download/23.13.26032.30/intel-opencl-icd_23.13.26032.30_amd64.deb
-  curl -L -O https://github.com/intel/compute-runtime/releases/download/23.13.26032.30/libigdgmm12_22.3.0_amd64.deb
-  dpkg -i ./*.deb
-  rm -rf /tmp/gpu_deps
-  cd ${PROJECTDIR}
-fi
-
-
-
-# 4. Build OpenVINO
-if [ -z "$(git config --global user.name)" ]; then
-    git config --global user.name "no name"
-fi
-
-if [ -z "$(git config --global user.email)" ]; then
-    git config --global user.email "noname@example.com"
-fi
-echo "Start building OpenVINO"
-export LD_LIBRARY_PATH=${OPENCV_BASE}/install/lib:$LD_LIBRARY_PATH
-export OpenCV_DIR=${OPENCV_BASE}/install/lib/cmake/opencv4
-OV_REPO=https://github.com/openvinotoolkit/openvino.git
-OV_BRANCH=${OV_VERSION}.0
-IVSR_OV_DIR=${PROJECTDIR}/ivsr_ov/based_on_openvino_${OV_VERSION}/openvino
-git clone ${OV_REPO} ${IVSR_OV_DIR}
-cd ${IVSR_OV_DIR}
-git config --global --add safe.directory ${IVSR_OV_DIR}
-git checkout ${OV_BRANCH}
-git submodule update --init --recursive
-
-## 4.1 applying ov22.3 patches to enable Enhanced BasicVSR model
-if [ "$ENABLE_OV_PATCH" = "true" ] && [ "$OV_VERSION" = "2022.3" ]; then
-    for patch_file in $(find ../patches -iname "*.patch" | sort -n);do
-        echo "Applying: ${patch_file}"
-        git am --whitespace=fix ${patch_file}
-    done
-fi
-
-cd ${IVSR_OV_DIR}
-mkdir -p build && cd build && \
-cmake \
-  -DCMAKE_INSTALL_PREFIX=${PWD}/../install \
-  -DENABLE_INTEL_CPU=ON \
-  -DENABLE_CLDNN=ON \
-  -DENABLE_INTEL_GPU=ON \
-  -DENABLE_ONEDNN_FOR_GPU=OFF \
-  -DENABLE_INTEL_GNA=OFF \
-  -DENABLE_INTEL_MYRIAD_COMMON=OFF \
-  -DENABLE_INTEL_MYRIAD=OFF \
-  -DENABLE_PYTHON=ON \
-  -DENABLE_OPENCV=ON \
-  -DENABLE_SAMPLES=ON \
-  -DENABLE_CPPLINT=OFF \
-  -DTREAT_WARNING_AS_ERROR=OFF \
-  -DENABLE_TESTS=OFF \
-  -DENABLE_GAPI_TESTS=OFF \
-  -DENABLE_BEH_TESTS=OFF \
-  -DENABLE_FUNCTIONAL_TESTS=OFF \
-  -DENABLE_OV_CORE_UNIT_TESTS=OFF \
-  -DENABLE_OV_CORE_BACKEND_UNIT_TESTS=OFF \
-  -DENABLE_DEBUG_CAPS=ON \
-  -DENABLE_GPU_DEBUG_CAPS=ON \
-  -DENABLE_CPU_DEBUG_CAPS=ON \
-  -DCMAKE_BUILD_TYPE=Release \
-  .. && \
-make -j $(nproc --all) && \
-make install
-bash ${PWD}/../install/setupvars.sh
-echo "Build OpenVINO finished."
-
-
-
-#5. Build iVSR-SDK
-CUSTOM_OV_INSTALL_DIR=${IVSR_OV_DIR}/install
-CUSTOM_IE_DIR=${CUSTOM_OV_INSTALL_DIR}/runtime
-CUSTOM_IE_LIBDIR=${CUSTOM_IE_DIR}/lib/intel64
-export OpenVINO_DIR=${CUSTOM_IE_DIR}/cmake
-export InferenceEngine_DIR=${CUSTOM_IE_DIR}/cmake
-export TBB_DIR=${CUSTOM_IE_DIR}/3rdparty/tbb/cmake
-export ngraph_DIR=${CUSTOM_IE_DIR}/cmake
-export LD_LIBRARY_PATH=${CUSTOM_IE_DIR}/3rdparty/tbb/lib:${CUSTOM_IE_LIBDIR}:$LD_LIBRARY_PATH
-
-echo "Start building ivsr sdk."
-IVSR_SDK_DIR=${PROJECTDIR}/ivsr_sdk/
-mkdir -p ${IVSR_SDK_DIR}/build 
-cd ${IVSR_SDK_DIR}/build 
-cmake .. \
-  -DENABLE_LOG=OFF -DENABLE_PERF=OFF -DENABLE_THREADPROCESS=ON \
-  -DCMAKE_BUILD_TYPE=Release
-make -j $(nproc --all)
-make install
-echo "Build ivsr sdk finished."
-
-
-
-#6. Build ffmpeg with iVSR SDK backend, disable it if you don't need it.
-if ${ENABLE_COMPILE_FFMPEG}; then
-  echo "Start building FFMPEG"
-  apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
-    ca-certificates tar g++ wget pkg-config nasm yasm libglib2.0-dev flex bison gobject-introspection libgirepository1.0-dev python3-dev \
-    libx11-dev \
-    libxv-dev \
-    libxt-dev \
-    libasound2-dev \
-    libpango1.0-dev \
-    libtheora-dev \
-    libvisual-0.4-dev \
-    libgl1-mesa-dev \
-    libcurl4-gnutls-dev \
-    librtmp-dev \
-    mjpegtools \
-    libx264-dev \
-    libx265-dev \
-    libde265-dev \
-    libva-dev
-  export LD_LIBRARY_PATH=${IVSR_SDK_DIR}/lib:/usr/local/lib:$LD_LIBRARY_PATH
-  FFMPEG_IVSR_SDK_PLUGIN_DIR=${PROJECTDIR}/ivsr_ffmpeg_plugin
-  FFMPEG_DIR=${FFMPEG_IVSR_SDK_PLUGIN_DIR}/ffmpeg
-  FFMPEG_REPO=https://github.com/FFmpeg/FFmpeg.git
-  FFMPEG_VERSION=n6.1
-  git clone ${FFMPEG_REPO} ${FFMPEG_DIR}
-  cd ${FFMPEG_DIR}
-  git config --global --add safe.directory ${FFMPEG_DIR}
-  git checkout ${FFMPEG_VERSION}
-
-  cp  ${PROJECTDIR}/ivsr_ffmpeg_plugin/patches/*.patch ${FFMPEG_DIR}/
-  cd ${FFMPEG_DIR} && { set -e;
-  for patch_file in $(find -iname "*.patch" | sort -n); do
-    echo "Applying: ${patch_file}";
-    git am --whitespace=fix ${patch_file};
-  done; }
-  if [ -f "${CUSTOM_OV_INSTALL_DIR}/setvars.sh" ]; then
-    . ${CUSTOM_OV_INSTALL_DIR}/setvars.sh
-  fi
-  export LD_LIBRARY_PATH=${IVSR_SDK_DIR}/lib:${CUSTOM_IE_LIBDIR}:${TBB_DIR}/../lib:"$LD_LIBRARY_PATH"
-  cd ${FFMPEG_DIR}
-  ./configure \
-  --extra-cflags=-fopenmp \
-  --extra-ldflags=-fopenmp \
-  --enable-libivsr \
-  --disable-static \
-  --disable-doc \
-  --enable-shared \
-  --enable-vaapi \
-  --enable-gpl \
-  --enable-libx264 \
-  --enable-libx265 \
-  --enable-version3
-  make -j $(nproc --all)
-  make install
-  echo "Build FFMPEG finished."
-fi
-
diff --git a/docs/docker_image_build.md b/docs/docker_image_build.md
index af64ae0..9d17cef 100644
--- a/docs/docker_image_build.md
+++ b/docs/docker_image_build.md
@@ -22,15 +22,27 @@ sudo systemctl restart docker
 cd ./ivsr_ffmpeg_plugin
 ./build_docker.sh --enable_ov_patch [true|false] --ov_version [2022.3|2023.2|2024.5|2024.5s] --os_version [rockylinux9|ubuntu22]
 ```
-- `enable_ov_patch`: Set as `true` or `flase` to enable or disable the application of OpenVINO 2022.3 patches, which are needed to support the Enhanced BasicVSR model.<br>
-- `ov_version`: Set the OpenVINO version to `2022.3`, `2023.2`, `2024.5`, `2024.5s`, which will be built and installed, the 2024.5s mean install openvino 2024.5 via apt or yum not build and install from source code. iVSR currently supports both OpenVINO 2022.3, 2023.2 and 2024.5, but the patches to enable the Enhanced BasicVSR model are only for OpenVINO 2022.3.<br>
-- `os_version`: Set OS version of Docker image to ubuntu22(Ubuntu 22.04) or rockylinux9(Rocky Linux 9.3) to build docker image based on specific OS.<br>
-If the docker image builds successfully, you can see a docker image named `ffmpeg_ivsr_sdk_${os_version}_ov${ov_version}` such as `ffmpeg_ivsr_sdk_ubuntu22_ov2022.3` or `ffmpeg_ivsr_sdk_rockylinux9_ov2022.3` in the output of `docker image ls`.<br>
+- `enable_ov_patch`: Set as `true` or `false` to enable or disable the application of OpenVINO 2022.3 patches, which are needed to support the Enhanced BasicVSR model.
+- `ov_version`: Set the OpenVINO version to `2022.3`, `2023.2`, `2024.5`, or `2024.5s`. These versions will be built and installed. The `2024.5s` version means installing OpenVINO 2024.5 via apt or yum, not building and installing from source code. iVSR currently supports OpenVINO 2022.3, 2023.2, and 2024.5. However, the patches to enable the Enhanced BasicVSR model are only for OpenVINO 2022.3.
+- `os_version`: Set OS version of Docker image to `ubuntu22` (Ubuntu 22.04) or `rockylinux9` (Rocky Linux 9.3) to build docker image based on specific OS.
+
+If the docker image builds successfully, you can see a docker image named `ffmpeg_ivsr_sdk_${os_version}_ov${ov_version}` such as `ffmpeg_ivsr_sdk_ubuntu22_ov2022.3` or `ffmpeg_ivsr_sdk_rockylinux9_ov2022.3` in the output of `docker image ls`.
 
 ### 4. Start Docker Container
 
 ```bash
-sudo docker run -itd --name ffmpeg_ivsr_sdk_container --privileged -e MALLOC_CONF="oversize_threshold:1,background_thread:true,metadata_thp:auto,dirty_decay_ms:9000000000,muzzy_decay_ms:9000000000" -e http_proxy=$http_proxy -e https_proxy=$https_proxy -e no_proxy=$no_proxy --shm-size=128g --device=/dev/dri:/dev/dri ffmpeg_ivsr_sdk_[ubuntu22|rockylinux9]_[ov2022.3|ov2023.2|ov2024.5]:latest bash
+# The backslash at the end of the line indicates that the command continues on the next line
+sudo docker run -itd --name ffmpeg_ivsr_sdk_container --privileged \
+  -e MALLOC_CONF="oversize_threshold:1,background_thread:true,metadata_thp:auto,dirty_decay_ms:9000000000,muzzy_decay_ms:9000000000" \
+  -e http_proxy=$http_proxy \
+  -e https_proxy=$https_proxy \
+  -e no_proxy=$no_proxy \
+  --shm-size=128g \
+  --device=/dev/dri:/dev/dri \
+  ffmpeg_ivsr_sdk_<os_version>_<ov_version>:latest bash
+
+# Open another shell terminal to interact with the running container
 sudo docker exec -it ffmpeg_ivsr_sdk_container bash
 ```
+
 Note `--device=/dev/dri:/dev/dri` is specified in the command to add the host gpu device to container.<br>
\ No newline at end of file
diff --git a/docs/figs/logo.bmp b/docs/figs/logo.bmp
deleted file mode 100644
index d46a7b9f4cd1a77c99677f25693f35b60dd4b24d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 135054
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
XfIvVXAP^7;2m}NI0s(;l4+Q=XV5ZjS

diff --git a/docs/figs/logo.png b/docs/figs/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..a0d2553efa02bcc03b00ff1b08c2a853ca72ffc9
GIT binary patch
literal 7168
zcmcIp^;gtSxF%(hTpH=6LAsV)SQ-gIVCfL0LAslz8>CBMDM{&$MM}C;1VlOnrNg`5
zAMRgp&z&>#nK++$&zX7V%=<j=#Jtv2CV2khIT{)ofvSpv4jLNzOH?}pfPwlRiGw0g
z6|Relp*yPnFQKEseJN2LVl-6+IbEN;ll++Aj|=U?_crSrYgcoqvf<{y-Ns0!JrCk}
zt4(Ht=dAZx?{L;$k62NmTTYfgtQv%?sxs1(7FbxFHd>(0mL2G8^P_b=4L`<8(0$|m
zq;IBAPvM@s%rGo9&-=F9#<%c~6eNp@7!Y=WSwtht81RD$#6pY}8J#RkOa+2s$XP@K
zaIr%FkAwZJNEenvq6h)%GSLBQK|lU%#&UULqBaGp7^Nr=ef7x73F5;cr++PVxKZ7v
z68--Uh!wDhw)Ta8y_nVkzwGn3xzQiRVgoK}E&Iw)hAsDTK&yu9rgi>UD;kJ(2HfQ2
zC+peKfyr);v{rp(fMI}s4&-YVuBF#tN90c5(s5~1C2dwm|I+iJ8!2EIxW7|E!qV%?
zj)Rs0U%9?Ts^F14Ela^b0Mz%8!6^DWc6#UHvZ9i{8T;e+xr`4-_OD`xZ)sC%r59u5
zLm`mmZ)=>yU-8X=ck)}OhAU{~+NQ6*=_V#+=NTCH$kr`JRMI>+oB|-_vc%%ckVPUI
zy8O9}NxRSP_O%KyBE=i3lpqtK2vzv)BOCpy7BR#`VcCJugX-ZqSKki95v|z@8EbBt
z#ID*(YU&@?#<i)UbI11kIA_}D4>M2J=E=QwJaXgpq?QX!-hs7VgQW*q-(d)xF!;Y{
zF=G2ShO2rMJHI%dfCu$6;gvK2cNfH`L!<}{JYdkOlX0?n7rDkP*zD5I$%*T;r@lDH
z*cB%iNkW;|oiMG_Yb%niU-X!Z8SLQ~5uF-Ov7A%Cv|)a|Kik&nKWwU8WmPGiq#I)x
zd8;H-1QA(sLHTdgD`YKN-&JivB;WsOQa8$B=NWmm&OCdsIVKP@z5D9`=#9<nY4pJ;
z=_E$&r;~WjJ28Rmn#n~+-dSlqCn?6p-T2P?m+`xdSo-|rTiJ5#JNlkfmTz5d<tNf~
z=c?U^GfS)~W8;#k(ifssLzB#OHyuR#7!t!`Fq0=*bTEw<1isX;-UXg4+BYweA|**U
zwSBKz-b^iIdFfN1uQZC3^@<twF<@AA^N}aUYs1bF<z`1TjW}NlzGJ8>`czL5wsSWz
z>twI4eroz!?b?&-*R7~n8i1YZ_E{rJ6}~6wk+oXw6+!5^0{-i>emtapd8Cn{-%S)n
z5qfnaju#!Oy)kM3)291M6m#fo7G)7Z$%gF06?+(F=g{h&ZJ2*SLif%y?_$%>RNBKV
zR2A-rb0=q-HhCRTa}bQ}XK=>181Bmk<wO>W$sI2`PE;jiG;sbkp7J3n`c7G$Uq7#5
zketbEodcO5DB+G)4JFD;FLAP8%)(P&!wOb{jT5{%5;kLD$KEXtE7TP16w<o)E&RSM
z-;y514#ddOTg<_IHIe5=kzPsrLC4ayw`<w1j|ItREL`!z*LnK3le^g8!22UjWHl#&
z7JfnfYf}k#<Mh&J#V$oR%VULrD2>`f*FPkUED|H9;9rUmP~i3~BO8#56RQy~LGrJP
zc!nY+%T=zrr(ZAgxTlZATfA6vxB%wd*&q4Jpt@ZxIEB_H`*pYPLoWeG0~N{$!eFX2
zjDIel#V&VEslDsEswp0BOPWm=l-SD?p-@o#O2*s3@|gQ2!7|VTZHI)BN~^?+5`9&@
z`0Nzp0hVo`on{?w8X#$2t9+I}7<^Z!ulCy}vHh{=_3&27zk0p5AS^HWAz>eJx6T@M
zMZgmp0$bWzsV+3Aq$*%s(4i#bD1D_vyms=uZ6fMo?Yhx$AWH#kySZV9i7lgTr+#kO
zF8+$ZY;9^OXXC8CfZioT%U1&b$;UzH=J`iw{;YuV1i#&!gN-oV%z)F8IZg2L1SQK7
zDev-(jAWDm_zf_pYwKO`O+i4Jc{hHo>_K$9$9#MjtthiGm@u*g64Z+wg&~%=uUTrz
zw~*T|O>O+@FV4F~l62*P1=5Lqg7E9(cDcP%BcUkIF%j_>`V#Osmk*N7`-7q1V%ek%
zz1I4w_7=$&t%*EWmJgF7&h|@zOS6#nt<PRr6FOA;&1y<KtjxPdkrifj4PT_r5o81g
z{GQ<qrf*!G7jOi**UGof)vR_a#txNxVe)d=A)gH^fgZgwLwF)Cz#x%6Wf#(BZe8&c
z?AX=*AoTbe!j+R^G}ynv+iQU~92`lfQ%1=Z@1s0L=G|gTp^Mp5Wg$=?=LfPhK&J?8
z=FCNUeS06sIKM=E(Pppz@kR9Wc%%NC49kHH2O9}b%5cC>bV|~^10zxM@P;7+u<iw2
zsPWNXO2XXUX5b(1C!vU+0~Er{v*tnbk@BGqiC%6FL{uXJz1LCx(*f;o6NRY6CHGA-
z$M(_Rx8dkHg5tOE6t%c$$IlcYjcNH?=I||*CX3}f$h&V0P?N=C1Lm3+U)~-*yH4kB
z7qNqhlniD~C`v>ofeF<&ep`|M9cWShM(wmoQVy`<pzA+*AOEa^2G7IHn%M>2O}ojC
z78W%Q9;a4WNZY?ex~hX5vv){#u5(t$c7pzutZWZ<6@}t{XqgU{smv+6b_fqH2A2}+
zz(Xup{3?XbH&zvgT--Q90D4~Lr=K{zr%^}X3*xZtCRghV)@`>yO}Mdti;w|1SZw6Y
zI5*p|L%E@>Ut4^S5ShDHo9qlCYSf#|g}13!4Gs7VIl~=pO{+gv*=qPn+irNC;Hl9k
zPu{=pv7~$WN4&+l_Gp4l?Tn+`A^cP(KP4J~?(~eIhS1!hVcIM5Si$y>GB3Wkc}4#B
zcevl;1~i?=&<NgK9ix*Hy5qDbsr=x1^OnSNf-3X&P_9E@YHsN(Rb9e`@}~1Ih7sG^
zNL>X0$LkI|&kB#(YTZWSErd{$2hj0N(ImY^&454^pF>}shy~OvQD<El(MsQs+Mr;<
zW>*KIwwB+WRmGj1P;Jp)p~C*&`P5H8L4~BeZ?!NJNC(-!3k%6pfYx=YwQj@;sw^L6
zuCSQ1pOX?+W$)Z9n2DZzohRsV^ZY39&&aDLaBtHXv6g)?Fff`)Jm+U?O+a#pYqNVg
zuQ8oe`soPDjP$D^y08Jaz1P)R6(TFckD&HFz;mT$3N|Q3vLI*Wc<oUL8B*5F6|cy|
z#V|Q+<MQ}`63lWq!<!VqLap8CG8|4b16Oqd<d(eip`E#pGKq4H*EH=1xk02CZt-)G
z-Iv2C&>jy$Gx*Ef;$iHzUGE<9T93{ZbNgGjK8yBD<i>ft!H=9yB`p%7YRBzpKc<@h
zl3NLA93}xL@=`_dgC}Kgiq}29{D5~=Ykx6g*4zJ%Vj+9(kt?EXO1m7#VRcgrZuiX(
zbBI5oh9-W!nD}K>Pti@gaDk1pkigtq_jK)e5Z1?dL%tCW%DZ^?Qd~>vk%ml_s@x$K
zq>1=2_Bft=JylxnbJsx!QcN8(CMtaBYJgRl5dw59(l#}wv3I|#(Sz9W3qXFWm8Q|U
zdP`E2TSZFL#f~)~<=m@JqT&pGfk|&Sn<vHpF&TvDDr)R56Y3sn{6hiLIsjJz5877Z
zR6`|&o{5`eP_c3?bN&1LGN)oMRjC*R$5BgX_16CH=&xHI{;dvDKmV1@s=Q1OS+a@c
zr%x`howXp@D&;-JWq<K$Z05IE)qF|?V2iLcIiwULu3moc?(=Z;z(>(Cyq4?2{&W{)
zD%4_ITcWTzfHfne>aA?7JG5`mk{z)^U7|{dk4;fDLnpOjC6PX&BV{HzxUX+_9Hjny
z{oGRxmt9t?=Xu8=k7l6=i%JuF^@0!6geDA}N-&8<!L*r*e0bj~(7hJjBDFTWPc1!{
z$i0PiGm%%P8V`ZZ9J9P5H&B40ra8{{KeYGmQ+@&D&TD?k=G*-k-l8kMuZ&pZ+f)Oi
z-x*9Uu{>*YasfKOoEBe^JdI_Dxq|D>)ffCWxuEJt#=ZWDpSLeae<ldxvr|S;h}FVL
zEeb|&!(LkaomCDGZW|Aggi!xe(S=h+TDT+gcC=L^D48~^*B@^4+@>>Z?rpm+`8>DO
zz^=u(8pxP(s;@1}M#aimc?$TbIcIWW!eXr64CE022i?Sy{79?(p%TFX?bpRsRr&Sx
z+>$~rta(&gzDdFHUg3rM@IL3Mg&?8r3!Y3~?P5?@9mlz7NtWDIehd_zcGU;WK36Gs
zEs}Zx)B5G}=rJ4GCK<xL^>ru>K%)7wzBAEo{6}u%{QYW83H~-`G%Y9Zc!epGN-oTl
zqH4`ZioHXla5O$j62Gx@Jmhl_+ikQk47H~UMy4nzC<G4hYu?hX30V_m9Ljmi(I`Tj
zRKBo3H2grf`;%7extUn5egJ+cROU(bbF7I~8BDv>PI8SuW%E-FJX0r6dtIun{8Jk9
zOVk)X!?$Y6$h=Z6tvYeW7^bQnKPZg9f#MMSd`g>%0+{&vNo$P&T+K8SEleBpbS%qF
zh+PXQ&_Tw$Bdf<n614IR-hFT0^<Jy63iRSndzpLDG{tU(md{Q#k+U!QeOt**dTZEJ
zcqXKyh&t^n2&p3c{O*g^DnVfrGw;;Zn^*r#4j54o;(TU%(?vFFyLj(By35DIlx4Y*
zR_9+aj>c9R)!~?_Y`V#d={tQIr$uKML)_KAX`XsIxm1k%A=DTi@*r?uB#KEW#CyKA
zo(73jh11PZF#t=M0Wsf^<tWY`+?oE3&im)@)s$(Mj~B|$<zw2eCI#~_w#aCO3jTW;
zd!c}NYXvh=2g+df$A#e&FqzMoO~ZU0CeL0}-uPVoZ>wvHeKV(~kPV$tL2^qdVwMyG
z+nGBeFaxdSq9NysyEa;3pGX<vD6(1a{(~-MF>wt=3C=!hB7*3$Hu05a@97*q#i2u2
z81OtlIaMMeQsIDmo>2db<|bIUDoX$`hB#ToQF7Y8&r)}NZGU1L7v&7IWHZ=Oa5tOv
ziZ709MSdhRbzM<Vzn=MVIH4Za$EUah`WsOawXgs7ZHo-d!D@4zn-}Os(|y)TwX4AZ
z6GQlP>0O^>d`q_zq<!ACmFC4l8H$-G%VIPBC~W%RD|ej!OlWYnN^>0KICC#5pvh!b
zWw`@p<pp+xr#$jJqxCX#mHz8j^(_>oY-(KaM-^4Dz4?vmE=w<$z4fWLzU<#NEv)2V
zh#Ds=azN9CJfNp-x&1fp{aJfQ<e30;O0vbk2|wE1EE=jVm_UpwJe?W0Cjt=1O?4o8
z`-g2^HiJ(rt2L8Glwu#ulCS)>iIanZI0<n7GSn*Ys)kj#itm+^jmWs7HL#e}GIz4E
zb%ozSBl3t`;gaz2c-i9Q3olBf4fgBn!a^AOh_w#@7%^c?Z=T@y56PrbPG>FJ7Lm8M
z5tiE1X1Z58(i1%yR4%|%r*etiZoFxu{2_m}EuWH=3xkNQTC&={T@Z}W6dMf<uk62A
zKzF!CG0O}}QxWyfA%-nKC7sN4pwQ&oP5jh>vE6@|6u%l~LGiK9qmbT(_PFW9uIbn!
zSrGX4tZ62RauY<>{#dC{cU_;08K(&kNei4`(}--PxomttPP_p5+)uvK`nrFguGev2
z1V?rcH?r-w2?y>;z=ia#0D>F2XRoe#HHtCFf%I#>uTgq5Ch*(&m8kwwa}BcbgLd;{
zgf;ahkun~;bW@BRW%ereeJtQQ3s@eS?X^gyJRB$xJH1cPyHXL{Xt^=Hz%VwLn);Mo
z%>*y!(-uCRF5;z;KU<`<x3p|SutKNjgPV28?!Ugni`IsRlzh(!o<FKH9!O0+Iu|><
zg!uJhw*wme6Ku82JC-q1D37R5pphPtBrg(s7N7*B$I{$7K>g3_vi!KHi$P9w_`^L$
z;3{sE7J}M6V%sGt|LR;iPfD-iMzIa$zq@~gasfJ26f3-*nODtq>z6B=Igh<itm+%?
zrIz(S9SiSvB6|?;k%ZW3(#*uVIK;@*3@=*B(l*E<Kv=Yg{Jloy%FcY|b5Abj%urwu
z&m1%4`h5r=SvPy(P&fCAPS3J}5A<|j@b)|+gRBmKH$>-ef9Y@UIWm?DQO^FjghsG`
z706b|yW--TO3N8=%HD;qAxGJGA6M6DYzgfG<<;YuRWAIj=gDTSAZt4bfLxH8YxX_D
z(lqdVH|G7TlY*XgcCT*^WE7fofv}F9M4xJuaE?pcN%S81$nAAOQVSh<X`W@1+ywRM
zvtl_sxWTdi@-IKM&W>AzN*h}tg&E140gcMEe3M+t4BY0iRpmYpt;*9r$)63%u%3F(
zOEEGutze$pT9OZO{3Q7+n1SYB@w?u*#H%UtAep}XTXK+~^*U3;sujxZJsfad9K-cV
zZktfNgPX=N3Rw49xKoBBFz+R+M>^%T<A{GNg<D>WJf1pqL|jC)N$maXR3iqb&^v81
z+jyQM_S)79#1B)A5v>@yL=$2UQP6y!|43T#*jMStKQa`f%h`-xz#wT0{~n|3OfI?$
zx52GRGDWbXS`HdDF2hK59EL<_treHA8YVE6=meLcMkP<vq|er2QuduY)8o+X_>P^o
zILgFTPC#(wqBN{j-fY8Drqq$&yZqWh;ujSkdv>uSm%7L`M`0d~2b4bd9X$dWDJAST
zKyzU$N*cDSr(QC8E5sZG#4xL#fxM{<Y*D*bFLkb+=jCjt4MxbO#{wX=*+}ni8q;mp
zoBy`&=WKm(50&q%Uu}0sgbmZ>dqmoXhp#7x9xJKH!prZRv|xt?m9v4y`iB$@TOJR+
zkYDuYm9RMQmV%Vs>mOs%2{EuMML<BSWkW(lSRDW2v(=hZZoaA%^?6oCq*u2$EJD;;
zYXX)${{bT1rxEIq<hdnj-Uq`Jj%je>bj;gI$a8&>l-<LkRZpb=*yq3bFpiknI;5Sb
z2+Te$j%Fv0k<qJMGZb*><f?^HP`Cah+I7XhYwCSV^5YhROcyQajEJ8whlMdW&Vrkk
zJFWbfGzNg~`GU_$eaW-^1>KkrMO<<S0A1O?0+Q)a_;Lxv7yRUkg9B{QunZ;?ovE2A
z?MWcuHvc>4v0Eq1LI42K12Jkf+w8hW#VGc5Mh$ogfTFfiS{X+L97_}FtL)o{ob=}I
zYW@15RfK<1T(-&Pm);Go>oZmv;FJn72WFgQ?1--`vLdOUHHMSBYi`ss4o}_85*Kk(
z`BtmP4T#z_62|<~$7R4}&kF@OEoPqldM36+la$1pRw&xcFJ+vytN;Mdt1?_aeR<9-
z#{R)Bn%G4}N!qAv&=Mj!!YlvgJ6H>sebWIU;NLa7|FwNAlBXH9+T74z8hsdUaj)Sa
zVmU9H_68?LjRir~d2VMM3)}U%v%kj4+qSKqNHkwRjo3f)&6KSx{sh0a#mq-rH}&tQ
z=Y4g|(HH_&1W2^++3$yc>)v>0d9U*^9>8ht<6lV;<uv|I0QBfDQ-{l5TS@Ktl6yDo
zu=u$zGIU&fNn)sy&u>Dw4&OD_#hSP0=TGwe{4Q2zXy1nZA9>c*s92H4_c6~bAK4iM
zC(O-7$Gwp;;rQ0f0>-|E`HNPsSg+`D`f7qhc(tv&-p5Z%ibw0ih1@y4pLErOdk&uG
z9Cw|osKO)Eu3Jb>THf+pT(q*^WpVt5KpYbkunhpd8SibsXVQ%8?Mu;+f`sl+fd}WQ
z_nGzR4}dgtUTfgwIKj8m_sMhwGG__OYM^<4BoUbd1IO%m#^4M1rDU(=M`X}7xh08a
zTUZJY{zgw6{y2O81B=!CAkUjUP@hWm*iJA14pwj4?TFAu*1Mu;CO4E#>Dbo2SrfRq
z4Zr6_Mk>I@8dfoG9M@zV*E}-z&w`i?tVI|{lR#btX=scM5=|X<9@U2gPW<)a_B3(s
z6+CsGxld)yypAYQQwFS02b9uCouclB;3_f5h;?7~^i^}C%Q>(YfNpiQ>EtnHE%r{m
zRVX@%LjY)<Byq+!zgch2P>TEf;p|MrA0w<L;Oot6YYlDuuw{XaPK&{`LSoH2aoM9C
zf+zHo)#k4X6>gC&WcH|>l6llqMxAo{jcR9)c1yRa8~Xls$Kn%?^K?UyD9a4#knQ4a
zko=yB-;!Pp-5n1M6{_koa9B6_B<CDFzVzS{ETjOZ{w{3Z>Vv7SvTQ9!^7TsCXmceq
zl_|Y|Un%CB{E^8W`rnd>zY0E<Be%+*vJK}ZVJKJWiNFCtzcKSh9XQyZogF|;@ZM|b
zzOaKlgNDTYZW>Vlv<YvA9l7XT@GuLFD*|>1Z)pPj9Pte?b1y`|j+ZM4re&{yn#~ie
zY|>Z-6#uy<FYT}oo2IW5ZehC~w~n5niIkeVRV#b-FTf4z9Cbt-3g~acD88_OFV)#-
z=~16fEHSqFyQMwDmRaLH9O3meI)mi!aPu{4=EO~#eQ4k}#C<nXw!^T!%vQ3Sa4nh2
zn;UA!gaO2Os+0V3q~r(rF%a(2esT>HaW5;V`&9W4#N+zfqK3{DL{IA@->B+tUh&Jb
zqpf7!#jj7b=qk%WljQxL3g5O%xUH{rOxm@$ZKMkY2rFRGAxUe{&!#}sMm^+<T-{3W
zlpX<L=fU4;9qgxr_`HAa>e&8_81pyIG}vZ+U^q&=Uo9x%wOtyR?kG9+<Gi}0+3QsJ
zy&1^nj6Jlx)B`S-+3()ORP+MHGYL)lY2q72{9O-j)AfcGylAhP(j*Q$iL*`!vB?2Z
zm{Y}*^gphyDM{;FA|7j-=NC<9qzvDqf`t;&n-z0D{qTgnH_65rqs24Pq}b%(N*CJ9
zwO(Cts<`6U0Y&)RO_x?r`2uVCTI-g0!&-^j$;X@Ezz#6SZ#Z@x1KSiB6QvjC?fzzJ
z`SK>TX^z-1P+G`Zwf}TxY$ObaSa<J+0K^FRAP6p`X!lv7i3nlm){Zx{{=0tzY~P*r
zr8|NP+P4cmx#K>(Y|puDcmI{n%3A)@L9mB3?8N1J(=@x9!LEt{97m$!$FGVdQ|-E3
zZs20@-Ds;^D7l|NP&()(JIhNbzrSIwP*t{JXK~`f($Io9gLz6&pn~7<xpUD}YW+h>
zJz!vlBMVtGs$Dl)z}NWmkdwCepjeO%8NR^vzkk?RH_{qAkLeFPUIx5Rag}^ZOR^5f
z@cwN1!vGhHMa3BYo@=Vc@X)xSEG4s7YNPi~rF?o%`NoXV3Frr%F>aU_o8rO=ymijj
z+5f{Fz?a+tKwqoXbQ;U`v#nJyo}x~coh3&K%3h!zuMmVlrcg$H1vpk%A2E;wfFZA-
g!U(|s{~dgQcoxnTMem`v{P&Khs;H?@3$+OQAL5jO(*OVf

literal 0
HcmV?d00001

diff --git a/docs/generic_manual_build.md b/docs/generic_manual_build.md
index 93b846c..a033ebf 100644
--- a/docs/generic_manual_build.md
+++ b/docs/generic_manual_build.md
@@ -1,19 +1,19 @@
 # Generic Manual Build Steps for FFmpeg + IVSR plugin Software
 
 ### 1. (Optional) Install software for Intel® Data Center GPU Flex Series
-To facilitate inference on Intel Data Center GPU, it's necessary to have both the kernel driver and the run-time driver and software installed. If you're planning to run inference on a CPU only, you can disregard this step.<br>
+To facilitate inference on Intel Data Center GPU, it's necessary to have both the kernel driver and the run-time driver and software installed. Disregard this step if running inference on a CPU only.<br>
 
-The detailed installation instruction is on [this page](https://dgpu-docs.intel.com/driver/installation.html#).<br>
+The detailed installation instruction is on [this page](https://dgpu-docs.intel.com/driver/installation.html#).
 
 
 ### 2. Install OpenCV
-OpenCV, which is used by the iVSR SDK sample for image processing tasks, needs to be installed. Detailed installation instructions can be found at [Installation OpenCV in Linux](https://docs.opencv.org/4.x/d7/d9f/tutorial_linux_install.html).<br>
+OpenCV, which is used by the iVSR SDK sample for image processing tasks, needs to be installed. Detailed installation instructions can be found at [Installation OpenCV in Linux](https://docs.opencv.org/4.x/d7/d9f/tutorial_linux_install.html).
 
 ### 3. Install OpenVINO
-OpenVINO, currently the only backend supported by iVSR for model inference, should also be installed. You can refer to this [instruction](https://github.com/openvinotoolkit/openvino/blob/master/docs/dev/build_linux.md) to build OpenVINO from the source code.<br>
+OpenVINO, currently the only backend supported by iVSR for model inference, should also be installed. You can refer to this [instruction](https://github.com/openvinotoolkit/openvino/blob/master/docs/dev/build_linux.md) to build OpenVINO from the source code.
 
 ### 4. Build iVSR SDK
-Once the dependencies are installed in the system, you can proceed to build the iVSR SDK and its sample.<br>
+Once the dependencies are installed in the system, you can proceed to build the iVSR SDK and its sample.
 ```bash
 source <OpenVINO installation dir>/install/setupvars.sh
 export OpenCV_DIR=<OpenCV installation dir>/install/lib/cmake/opencv4
@@ -25,7 +25,7 @@ make
 make install
 ```
 ### 5. Build FFmpeg with iVSR plugin
-We provide patches specifically for FFmpeg n6.1. Apply these patches as instructed below:<br>
+We provide patches specifically for FFmpeg n6.1. Apply these patches as instructed below:
 ```bash
 git clone https://github.com/FFmpeg/FFmpeg.git ./ivsr_ffmpeg_plugin/ffmpeg
 cd ./ivsr_ffmpeg_plugin/ffmpeg
@@ -36,9 +36,9 @@ for patch_file in $(find -iname "*.patch" | sort -n); do \
     git am --whitespace=fix ${patch_file};               \
 done;
 ```
-Finally, build FFmpeg. You can also enable other FFmpeg plugins as per the instructions provided in the [Compile FFmpeg for Ubuntu](https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu) guide.<br>
+Finally, build FFmpeg. You can also enable other FFmpeg plugins as per the instructions provided in the [Compile FFmpeg for Ubuntu](https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu) guide.
 ```bash
-source <OpenVINO installation folder>/install/setupvars.sh
+source <OpenVINO installation dir>/install/setupvars.sh
 ./configure --enable-libivsr --extra-cflags=-fopenmp --extra-ldflags=-fopenmp
 make -j $(nproc --all)
 make install
diff --git a/docs/quick_try_manual_build.md b/docs/quick_try_manual_build.md
index e0a45a3..0d3d362 100644
--- a/docs/quick_try_manual_build.md
+++ b/docs/quick_try_manual_build.md
@@ -101,7 +101,7 @@ git am --whitespace=fix *.patch
 make -j$(nproc)
 sudo make install
 
-# Set the library path for FFmpeg or run ldconfig
+# Set the library path for FFmpeg to ensure it can find the necessary shared libraries
 export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
 
 # Run ffmpeg to test if it can run successfully
@@ -127,14 +127,17 @@ curl -L -O https://github.com/intel/compute-runtime/releases/download/24.31.3050
 sudo dpkg -i ./*.deb
 rm -Rf /tmp/gpu_deps
 ```
+Also, you can download the latest gpu driver from the [official website](https://github.com/intel/compute-runtime/releases).
 
-Also, you can download the latest gpu driver from the official website: https://github.com/intel/compute-runtime/releases
 ### 7. Environment Configuration for GPU
 
 Set the environment variables required for GPU drivers:
 
 ```bash
+# Set the driver name for VA-API to use Intel's iHD driver
 export LIBVA_DRIVER_NAME=iHD
+
+# Set the path where VA-API can find the driver
 export LIBVA_DRIVERS_PATH=/usr/lib/x86_64-linux-gnu/dri
 ```
 
@@ -165,8 +168,9 @@ cmake \
     -DWITH_FFMPEG=OFF \
     -DPYTHON3_EXECUTABLE=/usr/bin/python3 \
     ..
+
 make -j "$(nproc)"
 sudo make install
+# The setup_vars_opencv4.sh script sets up the environment variables required for OpenCV.
 cd ${OPENCV_BASE}/install/bin && bash ./setup_vars_opencv4.sh
-
 ```
diff --git a/ivsr_setupvar.sh b/ivsr_setupvar.sh
deleted file mode 100755
index 92a89cc..0000000
--- a/ivsr_setupvar.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-OV_VERSION="2022.3"
-# Parse the --ov_version
-while [ $# -gt 0 ]; do
-    case "$1" in
-        --ov_version)
-            shift
-            if [ "$1" = "2022.3" ] || [ "$1" = "2023.2" ] || [ "$1" = "2024.5" ]; then
-                OV_VERSION=$1
-            else
-                echo "Usage: $0  --ov_version [2022.3|2023.2|2024.5]"
-                exit 1
-            fi
-            shift
-            ;;
-        *)
-            echo "Usage: $0  --ov_version [2022.3|2023.2|2024.5]"
-            exit 1
-            ;;
-    esac
-done
-PROJECTDIR=${PWD}
-IVSR_OV_DIR=${PROJECTDIR}/ivsr_ov/based_on_openvino_${OV_VERSION}/openvino
-CUSTOM_OV_INSTALL_DIR=${IVSR_OV_DIR}/install
-IVSR_SDK_DIR=${PROJECTDIR}/ivsr_sdk/
-CUSTOM_IE_DIR=${CUSTOM_OV_INSTALL_DIR}/runtime
-CUSTOM_IE_LIBDIR=${CUSTOM_IE_DIR}/lib/intel64
-export OpenCV_DIR=${PROJECTDIR}/../opencv-4.5.3-openvino-2021.4.2/install/lib/cmake/opencv4
-export LD_LIBRARY_PATH=${PROJECTDIR}/../opencv-4.5.3-openvino-2021.4.2/install/lib:${IVSR_SDK_DIR}/lib:${CUSTOM_IE_DIR}/3rdparty/tbb/lib:/usr/local/lib:${CUSTOM_IE_LIBDIR}:$LD_LIBRARY_PATH
-bash ${CUSTOM_OV_INSTALL_DIR}/setupvars.sh
-sudo ldconfig