Merge branch 'master'

Co-Authored-By: twistedddx <bits@live.com>
Conflicts:
	dissector/baichuan.lua
	src/bc_protocol.rs
	src/bc_protocol/media_packet.rs
This commit is contained in:
QuantumEntangledAndyandtwistedddx committed 2020-11-26 17:01:58 +07:00
commit 21030072cc
10 files changed
+3201 -183

No files matched your search

+310 -82
View File
@@ -7,8 +7,13 @@ bc_protocol = Proto("Baichuan", "Baichuan/Reolink IP Camera Protocol")
magic_bytes = ProtoField.int32("baichuan.magic", "magic", base.DEC)
message_id = ProtoField.int32("baichuan.msg_id", "messageId", base.DEC)
message_len = ProtoField.int32("baichuan.msg_len", "messageLen", base.DEC)
xml_enc_offset = ProtoField.int32("baichuan.xml_encryption_offset", "xmlEncryptionOffset", base.DEC)
xml_enc_used = ProtoField.bool("baichuan.xml_encryption_used", "encrypted", base.NONE)
xml_enc_offset = ProtoField.int8("baichuan.xml_encryption_offset", "xmlEncryptionOffset", base.DEC)
encrypt_xml = ProtoField.bool("baichuan.encrypt_xml", "encrypt_xml", base.NONE)
channel_id = ProtoField.int8("baichuan.channel_id", "channel_id", base.DEC)
stream_id = ProtoField.int8("baichuan.stream_id", "streamID", base.DEC)
unknown = ProtoField.int8("baichuan.unknown", "unknown", base.DEC)
msg_handle = ProtoField.int8("baichuan.message_handle", "messageHandle", base.DEC)
status_code = ProtoField.int16("baichuan.status_code", "status_code", base.DEC)
message_class = ProtoField.int32("baichuan.msg_class", "messageClass", base.DEC)
f_payload_offset = ProtoField.int32("baichuan.payload_offset", "binOffset", base.DEC)
username = ProtoField.string("baichuan.username", "username", base.ASCII)
@@ -19,7 +24,12 @@ bc_protocol.fields = {
message_id,
message_len,
xml_enc_offset,
xml_enc_used,
channel_id,
stream_id,
unknown,
msg_handle,
encrypt_xml,
status_code,
message_class,
f_payload_offset,
username,
@@ -27,16 +37,106 @@ bc_protocol.fields = {
}
message_types = {
[1]="login",
[1]="login", -- <Encryption> <LoginUser>/<LoginNet> <DeviceInfo>/<StreamInfoList>
[2]="logout",
[3]="<Preview> (video)",
[58]="<AbilitySupport>",
[78]="<VideoInput>",
[79]="<Serial>",
[4]="<Preview> (stop)",
[5]="<FileInfoList> (replay)",
[7]="<FileInfoList> (stop)",
[8]="<FileInfoList> (DL Video)",
[10]="<TalkAbility>",
[13]="<FileInfoList> (download)",
[14]="<FileInfoList>",
[15]="<FileInfoList>",
[16]="<FileInfoList>",
[18]="<PtzControl>",
[23]="Reboot",
[25]="<VideoInput> (write)",
[26]="<VideoInput>", -- <InputAdvanceCfg>
[31]="Start Motion Alarm",
[33]="<AlarmEventList>",
[36]="<ServerPort> (write)",
[37]="<ServerPort>", -- <HttpPort>/<RtspPort>/<OnvifPort>/<HttpsPort>/<RtmpPort>
[38]="<Ntp>",
[39]="<Ntp> (write)",
[40]="<Ddns>",
[41]="<Ddns> (write)",
[42]="<Email>",
[43]="<Email> (write)",
[44]="<OsdChannelName>", -- <OsdDatetime>
[45]="<OsdChannelName> (write)",
[46]="<MD>",
[47]="<MD> (write)",
[50]="<VideoLoss>",
[51]="<VideoLoss> (write)",
[52]="<Shelter> (priv mask)",
[53]="<Shelter> (write)",
[54]="<RecordCfg>",
[55]="<RecordCfg> (write)",
[56]="<Compression>",
[57]="<Compression> (write)",
[58]="<AbilitySupport>", -- <UserList>
[59]="<UserList> (write)",
[65]="<ConfigFileInfo> (Export)",
[66]="<ConfigFileInfo> (Import)",
[67]="<ConfigFileInfo> (FW Upgrade)",
[68]="<Ftp>",
[69]="<Ftp> (write)",
[70]="<FtpTask>",
[71]="<FtpTask> (write)",
[76]="<Ip>", -- <Dhcp>/<AutoDNS>/<Dns>
[77]="<Ip> (write)",
[78]="<VideoInput> (IPC desc)",
[79]="<Serial> (ptz)",
[80]="<VersionInfo>",
[81]="<Record> (schedule)",
[82]="<Record> (write)",
[83]="<HandleException>",
[84]="<HandleException> (write)",
[91]="<DisplayOutput>",
[92]="<DisplayOutput> (write)",
[93]="<LinkType>",
[97]="<Upnp>",
[98]="<Upnp> (write)",
[99]="<Restore> (factory default)",
[100]="<AutoReboot> (write)",
[101]="<AutoReboot>",
[102]="<HDDInfoList>",
[103]="<HddInitList> (format)",
[104]="<SystemGeneral>",
[105]="<SystemGeneral> (write)",
[106]="<Dst>",
[107]="<Dst> (write)",
[108]="<ConfigFileInfo> (log)",
[114]="<Uid>",
[115]="<WifiSignal>",
[120]="<OnlineUserList>",
[122]="<PerformanceInfo>",
[123]="<ReplaySeek>",
[132]="<VideoInput>", -- <InputAdvanceCfg>
[133]="<RfAlarm>",
[141]="<Email> (test)",
[142]="<DayRecords>",
[145]="<ChannelInfoList>",
[146]="<StreamInfoList>",
[151]="<AbilityInfo>",
[190]="PTZ Preset",
[194]="<Ftp> (test)",
[199]="<Support>",
[208]="<LedState>",
[209]="<LedState> (write)",
[210]="<PTOP>",
[211]="<PTOP> (write)",
[216]="<EmailTask> (write)",
[217]="<EmailTask>",
[218]="<PushTask> (write)",
[219]="<PushTask>",
[228]="<Crop>",
[229]="<Crop> (write)",
[230]="<cropSnap>",
[272]="<findAlarmVideo>",
[273]="<alarmVideoInfo>",
[274]="<findAlarmVideo>",
}
message_classes = {
@@ -54,7 +154,7 @@ header_lengths = {
}
function xml_encrypt(ba, offset)
local key = "\031\045\060\075\090\105\120\255"
local key = "\031\045\060\075\090\105\120\255" -- 1f, 2d, 3c, 4b, 5a, 69, 78 ,ff
local e = ByteArray.new()
e:set_size(ba:len())
for i=0,ba:len() - 1 do
@@ -63,103 +163,231 @@ function xml_encrypt(ba, offset)
return e
end
function bc_protocol.dissector(buffer, pinfo, tree)
length = buffer:len()
if length == 0 then return end
if buffer:len() < 20 then
-- Need more bytes but we don't have a header to learn how many bytes
pinfo.desegment_len = DESEGMENT_ONE_MORE_SEGMENT
pinfo.desegment_offset = 0
return
end
pinfo.cols.protocol = bc_protocol.name
function get_header_len(buffer)
local magic = buffer(0, 4):le_uint()
if magic ~= 0x0abcdef0 then
-- Case 3, capture started in middle of packet,
-- from https://wiki.wireshark.org/Lua/Dissectors#TCP_reassembly
-- The camera always seems to emit a new TCP packet for a new message
return 0
return -1 -- No header found
end
local msg_type = buffer(4, 4):le_uint()
local msg_type_str = message_types[msg_type] or "unknown"
local msg_len = buffer(8, 4):le_uint()
local enc_offset = buffer(12, 4):le_uint()
local msg_cls = buffer(18, 2):le_uint()
local encrypted = (msg_cls == 0x6414 or buffer(16, 1):le_uint() ~= 0)
local class = message_classes[buffer(18, 2):le_uint()]
local header_len = header_lengths[buffer(18, 2):le_uint()]
return header_len
end
if buffer:len() ~= msg_len + header_len then
-- Case 1, need more bytes,
-- from https://wiki.wireshark.org/Lua/Dissectors#TCP_reassembly
pinfo.desegment_len = msg_len + header_len - buffer:len()
pinfo.desegment_offset = 0
return buffer:len()
end
-- payload_offset is either nil (no binary data) or nonzero
-- TODO: payload_offset is actually stateful!
local payload_offset = nil
function get_header(buffer)
-- bin_offset is either nil (no binary data) or nonzero
-- TODO: bin_offset is actually stateful!
local bin_offset = nil
local status_code = nil
local encrypt_xml = nil
local header_len = header_lengths[buffer(18, 2):le_uint()]
local msg_type = buffer(4, 4):le_uint()
if header_len == 24 then
payload_offset = buffer(20, 4):le_uint()
if payload_offset == 0 then payload_offset = nil end
bin_offset = buffer(20, 4):le_uint() -- if NHD-805/806 legacy protocol 30 30 30 30 aka "0000"
status_code = buffer(16, 2):le_uint()
else
encrypt_xml = buffer(16, 1):le_uint()
end
local msg_type = buffer(4, 4):le_uint()
local stream_text = "HD (Clear)"
if buffer(13, 1):le_uint() == 1 then
stream_text = "SD (Fluent)"
end
return {
magic = buffer(0, 4):le_uint(),
msg_type = buffer(4, 4):le_uint(),
msg_type_str = message_types[msg_type] or "unknown",
msg_len = buffer(8, 4):le_uint(),
encrypt_xml = encrypt_xml,
channel_id = buffer(12, 1):le_uint(),
enc_offset = buffer(12, 1):le_uint(),
stream_type = stream_text,
unknown = buffer(14, 1):le_uint(),
msg_handle = buffer(15, 1):le_uint(),
msg_cls = buffer(18, 2):le_uint(),
status_code = status_code,
class = message_classes[buffer(18, 2):le_uint()],
header_len = header_lengths[buffer(18, 2):le_uint()],
bin_offset = bin_offset,
}
end
local bc_subtree = tree:add(bc_protocol, buffer(),
"Baichuan IP Camera Protocol, " .. msg_type_str .. " message")
local header = bc_subtree:add(bc_protocol, buffer(0, header_len),
"Baichuan Message Header, length: " .. header_len)
pinfo.cols['info'] = msg_type_str .. ", type " .. msg_type .. ", " .. msg_len .. " bytes"
function process_header(buffer, headers_tree)
local header_data = get_header(buffer)
local header = headers_tree:add(bc_protocol, buffer(0, header_len),
"Baichuan Message Header, length: " .. header_data.header_len .. ", type " .. header_data.msg_type)
local stream_text = " HD (Clear)"
if buffer(13, 1):le_uint() == 1 then
stream_text = " SD (Fluent)"
end
header:add_le(magic_bytes, buffer(0, 4))
header:add_le(message_id, buffer(4, 4))
:append_text(" (" .. msg_type_str .. ")")
:append_text(" (" .. header_data.msg_type_str .. ")")
header:add_le(message_len, buffer(8, 4))
header:add_le(xml_enc_offset, buffer(12, 4))
:append_text(" (& 0xF == " .. bit32.band(enc_offset, 0xF) .. ")")
header:add_le(xml_enc_used, buffer(16, 1))
header:add_le(message_class, buffer(18, 2))
:append_text(" (" .. class .. ")")
header:add_le(f_payload_offset, buffer(20, 4))
if msg_len == 0 then
header:add_le(xml_enc_offset, buffer(12, 1))
:append_text(" (& 0xF == " .. bit32.band(header_data.enc_offset, 0xF) .. ")")
header:add_le(channel_id, buffer(12, 1))
header:add_le(stream_id, buffer(13, 1))
:append_text(stream_text)
header:add_le(unknown, buffer(14, 1))
header:add_le(msg_handle, buffer(15, 1))
header:add_le(message_class, buffer(18, 2)):append_text(" (" .. header_data.class .. ")")
if header_data.header_len == 24 then
header:add_le(status_code, buffer(16, 2))
header:add_le(f_bin_offset, buffer(20, 4))
else
header:add_le(encrypt_xml, buffer(16, 1))
end
return header_len
end
function process_body(header, body_buffer, bc_subtree, pinfo)
if header.msg_len == 0 then
return
end
local body = bc_subtree:add(bc_protocol, buffer(header_len, nil),
"Baichuan Message Body, " .. class .. ", length: " .. msg_len .. ", encrypted: " .. tostring(encrypted))
local body = bc_subtree:add(bc_protocol, body_buffer(0,header.msg_len),
"Baichuan Message Body, " .. header.class .. ", length: " .. header.msg_len .. ", type " .. header.msg_type)
if class == "legacy" then
if msg_type == 1 then
body:add_le(username, buffer(header_len, 32))
body:add_le(password, buffer(header_len + 32, 32))
if header.class == "legacy" then
if header.msg_type == 1 then
body:add_le(username, body_buffer(0, 32))
body:add_le(password, body_buffer(0 + 32, 32))
end
else
local body_tvb = buffer(header_len, payload_offset):tvb()
body:add(body_tvb(), "XML Payload")
if encrypted then
local ba = buffer(header_len, payload_offset):bytes()
local decrypted = xml_encrypt(ba, enc_offset)
body_tvb = decrypted:tvb("Decrypted XML")
-- Create a tree item that, when clicked, automatically shows the tab we just created
body:add(body_tvb(), "Decrypted XML")
local xml_len = header.bin_offset
if xml_len == nil then
xml_len = header.msg_len
end
local xml_buffer = body_buffer(0, xml_len)
if xml_len > 0 then
local body_tvb = xml_buffer:tvb("Meta Payload")
body:add(body_tvb(), "Meta Payload")
if xml_len >= 4 then
if xml_encrypt(xml_buffer(0,5):bytes(), header.enc_offset):raw() == "<?xml" then -- Encrypted xml found
local ba = xml_buffer:bytes()
local decrypted = xml_encrypt(ba, header.enc_offset)
body_tvb = decrypted:tvb("Decrypted XML (in Meta Payload)")
-- Create a tree item that, when clicked, automatically shows the tab we just created
body:add(body_tvb(), "Decrypted XML (in Meta Payload)")
Dissector.get("xml"):call(body_tvb, pinfo, body)
elseif xml_buffer(0,5):string() == "<?xml" then -- Unencrypted xml
body:add(body_tvb(), "XML (in Meta Payload)")
Dissector.get("xml"):call(body_tvb, pinfo, body)
else
body:add(body_tvb(), "Binary (in Meta Payload)")
end
end
end
Dissector.get("xml"):call(body_tvb, pinfo, body)
if payload_offset ~= nil then
local binary_tvb = buffer(header_len + payload_offset, nil):tvb()
body:add(binary_tvb(), "Binary Payload")
if msg_type == 0x03 then -- video
Dissector.get("h265"):call(binary_tvb, pinfo, tree)
if header.bin_offset ~= nil then
local bin_len = header.msg_len - header.bin_offset
if bin_len > 0 then
local binary_buffer = body_buffer(header.bin_offset, bin_len) -- Don't extend beyond msg size
body_tvb = binary_buffer:tvb("Main Payload");
body:add(body_tvb(), "Main Payload")
if bin_len > 4 then
if xml_encrypt(binary_buffer(0,5):bytes(), header.enc_offset):raw() == "<?xml" then -- Encrypted xml found
local decrypted = xml_encrypt(binary_buffer:bytes(), header.enc_offset)
body_tvb = decrypted:tvb("Decrypted XML (in Main Payload)")
-- Create a tree item that, when clicked, automatically shows the tab we just created
body:add(body_tvb(), "Decrypted XML (in Main Payload)")
Dissector.get("xml"):call(body_tvb, pinfo, body)
elseif binary_buffer(0,5):string() == "<?xml" then -- Unencrypted xml
body:add(body_tvb(), "XML (in Main Payload)")
Dissector.get("xml"):call(body_tvb, pinfo, body)
else
body:add(body_tvb(), "Binary (in Main Payload)")
end
end
end
end
end
end
function bc_protocol.dissector(buffer, pinfo, tree)
length = buffer:len()
if length == 0 then return end
pinfo.cols.protocol = bc_protocol.name
local sub_buffer = buffer
local table_msg_type_str = {}
local table_msg_type = {}
local continue_loop = true
while ( continue_loop )
do
-- Get min bytes for a magic and header len
if sub_buffer:len() < 20 then
-- Need more bytes but we don't have a header to learn how many bytes
pinfo.desegment_len = DESEGMENT_ONE_MORE_SEGMENT
pinfo.desegment_offset = 0
pinfo.cols['info'] = "Need more header"
return
end
header_len = get_header_len(sub_buffer(0, nil))
if header_len >= 0 then
pinfo.cols['info'] = "Valid header"
-- Valid magic and header found
-- Ensure min bytes for full header
if sub_buffer:len() < header_len then
pinfo.cols['info'] = "Need even more header"
-- Need more bytes
pinfo.desegment_len = header_len - sub_buffer:len()
pinfo.desegment_offset = 0
return buffer:len()
end
local header = get_header(sub_buffer(0, nil))
table.insert(table_msg_type_str, header.msg_type_str)
table.insert(table_msg_type, header.msg_type)
-- Get full header and body
local full_body_len = header.msg_len + header.header_len
if sub_buffer:len() < full_body_len then
-- need more bytes,
-- from https://wiki.wireshark.org/Lua/Dissectors#TCP_reassembly
pinfo.cols['info'] = "Need more body: " .. sub_buffer:len() .. " expected " .. full_body_len
pinfo.desegment_len = full_body_len - sub_buffer:len()
pinfo.desegment_offset = 0
return buffer:len()
end
local remaining = sub_buffer:len() - header.header_len
local bc_subtree = tree:add(bc_protocol, sub_buffer(0, header.msg_len),
"Baichuan IP Camera Protocol, " .. header.msg_type_str .. ":" .. header.msg_type .. " message")
process_header(sub_buffer, bc_subtree)
if header.header_len < sub_buffer:len() then
local body_buffer = sub_buffer(header.header_len,nil)
process_body(header, body_buffer, bc_subtree, pinfo)
remaining = body_buffer:len() - header.msg_len
end
-- Remaning bytes?
if remaining == 0 then
continue_loop = false
else
pinfo.cols['info'] = "Another packet"
sub_buffer = sub_buffer(full_body_len, nil)
end
else
pinfo.cols['info'] = "Invalid magic"
return -- Not a valid header
end
end
local msg_type_strs = table.concat(table_msg_type_str, ",")
local msg_types = table.concat(table_msg_type, ",")
pinfo.cols['info'] = msg_type_strs .. ", type " .. msg_types
end
DissectorTable.get("tcp.port"):add(9000, bc_protocol)
DissectorTable.get("tcp.port"):add(52941, bc_protocol) -- change to your own custom port
+111
View File
@@ -0,0 +1,111 @@
# Media Packets
This file attempts to document the encapsulated stream that makes up the binary
data of message ID 3. This stream represents the video and audio data.
The are six types of media packets
- Info V1
- Info V2
- I Frame
- P Frame
- AAC
- ADPCM
The I and P frames come in two formats H264 and H265.
The ADPCM is DVI-4 encoded with an extra header that represents the block size.
## Magic
Each packet can be distinguished with the following magic bytes
- Info V1: 0x31, 0x30, 0x30, 0x31
- Info V2: 0x31, 0x30, 0x30, 0x32
- I Frame: 0x30, 0x30, 0x64, 0x63
- P Frame: 0x30, 0x31, 0x64, 0x63
- AAC: 0x30, 0x35, 0x77, 0x62
- ADPCM: 0x30, 0x31, 0x77, 0x62
## Headers
The full headers for each of these are as follows:
Most of this information comes from the work of @twisteddx at his
[site](https://www.wasteofcash.com/BCConvert/BC_fileformat.txt)
- Info V1/V2:
- 4 bytes magic
- 4 bytes data size of header itself
- 4 bytes video width
- 4 bytes video height
- 1 byte unknown. Known values 00/01
- 1 byte Frames per second (Reolink=FPS, Swann=Appears to be the index value of the FPS setting)
- 1 byte Start UTC year since 1900
- 1 byte Start UTC month
- 1 byte Start UTC date
- 1 byte Start UTC hour
- 1 byte Start UTC minute
- 1 byte Start UTC seconds
- 1 byte End UTC year since 1900
- 1 byte End UTC month
- 1 byte End UTC date
- 1 byte End UTC hour
- 1 byte End UTC minute
- 1 byte End UTC seconds
- 2 bytes reserved
- I Frame
- 4 bytes magic
- 4 bytes video type (ASCII text of either H264 or H265)
- 4 bytes data size of payload after header
- 4 bytes unknown. NVR channel count? Known values 1-00/08 2-00 3-00 4-00
- 4 bytes Microseconds
- 4 bytes unknown. Known values 1-00/23/5A 2-00 3-00 4-00
- 4 bytes POSIX time_t 32bit UTC time (seconds since 00:00:00 Jan 1 1970)
- 4 bytes unknown. Known values 1-00/06/29 2-00/01 3-00/C3 4-00
- P Frame
- 4 bytes magic
- 4 bytes video type (eg H264 or H265)
- 4 bytes data size of payload after header
- 4 bytes unknown. Known values 1-00 2-00 3-00 4-00
- 4 bytes Microseconds
- 4 bytes unknown. Known values 1-00/5A 2-00 3-00 4-00
- AAC
- 4 bytes magic
- 2 bytes data size of payload after header
- 2 bytes data size of payload after header (Same as previous)
- ADPCM
- 4 bytes magic
- 2 bytes data size of payload after header
- 2 bytes data size of payload after header
### ADPCM
After the ADPCM header is another header of the form
- 2 bytes Magic either 0x00 0x01 or 0x00 0x7a
- 2 Bytes DVI-4 Block size
After this header the adpcm DVI-4 data follows.
## Processing
The data in ID 3 messages represents an encapsulated stream. BC messages may
terminate mid media packet messages. Clients should create a buffer of the
BC ID 3 messages then read the media packet magic and expected length. Once
length is known they should wait for more BC message ID 3 packets until a
complete media packet is received before processing it.
File diff suppressed because it is too large. Load diff
+235
View File
@@ -0,0 +1,235 @@
# BC Protocol
This is an attempt to document the BC protocol. It is far from complete
but should serve as a good basis for those wishing to develop apps for
BC cameras.
## Messages
Each message has the general format:
- Header: 20-24 bytes
- Message Body
### Header
The header has the format:
| magic | message id | message length | encryption offset | Encryption flag | Unknown | message class |
|--------------|--------------|----------------|-------------------|-----------------|---------|---------------|
| f0 de bc 0a | 01 00 00 00 | 2c 07 00 00 | 00 00 00 01 | 01 | dc | 14 65 |
Or
| Magic | Message ID | Message Length | Encryption Offset | Encryption Flag | Unknown | Message Class | Binary Offset |
|--------------|--------------|----------------|-------------------|-----------------|---------|---------------|---------------|
| f0 de bc 0a | 01 00 00 00 | 28 01 00 00 | 00 00 00 01 | 00 | 00 | 14 64 | 00 00 00 00 |
- Magic 4 bytes
- ID 4 bytes
- Message length 4 bytes
- Encryption offset 4 bytes
- Encryption flag (not always honoured by clients) 1 byte
- Unknown 1 byte (always zero)
- Binary offset 4 bytes (Presence depend on message class)
#### Magic
The magic bytes for BC messages is always `f0 de bc 0a`. When receiving packet
this should be used to quickly discard invalid packets.
#### Message ID
Each function in BC has its own message ID. For example login is 1, video data
is 3, motion detection is 33.
For a more complete list please see the [messages doc](dissector/messages.md)
#### Message length
The message length contains the full length of the data to follow the header
this includes both the XML and binary parts.
#### Encryption offset
The encryption offset is used as part of the decoding process. It is combined
with the key to decrypt the data.
Here is an example decrypter in rust
```rust
const XML_KEY: [u8; 8] = [0x1F, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78, 0xFF];
pub fn crypt(offset: u32, buf: &[u8]) -> Vec<u8> {
let key_iter = XML_KEY.iter().cycle().skip(offset as usize % 8);
key_iter
.zip(buf)
.map(|(key, i)| *i ^ key ^ (offset as u8))
.collect()
}
```
In short the key is offset by the encryption offset in the header. Then each
encrypted byte is paired with the offseted keys bytes (looping the offseted
key as necessary). Then each byte is XORed with the paired key byte and the
offset.
The key is the same for all cameras.
Older cameras do not use encryption and all messages are sent as plain text.
#### Encryption Flag
This flag is 0 for unencrypted or non zero for encrypted. This flag seems
only to be valid during the login step, and seems to be arbitrary otherwise.
Clients should decide to use encryption or not based on this byte that the
camera send during login. Then should use that same setting for all further
messages with the camera.
#### Unknown
The purpose of this byte is unknown but is always zero. If you figure out
what it does please submit a PR.
#### Message class
The message class determines the length of the header. The following classes
and header lengths are known.
- 0x6514: "legacy" 20 bytes
- 0x6614: "modern" 20 bytes
- 0x6414: "modern" 24 bytes
- 0x0000: "modern" 24 bytes
#### Binary offset
For messages that contain the binary offset field this represents where to start
the binary part of the message. The total length of XML + binary is equal
to the message length in the header so Binary Offset is
total_length - this_offset. Where as this field also represents the end of the
XML part of the message.
Some messages seems to not set this field correctly. For example message ID 1
sets this to zero meaning that all data in the message is binary, however
it contains XML. This best way to tell is this is binary or XML is to check the
message ID and determine from there. Alternatively you could look for `<xml?` at
the beginning of the message (although may need to decrypt first for this to
work)
# Login
For message details see the [docs](dissector/messages.md)
Clients should login by
- Send legacy login message
- User and pass MD5'ed
- Capped at 32 bytes with a null terminator
- Bytes 32 is always zero so only first 31 bytes are compared
- Receive modern upgrade message with nonce in XML
- Send modern login:
- User and pass concatenated with the nonce
- Send MD5'ed user and password
- Receive reply with device info
# Starting Video
Video is requested and received with message ID 3.
Video is requested with an XML of the following format:
```xml
<?xml version="1.0" encoding="UTF-8" ?>
<body>
<Preview version="1.1">
<channelId>0</channelId>
<handle>0</handle>
<streamType>mainStream</streamType>
</Preview>
</body>
```
streamType can be either
- `mainStream` in which case it will be HD
- `subStream` in which case it will be SD
channelId is part of the NVR when multiple cameras use the same IP. In this
case each camera has its own channelId.
Not sure what handle does.
The reply is first a message with the following xml
```xml
<?xml version="1.0" encoding="UTF-8" ?>
<Extension version="1.1">
<binaryData>1</binaryData>
</Extension>
```
After which all message bodies of type id 3 are binary.
The binary represents a stream of data. It can be interrupted by packet
boundaries. Clients should create a buffer and pop bytes for processing when
complete media packets are received. Media packets descriptions can be found in
the [docs](dissector/mediapacket.md)
# Other Function
Other data can be received from the camera by sending the appropriate header to
the camera. For example sending the header for ID 78
| Magic | Message ID | Message Length | Encryption Offset | Encryption Flag | Unknown | Message Class | Binary Offset |
|--------------|--------------|----------------|-------------------|-----------------|---------|---------------|---------------|
| f0 de bc 0a | 4e 00 00 00 | d3 00 00 00 | 08 db 9c 00 | c8 | 00 | 00 00 | 00 00 00 00 |
The camera will reply with an xml with brightness and contrast
```xml
<?xml version="1.0" encoding="UTF-8" ?>
<body>
<VideoInput version="1.1">
<channelId>0</channelId>
<bright>128</bright>
<contrast>128</contrast>
<saturation>128</saturation>
<hue>128</hue>
</VideoInput>
</body>
```
Some message IDs also require input along with the request header. For example
ID 151 which is the users ability info requires the header
| Magic | Message ID | Message Length | Encryption Offset | Encryption Flag | Unknown | Message Class | Binary Offset |
|--------------|--------------|----------------|-------------------|-----------------|---------|---------------|---------------|
| f0 de bc 0a | 97 00 00 00 | a7 00 00 00 | 00 00 00 02 | 00 | 00 | 14 64 | a7 00 00 00 |
and the body of
```xml
<?xml version="1.0" encoding="UTF-8" ?>
<Extension version="1.1">
<userName>...</userName> <!-- Plain text username -->
<token>system, network, alarm, record, video, image</token>
</Extension>
```
Which contains the plain text of the username of interest and the tokens for
abilities you want to know about.
Details of expected formats should be found from the
[docs](dissector/messages.md)
+23 -11
View File
@@ -2,6 +2,8 @@ use self::connection::BcConnection;
use self::media_packet::{MediaDataKind, MediaDataSubscriber};
use crate::bc;
use crate::bc::{model::*, xml::*};
use crate::gst::GstOutputs;
use adpcm::adpcm_to_pcm;
use err_derive::Error;
use log::*;
use std::io::Write;
@@ -11,6 +13,7 @@ use std::sync::atomic::{AtomicU16, Ordering};
use Md5Trunc::*;
mod adpcm;
mod connection;
mod media_packet;
mod time;
@@ -53,17 +56,12 @@ pub enum Error {
#[error(display = "Timeout")]
Timeout(#[error(source)] std::sync::mpsc::RecvTimeoutError),
// We map std::sync::mpsc::RecvTimeoutError onto one of these based on
// the errors enum
#[error(display = "Dropped connection")]
TimeoutDropped,
#[error(display = "Timeout")]
TimeoutTimeout,
#[error(display = "Credential error")]
AuthFailed,
#[error(display = "ADPCM Decoding Error")]
AdpcmDecodingError(&'static str),
#[error(display = "Other error")]
Other(&'static str),
}
@@ -279,7 +277,7 @@ impl BcCamera {
pub fn start_video(
&self,
data_out: &mut dyn Write,
data_outs: &mut GstOutputs,
stream_name: &str,
channel_id: u32,
) -> Result<Never> {
@@ -320,12 +318,26 @@ impl BcCamera {
let mut media_sub = MediaDataSubscriber::from_bc_sub(&sub_video);
loop {
let binary_data = media_sub.next_media_packet(RX_TIMEOUT)?;
let binary_data = media_sub.next_media_packet()?;
// We now have a complete interesting packet. Send it to gst.
// Process the packet
match binary_data.kind() {
MediaDataKind::VideoDataIframe | MediaDataKind::VideoDataPframe => {
data_out.write_all(binary_data.body())?;
let media_format = binary_data.media_format();
data_outs.set_format(media_format);
data_outs.vidsrc.write_all(binary_data.body())?;
}
MediaDataKind::AudioDataAac => {
let media_format = binary_data.media_format();
data_outs.set_format(media_format);
data_outs.audsrc.write_all(binary_data.body())?;
}
MediaDataKind::AudioDataAdpcm => {
let media_format = binary_data.media_format();
data_outs.set_format(media_format);
let adpcm = binary_data.body();
let pcm = adpcm_to_pcm(adpcm)?;
data_outs.audsrc.write_all(&pcm)?;
}
_ => {}
};
+244
View File
@@ -0,0 +1,244 @@
/*
This is a rust implementation of OKI and DVI/IMA ADPCM.
*/
use crate::Error;
use log::error;
use std::convert::TryInto;
struct AdpcmSetup {
max_step_index: u32,
steps: &'static [u32],
max_sample_size: i32,
changes: &'static [i32],
}
impl AdpcmSetup {
// Unused, originally we thought BC might be using OKI but it is actually DVI4
fn new_oki() -> Self {
Self {
max_step_index: 48,
steps: &[
16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97,
107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449,
494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552,
],
changes: &[-1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8],
max_sample_size: 2048,
}
}
// This is IMA format, but it is the same as DVI4 format except in the block header
fn new_ima() -> Self {
Self {
max_step_index: 88,
steps: &[
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50,
55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279,
307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871,
5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818,
18500, 20350, 22385, 24623, 27086, 29794, 32767,
],
changes: &[-1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8],
max_sample_size: 32768,
}
}
}
struct Nibble {
// A nibble is a 4bit int
data: u8, // This is the raw data for the nibble
}
impl Nibble {
// Use u/i32 throughout to ensure that we always have enough
// Headroom to do the math without needing `as` casting everywhere
fn unsigned(&self) -> u32 {
(self.data & 0b00001111) as u32 // Mask first 4 bits it just to be sure its in nibble range
}
fn signed_magnitude(&self) -> u32 {
(self.data & 0b00000111) as u32 // Mask of first 3 bits which are the magnitiude bits in signed int
}
fn signed(&self) -> i32 {
match self.data & 0b00001000 {
// Sign bit is at the 4th bit
0b00001000 => -(self.signed_magnitude() as i32),
_ => self.signed_magnitude() as i32,
}
}
fn from_byte(byte: &u8) -> [Self; 2] {
// Two nibbles per byte
[
Self {
data: (byte & 0b11110000) >> 4,
},
Self {
data: byte & 0b00001111,
},
]
}
}
pub fn adpcm_to_pcm(bytes: &[u8]) -> Result<Vec<u8>, Error> {
let context = AdpcmSetup::new_ima();
let mut result: Vec<u8> = vec![]; // Stores the PCM byte array
// ADPCM is not really a streamable format
// Each audio sample requires information on the previous sample
// To solve this reolink caches the intermediate variables (step_index and last_output)
// Into the block header in the stream. When ever an adpcm packet arrives it starts with
// 0x0001 which is the frame time from HISilicon documentation (I think) following by
// 0xWW which is half the block size
// 0xYY which is the last output
// 0xZZ which is the step index of the last output
// We must initialise our decoder with this data
if bytes.len() < 4 {
error!("ADPCM data is too short for even the magic.");
return Err(Error::AdpcmDecodingError(
"ADPCM data is too short for even the magic.",
));
}
// Check for valid number of frame type
let frame_type_bytes = &bytes[0..2];
const FRAME_TYPE_HISILICON: &[u8] = &[0x00, 0x01];
if frame_type_bytes != FRAME_TYPE_HISILICON {
error!("Unexpected ADPCM frame type: {:x?}", frame_type_bytes);
return Err(Error::AdpcmDecodingError("Unexpected ADPCM frame type"));
}
// Check for valid block size
let block_size_bytes = &bytes[2..4];
let block_size = (u16::from_le_bytes(
block_size_bytes
.try_into()
.expect("slice with incorrect length"),
) as u32)
* 2; // Block size is stored as 1/2 (don't know why)
let full_block_size = block_size + 4; // block_size + magic (2 bytes) + size (2 bytes)
if !bytes.len() % full_block_size as usize == 0 {
error!("ADPCM Data is not a multiple of the block size");
return Err(Error::AdpcmDecodingError(
"ADPCM block size does not match data length.",
));
}
// Chunk on block size
for bytes in bytes.chunks(full_block_size as usize) {
// Get predictor state from block header using DVI 4 format.
if bytes.len() < 8 {
error!("ADPCM Block size is not long enough for header");
return Err(Error::AdpcmDecodingError(
"ADPCM has insufficent block size",
));
}
let step_output_bytes = &bytes[4..6];
let mut last_output = i16::from_le_bytes(
step_output_bytes
.try_into()
.expect("slice with incorrect length"),
) as i32;
let step_index_bytes = &bytes[6..8];
let mut step_index = u16::from_le_bytes(
step_index_bytes
.try_into()
.expect("slice with incorrect length"),
) as i32;
// To avoid casting to u8 <-> u16 <-> u32 and back all the time I just do all maths in u/i32
// This gives enough headroom to do all calculations without overflow because adpcm puts artifical
// limits on the sample sizes
let mut step: u32;
// The rest is all data to be decoded
let data = &bytes[8..];
for byte in data {
let nibbles: [Nibble; 2] = Nibble::from_byte(byte);
for nibble in &nibbles {
let unibble = nibble.unsigned();
// Specifications say: Clamp it in max index range 0..context.max_step_index
step_index = match step_index {
n if n < 0 => 0,
n if n > context.max_step_index as i32 => context.max_step_index as i32,
n => n,
};
// This is just Eulers approximation with a variable step size
// **Adaptive** Differential PCM
// Adaptive: because the step size is variable
step = context.steps[step_index as usize];
let raw_sample;
/* == Non approxiate version ===
// This is the full maths version
// We don't use this one as we need to match the way the encoder
// works if we want to use the state stored in the header.
// I have Left it here as it is easier to understand then the bit shift version below
let inibble = nibble.signed();
// Calculate the delta (which is really what adpcm is all about)
// Adaptive **Differential** PCM
// Differential: Becuase its all about the difference (gradient)
let diff = (step as i32) * (inibble) / 2 + (step as i32) / 8;
// Eulers approxiation
// Sample = Previous_Sample + difference*step_size
raw_sample = last_output + diff;
*/
// === Approximate version ==
// Approximate form uses bit shift operators.
// This is a legacy of the days when mult/divides were expensive
// It is also the format used on low end CPUs like cameras
let mut diff = step >> 3;
if (unibble & 0b0100) == 0b0100 {
diff += step;
}
if (unibble & 0b0010) == 0b0010 {
diff += step >> 1;
}
if (unibble & 0b0001) == 0b0001 {
diff += step >> 2;
}
// Sign test
if (unibble & 0b1000) == 0b1000 {
raw_sample = last_output - (diff as i32);
} else {
raw_sample = last_output + (diff as i32);
}
// Specifications say: Clamp it in max sample range -context.max_sample_size..context.max_sample_size
let sample = match raw_sample {
value if value > context.max_sample_size - 1 => context.max_sample_size - 1,
value if value < -context.max_sample_size => -context.max_sample_size,
value => value,
};
// PCM is really in i16 range
// Some formats e.g. OKI are not in the full PCM range of values
// To convert we must scale it to the i16 range
// We also cast to i16 at this point ready for the conversion to u8 bytes of the output
let scaled_sample = (sample as i32 * (i16::MAX as i32)
/ (context.max_sample_size - 1) as i32)
as i16;
// Get the results in bytes
result.extend(scaled_sample.to_le_bytes().iter());
// Increment the step index
step_index = step_index as i32 + context.changes[unibble as usize];
// cache the last_output ready for next run
last_output = sample;
}
}
}
Ok(result)
}
+79 -25
View File
@@ -1,11 +1,11 @@
use super::Error;
use super::{Error, Result, RX_TIMEOUT};
use crate::bc::model::*;
use crate::bc_protocol::connection::BcSubscription;
use crate::gst::StreamFormat;
use log::trace;
use log::*;
use std::collections::VecDeque;
use std::convert::TryInto;
use std::time::Duration;
const INVALID_MEDIA_PACKETS: &[MediaDataKind] = &[MediaDataKind::Unknown];
@@ -15,8 +15,6 @@ const MAGIC_SIZE: usize = 4;
// PAD_SIZE: Media packets use 8 byte padding
const PAD_SIZE: usize = 8;
type Result<T> = std::result::Result<T, Error>;
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
pub enum MediaDataKind {
VideoDataIframe,
@@ -44,7 +42,7 @@ impl MediaData {
MediaDataKind::VideoDataIframe => 32,
MediaDataKind::VideoDataPframe => 24,
MediaDataKind::AudioDataAac => 8,
MediaDataKind::AudioDataAdpcm => 16,
MediaDataKind::AudioDataAdpcm => 8,
MediaDataKind::InfoData => 32,
MediaDataKind::Unknown => 0,
}
@@ -55,6 +53,39 @@ impl MediaData {
MediaData::header_size_from_kind(kind)
}
pub fn header(&self) -> &[u8] {
&self.data[0..self.header_size()]
}
pub fn header_dump(&self) {
info!("{:?}-hex: {:02?}", self.kind(), self.header());
let mut result = vec![];
for four in self.header().chunks(4) {
result.push(u32::from_le_bytes(four.try_into().unwrap()));
}
info!("{:?}-32: {:?}", self.kind(), result);
let mut result = vec![];
for two in self.header().chunks(2) {
result.push(u16::from_le_bytes(two.try_into().unwrap()));
}
info!("{:?}-16: {:?}", self.kind(), result);
let mut result = vec![];
for one in self.header().chunks(1) {
result.push(u8::from_le_bytes(one.try_into().unwrap()));
}
info!("{:?}-8: {:?}", self.kind(), result);
let mut result = vec![];
for four in self.header().chunks(4) {
result.push(f32::from_le_bytes(four.try_into().unwrap()));
}
info!("{:?}-f32: {:?}", self.kind(), result);
let mut result = vec![];
for four in self.header().chunks(4) {
result.push(String::from_utf8_lossy(four));
}
info!("{:?}-utf8: {:?}", self.kind(), result);
}
fn header_size(&self) -> usize {
MediaData::header_size_from_raw(&self.data)
}
@@ -123,7 +154,7 @@ impl MediaData {
MAGIC_IFRAME => MediaDataKind::VideoDataIframe,
MAGIC_PFRAME => MediaDataKind::VideoDataPframe,
_ => {
trace!("Unknown magic kind: {:x?}", &magic);
//trace!("Unknown magic kind: {:x?}", &magic);
MediaDataKind::Unknown
}
}
@@ -132,6 +163,39 @@ impl MediaData {
pub fn kind(&self) -> MediaDataKind {
MediaData::kind_from_raw(&self.data)
}
pub fn media_format(&self) -> Option<StreamFormat> {
let kind = self.kind();
match kind {
MediaDataKind::VideoDataIframe | MediaDataKind::VideoDataPframe => {
let stream_type = &self.data[4..8];
const H264_STR_UPPER: &[u8] = &[0x48, 0x32, 0x36, 0x34];
const H264_STR_LOWER: &[u8] = &[0x68, 0x32, 0x36, 0x34];
const H265_STR_UPPER: &[u8] = &[0x48, 0x32, 0x36, 0x35];
const H265_STR_LOWER: &[u8] = &[0x68, 0x32, 0x36, 0x35];
match stream_type {
H264_STR_UPPER | H264_STR_LOWER => Some(StreamFormat::H264), // Offically it should be "H264" not "h264" but covering all cases
H265_STR_UPPER | H265_STR_LOWER => Some(StreamFormat::H265),
_ => None,
}
}
MediaDataKind::AudioDataAac => Some(StreamFormat::AAC),
MediaDataKind::AudioDataAdpcm => Some(StreamFormat::ADPCM),
_ => None,
}
}
pub fn timestamp(&self) -> Option<u64> {
let kind = self.kind();
match kind {
MediaDataKind::VideoDataIframe | MediaDataKind::VideoDataPframe => Some(
Self::bytes_to_size(&self.data[16..20])
.try_into()
.expect("usize wont fit into u64"),
),
_ => None,
}
}
}
pub struct MediaDataSubscriber<'a> {
@@ -147,17 +211,10 @@ impl<'a> MediaDataSubscriber<'a> {
}
}
fn fill_binary_buffer(&mut self, rx_timeout: Duration) -> Result<()> {
fn fill_binary_buffer(&mut self) -> Result<()> {
// Loop messages until we get binary add that data and return
loop {
let msg = self
.bc_sub
.rx
.recv_timeout(rx_timeout)
.map_err(|e| match e {
std::sync::mpsc::RecvTimeoutError::Timeout => Error::TimeoutTimeout,
std::sync::mpsc::RecvTimeoutError::Disconnected => Error::TimeoutDropped,
})?;
let msg = self.bc_sub.rx.recv_timeout(RX_TIMEOUT)?;
if let BcBody::ModernMsg(ModernMsg {
payload: Some(BcPayloads::Binary(binary)),
..
@@ -171,11 +228,11 @@ impl<'a> MediaDataSubscriber<'a> {
Ok(())
}
fn advance_to_media_packet(&mut self, rx_timeout: Duration) -> Result<()> {
fn advance_to_media_packet(&mut self) -> Result<()> {
// In the event we get an unknown packet we advance by brute force
// reading of bytes to the next valid magic
while self.binary_buffer.len() < MAGIC_SIZE {
self.fill_binary_buffer(rx_timeout)?;
self.fill_binary_buffer()?;
}
// Check the kind, if its invalid use pop a byte and try again
@@ -187,7 +244,7 @@ impl<'a> MediaDataSubscriber<'a> {
while INVALID_MEDIA_PACKETS.contains(&MediaData::kind_from_raw(&magic)) {
self.binary_buffer.pop_front();
while self.binary_buffer.len() < MAGIC_SIZE {
self.fill_binary_buffer(rx_timeout)?;
self.fill_binary_buffer()?;
}
magic = MediaDataSubscriber::get_first_n_deque(&self.binary_buffer, MAGIC_SIZE);
}
@@ -214,12 +271,9 @@ impl<'a> MediaDataSubscriber<'a> {
}
}
pub fn next_media_packet(
&mut self,
rx_timeout: Duration,
) -> std::result::Result<MediaData, Error> {
pub fn next_media_packet(&mut self) -> std::result::Result<MediaData, Error> {
// Find the first packet (does nothing if already at one)
self.advance_to_media_packet(rx_timeout)?;
self.advance_to_media_packet()?;
// Get the magic bytes (guaranteed by advance_to_media_packet)
let magic = MediaDataSubscriber::get_first_n_deque(&self.binary_buffer, MAGIC_SIZE);
@@ -227,7 +281,7 @@ impl<'a> MediaDataSubscriber<'a> {
// Get enough for the full header
let header_size = MediaData::header_size_from_raw(&magic);
while self.binary_buffer.len() < header_size {
self.fill_binary_buffer(rx_timeout)?;
self.fill_binary_buffer()?;
}
// Get enough for the full data + 8 byte buffer
@@ -236,7 +290,7 @@ impl<'a> MediaDataSubscriber<'a> {
let pad_size = MediaData::pad_size_from_raw(&header);
let full_size = header_size + data_size + pad_size;
while self.binary_buffer.len() < full_size {
self.fill_binary_buffer(rx_timeout)?;
self.fill_binary_buffer()?;
}
// Pop the full binary buffer
+2 -12
View File
@@ -8,7 +8,6 @@ use validator::{Validate, ValidationError};
use validator_derive::Validate;
lazy_static! {
static ref RE_STREAM_FORM: Regex = Regex::new(r"^([hH]26[45]|[ \t]*[!].*)$").unwrap();
static ref RE_STREAM_SRC: Regex = Regex::new(r"^(mainStream|subStream|both)$").unwrap();
static ref RE_TLS_CLIENT_AUTH: Regex = Regex::new(r"^(none|request|require)$").unwrap();
}
@@ -54,13 +53,8 @@ pub struct CameraConfig {
// no longer used, but still here so we can warn users:
pub timeout: Option<Duration>,
#[validate(regex(
path = "RE_STREAM_FORM",
message = "Incorrect stream format",
code = "format"
))]
#[serde(default = "default_format")]
pub format: String,
// no longer used, but still here so we can warn users:
pub format: Option<String>,
#[validate(regex(
path = "RE_STREAM_SRC",
@@ -95,10 +89,6 @@ fn default_bind_port() -> u16 {
8554
}
fn default_format() -> String {
"h265".to_string()
}
fn default_stream() -> String {
"both".to_string()
}
+96 -29
View File
@@ -1,7 +1,6 @@
//! This module provides an "RtspServer" abstraction that allows consumers of its API to feed it
//! data using an ordinary std::io::Write interface.
pub use self::maybe_app_src::MaybeAppSrc;
use gstreamer::prelude::Cast;
use gstreamer::{Bin, Structure};
use gstreamer_app::AppSrc;
@@ -27,10 +26,82 @@ pub struct RtspServer {
server: GstRTSPServer,
}
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
pub enum StreamFormat {
H264,
H265,
Custom(String),
AAC,
ADPCM,
}
pub struct GstOutputs {
pub audsrc: MaybeAppSrc,
pub vidsrc: MaybeAppSrc,
video_format: Option<StreamFormat>,
audio_format: Option<StreamFormat>,
factory: RTSPMediaFactory,
}
impl GstOutputs {
pub fn from_appsrcs(vidsrc: MaybeAppSrc, audsrc: MaybeAppSrc) -> GstOutputs {
let result = GstOutputs {
vidsrc,
audsrc,
video_format: None,
audio_format: None,
factory: RTSPMediaFactory::new(),
};
result.apply_format();
result
}
pub fn set_format(&mut self, format: Option<StreamFormat>) {
match format {
Some(StreamFormat::H264) | Some(StreamFormat::H265) => {
if format != self.video_format {
self.video_format = format;
self.apply_format();
}
}
Some(StreamFormat::AAC) | Some(StreamFormat::ADPCM) => {
if format != self.audio_format {
self.audio_format = format;
self.apply_format();
}
}
_ => {}
}
}
fn apply_format(&self) {
let launch_vid = match self.video_format {
Some(StreamFormat::H264) => {
"! queue silent=true max-size-bytes=10485760 min-threshold-bytes=1024 ! h264parse ! rtph264pay name=pay0"
}
Some(StreamFormat::H265) => {
"! queue silent=true max-size-bytes=10485760 min-threshold-bytes=1024 ! h265parse ! rtph265pay name=pay0"
}
_ => "! fakesink",
};
let launch_aud = match self.audio_format {
Some(StreamFormat::ADPCM) => "! queue silent=true max-size-bytes=10485760 min-threshold-bytes=1024 ! rawaudioparse format=pcm pcm-format=s16le sample-rate=8000 num-channels=1 interleaved=true ! audioconvert ! rtpL16pay name=pay1", // DVI4 is converted to pcm in the appsrc
Some(StreamFormat::AAC) => "! queue silent=true max-size-bytes=10485760 min-threshold-bytes=1024 ! aacparse ! rtpmp4apay name=pay1",
_ => "! fakesink",
};
self.factory.set_launch(
&vec![
"( ",
"appsrc name=vidsrc is-live=true block=true emit-signals=false max-bytes=52428800 do-timestamp=true format=GST_FORMAT_TIME", // 50MB max size so that it won't grow to infinite if the queue blocks
launch_vid,
"appsrc name=audsrc is-live=true block=true emit-signals=false max-bytes=52428800 do-timestamp=true format=GST_FORMAT_TIME", // 50MB max size so that it won't grow to infinite if the queue blocks
launch_aud,
")"
]
.join(" "),
);
}
}
impl Default for RtspServer {
@@ -50,21 +121,23 @@ impl RtspServer {
pub fn add_stream(
&self,
paths: &[&str],
stream_format: StreamFormat,
permitted_users: &HashSet<&str>,
) -> Result<MaybeAppSrc> {
) -> Result<GstOutputs> {
let mounts = self
.server
.get_mount_points()
.expect("The server should have mountpoints");
let launch_str = match stream_format {
StreamFormat::H264 => "! h264parse ! rtph264pay name=pay0",
StreamFormat::H265 => "! h265parse ! rtph265pay name=pay0",
StreamFormat::Custom(ref custom_format) => custom_format,
};
// Create a MaybeAppSrc: Write which we will give the caller. When the backing AppSrc is
// created by the factory, fish it out and give it to the waiting MaybeAppSrc via the
// channel it provided. This callback may be called more than once by Gstreamer if it is
// unhappy with the pipeline, so keep updating the MaybeAppSrc.
let (maybe_app_src, tx) = MaybeAppSrc::new_with_tx();
let (maybe_app_src_aud, tx_aud) = MaybeAppSrc::new_with_tx();
let factory = RTSPMediaFactory::new();
let outputs = GstOutputs::from_appsrcs(maybe_app_src, maybe_app_src_aud);
let factory = &outputs.factory;
debug!(
"Permitting {} to access {}",
@@ -76,25 +149,10 @@ impl RtspServer {
.collect::<String>(),
paths.join(", ")
);
self.add_permitted_roles(&factory, permitted_users);
self.add_permitted_roles(factory, permitted_users);
//factory.set_protocols(RTSPLowerTrans::TCP);
factory.set_launch(&format!("{}{}{}{}",
"( ",
"appsrc name=writesrc is-live=true block=true emit-signals=false max-bytes=0 do-timestamp=true ",
launch_str,
" )"
));
factory.set_shared(true);
// TODO maybe set video format via
// https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/blob/master/examples/src/bin/appsrc.rs#L66
// Create a MaybeAppSrc: Write which we will give the caller. When the backing AppSrc is
// created by the factory, fish it out and give it to the waiting MaybeAppSrc via the
// channel it provided. This callback may be called more than once by Gstreamer if it is
// unhappy with the pipeline, so keep updating the MaybeAppSrc.
let (maybe_app_src, tx) = MaybeAppSrc::new_with_tx();
factory.connect_media_configure(move |_factory, media| {
debug!("RTSP: media was configured");
let bin = media
@@ -103,18 +161,25 @@ impl RtspServer {
.dynamic_cast::<Bin>()
.expect("Media source's element should be a bin");
let app_src = bin
.get_by_name_recurse_up("writesrc")
.get_by_name_recurse_up("vidsrc")
.expect("write_src must be present in created bin")
.dynamic_cast::<AppSrc>()
.expect("Source element is expected to be an appsrc!");
let _ = tx.send(app_src); // Receiver may be dropped, don't panic if so
let app_src_aud = bin
.get_by_name_recurse_up("audsrc")
.expect("write_src must be present in created bin")
.dynamic_cast::<AppSrc>()
.expect("Source element is expected to be an appsrc!");
let _ = tx_aud.send(app_src_aud); // Receiver may be dropped, don't panic if so
});
for path in paths {
mounts.add_factory(path, &factory);
mounts.add_factory(path, factory);
}
Ok(maybe_app_src)
Ok(outputs)
}
pub fn add_permitted_roles(&self, factory: &RTSPMediaFactory, permitted_roles: &HashSet<&str>) {
@@ -241,12 +306,14 @@ mod maybe_app_src {
Some(src) => src,
None => return Ok(buf.len()),
};
let mut gst_buf = gstreamer::Buffer::with_size(buf.len()).unwrap();
{
let gst_buf_mut = gst_buf.get_mut().unwrap();
let mut gst_buf_data = gst_buf_mut.map_writable().unwrap();
gst_buf_data.copy_from_slice(buf);
}
let res = app_src.push_buffer(gst_buf); //.map_err(|e| io::Error::new(io::ErrorKind::Other, Box::new(e)))?;
if res.is_err() {
self.app_src = None;
+18 -24
View File
@@ -3,11 +3,10 @@ use err_derive::Error;
use gio::TlsAuthenticationMode;
use log::*;
use neolink::bc_protocol::BcCamera;
use neolink::gst::{MaybeAppSrc, RtspServer, StreamFormat};
use neolink::gst::{GstOutputs, RtspServer};
use neolink::Never;
use std::collections::HashSet;
use std::fs;
use std::io::Write;
use std::sync::Arc;
use std::time::Duration;
use structopt::StructOpt;
@@ -30,6 +29,8 @@ pub enum Error {
IoError(#[error(source)] std::io::Error),
#[error(display = "Validation error")]
ValidationError(#[error(source)] validator::ValidationErrors),
#[error(display = "ADPCM Decoding Error")]
AdpcmDecodingError(&'static str),
}
fn main() -> Result<(), Error> {
@@ -60,22 +61,14 @@ fn main() -> Result<(), Error> {
crossbeam::scope(|s| {
for camera in config.cameras {
let stream_format = match &*camera.format {
"h264" | "H264" => StreamFormat::H264,
"h265" | "H265" => StreamFormat::H265,
custom_format => StreamFormat::Custom(custom_format.to_string()),
};
if camera.format.is_some() {
warn!("The format config option of the camera has been removed in favour of auto detection.")
}
// Let subthreads share the camera object; in principle I think they could share
// the object as it sits in the config.cameras block, but I have not figured out the
// syntax for that.
let arc_cam = Arc::new(camera);
// The substream always seems to be H264, even on B800 cameras
let substream_format = match &*arc_cam.format {
"h264" | "H264" | "h265" | "H265" => StreamFormat::H264,
custom_format => StreamFormat::Custom(custom_format.to_string()),
};
let permitted_users =
get_permitted_users(config.users.as_slice(), &arc_cam.permitted_users);
@@ -85,20 +78,20 @@ fn main() -> Result<(), Error> {
&*format!("/{}", arc_cam.name),
&*format!("/{}/mainStream", arc_cam.name),
];
let mut output = rtsp
.add_stream(paths, stream_format, &permitted_users)
let mut outputs = rtsp
.add_stream(paths, &permitted_users)
.unwrap();
let main_camera = arc_cam.clone();
s.spawn(move |_| camera_loop(&*main_camera, "mainStream", &mut output, true));
s.spawn(move |_| camera_loop(&*main_camera, "mainStream", &mut outputs, true));
}
if ["both", "subStream"].iter().any(|&e| e == arc_cam.stream) {
let paths = &[&*format!("/{}/subStream", arc_cam.name)];
let mut output = rtsp
.add_stream(paths, substream_format, &permitted_users)
let mut outputs = rtsp
.add_stream(paths, &permitted_users)
.unwrap();
let sub_camera = arc_cam.clone();
let manage = arc_cam.stream == "subStream";
s.spawn(move |_| camera_loop(&*sub_camera, "subStream", &mut output, manage));
s.spawn(move |_| camera_loop(&*sub_camera, "subStream", &mut outputs, manage));
}
}
@@ -112,7 +105,7 @@ fn main() -> Result<(), Error> {
fn camera_loop(
camera_config: &CameraConfig,
stream_name: &str,
output: &mut MaybeAppSrc,
outputs: &mut GstOutputs,
manage: bool,
) -> Result<Never, Error> {
let min_backoff = Duration::from_secs(1);
@@ -120,8 +113,9 @@ fn camera_loop(
let mut current_backoff = min_backoff;
loop {
let cam_err = camera_main(camera_config, stream_name, output, manage).unwrap_err();
output.on_stream_error();
let cam_err = camera_main(camera_config, stream_name, outputs, manage).unwrap_err();
outputs.vidsrc.on_stream_error();
outputs.audsrc.on_stream_error();
// Authentication failures are permanent; we retry everything else
if cam_err.connected {
current_backoff = min_backoff;
@@ -200,7 +194,7 @@ fn get_permitted_users<'a>(
fn camera_main(
camera_config: &CameraConfig,
stream_name: &str,
output: &mut dyn Write,
outputs: &mut GstOutputs,
manage: bool,
) -> Result<Never, CameraErr> {
let mut connected = false;
@@ -252,7 +246,7 @@ fn camera_main(
"{}: Starting video stream {}",
camera_config.name, stream_name
);
camera.start_video(output, stream_name, camera_config.channel_id)
camera.start_video(outputs, stream_name, camera_config.channel_id)
})()
.map_err(|err| CameraErr { connected, err })
}