Kurento වලින් සුපිරි වැඩක් කරමුද? Live Video වලට AI Magic දාන හැටි! 🧙‍♂️

හිතන්නකො ඔයා Zoom කෝල් එකක ඉන්නවා, ඔයා කතා කරද්දී ඔයාගේ මූණ වටේට ලස්සනට මල් වැටෙනවා, එහෙමත් නැත්නම් ඔයාගේ background එක auto-magically අයින් වෙලා වෙන ලස්සන beach එකක් වැටෙනවා. නැත්නම් ඔයාගේ මූණට විහිලු කණ්ණාඩි දෙකක් වැටෙනවා. මේ වගේ වැඩ කෑලි real-time, ඒ කියන්නේ live video එකකම කරන එක තමයි Kurento වලින් අපිට කරන්න පුළුවන් සුපිරිම වැඩක්.

අද අපි කතා කරන්නේ ඔන්න ඔය වගේ magic එකක් අපිම හදාගන්නේ කොහොමද කියලා. මේකට අපි “වීරයෝ” හතර දෙනෙක් පාවිච්චි කරනවා.

1. Kurento Media Server: මෙයා තමයි අපේ කතාවේ “Traffic Police Officer”. එන video, යන video, කාටද යවන්නේ, කොහෙන්ද ගන්නේ කියන ඔක්කොම පාලනය කරන්නේ මෙයා.
2. FastAPI (Python Backend): මෙයා තමයි අපේ වැඩේ “මොළේ”. Kurento ට මොනවද කරන්න ඕන කියලා අණ දෙන්නේ, video එකේ මොන වගේ magic එකක්ද කරන්න ඕන කියලා තීරණය කරන්නේ අපේ FastAPI backend එක.
3. OpenCV (Python Library): මෙයා තමයි නියම “මැජික්කාරයා”. Video එකේ තියෙන මූණු අඳුරගන්න, background එක අයින් කරන්න, filter දාන්න වගේ ඔක්කොම ඇස්බැන්දුම් වැඩ කරන්නේ මෙයා.
4. Frontend (JavaScript): මෙයා තමයි “පරිශීලකයාගේ මුහුණත”. ඒ කියන්නේ ඔයාගේ web browser එක. ඔයාගේ කැමරාවෙන් video එක අරන් Kurento ට යවන, අන්තිමට magic කරපු video එක ඔයාට ආපහු පෙන්නන control panel එක තමයි මේ.

වැඩේ වෙන්නේ කොහොමද? (The Big Picture)

මේක හිතාගන්න අමාරු දෙයක් නෙවෙයි. වැඩේ වෙන්නේ මෙන්න මෙහෙමයි, step by step:

1. Step 1: User Starts the Show ඔයා browser එකේ තියෙන “Start Video” button එක ඔබනවා. ඔයාගේ Frontend (JavaScript) එක ඔයාගේ කැමරාවෙන් video එක අරගෙන, FastAPI “මොළේට” කතා කරලා කියනවා “හලෝ, මම video එකක් එවන්න යන්නේ, ලෑස්ති වෙන්න” කියලා.
2. Step 2: FastAPI Takes Control FastAPI එක Kurento “Traffic Police” ට කතා කරලා කියනවා, “අලුත් video stream එකක් එනවා, ඒක ගන්න පාරක් හදන්න (Media Pipeline එකක් හදන්න)” කියලා.
3. Step 3: Kurento Sets Up the Road Kurento එක පාරවල් දෙකක් හදනවා.

• පාර 1 (WebRtcEndpoint): Browser එකෙන් එන video එක බාරගන්න.
• පාර 2 (FaceOverlayFilter or a custom filter): Video එකට මැජික් දාන්න. මේ filter එක ඇතුළේ ඉන්නේ අපේ OpenCV "මැජික්කාරයා".

ඊටපස්සේ Kurento මේ පාරවල් දෙක සම්බන්ධ කරනවා. ඒ කියන්නේ browser එකෙන් එන video එක කෙලින්ම යන්නේ OpenCV filter එක හරහා.

4. Step 4: The OpenCV Magic Trick OpenCV filter එකට video එකේ එක frame එකක් (photo එකක් වගේ) ගානේ එනවා. අපේ FastAPI backend එකේ තියෙන OpenCV code එකෙන් ඒ frame එක අරන්:

• මූණක් තියෙනවද කියලා හොයනවා.
• තිබුනොත්, ඒ මූණ උඩින් විහිලු තොප්පියක පින්තූරයක් අලවනවා.
• ඊටපස්සේ ඒ අලුත් frame එක ආපහු Kurento ටම දෙනවා.

5. Step 5: The Grand Finale Kurento එක, අර මැජික් කරපු අලුත් video stream එක ආපහු ඔයාගේ browser එකටම යවනවා. ඔයාට පේන්නේ ඔයාගේ ඔළුව උඩ තොප්පියක් තියෙන video එක! මේ ඔක්කොම වෙන්නේ ඇසිපිය ගහන සැනින්, ඒ කියන්නේ real-time.

පොඩ්ඩක් Technical වෙමුද? (Code Snippets)

මේකේ කෝඩ් එක ලියන එක ටිකක් සංකීර්ණයි, ඒත් මම සරලම අදහස දෙන්නම්.

FastAPI Backend එකේ වෙන්නේ මොකක්ද?

pip install fastapi uvicorn opencv-python pykurento

from fastapi import FastAPI import kurento_client as kurento

app = FastAPI() kurento_client = kurento.KurentoClient(“ws://localhost:8888/kurento”) # Kurento Server එකට connect වෙනවා

@app.post(“/start_stream”) async def start_stream(sdp_offer: str):

1. Media Pipeline එකක් හදනවා

pipeline = await kurento_client.create_media_pipeline()

2. Browser එකෙන් video ගන්න endpoint එක හදනවා

webrtc_endpoint = await pipeline.create_webrtc_endpoint()

3. OpenCV මැජික් දාන filter එක හදනවා (මේක Kurento වල built-in එකක්)

face_overlay_filter = await pipeline.create_faceoverlayfilter()

4. Filter එකට overlay කරන්න image එක දෙනවා

await face_overlay_filter.set_overlayed_image(“https://example.com/hat.png")

5. මේ ඔක්කොම connect කරනවා: Browser -> Filter -> Browser

await webrtc_endpoint.connect(face_overlay_filter) await face_overlay_filter.connect(webrtc_endpoint)

6. Browser එකට connection details (SDP Answer) එක යවනවා

sdp_answer = await webrtc_endpoint.process_offer(sdp_offer) return {“sdpAnswer”: sdp_answer}

Frontend (JavaScript) එකේ වෙන්නේ මොකක්ද?

JavaScript පැත්තේ kurento-utils.js වගේ library එකක් පාවිච්චි කරලා වැඩේ හරිම ලේසි කරගන්න පුළුවන්.

1. getUserMedia() වලින් user ගේ කැමරාව access කරනවා.
2. WebRtcPeer.WebRtcPeerSendrecv() වලින් Kurento එක්ක කතා කරන්න connection එක හදනවා.
3. ඒකෙන් එන SDP Offer එක අරගෙන, උඩ තියෙන FastAPI endpoint එකට POST request එකක් යවනවා.
4. FastAPI එකෙන් එන SDP Answer එක අරගෙන connection එක සම්පූර්ණ කරනවා.
5. අන්තිමට එන, මැජික් කරපු video stream එක <video> element එකක පෙන්නනවා.

අවසාන වශයෙන්

බලන්න, Kurento කියන “Traffic Police” ව පාලනය කරන්න FastAPI වගේ “මොළයක්” පාවිච්චි කරලා, OpenCV කියන “මැජික්කාරයා” ලවා කොච්චර සුපිරි වැඩක් කරගන්න පුළුවන්ද කියලා. මේක තමයි WebRTC (Real-Time Communication) වල නියම බලය.

ඔබට මේ ක්‍රමය පාවිච්චි කරලා:

• Online education platform වල virtual whiteboard හදන්න.
• Security කැමරා වලින් live object detection කරන්න.
• Telemedicine (දුරස්ථ වෛද්‍ය සේවා) වලදී රෝගීන්ව live analysis කරන්න.
• Virtual reality (VR) සහ Augmented Reality (AR) applications හදන්න.

වගේ අසීමිත දේවල් ප්‍රමාණයක් කරන්න පුළුවන්. පොඩ්ඩක් උත්සහ කරලා බලන්න, මේක හිතනවට වඩා හරිම thú vị වැඩක්!