रीयल-टाइम स्ट्रीम

रीयल-टाइम टाइमस्टैंप

MediaPipe कैल्क्यूलेटर ग्राफ़ का इस्तेमाल अक्सर वीडियो या ऑडियो की स्ट्रीम को प्रोसेस करने के लिए किया जाता है इंटरैक्टिव ऐप्लिकेशन के लिए फ़्रेम इस्तेमाल करती हैं. MediaPipe फ़्रेमवर्क के लिए आवश्यक है कि क्रम में लगे पैकेट को, एक क्रम में बढ़ते हुए टाइमस्टैंप असाइन किए जा सकते हैं. इन्होंने बदलाव किया है कन्वेंशन, रीयल-टाइम कैलकुलेटर और ग्राफ़, रिकॉर्डिंग समय या हर फ़्रेम के प्रज़ेंटेशन का समय, उसके टाइमस्टैंप के तौर पर दिखता है. हर टाइमस्टैंप से यह पता चलता है कि Jan/1/1970:00:00:00 के बाद से माइक्रोसेकंड. इसकी मदद से, अलग-अलग सोर्स को दुनिया भर में एक क्रम में प्रोसेस करना होगा.

रीयल-टाइम शेड्यूलिंग

आम तौर पर, किसी दिए गए कैलकुलेटर के लिए, हर कैलकुलेटर अपने सभी इनपुट पैकेट के साथ जल्द से जल्द चलता है टाइमस्टैंप उपलब्ध होगा. आम तौर पर, ऐसा तब होता है, जब कैलकुलेटर में पिछले फ़्रेम को प्रोसेस कर चुका है और हर एक कैलकुलेटर को प्रोसेस कर रहा है इसके इनपुट ने मौजूदा फ़्रेम की प्रोसेस पूरी कर ली है. MediaPipe शेड्यूलर ये शर्तें पूरी होते ही हर कैलकुलेटर को शुरू करता है. यहां जाएं: ज़्यादा जानकारी के लिए, सिंक करने की सुविधा.

टाइमस्टैंप की सीमाएं

जब कोई कैलकुलेटर किसी दिए गए टाइमस्टैंप के लिए कोई आउटपुट पैकेट नहीं बनाता, तो वह इसके बजाय एक "टाइमस्टैंप बाउंड" आउटपुट कर सकता है यह बताता है कि कोई पैकेट उस टाइमस्टैंप के लिए दिखाया गया. डाउनस्ट्रीम को अनुमति देने के लिए, यह सिग्नल देना ज़रूरी है कैलकुलेटर उस टाइमस्टैंप पर चलाए जा सकते हैं, भले ही उस टाइमस्टैंप के लिए कुछ स्ट्रीम. रीयल-टाइम रिपोर्ट के लिए यह खास तौर पर ज़रूरी है इंटरैक्टिव ऐप्लिकेशन में ग्राफ़ बनाना, जहां यह ज़रूरी है कि हर कैलकुलेटर जितनी जल्दी हो सके प्रोसेस शुरू कर दें.

इस तरह का ग्राफ़ देखें:

node {
   calculator: "A"
   input_stream: "alpha_in"
   output_stream: "alpha"
}
node {
   calculator: "B"
   input_stream: "alpha"
   input_stream: "foo"
   output_stream: "beta"
}

मान लीजिए: टाइमस्टैंप T पर, A नोड अपनी आउटपुट स्ट्रीम में कोई पैकेट नहीं भेजता है alpha. नोड B को foo में एक पैकेट मिलता है, जो T टाइमस्टैंप पर होता है T टाइमस्टैंप पर alpha में पैकेट. अगर A, B को नहीं भेजता है, तो टाइमस्टैंप की अवधि alpha के लिए अपडेट, B alpha में एक पैकेट आने का इंतज़ार करता रहेगा. इस दौरान, foo की पैकेट सूची में पैकेट देख लेने के लिए, T, T+1, और इसी तरह.

स्ट्रीम पर पैकेट चलाने के लिए, कैलकुलेटर एपीआई फ़ंक्शन का इस्तेमाल करता है CalculatorContext::Outputs और OutputStream::Add. इसके बजाय, किसी स्ट्रीम के लिए टाइमस्टैंप बाउंड, कैलकुलेटर एपीआई फ़ंक्शन का इस्तेमाल कर सकता है CalculatorContext::Outputs और CalculatorContext::SetNextTimestampBound. कॉन्टेंट बनाने तय की गई बाउंड, तय की गई आउटपुट स्ट्रीम. जब कोई पैकेट आउटपुट नहीं होता है, तो आम तौर पर एक कैलकुलेटर कुछ ऐसा करें:

cc->Outputs().Tag("output_frame").SetNextTimestampBound(
  cc->InputTimestamp().NextAllowedInStream());

Timestamp::NextAllowedInStream फ़ंक्शन, लगातार आने वाला टाइमस्टैंप दिखाता है. उदाहरण के लिए, Timestamp(1).NextAllowedInStream() == Timestamp(2).

टाइमस्टैंप की सीमाओं को लागू किया जा रहा है

रीयल-टाइम ग्राफ़ में इस्तेमाल किए जाने वाले कैलकुलेटर का आउटपुट तय करना होगा डाउनस्ट्रीम को अनुमति देने के लिए, इनपुट टाइमस्टैंप की सीमाओं पर आधारित टाइमस्टैंप की सीमाएं कैलकुलेटर तुरंत शेड्यूल किए जा सकते हैं. कैलकुलेटर का सामान्य पैटर्न ये होता है: आउटपुट पैकेट, जिनके टाइमस्टैंप और इनपुट पैकेट एक जैसे हों. इस मामले में, Calculator::Process को किए जाने वाले हर कॉल के लिए सिर्फ़ एक पैकेट देना काफ़ी होता है का इस्तेमाल करें.

हालांकि, आउटपुट के लिए कैलकुलेटर को इस सामान्य पैटर्न का पालन करने की ज़रूरत नहीं होती है टाइमस्टैंप के हिसाब से, उन्हें सिर्फ़ एक क्रम में बढ़ाए गए आउटपुट को चुनने की ज़रूरत होती है. टाइमस्टैंप. इस वजह से, कुछ कैलकुलेटर को टाइमस्टैंप की सीमाओं का हिसाब लगाना चाहिए साफ़ तौर पर बताया गया है. MediaPipe, सही टाइमस्टैंप की गिनती करने के लिए कई टूल उपलब्ध कराता है प्रत्येक कैलकुलेटर के लिए सीमित.

1. SetNextTimestampBound() का इस्तेमाल, किसी आउटपुट स्ट्रीम के लिए टाइमस्टैंप बाउंड, t + 1 की जानकारी देने के लिए किया जा सकता है.

cc->Outputs.Tag("OUT").SetNextTimestampBound(t.NextAllowedInStream());

इसके अलावा, टाइमस्टैंप t के साथ एक खाली पैकेट दिया जा सकता है, ताकि यह बताया जा सके कि टाइमस्टैंप की सीमा t + 1.

cc->Outputs.Tag("OUT").Add(Packet(), t);

इनपुट स्ट्रीम के टाइमस्टैंप की सीमा को पैकेट या खाली बॉक्स से दिखाया जाता है पैकेट पर डालें.

Timestamp bound = cc->Inputs().Tag("IN").Value().Timestamp();

2. TimestampOffset() को, अपने-आप कॉपी करने के लिए तय किया जा सकता है इनपुट स्ट्रीम से आउटपुट स्ट्रीम तक का टाइमस्टैंप.

cc->SetTimestampOffset(0);

इस सेटिंग का इस्तेमाल करके, टाइमस्टैंप की सीमाओं को अपने-आप लागू किया जा सकता है. तब भी जब सिर्फ़ टाइमस्टैंप की सीमाएं आएं और Calculator::प्रोसेस शुरू न हो.

3. शुरू करने के लिए, ProcessTimestampBounds() को तय किया जा सकता है हर नए "सेट किए गए टाइमस्टैंप" के लिए Calculator::Process, जहां "सेट किया गया" टाइमस्टैंप" टाइमस्टैंप की मौजूदा सीमाओं के नीचे, नया सबसे ज़्यादा टाइमस्टैंप है. ProcessTimestampBounds() के बिना, Calculator::Process को सिर्फ़ इसके साथ शुरू किया जाता है एक या एक से ज़्यादा आने वाले पैकेट.

cc->SetProcessTimestampBounds(true);

इस सेटिंग की मदद से, कैलकुलेटर अपनी टाइमस्टैंप सीमाओं का कैलकुलेशन खुद करता है सिर्फ़ इनपुट के टाइमस्टैंप अपडेट किए जाने पर भी ये बदलाव लागू होते हैं. इसका इस्तेमाल इन कामों के लिए किया जा सकता है TimestampOffset() के इफ़ेक्ट को कॉपी करें, लेकिन इसका इस्तेमाल इन कामों के लिए भी किया जा सकता है अतिरिक्त फ़ैक्टर को ध्यान में रखते हुए टाइमस्टैंप की सीमा का हिसाब लगाता है.

उदाहरण के लिए, SetTimestampOffset(0) को कॉपी करने के लिए, कैलकुलेटर ये काम करें:

absl::Status Open(CalculatorContext* cc) {
  cc->SetProcessTimestampBounds(true);
}

absl::Status Process(CalculatorContext* cc) {
  cc->Outputs.Tag("OUT").SetNextTimestampBound(
      cc->InputTimestamp().NextAllowedInStream());
}

कैल्क्यूलेटर::खोलें और Calculator::बंद करें

सभी ज़रूरी इनपुट साइड-पैकेट का इस्तेमाल करने के बाद, Calculator::Open शुरू हो जाता है बनाया गया. इनपुट साइड-पैकेट, पास में इस्तेमाल होने वाले ऐप्लिकेशन में दिए जा सकते हैं या इसके ज़रिए दिए जा सकते हैं "साइड-पैकेट कैलकुलेटर" पर क्लिक करें. साइड-पैकेट की जानकारी यहां दी जा सकती है के CalculatorGraph::Initialize का इस्तेमाल करके ग्राफ़ के बाहर और CalculatorGraph::StartRun. साइड पैकेट के लिए कैलकुलेटर की सुविधा का इस्तेमाल किया जा सकता है ग्राफ़ CalculatorGraphConfig::OutputSidePackets और OutputSidePacket::Set.

कैलकुलेटर::बंद करने का विकल्प तब इस्तेमाल होता है, जब सभी इनपुट स्ट्रीम Done हो जाती हैं बंद किया जा रहा हो या टाइमस्टैंप की सीमा Timestamp::Done तक पहुंच रहा हो.

ध्यान दें: अगर ग्राफ़, कैलकुलेटर को एक्ज़ीक्यूट करने की सभी प्रोसेस पूरी कर लेता है और Done, कुछ स्ट्रीम के Done होने से पहले, MediaPipe Calculator::Close के लिए बची हुई कॉल, ताकि हर कैलकुलेटर अपना आखिरी आउटपुट.

TimestampOffset के इस्तेमाल का Calculator::Close पर कुछ असर पड़ता है. ऐप्लिकेशन SetTimestampOffset(0) को तय करने वाला कैल्क्यूलेटर सभी इनपुट स्ट्रीम होने पर, इसकी आउटपुट स्ट्रीम Timestamp::Done तक पहुंच गई है Timestamp::Done तक पहुँच गई हैं. इसलिए, आगे कोई नतीजा नहीं मिलेगा. यह ऐसे कैलकुलेटर को डेटा के बीच में कोई पैकेट निकलने से रोकता है Calculator::Close. अगर कैलकुलेटर को Calculator::Close, Calculator::Process के लिए टाइमस्टैंप की सीमाएं ऐसी होनी चाहिए के दौरान कम से कम एक टाइमस्टैंप (जैसे कि Timestamp::Max) उपलब्ध रहेगा Calculator::Close. इसका मतलब है कि आम तौर पर इस तरह के कैलकुलेटर पर भरोसा नहीं किया जा सकता SetTimestampOffset(0) और इसके बजाय आपको टाइमस्टैंप की सीमाओं को साफ़ तौर पर बताना होगा SetNextTimestampBounds() का इस्तेमाल करके.