Go/Cgoで映像・音声のリアルタイム処理をやるまでの道のり - Go Conference 2023

Go Conference 2023 Room A : A7-L https://gocon.jp/2023/sessions/A7-L/

Transcript

1. Go/Cgoで映像・音声の リアルタイム処理をやるまでの道のり Mirrativ,inc. Mirrativ Service Department. Technology Development Division. Infrastructure Streaming Engineering Group Yusuke Hata Go Conference 2023 1
2. アジェンダ 1. 自己紹介 2. 背景と課題 3. リアルタイムに映像処理をするためには 4. 並列処理とSIMD 5. GoとCgoの連携 6. まとめ Go Conference 2023 2
3. 自己紹介 Yusuke Hata (漢 祐介) / @octu0 / @octu0 インフラ・ストリーミング MGR @ Mirrativ フロントエンド → バックエンド → ゲーム → インフラ(今ここ) インフラ基盤・ライブ配信基盤の設計開発 映像/音声配信サーバの開発運用...etc 過去に 猫と暮らしてます( ) Go Conference 2023 3
4. 背景と課題 ミラティブというスマホの画面共有を用いたライブ配信サービスにて 配信サーバ上でリアルタイムに映像/音声の処理をしたくなった Go Conference 2023 4
5. もう少し詳しく ライブ配信中の映像にリアルタイムで 特定のオブジェクトに「ぼかし処理」を入れて配信でき るようにしたい 要するに スマホを使ったライブ配信において 配信画面に映り込む「通知ダイアログ」を検出して ダイアログの「中身をぼかし」たい Go Conference 2023 5
6. もう少し細かく スマホ端末上でぼかし処理をしながら配信する実装はすでにあった ただゲーム中に配信すると端末が高負荷になりがち そこで映像・音声の「配信サーバ上で処理」したかった 配信サーバ ミラティブのライブ配信に使われる内製のミドルウェアが載ってるサーバ 映像と音声を受け取って、視聴端末に届けてる 配信サーバは調達のしやすさから汎用的なサーバを選択している 汎用的なサーバ = GPUがついてない、搭載メモリも普通 仮想化されたマシンやベアメタルサーバなどあるが、基本構成は同じ どのようなマシンでも動かせれるように全て CPU で処理できるようにしたい → GPUを使わずにCPUだけで画像処理を頑張りたい 6
7. リアルタイムに映像処理をするために 映像は30fpsから60fps程度のパラパラ漫画を見ているようなもの fps = frame per second 30fps だと 1秒間に 30枚の画像が流れてくる 1000ms/30枚 = 1枚あたりおおよそ 33ms Go Conference 2023 7
8. オブジェクト検出 → ぼかし処理まで 30ms 程度でやる必要がある 1画像あたりに残された処理時間は 約 30ms ちょっとでも過ぎると映像の遅延に繋がる サーバの負荷も考えると可能な限り低負荷に処理しないといけない とはいえ 30ms であれば意外といけそう？ Go Conference 2023 8
9. 画像についておさらい 僕らが普段使う画像の形式は RGBA R(red)/G(green)/B(blue)/A(alpha) Alphaを除いて 3つの色の種類から構成されてる CSSなんかでよくみる #C0FFEE という書式 R = C0 = 192 G = FF = 255 B = EE = 238 色にすると赤が少なく、緑と青っぽいのがわかる 実際は のような色 1px には3つ(+1)の色を組み合わせられてる Go Conference 2023 9
10. 二次元画像(色の表現) Go Conference 2023 10
11. 二次元画像とStride これを image パッケージの RGBA では 1次元配列で表現してる type RGBA struct { Pix []uint8 Stride int Rect Rectangle } 1次元配列から横を決めるのは Stride 400x300の画像だと 400x300x4 = 480000 個の要素 make([]byte, 480000) Go Conference 2023 11
12. 実際の映像処理では YCbCr 実際の映像処理に RGBA を直接使 うことはほぼなく、 YCbCr という形式使われる (YUV420/I420など) YCbCr は 輝度(Y)と色差信号 (CbCr)で表現 type YCbCr struct { Y, Cb, Cr []uint8 YStride int CStride int SubsampleRatio YCbCrSubsampleRatio Rect Rectangle } Go Conference 2023 12
13. YCbCr → RGBA → YCbCr YCbCr は直感的にも扱いづらい(当時) RGBAに変換して画像の読み込み各種処理をしてから再びYCbCrに戻すようにしていた image/color パッケージを使って変換する、か、 image/draw で書き出して使うこと になる Go Conference 2023 13
14. func YCbCrToRGBA(src *image.YCbCr) *image.RGBA { b := src.Bounds() dst := image.NewRGBA(b) for y := b.Min.Y; y < b.Max.Y; y += 1 { for x := b.Min.X; x < b.Max.X; x += 1 { c := color.RGBAModel.Convert(src.At(x, y)) dst.Set(x, y, c) } } } func RGBAToYCbCr(src *image.RGBA) *image.YCbCr { b := src.Bounds() dst := image.NewYCbCr(b, image.YCbCrSubsampleRatio420) for y := b.Min.Y; y < b.Max.Y; y += 1 { for x := b.Min.X; x < b.Max.X; x += 1 { c := src.RGBAAt(x, y) cy, cu, cv := color.RGBToYCbCr(c.R, c.G, c.B) dst.Y[dst.YOffset(x, y)] = cy dst.Cb[dst.COffset(x, y)] = cu dst.Cr[dst.COffset(x, y)] = cv } } } 14
15. 画像の読み込みはできた。次はダイアログを検出。 いわゆる Object Detection をやることになる 色々な手法(個別のアルゴリズムを書く等)があるが ここでは Template Matching を使う Go Conference 2023 15
16. Template Matching するために 1. 注目画像に対して、テンプレートとなる画像を比較して類似度合いを使う SAD / SSD / NCC などを使って類似度の計算 2. 輝度の影響を受けにくくするためグレースケール化 3. Edge処理 Go Conference 2023 16
17. まずはグレースケール化 画像には色々な情報が含まれてる 明るさ(輝度) 色の種類 これらは計算する上で不要な情報なので、単一の色にする 色が多いと類似度判定の誤差が増えるため 単一の色になれば R/G/B/(A) が Gray 一色になり 1/4 関心事が減る Go Conference 2023 17
18. Grayscale (不要な色は捨てる) func Grayscale(src *image.RGBA) *image.RGBA { b := src.Bounds() w, h := b.Dx(), b.Dy() dst := image.NewRGBA(b) for y := 0; y < h; y += 1 { for x := 0; x < w; x += 1 { c := src.RGBAAt(x, y) gray := byte(( (76 * int(c.R)) + (152 * int(c.G)) + (28 * int(c.B)) ) >> 8) // RGB を同じ色にする dst.SetRGBA(x, y, color.RGBA{ R: gray, G: gray, B: gray, A: 0xff, }) } } return dst } Go Conference 2023 18
19. オブジェクトの検出(類似度) 画像の類似度は ここでは SAD (Sum of Absolute Difference) で計算するようにした 疑似コードにするとこんな感じ( Σ は for | は abs() に置き換えるイメージ) func SAD(dx, dy int) float64 { sum := 0.0 for x := 0; x < w; x += 1 { for y := 0; y < h; y += 1 { // 1px ずつ比較していって差分を蓄積 sum += Abs( Image(dx + x, dy + y) - Template(x, y) ) } } return sum } Go Conference 2023 19
20. オブジェクトの検出(類似度) func SAD(s, t *image.RGBA, dx, dy int) float64 { w, h := t.Rect.Dx(), t.Rect.Dy() sum := 0.0 for x := 0; x < w; x += 1 { for y := 0; y < h; y += 1 { // grayscale 済みなので R を使う a := float64(s.RGBAAt(dx + x, dy + y).R) b := float64(t.RGBAAt(x, y).R) sum += math.Abs(a - b) } } return sum } func Detect(src *image.RGBA, tpl *image.RGBA) { var pt []image.Point for x := 0; x < w; x += 1 { for y := 0; y < h; y += 1 { if SAD(src, tpl, x, y) < 10 { pt = append(pt, image.Pt(x, y)) } } } } Go Conference 2023 20
21. Edge処理 + 二値化 グレースケールによって色が減らせた が、まだまだ情報が多い、もっと減らしてもいいはず 濃いところだけで良い 境界をもっとハッキリさせたい Threshold(閾値)を使ってさらに色を減らして 0 と 1 にしよう 0 と 1 の二値化にすると画像比較にビット演算で処理しやすくなる SADを使っていたのは uint64 に詰めて ハミング距離を計算ができる 64要素まとめて処理できるようになる Go Conference 2023 21
22. Edge処理(ここでは閾値で判定) const threshold = 50 func IsEdge(graycolor color.RGBA) bool { return threshold < graycolor.R } func Binary(gray *image.RGBA) [][]uint64 { b := gray.Bounds() w, h := b.Dx(), b.Dy() dst := make([][]uint64, h) for y := 0; y < h; y += 1 { wc := (width - c) / 64 dst[y] = make([]uint64, w) for x := 0; x < wc; x += 1 { b := uint64(0) for i := 0; i < 64; i += 1 { if IsEdge(gray.RGBAAt(x, y)) { b |= 1 << (64 - i) } } dst[y][x] = b } } return dst } Go Conference 2023 22
23. ハミング距離 ハミング距離はビット列同士の異なって いる数のこと 一致していないビットは XOR を使 うことで出せる XOR 後に popcount を使うこと でビットが立っている数を出すこ とができる import "math/bits" func HammingDistance(a, b []uint64) int { sum := 0 for i := 0; i < cap(a); i += 1 { sum += bits.OnesCount64(a[i] ^ b[i]) } return sum } Go Conference 2023 23
24. 検出処理はだいたいできた アクティブ探索法なども組み込めば 情報量がある箇所だけオブジェクトの検出を実施できたりする オブジェクトの探索を行っているときのトレース(動画) の探索の様子 → オブジェクトが見つかれば次は「ぼかし処理」をやることになる Go Conference 2023 24
25. 画像をぼかす処理 オブジェクトを検出できたら ぼかし処理(ブラー処理)を行う 仕組みは上下左右の 数px ずつずらしな がら平均化する スマホのカメラに搭載されてる手ブレ補正の 逆をやるイメージ Go Conference 2023 25
26. ぼかし処理(ブラー処理) func BlurX(src *image.RGBA, size int) *image.RGBA { for y := 0; y < h; y += 1 { for x := 0; x < w; x += 1 { r, g, b := 0, 0, 0 for bx := 0; bx < size; bx += 1 { c := src.RGBAAt(x + bx, y) // X 方向にsize だけ集める r += int(c.R) g += int(c.G) b += int(c.B) } blur.SetRGBA(x, y, color.RGBA{ R: byte(r/size), G: byte(g/size), B: byte(b/size), A: 0xff, }) } } return blur } func BlurY(...) { ... } func BoxBlur(src *image.RGBA) *image.RGBA { return BlurY(BlurX(src, 50), 50) } Go Conference 2023 26
27. よしよしできた。 いろいろ実装できたので1枚の画像で実行 $ go run main.go elapsed = 580.107ms 1画像の処理に 580ms もかかった 遅すぎる…。リアルタイムに処理できてない。 30ms以内に処理しないといけないのに。 Go Conference 2023 27
28. どこが遅かったか 1. 画像の読み込み 13.68 ms 2. 検出のための前処理(グレースケール) 2.11 ms 3. 検出のための前処理(エッジ処理) 1.28 ms 4. 検出するロジック 38 ms 5. ぼかし処理 520 ms 無駄な処理が多いのはあるが、これではリアルタイムに処理はできない。 このスライドだけでも for が何回出てきたか分からないくらいループしている 不要な処理を可能な限り削る必要がある Go Conference 2023 28
29. 並列処理と SIMD これまで書いたロジックには大量のfor文が存在する 頭から配列を読み込んで処理をするのは効率が悪い まとめて読み込んで goroutine で回すというのは思いつく とはいえ goroutine は軽量スレッド 処理を同時に実行しているわけではない CPUにはまとめて処理できる機能がある (SIMD) Go Conference 2023 29
30. 並列処理と SIMD CPUにはまとめて処理できる機能がある (SIMD) 128bit レジスタであれば32bitずつ4個まとめて処理できる #include <immintrin.h> int main(int argc, char **argv) { __m128i a = _mm_set_epi32(1, 2, 3, 4); __m128i b = _mm_set_epi32(10, 20, 30, 40); __m128i sum = _mm_add_epi32(a, b); int r[4]; memcpy(r, &sum, sizeof(int)*4); printf("%d %d %d %d\n", r[3], r[2], r[1], r[0]); // => 11 22 33 44 return 0; } Go Conference 2023 30
31. 残念ながら標準のGoではSIMDで書けない、が、 cgo 経由であれば実行できる /* #include <string.h> #include <immintrin.h> int add4(int32_t *a, int32_t *b, int32_t *out) { __m128i aa = _mm_set_epi32(a[0], a[1], a[2], a[3]); __m128i bb = _mm_set_epi32(b[0], b[1], b[2], b[3]); __m128i sum = _mm_add_epi32(aa, bb); memcpy(out, &sum, sizeof(int) * 4); return 0; } */ import "C" func Add4(a [4]int32, b [4]int32) []int32 { out := make([]int32, 4) C.add4( (*C.int32_t)(unsafe.Pointer(&a[0])), (*C.int32_t)(unsafe.Pointer(&b[0])), (*C.int32_t)(&out[0]), ) return out } Go Conference 2023 31
32. これまでの for の中身をよく見るとデータ列に対して同じ処理をしている。 先程のグレースケールを例にすると c := src.RGBAAt(x, y) gray := byte(( (76 * int(c.R)) + (152 * int(c.G)) + (28 * int(c.B)) ) >> 8) dst.SetRGBA(x, y, color.RGBA{R: gray, G: gray, B: gray}) は、もう少し崩すと r[i] = 76 * c.R g[i] = 152 * c.G b[i] = 28 * c.B dst.Pix[i] = (r[i] + g[i] + b[i]) >>8 いい感じに取り出して、4つずつ処理させていけばSIMDでいけるのでは...？ Go Conference 2023 32
33. SIMD で書き換えてみた BenchmarkGray BenchmarkGray/Go BenchmarkGray/Go-8 788 1319082 ns/op BenchmarkGray/SIMD BenchmarkGray/SIMD-8 9007 135928 ns/op PASS Goで書いたグレースケール 1.329 ms SIMDで書いたグレースケール 0.127 ms SIMD で書き換えて 10倍 くらい高速になった が、単純な四則演算もpackしなおして流し直すの は、シンプルなGrayscaleでもとても大変...。 Go Conference 2023 33
34. どれくらい大変かと言うと... 横方向に処理したり縦方向に処理したり...。 ※ コードにすると画面が文字だらけになるので省略しました Go Conference 2023 34
35. libyuvにやりたいことが実装されてる https://chromium.googlesource.com/libyuv/libyuv/ Grayscale であれば ARGBGrayTo で最適化されたもので呼べる /* #cgo CFLAGS: -I/path/to/include #cgo LDFLAGS: -L/path/to/lib -lyuv #include "planar_functions.h" */ import "C" func Grayscale(src, dst *image.RGBA) bool { width, height := src.Rect.Dx(), src.Rect.Dy() stride := width * 4 C.ARGBGrayTo( (*C.uchar)(&src.Pix[0]), C.int(stride), (*C.uchar)(&dst.Pix[0]), C.int(stride), C.int(width), C.int(height), ) } 35
36. libyuvにやりたいことが実装されてる 今までのコードはほとんど置き換えできた 1. 画像の読み込み → I420ToARGB (13.68 ms → 0.14ms) 2. グレースケール → ARGBGrayTo (2.11 ms → 0.18 ms) 3. エッジ処理 → ARGBSobel (1.28 ms → 0.29ms) 4. 検出ロジック → 自前 38 ms 5. ぼかし処理 → ARGBBlur (520 ms → 8.49ms) この置き換えで 580ms → 47 ms で12倍くらい改善 無駄な処理が多く残っている状態でこれはすごい Go Conference 2023 36
37. スマホ特有の課題 libyuv は便利で高速、が、もっと細かい事をするには大変 例えば画面の回転処理、スマホは縦画面や横画面に回転する 画面回転のたびにデータ構造の入れ替え...は大変すぎる Go Conference 2023 37
38. 部分的に処理を適用できる仕組みが欲しい データとアルゴリズムセットで修正していくのは大変 畳み込み(convolve)処理なのでは...? 38
39. Halide言語 色々探したところ Halide 言語に出会った C++ の DSL 画像処理に特化コード 最適化されたコードを静的ライブラリとして出力できる → *.a で出力される → Goに組み込める!! アルゴリズムとスケジューラを分離することができる → アルゴリズム側は変えずにチューニングできる → コードが難しくならず保守しやすくなる 軽く紹介します! Go Conference 2023 39
40. Halide のコード 公式ページより Blur3x3 処理をするコード Func blur_3x3(Func input) { Func blur_x, blur_y; Var x, y, xi, yi; // The algorithm - no storage or order blur_x(x, y) = (input(x-1, y) + input(x, y) + input(x+1, y))/3; blur_y(x, y) = (blur_x(x, y-1) + blur_x(x, y) + blur_x(x, y+1))/3; // The schedule - defines order, locality; implies storage blur_y.tile(x, y, xi, yi, 256, 32) .vectorize(xi, 8).parallel(y); blur_x.compute_at(blur_y, x).vectorize(x, 8); return blur_y; } 非常にシンプルなコードですがHalideの魅力が詰まったコード 40
41. Goで書いた Grayscale (再掲) グレースケールを題材にHalideに置き換えてみます func Grayscale(src *image.RGBA) *image.RGBA { b := src.Bounds() w, h := b.Dx(), b.Dy() dst := image.NewRGBA(b) for y := 0; y < h; y += 1 { for x := 0; x < w; x += 1 { c := src.RGBAAt(x, y) gray := byte(( (76 * int(c.R)) + (152 * int(c.G)) + (28 * int(c.B)) ) >> 8) // RGB を同じ色にする dst.SetRGBA(x, y, color.RGBA{ R: gray, G: gray, B: gray, A: 0xff, }) } } return dst } 41
42. Halide で書き直した Grayscale for 文の中身を書いていくような感じで書き直します Func Grayscale(Func in) { Var x("x"), y("y"), ch("ch"); Func out = Func("grayscale"); Expr r = cast<int16_t>(in(x, y, 0)); Expr g = cast<int16_t>(in(x, y, 1)); Expr b = cast<int16_t>(in(x, y, 2)); Expr gray = ((76 * r) + (152 * g) + (28 * b)) >> 8; Expr value = select( ch == 0, gray, // R ch == 1, gray, // G ch == 2, gray, // B 255 // A ); out(x, y, ch) = cast<uint8_t>(value); return out; } 42
43. Go(cgo)から呼べるように 静的ライブラリにコンパイル void main() { Target target; target.os = Target::OSX; target.arch = Target::X86; target.bits = 64; target.set_features({ Target::AVX, Target::AVX2, Target::SSE41 }); ImageParam src(UInt(8), 3, "src"); Func fn = Grayscale(src.in()); OutputImageParam out = fn.output_buffer(); // rgba out out.dim(0).set_stride(4); out.dim(2).set_stride(1); out.dim(2).set_bounds(0, 4); fn.compile_to_static_library("lib/libgrayscale", {src}, "grayscale", target); } コンパイルして実行すると libgrayscale.a と libgrayscale.h が生成される 43
44. runtime込みで生成しているので libgrayscale.h に最低限必要なものは全て入ってる cgoで呼び出すエントリポイントを my_grayscale.h に、 my_grayscale.c で実装 #include "libgrayscale.h" #include "my_grayscale.h" int my_grayscale( unsigned char *in, int32_t width, int32_t height, unsigned char *out ) { halide_buffer_t *in_buf = create_rgba_buffer(in, width, height); halide_buffer_t *out_buf = create_rgba_buffer(out, width, height); int ret = grayscale(in_buf, out_buf); free(in_buf); free(out_buf); return ret; } ※ create_rgba_buffer() は github.com/octu0/blurry/buffer.h にサンプル実装があります 44
45. CFLAGS/LDFLAGS で libgrayscale.a を読み込み /* #cgo CFLAGS: -I${SRCDIR}/lib #cgo LDFLAGS: -L${SRCDIR}/lib -ldl -lm #cgo LDFLAGS: -lgrayscale #include "my_grayscale.h" */ import "C" func Grayscale(in *image.RGBA) *image.RGBA { b := in.Bounds() w, h := b.Dx(), b.Dy() out := image.NewRGBA(image.Rect(0, 0, w, h)) ret := C.my_grayscale( (*C.uchar)(unsafe.Pointer(&in.Pix[0])), C.int(w), C.int(h), (*C.uchar)(unsafe.Pointer(&out.Pix[0])), ) if ret != C.int(0) { panic("failed to call my_grayscale") } return out } Go Conference 2023 45
46. Halide版 Grayscale を実行 BenchmarkGrayscale BenchmarkGrayscale/go BenchmarkGrayscale/go-8 560 2109204 ns/op BenchmarkGrayscale/halide BenchmarkGrayscale/halide-8 868 1364983 ns/op 同じ条件になるように Go と Halide を書き直した状態 この時点でもGoで書いたものよりも速い ( 1.364ms ) が、これくらいならGoだけでも頑張ればいける Go Conference 2023 46
47. Halide のスケジューラ 作成済みのロジックには手を加えず次のように schedule を追加 やっていることは、ch 単位に parallel、 x方向にベクトル処理をするようにした Func grayscale(Func in) { Func out = Func("grayscale"); ... // schedule を定義 out.compute_root() .parallel(ch) .vectorize(x, 16); return out; } Go Conference 2023 47
48. BenchmarkGrayscale BenchmarkGrayscale/go BenchmarkGrayscale/go-8 554 2114768 ns/op BenchmarkGrayscale/halide BenchmarkGrayscale/halide-8 2391 491738 ns/op スケジューラを変えることでチューニングできる たった3行の修正で 0.491ms まで下げることができた SIMD で書き直したものまでは行かないが このコーディング量でこの速度は大きい Go Conference 2023 48
49. Halide のチューニング Halideは細かなチューニングができるようになってる compute_at/store_at reorder bound parallel / unroll fuse 紹介したいが分量が多くなってきたので泣く泣く省略 Go Conference 2023 49
50. Halideで色々チューニングしやすくなった libyuv でやっていたものは、全て halide に書き直しました 1. 画像の読み込み → YCbCr のまま処理するようにした (13.68 ms → 0) 2. グレースケール → halide化(libyuv よりちょっと遅い) (2.11 ms → 0.36 ms) 3. エッジ処理 → グレースケール時にまとめた (1.28 ms → 0) 4. 検出ロジック → halide化 (38 ms → 0.28 ms) 5. ぼかし処理 → halide化(libyuvよりよっと速い) (520 ms → 0.11ms) 必要な処理に応じて、必要なロジックだけを書けるので最適化が捗ります Go Conference 2023 50
51. もろもろチューニングした結果 $ go run main.go elapsed = 0.75ms 1画像 1ms 未満 で出来るようになった 30ms 以内に処理できる → リアルタイムに処理できる Go Conference 2023 51
52. 実際にぼかし処理が行われている様子 ※ 配信を録画した映像になります(動画) Go Conference 2023 52
53. よしよし後はリリースするだけ。 初めての cgo だったのもあるが、すぐにリリースできる状態ではなかった → もう少し改善する必要があった リリースまでに組み込む必要があったいくつかを紹介 Go Conference 2023 53
54. さらなる速さを求めて またまだ改善するところがある GoとC(cgo)のデータ型変換 make([]byte) を何とかしたい Go Conference 2023 54
55. CとGoでのデータ変換 Go で使っているデータを C (cgo) 側に渡したい時がちょくちょくある Go では []int16 として定義している値が C側では uchar* C では uchar* で返すが、値は float32 例えば Cでは、こんな感じの定義 int PCM16Decibel(unsigned char* in, int size, unsigned char* out); in と out が []byte で受け取るような実装があった際に 都度変換するの大変 Go Conference 2023 55
56. 通常であれば encoding/binary パッケージを使って変換して利用する(つらい) func calcDecibel(src []int16) (float32, error) { buf := bytes.NewBuffer(make([]byte, 0, len(src) * 2)) // []byte -> int16 for _, s := range src { if err := binary.Write(buf, binary.LittleEndian, s); err != nil { return 0.0, err } } in := buf.Bytes() out := make([]byte, 4) // byte -> float ret := C.PCM16Decibel( (*C.uchar)(&in[0]), C.int(len(src)), (*C.uchar)(&out[0]), ) var res float32 if err := binary.Read(bytes.NewReader(out), binary.LittleEndian, &res); err != nil { return 0.0, err } return res, nil } Go Conference 2023 56
57. データ型に注意しながら unsafe.Pointer / unsafe.Slice を使うことで直接渡せる func calcDecibel2(src []int16) (float32, error) { in := unsafe.Slice((*byte)(unsafe.Pointer(&src[0])), len(src)) // go1.17 out := make([]byte, 4) // byte -> float ret := C.PCM16Decibel( (*C.uchar)(&in[0]), C.int(len(src)), (*C.uchar)(&out[0]), ) if ret != C.int(0) { return 0.0, errors.New("...") } return *(*float32)(unsafe.Pointer(&out[0])), nil } Go Conference 2023 57
58. データ変換のパフォーマンスも結構ばかにならない BenchmarkFloat BenchmarkFloat/old BenchmarkFloat/old-8 40492 28886 ns/op 5644 B/op 1750 allocs/op BenchmarkFloat/new BenchmarkFloat/new-8 1000000 1033 ns/op 4 B/op 1 allocs/op よく見かける []byte <-> string と同じような要領で C.GoBytes や C.GoString などはこういった組み合わせで置き換え Go Conference 2023 58
59. make([]byte) を何とかしたい 動画で扱うフレームは1枚フレーム目から最後のフレームまで基本的の同じサイズ 全てのフレームで make([]byte, 1920*1080) をやっていたら大変 Effective Go の Leaky buffer で使いまわそう https://go.dev/doc/effective_go#leaky_buffer Go Conference 2023 59
60. var ( pool = make(chan []byte, 1000) // buffer 1000 ) func NewMakeSlice(size int) []byte { select { case buf := <-pool: return buf default: return make([]byte, size) } } func PutSlice(buf []byte) { select { case pool <- buf: // ok default: // discard } } Go Conference 2023 60
61. 再利用可能なものは使い回す func foo() { buf := NewMakeSlice(1920*1080) defer PutSlice(buf) grayscale(buf) } BenchmarkFloat BenchmarkFloat/old_make_slice BenchmarkFloat/old_make_slice-8 9337 129397 ns/op 2080774 B/op 1 allocs/op BenchmarkFloat/new_make_slice BenchmarkFloat/new_make_slice-8 26715202 44.29 ns/op 0 B/op 0 allocs/op 例えば image.RGBA{Pix:[]byte} はこのスライスを使い回すようにする Go Conference 2023 61
62. まとめ リアルタイム処理を行うにはそれなりに大変 速いGoでも " そのまま " だと厳しい (今回紹介しきれなかったチューニングがまだ沢山あります) アルゴリズムとスケジューラの書きやすさからHalide はあり 画像処理以外にも音声処理も Halide で！ 詳細は テックブログに書いてあります 「ミラティブ テックブログ」で検索！ 62
63. ライブラリの宣伝 Halideで作った画像処理ライブラリ ( よく使う変換系を実装 ) https://github.com/octu0/blurry Leaky buffer ライブラリ ( []byte 以外の色々なパターンをまとめた ) https://github.com/octu0/bp cgo <-> go の変換とか cgo.Handle 使ったりとか https://github.com/octu0/cgobytepool go generate を使ったHalide連携 https://github.com/octu0/example-halide-go Go Conference 2023 63
64. おわり Go Conference 2023 64