एक साथ कैमरे से रिकॉर्ड और स्ट्रीम वीडियो

Question

मैं पिआमेरा के साथ कैमरा मॉड्यूल का उपयोग करके पाई से वीडियो रिकॉर्ड कर रहा हूं:

import picamera

with picamera.PiCamera() as camera:
    camera.resolution = (640, 480)
    camera.start_recording('1.h264')
    camera.wait_recording(5)
    for i in range(2, 11):
        camera.split_recording('%d.h264' % i)
        camera.wait_recording(5)
    camera.stop_recording()

मैं अलग से एक संयोजन का इस्तेमाल किया है raspividऔर gstreamerबिना किसी देरी के अनुकरणीय से स्ट्रीम वीडियो करने के लिए। वहाँ एक साथ अजगर का उपयोग कर फुटेज को स्टोर और स्ट्रीम करने का एक तरीका है ?

मेरी सोच यह है कि कैमरा को इनपुट के रूप में उपयोग करने और दो आउटपुट स्रोत बनाने का एक तरीका होना चाहिए: भंडारण के लिए एक 720p वीडियो और gstreamer का उपयोग करके स्ट्रीमिंग के लिए एक 240s वीडियो डाउन ...?

Comments

आप पाइप रहे हैं, तो raspividआप कर सकता है teeएक फाइल करने के लिए उत्पादन और gstreamer या जो कुछ भी (देखें man tee)। जब तक एक धारा डिस्क पर सीधी होती है, तब तक यह बहुत अधिक ओवरहेड नहीं करेगा, लेकिन अगर आप इनपुट को दो अलग-अलग प्रारूपों में संसाधित करना चाहते हैं तो मुझे लगता है कि पीआई को संभालने के लिए बहुत अधिक काम होगा।

— गोल्डीलॉक्स

आप कृपया कोड में एक उदाहरण पोस्ट कर सकते हैं?

— कोगी

Answer 1

teeआदेश डिफ़ॉल्ट रूप से फ़ाइलें प्लस मानक आउटपुट के किसी भी संख्या के लिए मानक इनपुट और प्रतियां से पढ़ता है, को देखने के man teeअधिक जानकारी के लिए। इसका मतलब है कि आप टी को इनपुट से फाइल बनाने के लिए कह सकते हैं और फिर आउटपुट को किसी और चीज में पाइप कर सकते हैं।

एक अतिरिक्त पाइप के अलावा सिद्धांत में थोड़ी अक्षमता है। जैसे कि यह महत्वपूर्ण है या नहीं, आपको अपनी स्वयं की स्ट्रीमिंग पद्धति का उपयोग करके खुद के लिए न्याय करना होगा। मेरा वर्तमान तरीका पूर्ण संकल्प पर संतोषजनक नहीं है। यह अभी बहुत बड़ा हित नहीं है, लेकिन जब मैं यह करूँगा तो कुछ बेहतर खोजने की कोशिश करूँगा (जैसे कि माना जाता है कि gstreamer क्लिम्ब से बेहतर काम करता है)।

हालांकि, यह ध्यान देने योग्य है कि एक ही समय में पीआई पर स्थानीय रूप से सहेजी गई फ़ाइल सही गुणवत्ता है, इसलिए गतिविधि रास्पिड के साथ हस्तक्षेप नहीं करती है। यहाँ एक उदाहरण है:

raspivid -o - -t 0 | tee test_video.h264 |
cvlc -v stream:///dev/stdin --sout '#standard{access=http,mux=ts,dest=:8080' :demux=h264

मैंने इसे पठनीयता के लिए दो लाइनों में तोड़ दिया; आप |(पाइप) के बाद वापसी को हिट कर सकते हैं और कमांड खत्म कर सकते हैं जैसे आप एक लाइन को तोड़ सकते हैं \। आप cvlcजो चाहें उससे बदल सकते हैं। फिर, हालांकि धारा खराब गुणवत्ता की थी, test_video.h264एकदम सही निकली।

यदि मैं 640x360 तक रिज़ॉल्यूशन कम करता हूं, तो यह व्यवस्था ठीक है, एक या दो बार विलंबता के साथ जो मुझे सामान्य रूप से मिलता है। मुझे नहीं लगता कि teeया दूसरा पाइप स्ट्रीम की गुणवत्ता पर कोई फर्क पड़ता है; ये यहां आवश्यकता से अधिक उच्च थ्रूपुट के लिए सक्षम हैं और सिस्टम संसाधनों के रास्ते में बहुत अधिक आवश्यकता नहीं है।

सीपीयू 35-45% पर चला गया, जो कि वैसा ही है जैसा वीडियो स्ट्रीमिंग के दौरान होता है tee।

Comments

आपके पोस्ट के लिए शुक्रिया। जैसा कि मैं अपनी स्क्रिप्ट के भीतर ऐसा करना चाहता हूं, मैं PiCamera 1.9 एपीआई देख रहा हूं और एक विधि है record_sequenceजो एक splitter_portपैरामीटर लेती है । कैमरे से 4 एक साथ आउटपुट तक रिकॉर्डिंग का एक उदाहरण भी है।

— कोजी

मैं एक घंटे में एक 240p स्ट्रीम और स्टोरेज के लिए 720p वीडियो रिकॉर्ड करने के लिए एक साथ बांधने के साथ संघर्ष कर रहा हूं जो हर घंटे विभाजित होता है लेकिन मुझे लगता है कि यह एक आशाजनक दिशा है।

— कोगी

Answer 2

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

#!/usr/bin/env python

import io
import picamera
import socket


# An output (as far as picamera is concerned), is just a filename or an object
# which implements a write() method (and optionally the flush() and close()
# methods)
class MyOutput(object):
    def __init__(self, filename, sock):
        self.output_file = io.open(filename, 'wb')
        self.output_sock = sock.makefile('wb')

    def write(self, buf):
        self.output_file.write(buf)
        self.output_sock.write(buf)

    def flush(self):
        self.output_file.flush()
        self.output_sock.flush()

    def close(self):
        self.output_file.close()
        self.output_sock.close()


# Connect a socket to a remote server on port 8000
sock = socket.socket()
sock.connect(('my_server', 8000))

with picamera.PiCamera() as camera:
    camera.resolution = (640, 480)
    camera.framerate = 24

    # Construct an instance of our custom output splitter with a filename
    # and a connected socket
    my_output = MyOutput('output.h264', sock)

    # Record video to the custom output (we need to specify the format as
    # the custom output doesn't pretend to be a file with a filename)
    camera.start_recording(my_output, format='h264')
    camera.wait_recording(30)
    camera.stop_recording()