Захват видео с сетевых камер, часть 1 / Хабр

Сетевые видеокамеры постепенно вытесняют аналоговые, хоть и стоят они сейчас гораздо дороже. Сетевые обладают рядом очевидных приемуществ:

нет необходимости в отдельном регистраторе или плате захвата;
помехоустойчивость;
простая интеграция в существующую сеть;
нет ограничения по расстоянию;
наличие камер высокого разрешения;
просмотр камеры прямо с самой камеры по http;
наличие всевозможных настроек;
и др.

Нас интересует способ получения изображений с таких камер, для этого надо знать а как вообще они их передают? На наше счастье камеры используют существующие стандарты, а не то, что взбредёт в голову китайскому разработчику. Подавляющее большинство камер используют один или несколько способов передачи видео, это в основном Motion JPEG по HTTP, Motion JPEG по RTSP или H264 по RTSP. Также многие камеры могут передавать звук, но он нас не интересует сейчас.

В этой статье я рассмотрю эти способы передачи изображений с сетевых камер, а также приведу пример захвата таких изображений всё на том же Python'е.

MJPEG over HTTP

Самый простой способ передачи картинки — это MJPEG по HTTP. В этом случае кадры отдаются готовыми JPEG файлами через специальные разделители. Для таких случаев был разработан специальный MIME тип multipart. У него есть несколько подтипов, нас интересуют mixed и x-mixed-replace. Отличий между ними практически нет, мы их будем обрабатывать абсолютно одинаково. Отличие у них смысловое: mixed указывает просто на документ, состоящий из нескольких частей, эти части могут быть независимыми или могут объединяться; а тип x-mixed-replace прямо указывает, что каждая следующая часть должна заменять собой предыдущую и обрабатываться должны как обновление какого-то представления. Буква «x» вначале названия указывает на то, что этот тип является экспериментальным, но тем не менее он во всю используется.

В HTTP заголовке тип MIME указывается в Content-Type параметре:

Content-Type: multipart/mixed; boundary="some_boundary"

или

Content-Type: multipart/x-mixed-replace; boundary=other_boundary

У этих типов есть обязательный параметр boundary, который указывает каким текстом разделяются части документа. К разделителю также добавляются два дефиса в его начало. Важно чтобы этот разделитель не встречался в самом сообщении, если не указывается его размер в Content-Size.

Чтобы понять структуру передачи MJPEG по HTTP достаточно взглянуть на следующий пример:

HTTP/1.0 200 OK
Connection: close
Server: MJPG-Streamer/0.2
Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0
Pragma: no-cache
Expires: Mon, 3 Jan 2000 12:34:56 GMT
Content-Type: multipart/x-mixed-replace;boundary=boundarydonotcross

--boundarydonotcross
Content-Type: image/jpeg
Content-Length: 23950
X-Timestamp: 0.000000

%Binary JPEG%
--boundarydonotcross
Content-Type: image/jpeg
Content-Length: 24756
X-Timestamp: 0.000000

%Binary JPEG%
--boundarydonotcross
Content-Type: image/jpeg
Content-Length: 23950
X-Timestamp: 0.000000

%Binary JPEG%

Для анализа того, как ваша сетевая камера передаёт изображения, можно воспользоваться либо снифером (я пользуюсь WireShark), либо подключиться к камере через telnet, например так:

$ telnet 192.168.0.50 80
Trying 192.168.0.50..
Connected to 192.168.0.50.
Escape character is '^]'.
GET /jpeg HTTP/1.1

После строки GET нужно ещё отправить одну пустую строку для индикации того, что ваш заголовок закончился. А вместо "/jpeg" нужно написать тот запрос, по которому ваша камера отдаёт MJPEG.

В приведённом выше примере %Binary JPEG% соответствует интересующей нас информации — JPEG изображению. Его-то нам и нужно выделить из потока.

Как видно вначале идёт стандартный HTTP заголовок с описанием документа. Connection может быть как close, так и keep-alive, в нашем случае это не играет роли. Из заголовка нам всего навсего нужно две строчки: первая со статусом 200 OK, которая говорит нам, что всё хорошо, сейчас вылетит птичка; и Content-Type для определения параметра boundary.

После HTTP заголовка (после пустой строки) идёт тело передаваемого документа, состоящего из множества частей. Каждая часть начинается с разделителя, имеет свой собственный заголовок и своё тело документа после пустой строки. Content-Type: image/jpeg указывает нам, что мы действительно получаем JPEG изображения, Content-Length на размер текущего кадра в байтах (в первой части это 23950 байт), а в X-Timestamp может передаваться временная отметка текущего кадра, можно использовать для этих целей текущее время компьютера в момент приёма кадра, но X-Timestamp будет точнее, так как сеть может оказывать разное влияние на скорость передачи кадров.

Python MJPEG over HTTP Client

Несмотря на простой формат передачи изображений, их приём можно реализовать разными методами. Также играет роль TCP сегментация, а точнее подход к её обработке. Дело в том, что максимальный размер передаваемого сообщения (MTU) по Ethernet не может превышать 1500 байт и данные мы обрабатываем каждый раз когда такой пакет к нам приходит. Если анализировать информацию сраз�� по её приходу, то может случится так, что данные будут не полными и парсер не сможет справится со своей задачей. А если буферизировать поток входящих данных, то это не лучшим образом сказывается на производительности и ресурсоёмкости. Надежнее было бы воспользоваться буферизацией и приступать к анализу только когда уже накоплено достаточно информации (сначала нужно прочитать до '\r\n\r\n', чтобы выделить заголовок, а потом либо до тех пор пока не встретятся два раза в потоке разделители, либо также читать до пустой строки, определять размер изображения и отсчитывать количество байт). Но я воспользовался методом обработки информации сразу по её приходу.

Код клиента состоит из двух файлов: main.py и http_mjpeg_client.py. В первом производится запуск приложения, а во втором реализована работа с камерой. Сразу их и приведу здесь.
main.py

from twisted.internet import reactor
from http_mjpeg_client import MJPEGFactory

def processImage(img):
    'This function is invoked by the MJPEG Client protocol'
    # Process image
    # Just save it as a file in this example
    f = open('frame.jpg', 'wb')
    f.write(img)
    f.close()
    
def main():
    print 'Python M-JPEG Over HTTP Client 0.1'
    # Define connection parameters, login and password are optional.
    config = {'request': '/mjpeg',
              'login': 'admin',
              'password': 'admin',
              'ip': '127.0.0.1',
              'port': 8080,
              'callback': processImage}
    # Make a connection
    reactor.connectTCP(config['ip'], config['port'], MJPEGFactory(config))
    reactor.run()    
    print 'Python M-JPEG Client stopped.'

# this only runs if the module was *not* imported
if __name__ == '__main__':
    main()

http_mjpeg_client.py

from twisted.internet.protocol import Protocol, ClientFactory
from base64 import b64encode
import re

debug = 1

class MJPEGClient(Protocol):
    def __init__(self):
        # A place for configuration parameters
        self.config = {}
        # I we are connected to a web server
        self.isConnected = False
        # The boundary in multipart stream
        self.boundary = ''
        # Actual image data goes here
        self.img = ''
        # Size of the image frame being downloaded
        self.next_img_size = 0
        # Indicates that currently parsing a header
        self.isHeader = False

    def connectionMade(self):
        # Implement basic authorization
        if self.config['login']:
            authstring = 'Authorization: Basic ' + b64encode(self.config['login']+':'+self.config['password']) + '\r\n'
        else:
            authstring = ''
        # Form proper HTTP request with header
        to_send = 'GET ' + self.config['request'] + ' HTTP/1.1\r\n' + \
            authstring + \
            'User-Agent: Python M-JPEG Client\r\n' + \
            'Keep-Alive: 300\r\n' + \
            'Connection: keep-alive\r\n\r\n'
        # Send it
        self.transport.write(to_send)
        if debug:
            print 'We say:\n', to_send
    
    def dataReceived(self, data):
        if debug:
            print 'Server said:\n', len(data), 'bytes of data.'
        if not self.isConnected:
            # Response header goes before empty line
            data_sp = data.strip().split('\r\n\r\n', 1)
            header = data_sp[0].splitlines()
            # Parse header
            for line in header:
                if line.endswith('200 OK'): # Connection went fine
                    self.isConnected = True
                    if debug: print 'Connected'
                if line.startswith('Content-Type: multipart'): # Got multipart
                    r = re.search(r'boundary="?(.*)"?', line)
                    self.boundary = r.group(1) # Extract boundary
                    if debug: print 'Got boundary:', self.boundary
            # If we got more data, find a JPEG there
            if len(data_sp) == 2:
                self.findJPEG(data_sp[1])
        else:
            # If connection is alredy made find a JPEG right away
            self.findJPEG(data)
    
    def findJPEG(self, data):
        hasMoreThanHeader = False
        # If we know next image size, than image header is already parsed
        if not self.next_img_size:
            # Otherwise it should be a header first
            for line in data.splitlines():
                if line == '--'+self.boundary:
                    self.isHeader = True
                    if debug: print 'Got frame header'
                elif line == '':
                    if self.isHeader:
                        # If we might have more data after a header in a buffer
                        hasMoreThanHeader = True
                    self.isHeader = False
                elif self.isHeader:
                    # Here we can parse all the header information
                    # But we are really interested only in one
                    if line.startswith('Content-Length:'):
                        self.next_img_size = int(line.split(' ')[1])
                        if debug: print 'Next frame size:', self.next_img_size
                        
        else:
            # How many bytes left to read
            remains = self.next_img_size - len(self.img)
            self.img += data[:remains]
            # We got the whole image
            if len(self.img) == self.next_img_size:
                if debug: print 'Got a frame!'
                # Run a callback function
                self.config['callback'](self.img)
                # Reset variables
                self.img = ''
                self.next_img_size = 0
            # If something left in a buffer
            if data[remains:]:
                self.findJPEG(data[remains:])
        if hasMoreThanHeader:
            data_sp = data.split('\r\n\r\n', 1)
            # If there is something after a header in a buffer
            if len(data_sp) == 2:
                self.findJPEG(data_sp[1])

    def connectionLost(self, reason):
        print 'Connection lost, reconnecting'
        self.isConnected = False
        self.img = ''
        self.next_img_size = 0
        self.isHeader = 0
        self.boundary = ''

class MJPEGFactory(ClientFactory):
    def __init__(self, config):
        self.protocol = MJPEGClient
        self.config = config

    def buildProtocol(self, addr):
        prot = ClientFactory.buildProtocol(self, addr)
        # Weird way to pass the config parameters to the protocol
        prot.config = self.config
        return prot

    def clientConnectionLost(self, connector, reason):
        # Automatic reconnection
        connector.connect()

В главном файле мы определяем параметры подключения к камере в словаре config, запускаем реактор сетевого фрэймворка Twisted и обрабатываем получаемые изображения в функции processImage(). В этом примере каждый получаемый кадр просто записывается в текущую директорию с именем frame.jpg.

Работоспособность я проверял с помощью MJPEG стримера, запускал я его вот так:
./mjpg_streamer -i "./input_testpicture.so" -o "./output_http.so -w ./www"
При этом request в конфигурации клиента надо указать равным /?action=stream.
Передавать изображения с вебкамеры он у меня отказался.

Я старался хорошо документировать второй файл, чтобы читателю было легче понять как происходит процесс изъятия изображений из потока. На словах алгоритм можно описать следующим образом: при подсоединении к камере первым делом формируем HTTP заголовок с обращением к ней и отсылаем его, это функция connectionMade(). Функция dataReceived() вызывается всякий раз, когда к нам приходят новые данные. В ней мы проверяем установлена ли уже передача JPEG данных или нет. Если ещё нёт, то значит к нам должен прийти HTTP заголовок ответа камеры, мы его выделяем с помощью функции split('\r\n\r\n', 1), затем разбираем его по полочкам, выделяя нужные параметры (статус и boundary). В остальных случаях мы полученные данные сразу передаём функции findJPEG().

В этой функции так же происходит ветвление в зависимости от того получили ли мы внутренний заголовок JPEG документа или ещё нет. Если не получили — ожидаем его и разбираем, если получили — значит данные это непосредственно JPEG изображение и складываем их в переменную self.img до тех пор пока не получим все self.next_img_size байт изображения, а когда получим — вызываем функцию, переданную нам через параметр конфигурации callback, и отдаём ей только что полученное изображение.

Параметр debug можно выставить в ноль для отключения отображения выводимой информации.

Загрузить исходный код можно по этой ссылке: Python MJPEG over HTTP Client.

Продолжение следует…

Полезно почитать:

MIME
Motion JPEG
Список заголовков HTTP

P.S.: Я решил разбить статью на две части, так как единым целом она получается довольно объёмной, а я не хочу её перегружать для лучшего понимания и большего удобства.