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:
10 files changed
+3201
-183
No files matched your search
+310
-82
@@ -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
|
||||
@@ -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
@@ -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
@@ -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)?;
|
||||
}
|
||||
_ => {}
|
||||
};
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
@@ -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
@@ -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
@@ -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 })
|
||||
}
|
||||
Reference in new issue
Block a user