def handle_header(self):
if len(self.buffer_data) >= FLVHeader.object_size():
# We can try and parse the stream header
self.stream_header = FLVHeader()
nb_parsed = self.stream_header.parse(self.buffer_data)
self.publish_packet(self.stream_header.raw_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag
return True
else:
return False
def handle_header(self) -> bool:
if len(self.buffer_data) >= FLVHeader.object_size:
# We can try and parse the stream header
self.stream_header = FLVHeader()
nb_parsed = self.stream_header.parse(self.buffer_data)
self.publish_packet(self.stream_header.raw_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag
return True
else:
return False
class FLVSource(StreamSource):
# Initial burst duration, in milliseconds
BURST_DURATION = 5 * 1000
def __init__(self, sock, server, address, content_type, request_parser,
path = None, burst_size = None, on_demand = False,
keepalive = False):
StreamSource.__init__(self, sock, server, address, content_type,
request_parser, path, burst_size, on_demand,
keepalive)
# Initial buffer data
self.buffer_data = request_parser.body
# The FLV stream header
self.stream_header = None
# These are the initial setup tags we send out to each new
# client
self.initial_tags = collections.deque()
# Which type of initial tag we already got
self.got_initial_meta = self.got_initial_audio = self.got_initial_video = False
# Our current packets group
self.packets_group = collections.deque()
# Our current "burst" packets groups list
self.burst_groups = collections.deque()
# List of buffers for the "burst" packets
self.burst_groups_data = collections.deque()
# At startup we want to parse the stream header
self.handle_data = self.handle_header
def on_demand_deactivate(self):
StreamSource.on_demand_deactivate(self)
self.stream_header = None
self.got_initial_meta = self.got_initial_audio = self.got_initial_video = False
self.initial_tags.clear()
self.packets_group.clear()
self.burst_groups.clear()
self.burst_groups_data.clear()
self.handle_data = self.handle_header
self.buffer_data = b''
def on_demand_connected(self, sock, request_parser):
self.buffer_data = request_parser.body
StreamSource.on_demand_connected(self, sock, request_parser)
def new_client(self, client):
StreamSource.new_client(self, client)
if self.stream_header:
client.add_packet(self.stream_header.raw_data)
for tag in self.initial_tags:
client.add_packet(tag.raw_data + tag.body)
for group_data in self.burst_groups_data:
client.add_packet(group_data)
def handle_packet(self, packet):
self.buffer_data = self.buffer_data + packet
while self.handle_data():
pass
def handle_header(self):
if len(self.buffer_data) >= FLVHeader.object_size():
# We can try and parse the stream header
self.stream_header = FLVHeader()
nb_parsed = self.stream_header.parse(self.buffer_data)
self.publish_packet(self.stream_header.raw_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag
return True
else:
return False
def handle_tag(self):
if len(self.buffer_data) >= FLVTag.object_size():
# We can try and parse one FLV tag
self.current_tag = FLVTag()
nb_parsed = self.current_tag.parse(self.buffer_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag_body
return True
else:
return False
def handle_tag_body(self):
body_length = (self.current_tag.data_size +
self.current_tag.TRAILER_SIZE)
if len(self.buffer_data) >= body_length:
self.current_tag.body = self.buffer_data[:body_length]
if self.check_for_initial_tag(self.current_tag):
# Tag is one of the initial tag, just publish it
self.publish_packet(self.current_tag.raw_data)
self.publish_packet(self.current_tag.body)
else:
# We need to add it to our current packets group
self.add_to_packets_group(self.current_tag)
self.buffer_data = self.buffer_data[body_length:]
self.handle_data = self.handle_tag
return True
else:
return False
def check_for_initial_tag(self, flv_tag):
if (not self.got_initial_meta and flv_tag.tag_type == 'meta'):
self.got_initial_meta = True
self.initial_tags.append(flv_tag)
return True
elif (not self.got_initial_audio and flv_tag.tag_type == 'audio'):
audio_data = FLVAudioData()
audio_data.parse(flv_tag.body[:audio_data.object_size])
if (audio_data.sound_format == 'AAC' and
audio_data.aac_packet_type == audio_data.AAC_SEQUENCE_HEADER):
self.got_initial_audio = True
self.initial_tags.append(flv_tag)
return True
elif (not self.got_initial_video and flv_tag.tag_type == 'video'):
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
if (video_data.codec == 'AVC' and
video_data.avc_packet_type == video_data.AVC_SEQUENCE_HEADER):
self.got_initial_video = True
self.initial_tags.append(flv_tag)
return True
return False
def add_to_packets_group(self, flv_tag):
if self.is_sync_point(flv_tag):
# Current packets group is over, publish all of its
# packets. It seems buffering is needed to avoid a
# skyrocketing CPU consumption, hence the ''.join()
self.publish_packet(b''.join(
itertools.chain.from_iterable((tag.raw_data, tag.body) for tag in self.packets_group)))
# And add it to the burst packets groups list
self.add_to_burst_groups(self.packets_group)
# Reset the current packets group
self.packets_group = collections.deque()
self.packets_group.append(flv_tag)
def add_to_burst_groups(self, group):
while ((len(self.burst_groups) >= 2) and
((group[0].timestamp -
self.burst_groups[1][0].timestamp) > self.BURST_DURATION)):
# We try to keep the burst data to at most
# BURST_DURATION seconds
self.burst_groups.popleft()
self.burst_groups_data.popleft()
self.burst_groups.append(group)
self.burst_groups_data.append(b''.join(
itertools.chain.from_iterable((tag.raw_data, tag.body) for tag in group)))
def is_sync_point(self, flv_tag):
if self.stream_header.video:
# If our stream has video, we need to sync on keyframes
if (flv_tag.tag_type == 'video'):
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
return (video_data.frame_type == 'keyframe')
else:
# It's either a non-keyframe video tag or an audio or
# metadata tag
return False
else:
# Audio only, no sync point needed
return True
class FLVSource(StreamSource):
# Initial burst duration, in milliseconds
BURST_DURATION = 5 * 1000
def __init__(
self,
server: "TCPServer",
sock: socket.socket,
address: tuple[str, int],
content_type: str,
request_parser: HTTPParser,
path: Optional[str] = None,
burst_size: Optional[int] = None,
on_demand: bool = False,
keepalive: Optional[int] = None,
) -> None:
super().__init__(server, sock, address, content_type, request_parser,
path, burst_size, on_demand, keepalive)
# Initial buffer data
self.buffer_data = request_parser.body
# The FLV stream header
self.stream_header: Optional[FLVHeader] = None
# These are the initial setup tags we send out to each new
# client
self.initial_tags: collections.deque[FLVTag] = collections.deque()
# Which type of initial tag we already got
self.got_initial_meta = self.got_initial_audio = self.got_initial_video = False
# Our current packets group
self.packets_group: collections.deque[FLVTag] = collections.deque()
# Our current "burst" packets groups list
self.burst_groups: collections.deque[
Sequence[FLVTag]] = collections.deque()
# List of buffers for the "burst" packets
self.burst_groups_data: collections.deque[bytes] = collections.deque()
# At startup we want to parse the stream header
self.handle_data = self.handle_header
def on_demand_deactivate(self) -> None:
StreamSource.on_demand_deactivate(self)
self.stream_header = None
self.got_initial_meta = self.got_initial_audio = self.got_initial_video = False
self.initial_tags.clear()
self.packets_group.clear()
self.burst_groups.clear()
self.burst_groups_data.clear()
self.handle_data = self.handle_header
self.buffer_data = b""
def on_demand_connected(self, sock: socket.socket,
request_parser: HTTPParser) -> None:
self.buffer_data = request_parser.body
super().on_demand_connected(sock, request_parser)
def new_client(self, client: "StreamClient") -> None:
super().new_client(client)
if self.stream_header:
client.add_packet(self.stream_header.raw_data)
for tag in self.initial_tags:
client.add_packet(tag.raw_data + tag.body)
for group_data in self.burst_groups_data:
client.add_packet(group_data)
def handle_packet(self, packet: bytes) -> None:
self.buffer_data = self.buffer_data + packet
while self.handle_data():
pass
def handle_header(self) -> bool:
if len(self.buffer_data) >= FLVHeader.object_size:
# We can try and parse the stream header
self.stream_header = FLVHeader()
nb_parsed = self.stream_header.parse(self.buffer_data)
self.publish_packet(self.stream_header.raw_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag
return True
else:
return False
def handle_tag(self) -> bool:
if len(self.buffer_data) >= FLVTag.object_size:
# We can try and parse one FLV tag
self.current_tag = FLVTag()
nb_parsed = self.current_tag.parse(self.buffer_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag_body
return True
else:
return False
def handle_tag_body(self) -> bool:
body_length = self.current_tag.data_size + self.current_tag.TRAILER_SIZE
if len(self.buffer_data) >= body_length:
self.current_tag.body = self.buffer_data[:body_length]
if self.check_for_initial_tag(self.current_tag):
# Tag is one of the initial tag, just publish it
self.publish_packet(self.current_tag.raw_data)
self.publish_packet(self.current_tag.body)
else:
# We need to add it to our current packets group
self.add_to_packets_group(self.current_tag)
self.buffer_data = self.buffer_data[body_length:]
self.handle_data = self.handle_tag
return True
else:
return False
def check_for_initial_tag(self, flv_tag: FLVTag) -> bool:
if not self.got_initial_meta and flv_tag.tag_type == "meta":
self.got_initial_meta = True
self.initial_tags.append(flv_tag)
return True
elif not self.got_initial_audio and flv_tag.tag_type == "audio":
audio_data = FLVAudioData()
audio_data.parse(flv_tag.body[:audio_data.object_size])
if audio_data.sound_format == "AAC" and audio_data.aac_packet_type == audio_data.AAC_SEQUENCE_HEADER:
self.got_initial_audio = True
self.initial_tags.append(flv_tag)
return True
elif not self.got_initial_video and flv_tag.tag_type == "video":
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
if video_data.codec == "AVC" and video_data.avc_packet_type == video_data.AVC_SEQUENCE_HEADER:
self.got_initial_video = True
self.initial_tags.append(flv_tag)
return True
return False
def add_to_packets_group(self, flv_tag: FLVTag) -> None:
if self.is_sync_point(flv_tag):
# Current packets group is over, publish all of its
# packets. It seems buffering is needed to avoid a
# skyrocketing CPU consumption, hence the ''.join()
self.publish_packet(b"".join(
itertools.chain.from_iterable(
(tag.raw_data, tag.body) for tag in self.packets_group)))
# And add it to the burst packets groups list
self.add_to_burst_groups(self.packets_group)
# Reset the current packets group
self.packets_group = collections.deque()
self.packets_group.append(flv_tag)
def add_to_burst_groups(self, group: Sequence[FLVTag]) -> None:
while (len(self.burst_groups) >= 2) and (
(group[0].timestamp - self.burst_groups[1][0].timestamp) >
self.BURST_DURATION):
# We try to keep the burst data to at most
# BURST_DURATION seconds
self.burst_groups.popleft()
self.burst_groups_data.popleft()
self.burst_groups.append(group)
self.burst_groups_data.append(b"".join(
itertools.chain.from_iterable(
(tag.raw_data, tag.body) for tag in group)))
def is_sync_point(self, flv_tag: FLVTag) -> bool:
if self.stream_header and self.stream_header.video:
# If our stream has video, we need to sync on keyframes
if flv_tag.tag_type == "video":
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
return video_data.frame_type == "keyframe"
else:
# It's either a non-keyframe video tag or an audio or
# metadata tag
return False
else:
# Audio only, no sync point needed
return True
class FLVSource(BufferedRawSource):
# Initial burst duration, in milliseconds
BURST_DURATION = 5 * 1000
def __init__(self,
sock,
server,
address,
content_type,
request_parser,
path=None):
BufferedRawSource.__init__(self, sock, server, address, content_type,
request_parser, path)
# Initial buffer data
self.buffer_data = request_parser.body
# The FLV stream header
self.stream_header = None
# These are the initial setup tags we send out to each new
# client
self.initial_tags = collections.deque()
# Which type of initial tag we already got
self.got_initial_meta = self.got_initial_audio = self.got_initial_video = False
# Our current "burst" packets groups list
self.burst_groups = collections.deque()
# At startup we want to parse the stream header
self.handle_data = self.handle_header
def new_client(self, client):
if self.stream_header:
client.add_packet(self.stream_header.raw_data)
for tag in self.initial_tags:
client.add_packet(tag.raw_data)
client.add_packet(tag.body)
for group in self.burst_groups:
for tag in group:
client.add_packet(tag.raw_data)
client.add_packet(tag.body)
def handle_event(self, eventmask):
if eventmask & looping.POLLIN:
while True:
packet = helpers.handle_eagain(self.sock.recv,
self.RECV_BUFFER_SIZE)
if packet == None:
# EAGAIN
break
elif packet == b'':
# End of stream
self.server.logger.warn('End of stream for %s, %s',
self.path,
(self.sock, self.address))
self.close()
# FIXME: publish "EOS" packet
break
else:
self.buffer_data = self.buffer_data + packet
while self.handle_data():
pass
else:
self.server.logger.error('%s: unexpected eventmask %s', self,
eventmask)
def handle_header(self):
if len(self.buffer_data) >= FLVHeader.object_size():
# We can try and parse the stream header
self.stream_header = FLVHeader()
nb_parsed = self.stream_header.parse(self.buffer_data)
self.publish_packet(self.stream_header.raw_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag
return True
else:
return False
def handle_tag(self):
if len(self.buffer_data) >= FLVTag.object_size():
# We can try and parse one FLV tag
self.current_tag = FLVTag()
nb_parsed = self.current_tag.parse(self.buffer_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag_body
return True
else:
return False
def handle_tag_body(self):
body_length = (self.current_tag.data_size +
self.current_tag.TRAILER_SIZE)
if len(self.buffer_data) >= body_length:
self.current_tag.body = self.buffer_data[:body_length]
if not self.check_for_initial_tag(self.current_tag):
# Tag is not one of the initial tag, but should we add
# it to our burst tags list ?
self.add_to_burst_groups(self.current_tag)
self.publish_packet(self.current_tag.raw_data)
self.publish_packet(self.current_tag.body)
self.buffer_data = self.buffer_data[body_length:]
self.handle_data = self.handle_tag
return True
else:
return False
def check_for_initial_tag(self, flv_tag):
if (not self.got_initial_meta and flv_tag.tag_type == 'meta'):
self.got_initial_meta = True
self.initial_tags.append(flv_tag)
return True
elif (not self.got_initial_audio and flv_tag.tag_type == 'audio'):
audio_data = FLVAudioData()
audio_data.parse(flv_tag.body[:audio_data.object_size])
if (audio_data.sound_format == 'AAC' and audio_data.aac_packet_type
== audio_data.AAC_SEQUENCE_HEADER):
self.got_initial_audio = True
self.initial_tags.append(flv_tag)
return True
elif (not self.got_initial_video and flv_tag.tag_type == 'video'):
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
if (video_data.codec == 'AVC' and video_data.avc_packet_type
== video_data.AVC_SEQUENCE_HEADER):
self.got_initial_video = True
self.initial_tags.append(flv_tag)
return True
return False
def add_to_burst_groups(self, flv_tag):
if self.is_sync_point(flv_tag) or len(self.burst_groups) == 0:
group = collections.deque((flv_tag, ))
while ((len(self.burst_groups) >= 2)
and ((flv_tag.timestamp - self.burst_groups[1][0].timestamp)
> self.BURST_DURATION)):
# We try to keep the burst data to at most
# BURST_DURATION seconds
self.burst_groups.popleft()
self.burst_groups.append(group)
else:
self.burst_groups[-1].append(flv_tag)
def is_sync_point(self, flv_tag):
if self.stream_header.video:
# If our stream has video, we need to sync on keyframes
if (flv_tag.tag_type == 'video'):
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
return (video_data.frame_type == 'keyframe')
else:
# It's either a non-keyframe video tag or an audio or
# metadata tag
return False
else:
# Audio only, no sync point needed
return True
class FLVSource(BufferedRawSource):
# Initial burst duration, in milliseconds
BURST_DURATION = 5 * 1000
def __init__(self, sock, server, address, content_type, request_parser, path = None):
BufferedRawSource.__init__(self, sock, server, address, content_type, request_parser, path)
# Initial buffer data
self.buffer_data = request_parser.body
# The FLV stream header
self.stream_header = None
# These are the initial setup tags we send out to each new
# client
self.initial_tags = collections.deque()
# Which type of initial tag we already got
self.got_initial_meta = self.got_initial_audio = self.got_initial_video = False
# Our current "burst" packets groups list
self.burst_groups = collections.deque()
# At startup we want to parse the stream header
self.handle_data = self.handle_header
def new_client(self, client):
if self.stream_header:
client.add_packet(self.stream_header.raw_data)
for tag in self.initial_tags:
client.add_packet(tag.raw_data)
client.add_packet(tag.body)
for group in self.burst_groups:
for tag in group:
client.add_packet(tag.raw_data)
client.add_packet(tag.body)
def handle_event(self, eventmask):
if eventmask & looping.POLLIN:
while True:
packet = helpers.handle_eagain(self.sock.recv, self.RECV_BUFFER_SIZE)
if packet == None:
# EAGAIN
break
elif packet == b'':
# End of stream
self.server.logger.warn('End of stream for %s, %s', self.path, (self.sock, self.address))
self.close()
# FIXME: publish "EOS" packet
break
else:
self.buffer_data = self.buffer_data + packet
while self.handle_data():
pass
else:
self.server.logger.error('%s: unexpected eventmask %s', self, eventmask)
def handle_header(self):
if len(self.buffer_data) >= FLVHeader.object_size():
# We can try and parse the stream header
self.stream_header = FLVHeader()
nb_parsed = self.stream_header.parse(self.buffer_data)
self.publish_packet(self.stream_header.raw_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag
return True
else:
return False
def handle_tag(self):
if len(self.buffer_data) >= FLVTag.object_size():
# We can try and parse one FLV tag
self.current_tag = FLVTag()
nb_parsed = self.current_tag.parse(self.buffer_data)
self.buffer_data = self.buffer_data[nb_parsed:]
self.handle_data = self.handle_tag_body
return True
else:
return False
def handle_tag_body(self):
body_length = (self.current_tag.data_size +
self.current_tag.TRAILER_SIZE)
if len(self.buffer_data) >= body_length:
self.current_tag.body = self.buffer_data[:body_length]
if not self.check_for_initial_tag(self.current_tag):
# Tag is not one of the initial tag, but should we add
# it to our burst tags list ?
self.add_to_burst_groups(self.current_tag)
self.publish_packet(self.current_tag.raw_data)
self.publish_packet(self.current_tag.body)
self.buffer_data = self.buffer_data[body_length:]
self.handle_data = self.handle_tag
return True
else:
return False
def check_for_initial_tag(self, flv_tag):
if (not self.got_initial_meta and flv_tag.tag_type == 'meta'):
self.got_initial_meta = True
self.initial_tags.append(flv_tag)
return True
elif (not self.got_initial_audio and flv_tag.tag_type == 'audio'):
audio_data = FLVAudioData()
audio_data.parse(flv_tag.body[:audio_data.object_size])
if (audio_data.sound_format == 'AAC' and
audio_data.aac_packet_type == audio_data.AAC_SEQUENCE_HEADER):
self.got_initial_audio = True
self.initial_tags.append(flv_tag)
return True
elif (not self.got_initial_video and flv_tag.tag_type == 'video'):
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
if (video_data.codec == 'AVC' and
video_data.avc_packet_type == video_data.AVC_SEQUENCE_HEADER):
self.got_initial_video = True
self.initial_tags.append(flv_tag)
return True
return False
def add_to_burst_groups(self, flv_tag):
if self.is_sync_point(flv_tag) or len(self.burst_groups) == 0:
group = collections.deque((flv_tag,))
while ((len(self.burst_groups) >= 2) and
((flv_tag.timestamp -
self.burst_groups[1][0].timestamp) > self.BURST_DURATION)):
# We try to keep the burst data to at most
# BURST_DURATION seconds
self.burst_groups.popleft()
self.burst_groups.append(group)
else:
self.burst_groups[-1].append(flv_tag)
def is_sync_point(self, flv_tag):
if self.stream_header.video:
# If our stream has video, we need to sync on keyframes
if (flv_tag.tag_type == 'video'):
video_data = FLVVideoData()
video_data.parse(flv_tag.body[:video_data.object_size])
return (video_data.frame_type == 'keyframe')
else:
# It's either a non-keyframe video tag or an audio or
# metadata tag
return False
else:
# Audio only, no sync point needed
return True