🐌 👨🏻‍⚖️ 🙍🏽 नेटवर्क कैमरों से वीडियो कैप्चर करना, भाग 2 🤹🏽 🤳 🤠

अपने पहले लेख में, "किसी वस्तु की दूरी और उसकी गति को मापना," मैंने वीडियोकैमिनक्स 2 के माध्यम से और डायरेक्टएक्स के माध्यम से वेबकैम से छवियों पर कब्जा करने की जांच की। अगले लेख में, "नेटवर्क कैमरों से वीडियो कैप्चरिंग, भाग 1," मैंने जांच की कि नेटवर्क मोशन-जेपीईजी कैमरों के साथ कैसे काम किया जाए। अब मैं आपको नेटवर्क RTSP कैमरों से छवियों को कैप्चर करने के बारे में बताऊंगा, विशेष रूप से, RTSP पर Motion-JPEG।

यह कार्य HTTP से अधिक गति-जेपीईजी से अधिक जटिल है, क्योंकि अधिक कार्यों के लिए, अधिक कनेक्शन की आवश्यकता होती है, लेकिन बदले में हमें अधिक लचीलापन, गति, कार्यक्षमता और यहां तक कि कुछ प्रकार की बहुमुखी प्रतिभा भी मिलती है। ईमानदारी से, आरटीएसपी सरल कार्यों के लिए बेमानी है, लेकिन मुझे इसमें कोई संदेह नहीं है कि ऐसी परिस्थितियां होंगी जहां इसकी आवश्यकता होगी।

RTSP क्या है?

RTSP का अर्थ रियल टाइम स्ट्रीमिंग प्रोटोकॉल - एक रीयल-टाइम स्ट्रीमिंग प्रोटोकॉल है - वास्तव में यह एक प्रसारण नियंत्रण प्रोटोकॉल है, यह आपको कई कमांड निष्पादित करने की अनुमति देता है, जैसे "प्रारंभ", "स्टॉप", "एक विशिष्ट समय में संक्रमण"। यह प्रोटोकॉल कार्यान्वयन में HTTP के समान है, हेडर भी हैं, सब कुछ टेक्स्ट फॉर्म में भी प्रेषित होता है। यहाँ विनिर्देश से मुख्य आदेश हैं:

विकल्प - समर्थित तरीकों की एक सूची देता है (विकल्प, विवरण, आदि);
DESCRIBE - सामग्री के विवरण के लिए अनुरोध, एसडीपी प्रारूप में प्रत्येक ट्रैक का वर्णन करता है;
सेतुप - धाराओं के लिए कनेक्शन और परिवहन स्थापित करने का अनुरोध;
प्ले - प्रसारण शुरू;
TEARDOWN - प्रसारण बंद करो।

और RTSP की ख़ासियत यह है कि यह हमारे द्वारा आवश्यक वीडियो डेटा को प्रसारित नहीं करता है! सम्पूर्ण प्रोटोकॉल केवल संचार के लिए है। यहां आप एमवीसी के साथ सादृश्य देख सकते हैं, डेटा और उनके विवरण के बीच अलगाव है।

वर्कहॉर्स एक और प्रोटोकॉल है: आरटीपी - रीयल-टाइम ट्रांसपोर्ट प्रोटोकॉल - रियल-टाइम ट्रांसपोर्ट प्रोटोकॉल। इसकी मदद से, हमें जिस डेटा की आवश्यकता होती है, वह प्रसारित होता है। यह ध्यान देने योग्य है कि इस प्रोटोकॉल के साथ काम करना बहुत सुखद है, तथ्य यह है कि यह क्लाइंट सॉफ़्टवेयर के लिए डेटा लिंक परत पर विखंडन के बाद डेटा को पुनर्प्राप्त करना आसान बनाता है। यह कुछ और उपयोगी क्षेत्रों को भी वहन करता है: प्रेषित डेटा का प्रारूप, समय टिकट और सिंक्रनाइज़ेशन फ़ील्ड (यदि, उदाहरण के लिए, ऑडियो और वीडियो एक साथ प्रेषित होते हैं)। यद्यपि यह प्रोटोकॉल टीसीपी पर काम कर सकता है, यह आमतौर पर यूडीपी के साथ इसके गति-उन्मुख दृष्टिकोण के कारण उपयोग किया जाता है। यानी RTP डेटा एक UDP डेटाग्राम है जिसमें हेडर और पेलोड डेटा मीडिया कंटेंट के लिए है।

ऐसा लगेगा कि हमें किसी और चीज की जरूरत नहीं है। हम RTSP के माध्यम से जुड़े हुए हैं, हम RTP के माध्यम से उठाते हैं। लेकिन यह वहाँ था, स्मार्ट अंकल एक तीसरे प्रोटोकॉल के साथ आए: RTCP - रीयल-टाइम ट्रांसपोर्ट कंट्रोल प्रोटोकॉल - एक रियल-टाइम ट्रांसपोर्ट कंट्रोल प्रोटोकॉल। इस प्रोटोकॉल का उपयोग सेवा की गुणवत्ता निर्धारित करने के लिए किया जाता है, इसकी मदद से ग्राहक और सर्वर को पता चलता है कि सामग्री कितनी अच्छी या बुरी है। इस डेटा के अनुसार, सर्वर, उदाहरण के लिए, बिट दर को कम कर सकता है या किसी अन्य कोडेक पर भी स्विच कर सकता है।

यह स्वीकार किया जाता है कि RTP एक सम पोर्ट नंबर का उपयोग करता है, और RTCP अगले विषम पोर्ट नंबर का उपयोग करता है।

RTSP संचार उदाहरण

मेरे पास आरटीएसपी स्ट्रीम का केवल एक स्रोत है - एविडेंस एपीएक्स बॉक्स एम 1 कैमरा, इसलिए सभी उदाहरण इससे संबंधित हैं।

नीचे VLC खिलाड़ी के बीच संचार का लॉग है (यह वास्तव में मेरे शोध में बहुत मदद करता है) और यह कैमरा। कैमरे के 554 पोर्ट को वीएलसी से पहला अनुरोध। जवाब एक खाली लाइन के माध्यम से है और "आरटीएसपी / 1.0" से शुरू होता है।

01: OPTIONS rtsp://192.168.0.254/jpeg RTSP/1.0 02: CSeq: 1 03: User-Agent: VLC media player (LIVE555 Streaming Media v2008.07.24) 04: 05: RTSP/1.0 200 OK 06: CSeq: 1 07: Date: Fri, Apr 23 2010 19:54:20 GMT 08: Public: OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE 09: 10: DESCRIBE rtsp://192.168.0.254/jpeg RTSP/1.0 11: CSeq: 2 12: Accept: application/sdp 13: User-Agent: VLC media player (LIVE555 Streaming Media v2008.07.24) 14: 15: RTSP/1.0 200 OK 16: CSeq: 2 17: Date: Fri, Apr 23 2010 19:54:20 GMT 18: Content-Base: rtsp://192.168.0.254/jpeg/ 19: Content-Type: application/sdp 20: Content-Length: 442 21: x-Accept-Dynamic-Rate: 1 22: 23: v=0 24: o=- 1272052389382023 1 IN IP4 0.0.0.0 25: s=Session streamed by "nessyMediaServer" 26: i=jpeg 27: t=0 0 28: a=tool:LIVE555 Streaming Media v2008.04.09 29: a=type:broadcast 30: a=control:* 31: a=range:npt=0- 32: a=x-qt-text-nam:Session streamed by "nessyMediaServer" 33: a=x-qt-text-inf:jpeg 34: m=video 0 RTP/AVP 26 35: c=IN IP4 0.0.0.0 36: a=control:track1 37: a=cliprect:0,0,720,1280 38: a=framerate:25.000000 39: m=audio 7878 RTP/AVP 0 40: a=rtpmap:0 PCMU/8000/1 41: a=control:track2 42: 43: 44: SETUP rtsp://192.168.0.254/jpeg/track1 RTSP/1.0 45: CSeq: 3 46: Transport: RTP/AVP;unicast;client_port=41760-41761 47: User-Agent: VLC media player (LIVE555 Streaming Media v2008.07.24) 48: 49: RTSP/1.0 200 OK 50: CSeq: 3 51: Cache-Control: must-revalidate 52: Date: Fri, Apr 23 2010 19:54:20 GMT 53: Transport: RTP/AVP;unicast;destination=192.168.0.4;source=192.168.0.254;client_port=41760-41761; server_port=6970-6971 54: Session: 1 55: x-Transport-Options: late-tolerance=1.400000 56: x-Dynamic-Rate: 1 57: 58: SETUP rtsp://192.168.0.254/jpeg/track2 RTSP/1.0 59: CSeq: 4 60: Transport: RTP/AVP;unicast;client_port=7878-7879 61: Session: 1 62: User-Agent: VLC media player (LIVE555 Streaming Media v2008.07.24) 63: 64: RTSP/1.0 200 OK 65: CSeq: 4 66: Cache-Control: must-revalidate 67: Date: Fri, Apr 23 2010 19:54:20 GMT 68: Transport: RTP/AVP;unicast;destination=192.168.0.4;source=192.168.0.254;client_port=7878-7879; server_port=6972-6973 69: Session: 1 70: x-Transport-Options: late-tolerance=1.400000 71: x-Dynamic-Rate: 1 72: 73: PLAY rtsp://192.168.0.254/jpeg/ RTSP/1.0 74: CSeq: 5 75: Session: 1 76: Range: npt=0.000- 77: User-Agent: VLC media player (LIVE555 Streaming Media v2008.07.24) 78: 79: RTSP/1.0 200 OK 80: CSeq: 5 81: Date: Fri, Apr 23 2010 19:54:20 GMT 82: Range: npt=0.000- 83: Session: 1 84: RTP-Info: url=rtsp://192.168.0.254/jpeg/track1;seq=20730; rtptime=3869319494,url=rtsp://192.168.0.254/jpeg/track2;seq=33509;rtptime=3066362516 85: 86: #              87: 88: TEARDOWN rtsp://192.168.0.254/jpeg/ RTSP/1.0 89: CSeq: 6 90: Session: 1 91: User-Agent: VLC media player (LIVE555 Streaming Media v2008.07.24) 92: 93: RTSP/1.0 200 OK 94: CSeq: 6 95: Date: Fri, Apr 23 2010 19:54:25 GMT

पहली बात वीएलसी ने कैमरे से पूछा:
"मैं आपके साथ क्या कर सकता हूं?" (विकल्प)
- आपको नमस्कार है। और क्या आप मुझसे कोई विकल्प, DESCRIBE, SETUP, TEARDOWN, PLAY और PAUSE करने को कह सकते हैं।
- ठीक है, तो मुझे बताएं कि आपके पास "/ jpeg" के लिए क्या है? (वर्णन)
- यहाँ मैं पहले ट्रैक में वीडियो, एम-जेपीईजी, और दूसरे ट्रैक में ऑडियो सरल है।
- वीडियो को देखने के लिए दिलचस्प है, पहला ट्रैक, इसे मुझे डालें, कृपया पॉकेट नंबर 41760 में, और आप पॉकेट नंबर 41761 में किसी भी भूसी को फेंक सकते हैं। (SETUP track1)
"ठीक है, आपकी आज्ञा पर ..."
- और मैं भी ध्वनि सुनना चाहता हूं, 7878, 7879 जेब में एक दाने। (SETUP track2)
- हां, कोई बात नहीं।
- ठीक है, छिड़का हुआ। (PLAY)
थोड़ी देर बाद:
- ठीक है, पर्याप्त, मैंने पर्याप्त देखा है। (टियरडाउन)
- जैसा आप कहें।

यह वह जगह है जहाँ थोड़ा विषयांतर समाप्त होता है। पहले अनुरोध में, " OPTIONS rtsp://192.168.0.254/jpeg RTSP/1.0 " " GET /jpeg HTTP/1.1 " से मिलता-जुलता है, इस अर्थ में कि इस के साथ बातचीत शुरू होती है, और HTTP प्रोटोकॉल में विकल्प विधि भी है। यहाँ 192.168.0.254 मेरे कैमरे का आईपी पता है। CSeq अनुरोध के अनुक्रम संख्या को दर्शाता है, सर्वर से प्रतिक्रिया में समान CSeq होना चाहिए।

और सर्वर से प्रतिक्रिया " RTSP/1.0 200 OK " से शुरू होती है, यह " HTTP/1.1 200 OK " की तरह है - एक संकेत है कि सब कुछ ठीक है: अनुरोध स्वीकार किया जाता है, अनुरोध स्पष्ट है और इसके कार्यान्वयन में कोई समस्या नहीं थी। और सादे पाठ में सभी उपलब्ध तरीकों की एक सूची का अनुसरण करता है।

अगला, हम अनुरोध / जेपीईजी पर हमें इंतजार करने के बारे में जानकारी एकत्र करते हैं, क्योंकि हमने अभी उसका अनुसरण किया है और " rtsp://192.168.0.254/jpeg " लिंक पर आया है। हम यह भी संकेत देते हैं कि हम एसडीपी (पंक्ति 12) के रूप में उत्तर प्राप्त करना चाहते हैं।

प्रतिक्रिया में, हमें एक RTSP हेडर मिलता है जो Content-Type और Content-Length संकेत देता है, और हेडर के बाद, खाली लाइन के माध्यम से, एसडीपी प्रारूप में सामग्री सीधे होती है:

 v=0 o=- 1272052389382023 1 IN IP4 0.0.0.0 s=Session streamed by "nessyMediaServer" i=jpeg t=0 0 a=tool:LIVE555 Streaming Media v2008.04.09 a=type:broadcast a=control:* a=range:npt=0- a=x-qt-text-nam:Session streamed by "nessyMediaServer" a=x-qt-text-inf:jpeg m=video 0 RTP/AVP 26 c=IN IP4 0.0.0.0 a=control:track1 a=cliprect:0,0,720,1280 a=framerate:25.000000 m=audio 7878 RTP/AVP 0 a=rtpmap:0 PCMU/8000/1 a=control:track2

यहाँ सब कुछ बहुत स्पष्ट है। हमें निम्नलिखित पंक्तियों की आवश्यकता है:

 #   m=video 0 RTP/AVP 26 #   RTP/AVP,  ,   26,   Motion-JPEG a=control:track1 #   a=cliprect:0,0,720,1280 #    a=framerate:25.000000 #       #   m=audio 7878 RTP/AVP 0 #  7878,    , 0 - PCM a=control:track2 #

यदि हम केवल वीडियो प्राप्त करना चाहते हैं, तो ऑडियो डेटा से हम ट्रैक के नाम को छोड़कर सब कुछ अनदेखा कर देते हैं। हमें स्ट्रीम को कॉन्फ़िगर करने की आवश्यकता है, लेकिन कोई भी हमें इस स्ट्रीम को स्वीकार करने के लिए मजबूर नहीं करता है, हालांकि, यदि आप ऑडियो को पूरी तरह से अनदेखा करते हैं (यदि SETUP केवल वीडियो ट्रैक के लिए किया SETUP है) तो कैमरा काम करने से इनकार कर देता है।

ईमानदारी से, मुझे पता नहीं है कि ऑडियो स्ट्रीम (7878) के लिए पोर्ट नंबर की उपेक्षा करने पर विभिन्न कैमरे कैसे प्रतिक्रिया देंगे, क्योंकि हम इसे SETUP कमांड के साथ निर्दिष्ट करते हैं।

अगले दो SETUP अनुरोध हैं, जो उन बंदरगाहों को इंगित करते हैं जिन पर हम वीडियो और ऑडियो स्ट्रीम प्राप्त करना चाहते हैं। पहला नंबर RTP के लिए पोर्ट है, दूसरा RTCP के लिए है। कैमरे की प्रतिक्रिया में बंदरगाहों के बारे में जानकारी होती है, आप उन्हें यह सुनिश्चित करने के लिए परामर्श कर सकते हैं कि सब कुछ सही तरीके से कॉन्फ़िगर किया गया है। हमें Session पहचानकर्ता को भी याद रखना चाहिए। हमें बाद की सभी कॉल में इसका संकेत देना होगा।

PLAY कमांड के बाद, वीडियो 41760 और ऑडियो को 7878 पोर्ट पर ट्रांसफर करना शुरू कर दिया जाएगा। और TEARDOWN कमांड के साथ TEARDOWN प्रसारण बंद हो जाता है, कनेक्शन काट दिया जाता है।

MJPEG RTP पर

आरटीपी पैकेट हमारे पास आते हैं, हमें उन्हें डिक्रिप्ट करना होगा। इसके लिए, मैं यहां सभी क्षेत्रों के विवरण के साथ इस तरह के पैकेज की एक तालिका दूंगा।

+ बिट ऑफसेट	0-1	2	3	4-7	8	9-15	16-31
0	वी	पी	एक्स	सीसी	एम	पीटी	अनुक्रम संख्या
32	समय-चिह्न
64	SSRC पहचानकर्ता
96	... CSRC पहचानकर्ता ...
96+ (CC × 32)	एक्सटेंशन हैडर आईडी						एक्सटेंशन हैडर की लंबाई (EHL)
96+ (CC × 32) + (X × 32)	... एक्सटेंशन हैडर ...
96+ (CC × 32) + (X × 32) + (X × EHL)	पेलोड

वी (संस्करण): (2) प्रोटोकॉल संस्करण। अब संस्करण संख्या 2।
P (पैडिंग, सप्लीमेंट): (1) RTP पैकेट को अंत में खाली बाइट्स के साथ गद्देदार किया जाता है, उदाहरण के लिए, एन्क्रिप्शन एल्गोरिदम के लिए।
एक्स (विस्तार): (1) एक विस्तारित हेडर की उपस्थिति को इंगित करता है, जो अनुप्रयोग द्वारा निर्धारित किया जाता है। हमारे मामले में, इसका उपयोग नहीं किया जाता है।
CC (CSRC काउंट): (4) में CSRC पहचानकर्ताओं की संख्या शामिल है। हम भी इस्तेमाल नहीं कर रहे हैं।
एम (मार्कर): (1) का उपयोग एप्लिकेशन स्तर पर किया जाता है, हमारे मामले में यह बिट एक पर सेट होता है यदि आरटीपी पैकेट में जेपीईजी फ्रेम का अंत होता है।
पीटी (पेलोड प्रकार): (7) पेलोड के प्रारूप को इंगित करता है - प्रेषित डेटा। MJPEG के लिए यह 26 है।
अनुक्रम संख्या : (16) आरटीपी पैकेट संख्या, खोए हुए पैकेटों का पता लगाने के लिए उपयोग की जाती है।
टाइमस्टैम्प (32): टाइमस्टैम्प, हमारे मामले में 90,000 हर्ट्ज (90000 = 1 सेकंड)।
SSRC (सिंक्रोनाइज़ेशन सोर्स): (32) सिंक्रनाइज़र की पहचानकर्ता, हालाँकि यह हास्यास्पद हो सकता है। धारा के स्रोत को निर्दिष्ट करता है।
CSRC (योगदान स्रोत): (32) अतिरिक्त स्रोतों के पहचानकर्ता, जिनका उपयोग तब किया जाता है जब हमारे पास कई स्थानों से आने वाली धारा होती है।
एक्सटेंशन हैडर आईडी : (16) एक्सटेंशन की पहचानकर्ता, अगर हमारे पास यह है, तो आपको यह जानना होगा कि यह क्या है। हमारे मामले में, इसका उपयोग नहीं किया जाता है।
एक्सटेंशन हैडर की लंबाई : (16) बाइट्स में इस हेडर की लंबाई।
एक्सटेंशन हैडर : शीर्षक ही। संदर्भ के आधार पर सामग्री बहुत भिन्न हो सकती है।
पेलोड : पेलोड डेटा हमारे बहुत ही जेपीईजी फ्रेम हैं। खंडित, निश्चित रूप से।

CSRC से शुरू होने वाले क्षेत्र वैकल्पिक हैं। जहाँ तक मुझे पता है, उनका उपयोग MJPEG को कैमरों से प्रसारित करने के लिए नहीं किया जाता है।

ऊपर एन्कैप्सुलेशन का एक स्तर हस्तांतरित। अब कार्य प्राप्त वीडियो डेटा को एक पूर्ण JPEG छवि में परिवर्तित करना है। HTTP पर MJPEG के मामले में, सब कुछ सरल है - हम स्ट्रीम का एक टुकड़ा काटते हैं और तुरंत JPEG छवि के साथ इसके साथ काम करते हैं। आरटीपी के मामले में, छवि पूरी तरह से प्रसारित नहीं होती है, ट्रैफ़िक को बचाने के लिए जेपीईजी हेडर को छोड़ा जाता है। इसे संलग्न आंकड़ों से स्वतंत्र रूप से बहाल किया जाना चाहिए।

MJPEG विनिर्देशन के लिए RTP पेलोड RFC2435 में वर्णित है। मैं आपको प्रारूप में सभी क्षेत्रों के विवरण के साथ एक तालिका भी दूंगा:

+ बिट ऑफसेट	0-7	8-15	16-23	24-31
0	विशेष प्रकार के	विखंडन ऑफसेट
32	टाइप	क्यू	चौड़ाई	ऊंचाई
अगर 64..127 में टाइप करें	मार्कर हेडर को पुनरारंभ करें
यदि 128 में क्यू। 25	MBZ	शुद्धता	लंबाई
यदि 128 में क्यू। 25	परिमाणीकरण तालिका डेटा

प्रकार-विशिष्ट (प्रकार पर निर्भर करता है): (8) क्षेत्र का अर्थ कार्यान्वयन पर निर्भर करता है, हमारे मामले में यह लागू नहीं होता है।
फ्रैगमेंट ऑफ़सेट : (24) संपूर्ण फ़्रेम में वर्तमान फ़्रेम के टुकड़े की स्थिति को इंगित करता है।
प्रकार : (8) छवि को कैसे पुनर्स्थापित किया जाता है यह प्रकार पर निर्भर करता है।
क्यू (गुणवत्ता): (8) छवि गुणवत्ता।
चौड़ाई : (8) फ्रेम की चौड़ाई।
ऊंचाई : (8) और ऊंचाई।
मार्कर हेडर रीस्टार्ट करें : (32) RST मार्कर का उपयोग करने पर JPEG को डीकोड करते समय उपयोग किया जाता है। मुझे नहीं पता कि उनके कैमरों का उपयोग किया गया है या नहीं, लेकिन मैं इस हेडर को अनदेखा करता हूं। यह फ़ील्ड केवल टाइप 64 से 127 के साथ दिखाई देती है।
परिमाणीकरण तालिका डेटा : यदि वे मौजूद हैं, तो आपको उन्हें अलग से गणना करने की आवश्यकता नहीं है। और उन्हें जेपीईजी डेटा से चित्रों को ठीक से बनाने की आवश्यकता है। यदि ये टेबल सही नहीं हैं, तो छवि गलत रंगों और विरोधाभासों के साथ होगी। क्रमशः चमक और रंग के लिए दो टेबल होनी चाहिए: लूमा और क्रोमा।
MBZ, परिशुद्धता, लंबाई : (32) परिमाणीकरण तालिकाओं के पैरामीटर, मैं उन्हें अनदेखा करता हूं, मैंने लंबाई निर्धारित की है - 64 बाइट्स की दो - प्रत्येक तालिका। अन्यथा, मुझे नहीं पता कि उनके साथ कैसे काम करना है।

RST मार्कर हेडर और क्वांटिज़ेशन टेबल मौजूद नहीं हो सकते हैं। यदि पहले नहीं है, तो यह बहुत अच्छा है, क्योंकि मैं किसी और चीज़ पर भरोसा नहीं करता। यदि कोई दूसरा नहीं है - पैरामीटर क्यू के आधार पर आवश्यक तालिकाओं की गणना की जाती है।

RTCP पैकेट में इसका एक उपसमूह होता है, यह चार प्रकार का हो सकता है: 201 - स्रोत रिपोर्ट, 202 - रिसीवर रिपोर्ट, 203 - स्रोत विवरण और 204 - गंतव्य अनुप्रयोग द्वारा निर्धारित किया जाता है। सबसे पहले, हमें टाइप 201 को स्वीकार करना होगा, फिर टाइप करें 202। 203 और 204 वैकल्पिक हैं, लेकिन मैं उन्हें भी ध्यान में रखता हूं। एक यूडीपी पैकेट में कई RTCP पैकेट हो सकते हैं।

सभी प्रकारों में समान संरचना होती है। कोई भी RTCP पैकेट निम्न डेटा से शुरू होता है:

+ बिट ऑफसेट	0-1		2	3-7					8-15								16-31
0	संस्करण		गद्दी	SC या RC या सबटाइप					पैकेट प्रकार								लंबाई

संस्करण : (2) आरटीपी संस्करण।
पैडिंग : (1) आरटीपी के लिए समान।
एससी या आरसी या सबटाइप : (5) प्रकार के आधार पर, यह स्रोत (स्रोत गणना) या प्राप्तकर्ता (स्रोत की गणना) की संख्या क्रमशः प्राप्तकर्ता और स्रोत की रिपोर्ट में शामिल हो सकती है। यदि यह एक एपीपी पैकेट है, तो यह क्षेत्र ऐसे पैकेट के उपप्रकार को परिभाषित करता है।
पैकेट प्रकार : (8) पैकेट प्रकार, 201 - स्रोत रिपोर्ट (प्रेषक की रिपोर्ट एसएस), 202 - रिसीवर रिपोर्ट (रिसीवर की रिपोर्ट आरआर), 203 - स्रोत विवरण एसडीईएस और 204 - गंतव्य एप्लिकेशन (एपीपी) द्वारा निर्धारित किया जाता है।
लंबाई : (16) हेडर के बाद डेटा का आकार, 32 बिट इकाइयों में मापा जाता है।

इसके अलावा, मैं प्रत्येक उपप्रकार के लिए फ़ील्ड नहीं दूंगा, उन्हें RFC3550 में देखा जा सकता है। मुझे केवल इतना कहना है कि एसएस और आरआर प्रकार भेजे गए / प्राप्त पैकेटों के बारे में और समय की देरी के बारे में जानकारी लेते हैं। एसडीईएस अपने आप में विभिन्न पाठ क्षेत्रों को वहन करता है जो स्रोत को परिभाषित करते हैं, जैसे कि उसका नाम, ईमेल, फोन, स्थान आदि।

इससे परिचय समाप्त होता है।

आरटीएसपी क्लाइंट पर अजगर एमजेपीईजी

इसलिए हम अजगर के पास गए। क्लाइंट में कई फाइलें होती हैं, main.py में एक कॉलबैक फ़ंक्शन होता है जो प्राप्त छवियों को संसाधित करता है, यह ट्विस्टेड नेटवर्क फ्रेमवर्क तंत्र भी शुरू करता है और कैमरे से कनेक्ट करने के लिए सेटिंग्स संग्रहीत करता है। सभी लिस्टिंग I को छोटा, पूर्ण संस्करण को लेख के अंत में लिंक से डाउनलोड किया जा सकता है।
main.py

 20: def processImage(img): 21: 'This function is invoked by the MJPEG Client protocol' 22: # Process image 23: # Just save it as a file in this example 24: f = open('frame.jpg', 'wb') 25: f.write(img) 26: f.close() 27: 28: def main(): 29: print 'Python M-JPEG Over RSTP Client 0.1' 30: config = {'request': '/jpeg', 31: 'login': '', 32: 'password': 'admin', 33: 'ip': '192.168.0.252', 34: 'port': 554, 35: 'udp_port': 41760, 36: 'callback': processImage} 37: # Prepare RTP MJPEG client (technically it's a server) 38: reactor.listenUDP(config['udp_port'], rtp_mjpeg_client.RTP_MJPEG_Client(config)) 39: reactor.listenUDP(config['udp_port'] + 1, rtcp_client.RTCP_Client()) # RTCP 40: # And RSTP client 41: reactor.connectTCP(config['ip'], config['port'], rtsp_client.RTSPFactory(config)) 42: # Run both of them 43: reactor.run() 44: # On exit: 45: print 'Python M-JPEG Client stopped.'

सिद्धांत रूप में, आप RTCP प्रोटोकॉल को लागू किए बिना और ऑडियो डेटा प्राप्त किए बिना काम कर सकते हैं। इस मामले में, कैमरा लगभग एक मिनट के बाद डिस्कनेक्ट हो जाता है। हमें हर समय पुन: कनेक्ट करना पड़ता है, यह स्वचालित रूप से किया जाता है, इसलिए यह समस्याएं पैदा नहीं करता है। हालाँकि, लेख के लिए, मैंने RTCP भाग को जोड़ा और ऑडियो डेटा प्राप्त करने के लिए एक रिक्त बनाया।

अगली महत्वपूर्ण फ़ाइल rtsp_client.py । वह सबसे अधिक भ्रमित है, लेकिन उसका लक्ष्य स्पष्ट है - ऊपर वर्णित कनेक्शन को सही ढंग से स्थापित करना।
rtsp_client.py

 012: class RTSPClient(Protocol): 013: def __init__(self): 014: self.config = {} 015: self.wait_description = False 016: 017: def connectionMade(self): 018: self.session = 1 019: # Authorization part 020: if self.config['login']: 021: authstring = 'Authorization: Basic ' + b64encode(self.config['login']+':'+self.config['password']) + '\r\n' 022: else: 023: authstring = '' 024: # send OPTIONS request 025: to_send = """\ 026: OPTIONS rtsp://""" + self.config['ip'] + self.config['request'] + """ RTSP/1.0\r 027: """ + authstring + """CSeq: 1\r 028: User-Agent: Python MJPEG Client\r 029: \r 030: """ 031: self.transport.write(to_send) 032: if debug: 033: print 'We say:\n', to_send 034: 035: def dataReceived(self, data): 036: if debug: 037: print 'Server said:\n', data 038: # Unify input data 039: data_ln = data.lower().strip().split('\r\n', 5) 040: # Next behaviour is relevant to CSeq 041: # which defines current conversation state 042: if data_ln[0] == 'rtsp/1.0 200 ok' or self.wait_description: 043: # There might be an audio stream 044: if 'audio_track' in self.config: 045: cseq_audio = 1 046: else: 047: cseq_audio = 0 048: to_send = '' 049: if 'cseq: 1' in data_ln: 050: # CSeq 1 -> DESCRIBE 051: to_send = """\ 052: DESCRIBE rtsp://""" + self.config['ip'] + self.config['request'] + """ RTSP/1.0\r 053: CSeq: 2\r 054: Accept: application/sdp\r 055: User-Agent: Python MJPEG Client\r 056: \r 057: """ 058: elif 'cseq: 2' in data_ln or self.wait_description: 059: # CSeq 2 -> Parse SDP and then SETUP 060: data_sp = data.lower().strip().split('\r\n\r\n', 1) 061: # wait_description is used when SDP is sent in another UDP 062: # packet 063: if len(data_sp) == 2 or self.wait_description: 064: # SDP parsing 065: video = audio = False 066: is_MJPEG = False 067: video_track = '' 068: audio_track = '' 069: if len(data_sp) == 2: 070: s = data_sp[1].lower() 071: elif self.wait_description: 072: s = data.lower() 073: for line in s.strip().split('\r\n'): 074: if line.startswith('m=video'): 075: video = True 076: audio = False 077: if line.endswith('26'): 078: is_MJPEG = True 079: if line.startswith('m=audio'): 080: video = False 081: audio = True 082: self.config['udp_port_audio'] = int(line.split(' ')[1]) 083: if video: 084: params = line.split(':', 1) 085: if params[0] == 'a=control': 086: video_track = params[1] 087: if audio: 088: params = line.split(':', 1) 089: if params[0] == 'a=control': 090: audio_track = params[1] 091: if not is_MJPEG: 092: print "Stream", self.config['ip'] + self.config['request'], 'is not an MJPEG stream!' 093: if video_track: self.config['video_track'] = 'rtsp://' + self.config['ip'] + self.config['request'] + '/' + basename(video_track) 094: if audio_track: self.config['audio_track'] = 'rtsp://' + self.config['ip'] + self.config['request'] + '/' + basename(audio_track) 095: to_send = """\ 096: SETUP """ + self.config['video_track'] + """ RTSP/1.0\r 097: CSeq: 3\r 098: Transport: RTP/AVP;unicast;client_port=""" + str(self.config['udp_port']) + """-"""+ str(self.config['udp_port'] + 1) + """\r 099: User-Agent: Python MJPEG Client\r 100: \r 101: """ 102: self.wait_description = False 103: else: 104: # Do not have SDP in the first UDP packet, wait for it 105: self.wait_description = True 106: elif "cseq: 3" in data_ln and 'audio_track' in self.config: 107: # CSeq 3 -> SETUP audio if present 108: self.session = data_ln[5].strip().split(' ')[1] 109: to_send = """\ 110: SETUP """ + self.config['audio_track'] + """ RTSP/1.0\r 111: CSeq: 4\r 112: Transport: RTP/AVP;unicast;client_port=""" + str(self.config['udp_port_audio']) + """-"""+ str(self.config['udp_port_audio'] + 1) + """\r 113: Session: """ + self.session + """\r 114: User-Agent: Python MJPEG Client\r 115: \r 116: """ 117: reactor.listenUDP(self.config['udp_port_audio'], rtp_audio_client.RTP_AUDIO_Client(self.config)) 118: reactor.listenUDP(self.config['udp_port_audio'] + 1, rtcp_client.RTCP_Client()) # RTCP 119: elif "cseq: "+str(3+cseq_audio) in data_ln: 120: # PLAY 121: to_send = """\ 122: PLAY rtsp://""" + self.config['ip'] + self.config['request'] + """/ RTSP/1.0\r 123: CSeq: """ + str(4+cseq_audio) + """\r 124: Session: """ + self.session + """\r 125: Range: npt=0.000-\r 126: User-Agent: Python MJPEG Client\r 127: \r 128: """ 129: elif "cseq: "+str(4+cseq_audio) in data_ln: 130: if debug: 131: print 'PLAY' 132: pass 133: 134: elif "cseq: "+str(5+cseq_audio) in data_ln: 135: if debug: 136: print 'TEARDOWN' 137: pass 138: 139: if to_send: 140: self.transport.write(to_send) 141: if debug: 142: print 'We say:\n', to_send

एक ऑडियो ट्रैक की उपस्थिति में, यह मॉड्यूल rtp_audio_client.py और संबंधित RTCP क्लाइंट भी लॉन्च करता है।

एक सफल कनेक्शन के बाद, rtp_mjpeg_client.py काम के लिए लिया जाता है, आने वाली डेटा स्ट्रीम को संसाधित करता है।
rtp_mjpeg_client.py

 08: class RTP_MJPEG_Client(DatagramProtocol): 09: def __init__(self, config): 10: self.config = config 11: # Previous fragment sequence number 12: self.prevSeq = -1 13: self.lost_packet = 0 14: # Object that deals with JPEGs 15: self.jpeg = rfc2435jpeg.RFC2435JPEG() 16: 17: def datagramReceived(self, datagram, address): 18: # When we get a datagram, parse it 19: rtp_dg = rtp_datagram.RTPDatagram() 20: rtp_dg.Datagram = datagram 21: rtp_dg.parse() 22: # Check for lost packets 23: if self.prevSeq != -1: 24: if (rtp_dg.SequenceNumber != self.prevSeq + 1) and rtp_dg.SequenceNumber != 0: 25: self.lost_packet = 1 26: self.prevSeq = rtp_dg.SequenceNumber 27: # Handle Payload 28: if rtp_dg.PayloadType == 26: # JPEG compressed video 29: self.jpeg.Datagram = rtp_dg.Payload 30: self.jpeg.parse() 31: # Marker = 1 if we just received the last fragment 32: if rtp_dg.Marker: 33: if not self.lost_packet: 34: # Obtain complete JPEG image and give it to the 35: # callback function 36: self.jpeg.makeJpeg() 37: self.config['callback'](self.jpeg.JpegImage) 38: else: 39: #print "RTP packet lost" 40: self.lost_packet = 0 41: self.jpeg.JpegPayload = ""

उसे समझना आसान है। हर बार जब हम एक और डेटाग्राम को स्वीकार करते हैं, हम इसे rtp_datagram.py मॉड्यूल का उपयोग करके पार्स करते हैं, और परिणाम को rfc2435jpeg.py मॉड्यूल में फीड करते हैं, जो एक पूर्ण JPEG छवि बनाता है। अगला, हम rtp_dg.Marker मार्कर की उपस्थिति की प्रतीक्षा करते हैं और यह प्रतीत होता है कि हम कॉलबैक फ़ंक्शन को पुनर्स्थापित छवि के साथ कॉल करते हैं।

RTP डेटाग्राम पार्सर इस तरह दिखता है:
rtp_datagram.py

 26: def parse(self): 27: Ver_P_X_CC, M_PT, self.SequenceNumber, self.Timestamp, self.SyncSourceIdentifier = unpack('!BBHII', self.Datagram[:12]) 28: self.Version = (Ver_P_X_CC & 0b11000000) >> 6 29: self.Padding = (Ver_P_X_CC & 0b00100000) >> 5 30: self.Extension = (Ver_P_X_CC & 0b00010000) >> 4 31: self.CSRCCount = Ver_P_X_CC & 0b00001111 32: self.Marker = (M_PT & 0b10000000) >> 7 33: self.PayloadType = M_PT & 0b01111111 34: i = 0 35: for i in range(0, self.CSRCCount, 4): 36: self.CSRS.append(unpack('!I', self.Datagram[12+i:16+i])) 37: if self.Extension: 38: i = self.CSRCCount * 4 39: (self.ExtensionHeaderID, self.ExtensionHeaderLength) = unpack('!HH', self.Datagram[12+i:16+i]) 40: self.ExtensionHeader = self.Datagram[16+i:16+i+self.ExtensionHeaderLength] 41: i += 4 + self.ExtensionHeaderLength 42: self.Payload = self.Datagram[12+i:]

JPEG रिकवरी मॉड्यूल काफी बड़ा है क्योंकि इसमें कई टेबल और एक लंबे हेडर जनरेशन फंक्शन हैं। इसलिए, मैं उन्हें यहां छोड़ दूँगा, केवल आरटीपी पेलोड को पार्स करने और अंतिम जेपीईजी छवि बनाने के कार्य प्रदान करेगा।
rfc2435jpeg.py

 287: def parse(self): 288: HOffset = 0 289: LOffset = 0 290: # Straightforward parsing 291: (self.TypeSpecific, 292: HOffset, #3 byte offset 293: LOffset, 294: self.Type, 295: self.Q, 296: self.Width, 297: self.Height) = unpack('!BBHBBBB', self.Datagram[:8]) 298: self.Offest = (HOffset << 16) + LOffset 299: self.Width = self.Width << 3 300: self.Height = self.Height << 3 301: 302: # Check if we have Restart Marker header 303: if 64 <= self.Type <= 127: 304: # TODO: make use of that header 305: self.RM_Header = self.Datagram[8:12] 306: rm_i = 4 # Make offset for JPEG Header 307: else: 308: rm_i = 0 309: 310: # Check if we have Quantinization Tables embedded into JPEG Header 311: # Only the first fragment will have it 312: if self.Q > 127 and not self.JpegPayload: 313: self.JpegPayload = self.Datagram[rm_i+8+132:] 314: QT_Header = self.Datagram[rm_i+8:rm_i+140] 315: (self.QT_MBZ, 316: self.QT_Precision, 317: self.QT_Length) = unpack('!BBH', QT_Header[:4]) 318: self.QT_luma = string2list(QT_Header[4:68]) 319: self.QT_chroma = string2list(QT_Header[68:132]) 320: else: 321: self.JpegPayload += self.Datagram[rm_i+8:] 322: # Clear tables. Q might be dynamic. 323: if self.Q <= 127: 324: self.QT_luma = [] 325: self.QT_chroma = [] 326: 327: def makeJpeg(self): 328: lqt = [] 329: cqt = [] 330: dri = 0 331: # Use exsisting tables or generate ours 332: if self.QT_luma: 333: lqt=self.QT_luma 334: cqt=self.QT_chroma 335: else: 336: MakeTables(self.Q,lqt,cqt) 337: JPEGHdr = [] 338: # Make a complete JPEG header 339: MakeHeaders(JPEGHdr, self.Type, int(self.Width), int(self.Height), lqt, cqt, dri) 340: self.JpegHeader = list2string(JPEGHdr) 341: # And a complete JPEG image 342: self.JpegImage = self.JpegHeader + self.JpegPayload 343: self.JpegPayload = '' 344: self.JpegHeader = '' 345: self.Datagram = ''

मैंने rtp_audio_client.py ऑडियो डेटा प्राप्त करने वाले मॉड्यूल को भी लागू किया, लेकिन उन्हें खेलने योग्य डेटा में परिवर्तित नहीं किया। अगर किसी को इसकी आवश्यकता होगी, तो मैंने इस फ़ाइल में एक स्केच बनाया, जैसा कि सब कुछ होना चाहिए। केवल rfc2435jpeg.py समान पार्सिंग को व्यवस्थित करना आवश्यक है। ऑडियो डेटा आसान है क्योंकि यह खंडित नहीं है। प्रत्येक पैकेज प्रजनन के लिए पर्याप्त डेटा वहन करता है। मैं इस मॉड्यूल को यहां नहीं लाऊंगा, क्योंकि लेख पहले से ही बहुत लंबा है (मैंने जल्द ही एक हैबरफोल्ड लागू किया होगा)।

सही संचालन के लिए, हमें RTCP पैकेट प्राप्त करने और भेजने की आवश्यकता है, प्रेषक की रिपोर्ट स्वीकार करें, प्राप्तकर्ता की रिपोर्ट भेजें। कार्य को सरल बनाने के लिए, हम कैमरे से एसआर प्राप्त करने के तुरंत बाद अपना आरआर भेजेंगे और हम उन्हें आदर्शित डेटा में रखेंगे कि सब कुछ ठीक है।
rtcp_client.py

 09: class RTCP_Client(DatagramProtocol): 10: def __init__(self): 11: # Object that deals with RTCP datagrams 12: self.rtcp = rtcp_datagram.RTCPDatagram() 13: def datagramReceived(self, datagram, address): 14: # SSRC Report received 15: self.rtcp.Datagram = datagram 16: self.rtcp.parse() 17: # Send back our Receiver Report 18: # saying that everything is fine 19: RR = self.rtcp.generateRR() 20: self.transport.write(RR, address)

लेकिन मॉड्यूल सीधे RTCP डेटाग्राम के साथ काम करता है। यह भी काफी बड़ा निकला।
rtcp_datagram.py

 049: def parse(self): 050: # RTCP parsing is complete 051: # including SDES, BYE and APP 052: # RTCP Header 053: (Ver_P_RC, 054: PacketType, 055: Length) = unpack('!BBH', self.Datagram[:4]) 056: Version = (Ver_P_RC & 0b11000000) >> 6 057: Padding = (Ver_P_RC & 0b00100000) >> 5 058: # Byte offset 059: off = 4 060: # Sender's Report 061: if PacketType == 200: 062: # Sender's information 063: (self.SSRC_sender, 064: self.NTP_TimestampH, 065: self.NTP_TimestampL, 066: self.RTP_Timestamp, 067: self.SenderPacketCount, 068: self.SenderOctetCount) = unpack('!IIIIII', self.Datagram[off: off + 24]) 069: off += 24 070: ReceptionCount = Ver_P_RC & 0b00011111 071: if debug: 072: print 'SDES: SR from', str(self.SSRC_sender) 073: # Included Receiver Reports 074: self.Reports = [] 075: i = 0 076: for i in range(ReceptionCount): 077: self.Reports.append(Report()) 078: self.Reports[i].SSRC, 079: self.Reports[i].FractionLost, 080: self.Reports[i].CumulativeNumberOfPacketsLostH, 081: self.Reports[i].CumulativeNumberOfPacketsLostL, 082: self.Reports[i].ExtendedHighestSequenceNumberReceived, 083: self.Reports[i].InterarrivalJitter, 084: self.Reports[i].LastSR, 085: self.Reports[i].DelaySinceLastSR = unpack('!IBBHIIII', self.Datagram[off: off + 24]) 086: off += 24 087: # Source Description (SDES) 088: elif PacketType == 202: 089: # RC now is SC 090: SSRCCount = Ver_P_RC & 0b00011111 091: self.SourceDescriptions = [] 092: i = 0 093: for i in range(SSRCCount): 094: self.SourceDescriptions.append(SDES()) 095: SSRC, = unpack('!I', self.Datagram[off: off + 4]) 096: off += 4 097: self.SourceDescriptions[i].SSRC = SSRC 098: SDES_Item = -1 099: # Go on the list of descriptions 100: while SDES_Item != 0: 101: SDES_Item, = unpack('!B', self.Datagram[off]) 102: off += 1 103: if SDES_Item != 0: 104: SDES_Length, = unpack('!B', self.Datagram[off]) 105: off += 1 106: Value = self.Datagram[off: off + SDES_Length] 107: off += SDES_Length 108: if debug: 109: print 'SDES:', SDES_Item, Value 110: if SDES_Item == 1: 111: self.SourceDescriptions[i].CNAME = Value 112: elif SDES_Item == 2: 113: self.SourceDescriptions[i].NAME = Value 114: elif SDES_Item == 3: 115: self.SourceDescriptions[i].EMAIL = Value 116: elif SDES_Item == 4: 117: self.SourceDescriptions[i].PHONE = Value 118: elif SDES_Item == 5: 119: self.SourceDescriptions[i].LOC = Value 120: elif SDES_Item == 6: 121: self.SourceDescriptions[i].TOOL = Value 122: elif SDES_Item == 7: 123: self.SourceDescriptions[i].NOTE = Value 124: elif SDES_Item == 8: 125: self.SourceDescriptions[i].PRIV = Value 126: # Extra parsing for PRIV is needed 127: elif SDES_Item == 0: 128: # End of list. Padding to 32 bits 129: while (off % 4): 130: off += 1 131: # BYE Packet 132: elif PacketType == 203: 133: SSRCCount = Ver_P_RC & 0b00011111 134: i = 0 135: for i in range(SSRCCount): 136: SSRC, = unpack('!I', self.Datagram[off: off + 4]) 137: off += 4 138: print 'SDES: SSRC ' + str(SSRC) + ' is saying goodbye.' 139: # Application specific packet 140: elif PacketType == 204: 141: Subtype = Ver_P_RC & 0b00011111 142: SSRC, = unpack('!I', self.Datagram[off: off + 4]) 143: Name = self.Datagram[off + 4: off + 8] 144: AppData = self.Datagram[off + 8: off + Length] 145: print 'SDES: APP Packet "' + Name + '" from SSRC ' + str(SSRC) + '.' 146: off += Length 147: # Check if there is something else in the datagram 148: if self.Datagram[off:]: 149: self.Datagram = self.Datagram[off:] 150: self.parse() 151: 152: def generateRR(self): 153: # Ver 2, Pad 0, RC 1 154: Ver_P_RC = 0b10000001 155: # PT 201, Length 7, SSRC 0xF00F - let it be our ID 156: Header = pack('!BBHI', Ver_P_RC, 201, 7, 0x0000F00F) 157: NTP_32 = (self.NTP_TimestampH & 0x0000FFFF) + ((self.NTP_TimestampL & 0xFFFF0000) >> 16) 158: # No lost packets, no delay in receiving data, RR sent right after receiving SR 159: # Instead of self.SenderPacketCount should be proper value 160: ReceiverReport = pack('!IBBHIIII', self.SSRC_sender, 0, 0, 0, self.SenderPacketCount, 1, NTP_32, 1) 161: return Header + ReceiverReport

आरएफसी के अनुसार पार्सिंग सख्ती से की जाती है। मैं unpackडेटा को संख्यात्मक चर में बदलने के लिए एक फ़ंक्शन का उपयोग करता हूं, मैं उस डेटा सरणी के माध्यम से एक चर का उपयोग करता हूं offजिसमें वर्तमान ऑफसेट होता है।

और यहाँ लिंक है: आरटीएसपी क्लाइंट पर अजगर एमजेपीईजी ।

रूसी टिप्पणियों के साथ लिस्टिंग का एक संस्करण बनाना अब संभव नहीं था, इसलिए अगर किसी के लिए सुविधाजनक नहीं है तो मुझे माफ़ करें।

पढ़ने के लिए उपयोगी

इस लेख के अंत में, और जिसने महारत हासिल की - अच्छी तरह से किया!

नेटवर्क कैमरों से वीडियो कैप्चर करना, भाग 2

RTSP क्या है?

RTSP संचार उदाहरण

MJPEG RTP पर

आरटीएसपी क्लाइंट पर अजगर एमजेपीईजी

पढ़ने के लिए उपयोगी

More articles: