### Installing Go Dependencies for BabitMF (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This snippet installs necessary Go-related system dependencies using `apt` and sets the `GOPATH` environment variable. It is intended to be run once in a Python runtime environment like Colab before proceeding with Go-specific operations.

```shell
# (1.1) run this cell first time using python runtime
!apt update
!apt install golang-go
!apt-get install libdw-dev
%env GOPATH=/root/go
# (1.2) then refresh, it will now use gophernotes. Skip to golang in later cells
```

--------------------------------

### Installing BMF and ONNX Runtime (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This snippet installs the `BabitMF` library and `onnxruntime` using `pip`, which are essential dependencies for running BMF applications and performing ONNX model inference.

```python
!pip install BabitMF
!pip3 install onnxruntime
```

--------------------------------

### Downloading Sample BMF Assets (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This snippet downloads a compressed archive of sample video assets from the BabitMF GitHub releases and then extracts its contents, providing media files for testing or demonstration.

```shell
!wget https://github.com/BabitMF/bmf/releases/download/files/files.tar.gz
!tar -zvxf files.tar.gz
```

--------------------------------

### Setting Up BMF and Real-ESRGAN Environment (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/video_enhance/bmf-enhance-demo.ipynb

This snippet installs essential Python packages for the BMF project, including BabitMF, basicsr, realesrgan, and torchvision. It also installs wurlitzer and loads its extension for capturing C extension module logs, and downloads a file using gdown.

```Python
!gdown --fuzzy https://drive.google.com/file/d/1vvUssyc8GC8SPzVdYwRwKc2OvyKGY-Px/view?usp=sharing
!pip install BabitMF basicsr==1.4.2 realesrgan torchvision==0.15.2
!pip install wurlitzer
%load_ext wurlitzer
```

--------------------------------

### Installing BabitMF Python Package

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_cpp.ipynb

This command installs the `BabitMF` Python package using pip, making the BMF library accessible within the Python environment. It's the primary way to get the BMF Python bindings.

```python
!pip install BabitMF
```

--------------------------------

### Installing BabitMF Python Library

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_python.ipynb

This snippet demonstrates how to install the BabitMF Python library using pip, which is the first step to integrate the framework into your Python project or Colab notebook.

```Shell
!pip install BabitMF
```

--------------------------------

### Installing System Dependencies (Linux) - Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_cpp.ipynb

This snippet updates the package list and installs `libdw-dev`, a development library often required for debugging tools or specific software builds on Linux systems. These are system-level prerequisites for the BMF library.

```python
!apt update
!apt-get install libdw-dev
```

--------------------------------

### Implementing Concurrent Synchronous Transcoding with BMF Go SDK

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This function illustrates a concurrent synchronous video transcoding pipeline using the BMF Go SDK. It sets up decoder, encoder, and pass-through modules and uses Go channels to manage packet flow between the pass-through and encoder stages, enabling parallel processing of video frames. The snippet shows the setup and the goroutine for the pass-through module.

```Go
func syncMode() {
	done := false
	decoder, err0 := bmf.NewModuleFunctorBuiltin("c_ffmpeg_decoder", map[string]interface{}{
		"input_path": "./files/big_bunny_10s_30fps.mp4",
	}, 0, 1)
	if decoder == nil {
			fmt.Printf("Load decoder module failed %v\n", err0)
	} else {
			fmt.Printf("Load decoder module successful\n")
	}

	encoder, err1 := bmf.NewModuleFunctorBuiltin("c_ffmpeg_encoder", map[string]interface{}{
		"output_path": "./output_sync_mode.mp4",
	}, 1, 0)
	if encoder == nil {
			fmt.Printf("Load encoder module failed %v\n", err1)
	} else {
			fmt.Printf("Load encoder module successful\n")
	}

	pass, err2 := bmf.NewModuleFunctorBuiltin("pass_through", nil, 1, 1)
	if pass == nil {
			fmt.Printf("Load pass_through module failed %v\n", err2)
	} else {
			fmt.Printf("Load pass_through module successful\n")
	}
	passChan := make(chan []*bmf.Packet, 10)
	encChan := make(chan []*bmf.Packet, 10)
	fmt.Println("Sync mode")
	// PassThrough
	go func() {
		for opkts_dec := range passChan {
			eofSet := false

			// do pass_through module
			for i := 0; i < len(opkts_dec); i++ {
				ipkts_pass := []*bmf.Packet{}
				ipkts_pass = append(ipkts_pass, opkts_dec[i])
				if opkts_dec[i].Timestamp() == bmf.EOF {
					eofSet = true
				}
				_, err2 := pass.Execute(ipkts_pass, true)
				if err2 != nil {
					fmt.Printf("Pass Through failed! %v\n", err2)
					break
				}

				opkts_pass, err1 := pass.Fetch(0)
				if err1 != nil {
					fmt.Printf("Pass Through Fetch failed! error : %v\n", err1)
					break
				}
				// do encoder module
				for i := 0; i < len(opkts_pass); i++ {
					encChan <- []*bmf.Packet{opkts_pass[i]}
				}

			}

			if eofSet {
				fmt.Println("pass done")
				encChan <- []*bmf.Packet{bmf.GenerateEofPacket()}
				pass.Free()
				break
			}
		}
	}()

		// Encoder
	go func() {
		for opkts_pass := range encChan {
			eofSet := false

			// do encoder module
			for i := 0; i < len(opkts_pass); i++ {
				_, err := encoder.Call([]*bmf.Packet{opkts_pass[i]})
				if err != nil {
					fmt.Printf("encoder call failed! error : %v\n", err)
					break
				}
				if opkts_pass[i].Timestamp() == bmf.EOF {
					eofSet = true
				}
```

--------------------------------

### Locating Project and Library Directories (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/wasm/README.md

This Bash script identifies the absolute paths for the BMF project directory containing HTML demos and the BMF library directory where built-in modules are located. It uses `find` and `realpath` commands to ensure correct paths for subsequent setup steps.

```bash
PATH_TO_YOUR_PROJECT=...
SERVER_DIRECTORY=$(realpath "$(dirname "$(find $PATH_TO_YOUR_PROJECT -name "demo_copy_module.html")")")
LIB_DIRCTORY=$(realpath $(dirname $(find $PATH_TO_YOUR_PROJECT/build/output/bmf/lib -name "libbuiltin_modules.so")))
```

--------------------------------

### Verifying BMF Environment Configuration (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This snippet checks the location of the `bmf_env` script, displays its content, and then executes it to ensure the BMF C library environment variables are correctly set up.

```shell
! which bmf_env
! cat /usr/local/bin/bmf_env
! bmf_env
```

--------------------------------

### Compiling Go Project for BMF Library

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This Python snippet executes shell commands to compile a Go project. It initializes a new Go module named 'test', tidies up module dependencies, and then builds the `sync_mode.go` file into an executable. This is a prerequisite step before running the Go application.

```Python
!go mod init test
!go mod tidy
!go build sync_mode.go
```

--------------------------------

### Cloning BMF Source Repository (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This snippet clones the official BabitMF GitHub repository, providing access to the BMF source code, including demo modules and examples necessary for development and testing.

```python
!git clone https://github.com/BabitMF/bmf.git
```

--------------------------------

### Importing Libraries and Initializing Logger in Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This snippet imports necessary libraries for numerical operations, image processing, ONNX runtime, and logging. It also sets up a global logger instance for consistent logging throughout the module.

```Python
from module_utils import SyncModule
import os
import time
import json
import pdb
import os.path as osp
import numpy as np

os.environ["OMP_NUM_THREADS"] = "8"
import onnxruntime as ort
import torch
import logging
import cv2


def get_logger():
    return logging.getLogger("main")


LOGGER = get_logger()
```

--------------------------------

### Installing BabitMF Python Package (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This command installs the BabitMF Python library using `pip`, making it available for use within the Python environment.

```shell
!pip install BabitMF
```

--------------------------------

### Downloading and Extracting Sample Video Files

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_python.ipynb

This code block illustrates how to download a compressed archive of sample transcoded video files (e.g., Big Bunny) from the BMF GitHub releases and then extract them. These files serve as example input for BMF operations.

```Shell
!wget https://github.com/BabitMF/bmf/releases/download/files/files.tar.gz
!tar -zvxf files.tar.gz
```

--------------------------------

### Installing BMF via Pip (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/transcode/README.md

This command installs the BabitMF library using `pip3`, the Python package installer. This is the recommended and simplest way to get BMF set up for Python development.

```bash
pip3 install BabitMF
```

--------------------------------

### Example BMF Multi-Module Configuration

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/LLM_video_preprocessing/README.md

An example `module_config.json` demonstrating how to configure the BMF pipeline. It specifies the module execution order, input/output paths, and module-specific options like batch size for LLM captioning.

```JSON
{
  "mode": "aesmod_module,ocr_crop,llm_caption",
  "input_file": "big_bunny_10s_30fps.mp4",
  "output_path": "clip_output",
  "output_configs": [
    {
      "res": "orig",
      "type": "jpg"
    },
    {
      "res": "480",
      "type": "mp4"
    }
  ],
  "ocr_crop": {
    "pre_module": true
  },
  "aesmod_module": {
    "entry": "aesmod_module.BMFAesmod",
    "module_path": "../aesthetic_assessment/",
    "pre_module": false
  },
  "llm_caption": {
    "module_path": "../llm_caption/",
    "pre_module": false,
    "options": {
      "batch_size": 6,
      "multithreading": false
    }
  }
}
```

--------------------------------

### Initializing ONNX Runtime Session for BMF Aesthetic Model (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This snippet imports necessary modules, constructs the file path to the ONNX aesthetic assessment model, and initializes an ONNX Runtime inference session. This session is used for loading and executing the pre-trained aesthetic model.

```python
import bmf
import sys
import onnxruntime as ort
from module_utils import SyncModule
import aesmod_module
import onnxruntime as ort
import os.path as osp
model_dir = osp.join(osp.abspath(osp.dirname('__file__')), 'models')
aesmod_ort_model_path = osp.realpath(osp.join(model_dir, 'aes_transonnx_update3.onnx'))
print(aesmod_ort_model_path)
ort_session = ort.InferenceSession(aesmod_ort_model_path)
```

--------------------------------

### Installing Python Dependencies

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/LLM_video_preprocessing/README.md

Installs all required Python packages listed in `requirement.txt`. This is the first step for setting up the project environment.

```Shell
pip install -r requirement.txt
```

--------------------------------

### Downloading BMF ONNX Models and Test Files (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This snippet uses `gdown` to download compressed archives containing ONNX models and test video files, then extracts them using `tar`. These files are prerequisites for running BMF aesthetic assessment demos.

```python
!gdown --fuzzy https://github.com/BabitMF/bmf/releases/download/files/models.tar.gz
!gdown --fuzzy https://github.com/BabitMF/bmf/releases/download/files/files.tar.gz
!tar xzvf models.tar.gz
!tar xzvf files.tar.gz
```

--------------------------------

### Copying BMF Modules to Server Directory (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/wasm/README.md

This Bash command creates a `lib` subdirectory within the server's root directory and copies all `.so` (shared object) files, which are the BMF modules, from the build output directory into this new `lib` folder. This makes the modules accessible to the web server for the browser demos.

```bash
mkdir $SERVER_DIRECTORY/lib
cp $LIB_DIRCTORY/*.so $SERVER_DIRECTORY/lib
```

--------------------------------

### Setting BMF C/C++ Library Environment Variables (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

These commands explicitly set critical environment variables (`C_INCLUDE_PATH`, `CPLUS_INCLUDE_PATH`, `LIBRARY_PATH`, `LD_LIBRARY_PATH`) to point to the BMF C/C++ library includes and binaries, which is essential for Go integration.

```shell
%env C_INCLUDE_PATH=/usr/local/lib/python3.10/dist-packages/bmf/include
%env CPLUS_INCLUDE_PATH=/usr/local/lib/python3.10/dist-packages/bmf/include
%env LIBRARY_PATH=/usr/local/cuda/lib64/stubs:/usr/local/lib/python3.10/dist-packages/bmf/lib
%env LD_LIBRARY_PATH=/usr/local/nvidia/lib:/usr/local/nvidia/lib64:/usr/local/lib/python3.10/dist-packages/bmf/lib
```

--------------------------------

### Installing FFmpeg and Libraries via APT (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/transcode/README.md

This command installs FFmpeg and its necessary development libraries using `apt install`, ensuring that BMF has the required dependencies for transcoding operations. The `-y` flag confirms the installation automatically.

```bash
apt install -y ffmpeg libavcodec-dev libavdevice-dev libavfilter-dev libavformat-dev libavresample-dev libavutil-dev libpostproc-dev libswresample-dev libswscale-dev
```

--------------------------------

### Copying BMF Aesthetic Assessment Demo Files (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This snippet copies Python script files from the BMF aesthetic assessment demo directory to the current working directory, making them accessible for execution and testing.

```python
!cp /content/bmf/bmf/demo/aesthetic_assessment/*.py .
```

--------------------------------

### Executing Go Application in Sync Mode

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This Python snippet executes the compiled Go application `sync_mode` with the `syncMode` argument. This command initiates the video processing in a general synchronous mode as defined within the Go program.

```Python
!./sync_mode syncMode
```

--------------------------------

### Downloading and Extracting Sample Files - Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_cpp.ipynb

This snippet downloads a compressed archive (`files.tar.gz`) containing sample media files (e.g., `big_bunny_10s_30fps.mp4`) from the BMF GitHub releases. It then extracts these files, which are used as input for the video processing example.

```python
!wget https://github.com/BabitMF/bmf/releases/download/files/files.tar.gz
!tar -zvxf files.tar.gz
```

--------------------------------

### Installing Golang for BMF Module Development

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/customize_module/bmf_customize_demo_latest.ipynb

This command installs the Golang compiler and associated tools using `apt`. This installation is a prerequisite for developers who plan to create custom modules using the Go programming language within the BMF framework.

```Shell
! apt install golang
```

--------------------------------

### Checking FFmpeg and Library Versions (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/transcode/README.md

This snippet uses `apt show` and `grep` to display the installed versions of FFmpeg and its associated development libraries, helping to verify if the current setup meets BMF's requirements.

```bash
apt show ffmpeg libavcodec-dev libavdevice-dev libavfilter-dev libavformat-dev libavresample-dev libavutil-dev libpostproc-dev libswresample-dev libswscale-dev | grep "^Package:|^Version:"
```

--------------------------------

### Displaying Videos in IPython Notebook

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This Python snippet provides a utility function `show_video` to embed local video files directly into an IPython notebook output. It reads a video file, encodes it to a base64 data URL, and generates an HTML `<video>` tag. The snippet then uses this function to display three specific video outputs, likely results from the Go processing.

```Python
from IPython.display import HTML
from base64 import b64encode

def show_video(video_path, video_width = 800):
  video_file = open(video_path, "r+b").read()
  video_url = f"data:video/mp4;base64,{b64encode(video_file).decode()}"
  return f"""
  <video width={video_width} controls>
    <source src=\"{video_url}\">
  </video>
  """

video_url1 = show_video('./files/big_bunny_10s_30fps.mp4')
video_url2 = show_video('output_sync_mode_serial.mp4')
video_url3 = show_video('output_sync_mode.mp4')

html = video_url1 + video_url2 + video_url3
HTML(html)
```

--------------------------------

### Processing Video Streams with BMF in Go

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This Go code snippet demonstrates the core logic for processing video streams using the BMF library. It manages the lifecycle of encoder and decoder modules, handles end-of-file (EOF) packets, and includes error handling for module execution and fetching operations. The `main` function allows selecting between `syncMode` and `syncModeSerial` execution paths based on command-line arguments.

```Go
}

			if eofSet {
				fmt.Println("enc done")
				encoder.Free()
				done = true
				break
			}
		}
	}()

	for {
		// do decoder module
        is_done, err := decoder.Execute([]*bmf.Packet{}, true)
        if is_done {
			fmt.Printf("Decode done\n")

			// EOF packet
			p_eof := bmf.GenerateEofPacket()
			pkts_eof := []*bmf.Packet{}
			pkts_eof = append(pkts_eof, p_eof)
			passChan <- pkts_eof
			decoder.Free()
			break
        }

        if err != nil {
			fmt.Printf("decoder execute failed! error : %v\n", err)
			break
        }

        opkts_dec, err1 := decoder.Fetch(0)
        if err1 != nil {
			fmt.Printf("decoder fetch failed!\n, error : %v", err1)
            break
        }

		// do pass_through module
		for i := 0; i < len(opkts_dec); i++ {
			ipkts_pass := []*bmf.Packet{}
			ipkts_pass = append(ipkts_pass, opkts_dec[i])
			passChan <- ipkts_pass
		 }
	}

	for !done {
		time.Sleep(100 * time.Millisecond)
	}

}

func main() {
	if os.Args[1] == "syncMode" {
	    syncMode()
	}
	if os.Args[1] == "syncModeSerial" {
	    syncModeSerial()
	}
}
```

--------------------------------

### Installing BabitMF-GPU Library

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/llm_caption/README.md

This command installs the BabitMF-GPU library using pip, which is a dependency for the video processing demo. It specifically targets the GPU-enabled version of the library.

```Shell
pip install BabitMF-GPU
```

--------------------------------

### Implementing Synchronous Serial Transcoding with BMF Go SDK

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This function demonstrates a synchronous, serial video transcoding pipeline using the BMF Go SDK. It initializes a decoder, an encoder, and a pass-through module, then processes video frames sequentially in a loop, handling packet execution, fetching, and EOF conditions. It's a straightforward, blocking approach for transcoding.

```Go
package main
import (
  "github.com/babitmf/bmf-gosdk/bmf"
  "fmt"
  "os"
	"time"
)
func syncModeSerial() {
	decoder, err0 := bmf.NewModuleFunctorBuiltin("c_ffmpeg_decoder", map[string]interface{}{
		"input_path": "./files/big_bunny_10s_30fps.mp4",
	}, 0, 1)
	defer decoder.Free()
	if decoder == nil {
			fmt.Printf("Load decoder module failed %v\n", err0)
	} else {
			fmt.Printf("Load decoder module successful\n")
	}

	encoder, err1 := bmf.NewModuleFunctorBuiltin("c_ffmpeg_encoder", map[string]interface{}{
		"output_path": "./output_sync_mode_serial.mp4",
	}, 1, 0)
	defer encoder.Free()
	if encoder == nil {
			fmt.Printf("Load encoder module failed %v\n", err1)
	} else {
			fmt.Printf("Load encoder module successful\n")
	}

	pass, err2 := bmf.NewModuleFunctorBuiltin("pass_through", nil, 1, 1)
	defer pass.Free()
	if pass == nil {
			fmt.Printf("Load pass_through module failed %v\n", err2)
	} else {
			fmt.Printf("Load pass_through module successful\n")
	}
	fmt.Println("Sync mode Serial")

	for {
		// do decoder module
        is_done, err := decoder.Execute([]*bmf.Packet{}, true)
        if is_done {
			fmt.Printf("Decode done\n")

			// EOF packet
			p_eof := bmf.GenerateEofPacket()
			pkts_eof := []*bmf.Packet{}
			pkts_eof = append(pkts_eof, p_eof)
			is_done_eof, err_eof := pass.Execute(pkts_eof, true)
			if is_done_eof {
					break
			}
			if err_eof != nil {
				fmt.Println("PassThrough EOF execute failed error : %v\n", err_eof)
			}
			opkts_eof, err1_eof := pass.Fetch(0)
			if err1_eof != nil {
				fmt.Println("PassThrough EOF fetch failed error : %v\n", err1_eof)
			}

			for i := 0; i < len(opkts_eof); i++ {
				_, err_enc_eof := encoder.Call([]*bmf.Packet{opkts_eof[i]})
				if err_enc_eof != nil {
					fmt.Printf("encoder EOF call failed! error : %v\n",err_enc_eof)
				}
			}
			break
        }

        if err != nil {
			fmt.Printf("decoder execute failed! error : %v\n", err)
			break
        }

        opkts_dec, err1 := decoder.Fetch(0)
        if err1 != nil {
			fmt.Printf("decoder fetch failed!\n, error : %v", err1)
            break
        }

		// do pass_through module
		for i := 0; i < len(opkts_dec); i++ {
			ipkts_pass := []*bmf.Packet{}
			ipkts_pass = append(ipkts_pass, opkts_dec[i])
			_, err2 := pass.Execute(ipkts_pass, true)
			if err2 != nil {
				fmt.Printf("Pass Through failed! %v\n", err2)
				break
			}

			opkts_pass, err1 := pass.Fetch(0)
			if err1 != nil {
				fmt.Printf("Pass Through Fetch failed! error : %v\n", err1)
				break
			}

			// do encoder module
			for i := 0; i < len(opkts_pass); i++ {
				_, err := encoder.Call([]*bmf.Packet{opkts_pass[i]})
				if err != nil {
					fmt.Printf("encoder call failed! error : %v\n", err)
				}
			}

		 }
	}
}
```

--------------------------------

### CMake Configuration for BMF Example - CMake

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_cpp.ipynb

This CMakeLists.txt file configures the build process for the `sync_mode` C++ executable. It specifies source files, links against BMF SDK libraries (`bmf_module_sdk`, `hmp`, `engine`), and includes the `nlohmann` JSON library, ensuring the project can be compiled.

```cmake
file(GLOB SRCS *.cpp *.h)
add_library(nlohmann INTERFACE IMPORTED GLOBAL)
# You may need this option on the version of BabitMF below 0.0.9, because the base image BMF uses for release is updated from Centos7 to AlmaLinux8
#add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
add_executable(sync_mode ${SRCS})

target_link_libraries(
    sync_mode
    PRIVATE
    bmf_module_sdk hmp engine nlohmann
)
```

--------------------------------

### Initializing BMFAesmod Module in Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

The constructor for `BMFAesmod` initializes the `Aesmod` instance with configurable `result_path`, `model_version`, and `model_path` options. It then calls the `SyncModule` base class constructor, setting up the module for video processing with one input stream in `rgb24` format.

```Python
class BMFAesmod(SyncModule):

    def __init__(self, node=None, option=None):
        result_path = option.get("result_path", 0)
        model_version = option.get("model_version", "v1.0")
        model_path = option.get("model_path",
                                "./models/aes_transonnx_update3.onnx")
        self._nrp = Aesmod(model_path, model_version, result_path)
        SyncModule.__init__(self,
                            node,
                            nb_in=1,
                            in_fmt="rgb24",
                            out_fmt="rgb24")
```

--------------------------------

### Installing TensorRT and Python APIs

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/face_detect/facedetect_demo_colab.ipynb

This snippet downloads and installs TensorRT binaries and its Python APIs. It sets up environment variables for TensorRT and installs necessary Python wheels for `tensorrt`, `uff`, `graphsurgeon`, and `onnx_graphsurgeon`.

```python
!mkdir -p trt
%cd trt
!wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/secure/8.6.1/tars/TensorRT-8.6.1.6.Linux.x86_64-gnu.cuda-12.0.tar.gz
%env version=8.6.1.6
%env arch=x86_64
%env cuda=cuda-12.0
!tar -xzvf TensorRT-${version}.Linux.${arch}-gnu.${cuda}.tar.gz
!python3 -m pip install --upgrade pip
%cd TensorRT-8.6.1.6/python
!python3 -m pip install tensorrt-8.6.1-cp310-none-linux_x86_64.whl
!python3 -m pip install tensorrt_lean-8.6.1-cp310-none-linux_x86_64.whl
!python3 -m pip install tensorrt_dispatch-8.6.1-cp310-none-linux_x86_64.whl
%cd -
%cd TensorRT-8.6.1.6/uff
!python3 -m pip install uff-0.6.9-py2.py3-none-any.whl
%cd -
%cd TensorRT-8.6.1.6/graphsurgeon
!python3 -m pip install graphsurgeon-0.4.6-py2.py3-none-any.whl
%cd -
%cd TensorRT-8.6.1.6/onnx_graphsurgeon
!python3 -m pip install onnx_graphsurgeon-0.3.12-py2.py3-none-any.whl
%cd ..
!rm -rf python uff graphsurgeon onnx_graphsurgeon
%cd /content
%env LIBRARY_PATH=/usr/local/cuda/lib64/stubs:/content/trt/TensorRT-8.6.1.6/lib
%env LD_LIBRARY_PATH=/content/trt/TensorRT-8.6.1.6/lib:/usr/lib64-nvidia:/content/trt/TensorRT-8.6.1.6/lib
%env PATH=/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin:/content/trt/TensorRT-8.6.1.6/bin
```

--------------------------------

### Building BMF C++ Example with CMake - Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_cpp.ipynb

These commands execute CMake to configure the build system based on `CMakeLists.txt` and then run `make` to compile the `sync_mode` C++ application. This step transforms the C++ source code into an executable binary.

```python
!cmake .
!make
```

--------------------------------

### Installing FFmpeg on Debian

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/llm_caption/README.md

This command installs the FFmpeg multimedia framework, which is required for video processing, such as extracting frames from input videos. It uses the `apt` package manager, common on Debian-based systems.

```Shell
apt install ffmpeg
```

--------------------------------

### Installing BMF Package using pip

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/audio_robot_effect/Readme.md

This command installs the BabitMF package using pip, which is a prerequisite for running the BMF Audio Module demo. It ensures that the core BMF functionalities are available in your Python environment.

```bash
pip3 install BabitMF
```

--------------------------------

### Executing Go Application in Sync Mode Serial

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb

This Python snippet executes the compiled Go application `sync_mode` with the `syncModeSerial` argument. This command initiates the video processing in a specific synchronous serial mode as defined within the Go program.

```Python
!./sync_mode syncModeSerial
```

--------------------------------

### Installing BMF with pip

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/transcode/bmf_transcode_demo.ipynb

This command installs the BabitMF library using pip3, the Python package installer. It's the primary method for setting up the BMF framework for transcoding tasks.

```Shell
! pip3 install BabitMF
```

--------------------------------

### Installing DeepSeek-VL2 Model Driver

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/llm_caption/README.md

This command navigates into the cloned DeepSeek-VL2 directory and installs the model driver in editable mode using pip. This allows for local development and ensures all necessary Python dependencies for the model are installed.

```Shell
(cd DeepSeek-VL2 && pip install -e .)
```

--------------------------------

### Installing BabitMF Python Package

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/customize_module/bmf_customize_demo_latest.ipynb

This command installs the `BabitMF` library using pip, which is the foundational step for setting up the BMF framework in a Python environment. It is a prerequisite for developing and running BMF applications.

```Python
!pip install BabitMF
```

--------------------------------

### Setting Up a Custom HTTPS Server with CORS (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/wasm/README.md

This Python script implements a simple HTTPS server using `http.server` and `ssl`. It serves files from a specified directory and adds `Cross-Origin-Opener-Policy` and `Cross-Origin-Embedder-Policy` headers, which are crucial for WebAssembly modules to function correctly in a browser environment. It requires a `server.pem` file for SSL.

```python
import http.server
import ssl
directory=$SERVER_DIRECTORY # EDIT IT ON YOUR OWN

class CustomHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=directory, **kwargs)
    def end_headers(self):
        self.send_header('Cross-Origin-Opener-Policy', 'same-origin')
        self.send_header('Cross-Origin-Embedder-Policy', 'require-corp')
        super().end_headers()

server_address = ('0.0.0.0', 443)
httpd = http.server.HTTPServer(server_address, CustomHTTPRequestHandler)
httpd.socket = ssl.wrap_socket(httpd.socket,
                               keyfile="server.pem",  
                               certfile="server.pem",# Create you own
                               server_side=True)

print(f"Serving on port {server_address[1]}")
httpd.serve_forever()
```

--------------------------------

### Installing FFmpeg via apt in Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/transcode/bmf_transcode_demo.ipynb

This command installs FFmpeg on a Debian-based system using `apt install`. It's used when the existing FFmpeg version meets BMF's requirements, providing the necessary transcoding capabilities.

```Shell
! apt install -y ffmpeg
```

--------------------------------

### Installing librosa Package using pip

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/audio_robot_effect/Readme.md

This command installs the `librosa` package, a dependency for the BMF Audio Module demo, specifically used for algorithm processing like robot audio effects. It provides essential audio analysis and manipulation tools.

```bash
pip3 install librosa
```

--------------------------------

### Installing Qualcomm QNN SDK for Android

Source: https://github.com/babitmf/bmf/blob/master/bmf_lite/README.md

This snippet outlines the steps to install and integrate the Qualcomm QNN SDK for Android development. It involves using the `qpm-cli` tool for login, license activation, and SDK extraction, followed by manual copying of header files and shared libraries to specific project directories for QNN ControlNet integration.

```Shell
qpm-cli --login <username>
qpm-cli --license-activate qualcomm_neural_processing_sdk
qpm-cli --extract qualcomm_neural_processing_sdk
Get header files from include/QNN, copy include/QNN to bmf_lite/src/algorithm/contrib_modules/QnnControlNet/QNN
Get libQnnSystem.so libQnnHtp.so libQnnHtpV75Stub.so from lib/aarch64-android, copy them to bmf_lite/android/app/SRC/main/assets folder
Get libQnnHtpV75Skel.so from lib/hexagon-v75/unsigned, copy them to bmf_lite/android/app/SRC/main/assets folder
```

--------------------------------

### Installing Python Dependencies

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/colorization_python/Readme.md

This command uses pip to install all required Python packages listed in the `requirements.txt` file. These packages are essential for the DeOldify algorithm and its integration.

```Bash
pip3 install -r ./requirements.txt
```

--------------------------------

### Installing BMF GPU Package

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/colorization_python/Readme.md

This command installs the BabitMF-GPU package using pip. BMF (BabitMF) is the video processing framework that integrates the DeOldify algorithm, and the GPU version is recommended for performance.

```Bash
pip3 install BabitMF-GPU
```

--------------------------------

### Verifying FFmpeg Library Installation

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/colorization_python/Readme.md

This command lists all installed Debian packages and filters for those containing 'ffmpeg' (case-insensitive). It helps verify that necessary FFmpeg libraries like libavcodec and libavformat are correctly installed.

```Bash
dpkg -l | grep -i ffmpeg
```

--------------------------------

### Installing FFmpeg Libraries

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/colorization_python/Readme.md

This command installs the FFmpeg multimedia framework libraries on Debian/Ubuntu-based systems. FFmpeg is a critical dependency for BMF, providing built-in video decoding and encoding capabilities.

```Bash
sudo apt install ffmpeg
```

--------------------------------

### Displaying Help for Main Script

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/LLM_video_preprocessing/README.md

Shows the command-line help message for `main.py`, listing available arguments and options. Useful for understanding script usage.

```Shell
python3 main.py -h
```

--------------------------------

### Installing CV-CUDA Binaries

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/gpu_module/Readme.md

Downloads pre-built CV-CUDA binaries from GitHub releases and then installs them using `apt`. CV-CUDA is a critical dependency for running the GPU modules in this demo, requiring version 0.2.1 or newer for proper functionality.

```Bash
wget https://github.com/CVCUDA/CV-CUDA/releases/download/v0.3.1-beta/nvcv-lib-0.3.1_beta-cuda12-x86_64-linux.deb
wget https://github.com/CVCUDA/CV-CUDA/releases/download/v0.3.1-beta/nvcv-dev-0.3.1_beta-cuda12-x86_64-linux.deb
wget https://github.com/CVCUDA/CV-CUDA/releases/download/v0.3.1-beta/nvcv-python3.10-0.3.1_beta-cuda12-x86_64-linux.deb
wget https://github.com/CVCUDA/CV-CUDA/releases/download/v0.3.1-beta/nvcv_python-0.3.1_beta-cp310-cp310-linux_x86_64.whl

sudo apt install ./nvcv-lib-0.3.1_beta-cuda12-x86_64-linux.deb ./nvcv-dev-0.3.1_beta-cuda12-x86_64-linux.deb ./nvcv-python3.10-0.3.1_beta-cuda12-x86_64-linux.deb
```

--------------------------------

### Enabling C++ Logs with Wurlitzer in Colab

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_python.ipynb

Since the BMF engine is implemented in C++, this snippet shows how to install and load the 'wurlitzer' library. This is crucial in Colab to prevent C++ layer logs from being hidden, allowing for better debugging and monitoring.

```Shell
!pip install wurlitzer
%load_ext wurlitzer
```

--------------------------------

### Installing BMF Python Library

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/edit/bmf_edit_python.ipynb

This snippet demonstrates how to install the BabitMF Python library using `pip`. This library is essential for interacting with the BMF framework's video processing functionalities.

```Python
!pip install BabitMF
```

--------------------------------

### Downloading Dependencies for Bmf Caption Demo (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/fast_caption_module/README.md

This script downloads necessary third-party libraries such as tensorrt_llm and libtorch, which are prerequisites for building the Bmf caption demo. It also implies the need for TensorRT10, which should be downloaded separately from NVIDIA.

```Shell
./download.sh
```

--------------------------------

### Installing FFmpeg on Ubuntu

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/inpaint/Readme.md

These commands update the package list and then install FFmpeg and libdw1 on Ubuntu systems using apt. FFmpeg is a crucial dependency for BMF, especially for hardware-accelerated video processing and codec utilization.

```Bash
sudo apt update
sudo apt install ffmpeg libdw1
```

--------------------------------

### Loading and Preparing Real-ESRGAN Model in Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/video_enhance/bmf-enhance-demo.ipynb

This snippet defines two helper functions: `load_model` and `prepare_model`. `load_model` initializes the `SRVGGNetCompact` model and specifies its configuration and download URL. `prepare_model` checks if the model weights exist locally and downloads them if necessary, returning the local path to the model.

```python
def load_model():
    model = SRVGGNetCompact(
        num_in_ch=3,
        num_out_ch=3,
        num_feat=64,
        num_conv=16,
        upscale=4,
        act_type="prelu",
    )
    netscale = 4
    file_url = [
        "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-animevideov3.pth"
    ]
    return model, netscale, file_url

def prepare_model(model_name, file_url):
    model_path = os.path.join("weights", model_name + ".pth")
    if not os.path.isfile(model_path):
        ROOT_DIR = "/content"
        for url in file_url:
            # model_path will be updated
            model_path = load_file_from_url(
                url=url,
                model_dir=os.path.join(ROOT_DIR, "weights"),
                progress=True,
                file_name=None,
            )
    return model_path
```

--------------------------------

### Installing OpenCV for NVIDIA Maxine Module

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/maxine_module/README.md

This snippet provides a series of bash commands to download, extract, build, and install OpenCV version 4.x along with its contrib modules. OpenCV is a prerequisite for building the NVIDIA Maxine module, enabling computer vision functionalities.

```bash
wget -O opencv.zip https://github.com/opencv/opencv/archive/4.x.zip
wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.x.zip
unzip opencv.zip && rm opencv.zip && unzip opencv_contrib.zip && rm opencv_contrib.zip
cd opencv-4.x
mkdir -p build && cd build
cmake -DOPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-4.x/modules .. && cmake --build . --config Release -- -j
make install
```

--------------------------------

### Installing FFmpeg Libraries (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/video_frame_extraction/Readme.md

This command installs the FFmpeg libraries and related dependencies using apt. While optional for this specific demo due to Colab's pre-installed FFmpeg, it's necessary if FFmpeg capabilities are required by BMF in other environments, supporting versions 4.2 to 5.1.

```bash
sudo apt install ffmpeg
```

--------------------------------

### Building NVIDIA Maxine Module

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/maxine_module/README.md

This snippet outlines the bash commands required to build the NVIDIA Maxine module. It sets the LD_LIBRARY_PATH to include the Maxine SDK library directory, creates a build directory, configures the build with CMake by specifying the Maxine SDK path, and then compiles the module using make.

```bash
export LD_LIBRARY_PATH=/path/to/maxine/folder/lib:$LD_LIBRARY_PATH
mkdir build
cd build
cmake .. -DMAXINE_DIR=/path/to/maxine/folder
make
```

--------------------------------

### Displaying Video Streams in IPython (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_python.ipynb

This Python snippet provides a utility function, `show_video`, to embed and display local video files within an IPython or Jupyter environment. It reads a video file, base64 encodes it, and then generates an HTML5 video tag. The example demonstrates its usage to display two different video files.

```Python
from IPython.display import HTML
from base64 import b64encode

def show_video(video_path, video_width = 800):
  video_file = open(video_path, "r+b").read()
  video_url = f"data:video/mp4;base64,{b64encode(video_file).decode()}"
  return f"""
  <video width={video_width} controls>
    <source src="{video_url}">
  </video>
  """

video_url1 = show_video('./files/big_bunny_10s_30fps.mp4')
video_url2 = show_video('video.mp4')

html = video_url1 + video_url2
HTML(html)
```

--------------------------------

### Installing FFmpeg on Ubuntu

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/gpu_module/Readme.md

Updates the package list and installs FFmpeg and `libdw1` on Ubuntu systems using `apt`. FFmpeg is an essential dependency for BMF, providing built-in demuxer/muxer/codec functionalities and enabling GPU hardware acceleration.

```Bash
sudo apt update
sudo apt install ffmpeg libdw1
```

--------------------------------

### Installing GPU-Supported BMF Packages

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/inpaint/Readme.md

This command installs the GPU-supported version of the BabitMF library using pip. It also sets the LIBRARY_PATH environment variable to include the BMF library directory, ensuring that the system can locate necessary shared libraries for BMF operations.

```Bash
pip3 install -i https://test.pypi.org/simple/ BabitMF-GPU
%env LIBRARY_PATH=$LIBRARY_PATH:/usr/local/lib/python3.10/dist-packages/bmf/lib
```

--------------------------------

### Installing and Applying Python Code Formatting with yapf

Source: https://github.com/babitmf/bmf/blob/master/CONTRIBUTING.md

This snippet first installs `yapf` version 0.40.1, a Python code formatter. The second command then applies the formatting recursively to all Python source files in the current directory and its subdirectories, setting the indent width to 4 spaces, with changes applied in-place.

```bash
pip install yapf==0.40.1
yapf --in-place --recursive --style="{indent_width: 4}"
```

--------------------------------

### Building Bmf Caption Demo (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/fast_caption_module/README.md

This script compiles the Bmf caption demo, preparing the C++ application for execution. It relies on the previously downloaded libraries and converted models to successfully build the project.

```Shell
./build_caption_demo.sh
```

--------------------------------

### Installing GPU-enabled BMF Package (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/video_frame_extraction/Readme.md

This command installs the GPU-supported version of the BabitMF (BMF) package using pip, enabling hardware acceleration features. It is a prerequisite for running GPU-accelerated video processing tasks with BMF.

```bash
pip install BabitMF-GPU
```

--------------------------------

### Installing BMF GPU Package

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/gpu_module/Readme.md

Installs the GPU-supported version of the BMF framework using pip. It also sets the `LIBRARY_PATH` environment variable to include the BMF library directory, which is crucial for runtime linking and ensuring the system can find BMF's shared libraries.

```Bash
pip3 install BabitMF-GPU
%env LIBRARY_PATH=$LIBRARY_PATH:/usr/local/lib/python3.10/dist-packages/bmf/lib
```

--------------------------------

### Executing BMF Synchronous Mode Example - Python

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_cpp.ipynb

This command executes the compiled `sync_mode` application. This runs the BMF video processing pipeline defined in the C++ code, which decodes, scales, adjusts volume, and encodes the input video, producing `sync_mode.mp4`.

```python
!./sync_mode
```

--------------------------------

### Displaying module_utils.py Content (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This shell command uses `cat` to display the contents of the `module_utils.py` file, which is expected to contain utility functions for video processing.

```shell
!cat module_utils.py
```

--------------------------------

### Installing FFmpeg Development Headers (Bash)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/video_frame_extraction/Readme.md

This command installs the development headers for FFmpeg's libavfilter and libavutil libraries. These headers are crucial for compiling custom C++ BMF modules that interact with FFmpeg's filtering and utility functionalities, especially when the environment lacks them.

```bash
apt install libavfilter-dev libavutil-dev
```

--------------------------------

### Compiling and Installing C++ Module (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/test/customize_module/bmf_customize_demo_latest.ipynb

These shell commands, executed via Python's `!`, first remove any existing `build` directory. Then, they configure the CMake project, build the `copy_module` shared library, and finally install it to the specified `CMAKE_INSTALL_PREFIX`. This sequence compiles the C++ module into a `.so` file.

```Shell
!if [ -d build ]; then rm -rf build; fi
!cmake -DCMAKE_CXX_STANDARD=17 -B build -S cpp_copy_module
!cmake --build build
!cmake --install build
```

--------------------------------

### Displaying res2.json Content (Shell)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This shell command uses `cat` to display the contents of `res2.json`, which is expected to contain the results of the video aesthetic analysis performed by the BMF module.

```shell
!cat res2.json
```

--------------------------------

### Cleaning NRP Instance (Python)

Source: https://github.com/babitmf/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb

This snippet calls the `clean` method on an object likely representing a resource pool or similar component, indicating a cleanup operation. Without further context, its exact purpose and dependencies are unclear.

```python
self._nrp.clean()
```