क्या मैं कैमरा मॉड्यूल के साथ रास्पबेरी पाई पर 24 घंटे का वीडियो रिकॉर्ड कर सकता हूं?

Question

यह देखते हुए कि मेरे पास पर्याप्त क्षमता वाला एसडी कार्ड है, क्या सैद्धांतिक रूप से कैमरा मॉड्यूल के साथ 24 घंटे का वीडियो रिकॉर्ड करना संभव है या रिकॉर्डिंग अवधि सीमित है? क्या किसी ने यह कोशिश की है?

क्या आपको लगता है कि 360p रिकॉर्डिंग की गुणवत्ता पर 64GB पर्याप्त है?

Answer 1

मुझे स्वीकार करना चाहिए कि मुझे रास्पिड के स्टॉक बिल्ड में 2Gb सीमा (लाइनस के उत्तर में उल्लिखित) के बारे में पता नहीं था। एक विकल्प (यदि आप उपयोगकर्ता को पुन: जमा नहीं करते हैं) तो पिकमेरा का उपयोग करना होगा (पायथन बॉक्स से बाहर 64-बिट फ़ाइल पॉइंटर्स का समर्थन करता है)। उदाहरण के लिए, निम्नलिखित को 24 घंटे में खुशी से चौड़ी स्क्रीन वाला 360 पी वीडियो रिकॉर्ड करना चाहिए:

import picamera

with picamera.PiCamera() as camera:
    camera.resolution = (640, 360)
    camera.framerate = 24
    camera.start_recording('one_day.h264')
    camera.wait_recording(24 * 60 * 60)
    camera.stop_recording()

सवाल का अगला हिस्सा यह है कि क्या यह 64 जीबी एसडी कार्ड पर फिट होगा। मेरा कूबड़ "शायद" है, लेकिन चलो सत्यापित करें कि ...

पाई के एच .264 एनकोडर को bitrateपिकमेरा के स्टार्ट_रेकोडिंग विधि में पैरामीटर के साथ या रास्पिड में पैरामीटर के साथ एक बिटरेट सीमा दी जा सकती है --bitrate। Raspivid और picamera दोनों में यह चूक 17Mbps (प्रति सेकंड मेगाबिट) है, इसलिए सैद्धांतिक रूप से डिफ़ॉल्ट सेटिंग के साथ रिकॉर्ड किया गया 24 घंटे का वीडियो इससे बड़ा नहीं हो सकता है:

  24         hours
* 60         minutes per hour
* 60         seconds per minute
* 17000000   bits per second
/ 8          bits per byte
/ 1073741824 bytes per gig
  ----------
  170.990825 Gb

हम्म ... कि मैं उम्मीद कर रहा था की तुलना में बड़ा है, लेकिन ठीक है। ध्यान में रखने वाली एक बात यह है कि 17Mbps की डिफ़ॉल्ट डिफ़ॉल्ट रिकॉर्डिंग रिज़ॉल्यूशन पर उपयोगी होती है, जो कि रास्पिविड के मामले में पूर्ण 1080p है (हालांकि पिकमालेरा डिस्प्ले रिज़ॉल्यूशन के लिए डिफ़ॉल्ट है या इसके प्रदर्शन में 720p नहीं है। लग रहा था "मैत्रीपूर्ण" जब मैंने इसे लिखा था)। यदि आप केवल 360 पी पर रिकॉर्डिंग कर रहे हैं, तो आप शायद बहुत कम बिटरेट सीमा के साथ दूर हो सकते हैं।

दूसरी बात को ध्यान में रखना है कि बिटरेट सीमा बस एक ऊपरी सीमा है। यदि एनकोडर को गति के एक सेकंड के मूल्य का एक अच्छा पर्याप्त प्रतिनिधित्व बनाने के लिए सभी 17 मिलियन बिट्स की आवश्यकता नहीं है, तो यह कई का उपयोग नहीं करेगा। एन्कोडर की मात्रा का ठहराव (जो qualityपिकामेरा में पैरामीटर है, और)--qpraspivid में पैरामीटर) हम एन्कोडर के विचार को समायोजित कर सकते हैं कि "अच्छा पर्याप्त" का क्या मतलब है। गुणवत्ता को 0 और 40 के बीच के मान से दर्शाया जाता है। निचले मूल्यों का मतलब बेहतर गुणवत्ता है, इसलिए 1 पागलपन अच्छी है, और 40 हास्यास्पद बुरी है। विशिष्ट "अच्छा पर्याप्त" मान लगभग 20-25 हैं। मान 0 (जो डिफ़ॉल्ट भी है) विशेष प्रतीत होता है; मुझे यकीन नहीं है कि एनकोडर के लिए इसका क्या मतलब है (आपको फर्मवेयर देवियों से पूछना होगा), लेकिन यह 15-20 के आसपास (यानी बहुत अच्छा) मूल्यों के समान गुणवत्ता पैदा करता है।

तो, औसत गुणवत्ता मानकर (मान लें कि 20), वाइड-स्क्रीन 360p वीडियो रिकॉर्ड करने के लिए हमें किस प्रकार की बिटरेट की आवश्यकता है? मैंने 30 सेकंड के वीडियो को रिकॉर्ड करने के लिए दो बार रास्पिविड कमांड लाइन चलाई, फिर पहली रिकॉर्डिंग कैमरे के चारों ओर लहराते हुए बिताई (इस धारणा के तहत कि अधिक गति का मतलब अधिक बैंडविड्थ की आवश्यकता है, और हम यहां सीमाओं का परीक्षण करना चाहते हैं), और दूसरा बिल्कुल स्थिर दृश्य के साथ:

raspivid --width 640 --height 360 --framerate 24 --bitrate 17000000 --qp 20 --timeout 30000 --output test.h264

परिणामी फाइलें क्रमशः आकार में 673675 बाइट्स (658Kb) और 2804555 बाइट्स (2.7Mb) थीं, इसलिए एनकोडर द्वारा उत्पादित बिट्रेट थे:

  673675   bytes
* 8        bits per byte
/ 30       seconds
  --------
  179646.6 bits per second (static scene)

  2804555  bytes
* 8        bits per byte
/ 30       seconds
  --------
  747881.3 bits per second (full motion scene)

इसलिए, ऊपर दिए गए समीकरण में उन मानों को जोड़ते हुए, हम वास्तविक रूप से 24 घंटे के वीडियो की उम्मीद कर सकते हैं, समान सेटिंग्स का उपयोग करके 1.8Gb और 7.5Gb के बीच कहीं आकार में आ सकते हैं। हम यह सुनिश्चित कर सकते हैं कि यह निश्चित रूप से इससे बड़ा नहीं होगा कि 750000 जैसी किसी चीज़ के लिए बिटरेट सेट करके जिसे हम जानते हैं कि एनकोडर को हमारी वांछित गुणवत्ता (20) पर गति को पुन: पेश करने के लिए पर्याप्त जगह मिलेगी, या आप निम्न गुणों के साथ प्रयोग कर सकते हैं (जैसे 25 ) यह देखने के लिए कि क्या वे स्वीकार्य होंगे, और फिर तदनुसार बिटरेट सीमा को कम कर देंगे। उस ने कहा, यह ध्यान में रखने योग्य है कि आप फ़ाइल के साथ 2Gb को तोड़ने की संभावना रखते हैं, इसलिए जैसा कि ऊपर उल्लेख किया गया है कि आप 64-बिट फ़ाइल पॉइंटर मुद्दे में चलने की संभावना रखते हैं जब तक कि आप पायथन या रेम्पाइल उपयोगकर्ता का उपयोग न करें।

संदर्भ के लिए, यहां ऊपर दी गई पायथन लिपि में अभी चर्चा की गई सीमाओं को शामिल करने के लिए संशोधित किया गया है:

import picamera

with picamera.PiCamera() as camera:
    camera.resolution = (640, 360)
    camera.framerate = 24
    camera.start_recording('one_day.h264', quality=20, bitrate=750000)
    camera.wait_recording(24 * 60 * 60)
    camera.stop_recording()

अंत में, सिर्फ गोल्डिलॉक्स की टिप्पणी 'लिनुस पर टिप्पणी' का जवाब देने के लिए: वीडियो फ़ाइल को कई भागों में विभाजित करना काफी आसान है (और आसानी से किसी भी 64-बिट फ़ाइल पॉइंटर चिंताओं को कम कर देगा)। Raspivid के साथ, आप यह --segmentनिर्दिष्ट करने के लिए पैरामीटर का उपयोग कर सकते हैं कि प्रत्येक n मिलीसेकंड में एक नई फ़ाइल खोली जानी चाहिए , उदाहरण के लिए प्रत्येक घंटे के लिए एक फ़ाइल रिकॉर्ड करने के लिए ( %02dफ़ाइल नाम में नंबर के लिए प्रतिस्थापित किया जाएगा, जैसे 01, 02, 03, ।। ।):

raspivid --width 640 --height 360 --framerate 24 --bitrate 750000 --qp 20 --timeout $((24*60*60*1000)) --segment $((1*60*60*1000)) --output hour%02d.h264

वैकल्पिक रूप से, पिकमेरा के साथ आप समय के आधार पर विभाजित करने के लिए record_fterence विधि का उपयोग कर सकते हैं :

import picamera

with picamera.PiCamera() as camera:
    camera.resolution = (640, 360)
    camera.framerate = 24
    for filename in camera.record_sequence([
            'hour%02d.h264' % (h + 1)
            for h in range(24)
            ], quality=20, bitrate=750000):
        camera.wait_recording(60 * 60)

या फ़ाइल-आकार पर आधारित है। नीचे दिए गए उदाहरण में, मैंने इसे प्रत्येक पहुंच> 1 एमबी पर एक बार 100 से अधिक फाइलों को रोल करने के लिए सेट किया है, और आउटपुट इटरेटर को अपने स्वयं के फ़ंक्शन में रखा है, यह प्रदर्शित करने के लिए कि अनंत पुनरावृत्तियों का उपयोग करना संभव record_sequenceहै:

import io
import itertools
import picamera

def outputs():
    for i in itertools.count(1):
        yield io.open('file%02d.h264' % i, 'wb')

with picamera.PiCamera() as camera:
    camera.resolution = (640, 360)
    camera.framerate = 24
    for output in camera.record_sequence(
            outputs(), quality=20, bitrate=750000):
        while output.tell() < 1048576:
            camera.wait_recording(0.1)
        if output.name == 'file99.h264':
            break

या ... ठीक है, आप जिस भी सीमा के लिए कोड सोच सकते हैं!

Comments

+1 मैंने सिंटैक्स हाइलाइटिंग को शामिल करने के लिए आपके अन्यथा शानदार उत्तर को संपादित किया है।

— Jacobm001

आह, धन्यवाद - मुझे शायद कुछ बिंदु पर एसओ के एमडी संस्करण का थोड़ा और अधिक सीखना चाहिए ...

— डेव जोन्स

Answer 2

यदि आप रिकॉर्ड करने के लिए raspivid का उपयोग कर रहे हैं, तो यह "संभव" है, बड़ी फ़ाइलों का समर्थन करने के लिए एक पैच है, जहां आकार> 2 जीबी ( -D_FILE_OFFSET_BITS=64gcc को आपूर्ति किए गए झंडे में आवश्यक है)। हालाँकि आपको उपयोगकर्ता के स्रोत को स्वयं द्वारा संकलित करने की आवश्यकता है ।

हालांकि यह ध्यान दिया जाना चाहिए, आपको बहुत सावधान रहना चाहिए, क्योंकि यदि आप लिनक्स पर सिस्टम विभाजन को भरते हैं, तो बहुत बुरा व्यवहार हो सकता है। इसलिए आपको अपने लंबे वीडियो के लिए एक अलग पार्टीशन बनाना चाहिए।

यदि आपके पास फ़ाइल आकार की समस्या है, तो बिट-रेट को कम करना भी एक अच्छा विचार हो सकता है।

Comments

यदि यह स्वीकार्य है, तो आप cronवर्तमान raspividप्रक्रिया को रोकने के लिए एक रुक-रुक कर स्क्रिप्ट (जैसे के माध्यम से ) चला सकते हैं , आउटपुट फ़ाइल को रोलओवर कर सकते हैं, और इसे फिर से शुरू कर सकते हैं, जैसे कि आप समय की विशिष्ट स्लाइस का प्रतिनिधित्व करने वाली छोटी फ़ाइलों की एक श्रृंखला के साथ समाप्त होते हैं।

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