def test_video_control(packets, channels):
    data = packets['tcp_video_control']

    payload = factory.video.control(request_keyframe=True, start_stream=True)
    msg = factory.streamer_tcp(sequence_num=2,
                               prev_sequence_num=1,
                               payload_type=enum.VideoPayloadType.Control,
                               payload=payload.container)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header(sequence_num=1, timestamp=188277389, csrc_list=[])
    msg.header.ssrc(channel_id=1024)

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 2
    assert msg.header.streamer.prev_sequence_num == 1
    assert msg.header.streamer.type == enum.VideoPayloadType.Control

    assert msg.payload.flags.request_keyframe is True
    assert msg.payload.flags.start_stream is True
    assert msg.payload.flags.stop_stream is False
    assert msg.payload.flags.queue_depth is False
    assert msg.payload.flags.lost_frames is False
    assert msg.payload.flags.last_displayed_frame is False

    assert len(packed) == len(data)
    assert packed == data
def test_input_client_handshake(packets, channels):
    data = packets['tcp_input_client_handshake']

    ref_ts = datetime.datetime.utcfromtimestamp(1498690645999 / 1000)

    payload = factory.input.client_handshake(max_touches=10,
                                             reference_timestamp=ref_ts)
    msg = factory.streamer_tcp(
        sequence_num=1,
        prev_sequence_num=0,
        payload_type=enum.InputPayloadType.ClientHandshake,
        payload=payload)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header.ssrc(channel_id=1028)
    msg.header(sequence_num=0, timestamp=2376737668, csrc_list=[])

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 1
    assert msg.header.streamer.prev_sequence_num == 0
    assert msg.header.streamer.type == enum.InputPayloadType.ClientHandshake

    assert msg.payload.max_touches == 10
    assert msg.payload.reference_timestamp == ref_ts

    assert len(packed) == len(data)
    assert packed == data
def test_audio_control(packets, channels):
    data = packets['tcp_audio_control']

    payload = factory.audio.control(reinitialize=False,
                                    start_stream=True,
                                    stop_stream=False)
    msg = factory.streamer_tcp(sequence_num=2,
                               prev_sequence_num=1,
                               payload_type=enum.AudioPayloadType.Control,
                               payload=payload.container)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header(sequence_num=1, timestamp=3916375209, csrc_list=[])
    msg.header.ssrc(channel_id=1025)

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 2
    assert msg.header.streamer.prev_sequence_num == 1
    assert msg.header.streamer.type == enum.AudioPayloadType.Control

    assert msg.payload.flags.reinitialize is False
    assert msg.payload.flags.start_stream is True
    assert msg.payload.flags.stop_stream is False

    assert len(packed) == len(data)
    assert packed == data
def test_control_msg_with_header_change_video_quality(packets, channels):
    data = packets['tcp_control_msg_with_header_change_video_quality']

    payload = factory.control.change_video_quality(3000001, 1, 30000, 1001,
                                                   3600, 0)

    control_header = factory.control.control_header(
        prev_seq_dup=2,
        unk1=1,
        unk2=1406,
        opcode=enum.ControlPayloadType.ChangeVideoQuality,
        payload=payload.container)

    msg = factory.streamer_tcp(sequence_num=3,
                               prev_sequence_num=2,
                               payload_type=0,
                               payload=control_header)

    msg.header.ssrc(channel_id=1027)
    msg.header(sequence_num=2, timestamp=852112921)
    packed = packer.pack_tcp([msg], channels)

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 3
    assert msg.header.streamer.prev_sequence_num == 2
    assert msg.header.streamer.type == 0

    assert msg.payload.prev_seq_dup == 2
    assert msg.payload.unk1 == 1
    assert msg.payload.unk2 == 1406
    assert msg.payload.opcode == enum.ControlPayloadType.ChangeVideoQuality

    assert len(packed) == len(data)
    assert packed == data
Ejemplo n.º 5
0
    def send_tcp_streamer(self, payload_type, payload):
        prev_seq = self.sequence_num
        msg = factory.streamer_tcp(
            self.next_sequence_num, prev_seq, payload_type, payload,
            channel_id=self.id
        )

        self.protocol.control_protocol.send_message(msg)
def test_video_client_handshake(packets, channels):
    data = packets['tcp_video_client_handshake']

    requested_format = packet.video.fmt(fps=30,
                                        width=1280,
                                        height=720,
                                        codec=0)
    payload = factory.video.client_handshake(
        initial_frame_id=3715731054,
        requested_format=requested_format.container)
    msg = factory.streamer_tcp(
        sequence_num=1,
        prev_sequence_num=0,
        payload_type=enum.VideoPayloadType.ClientHandshake,
        payload=payload)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header.ssrc(channel_id=1024)
    msg.header(sequence_num=0, timestamp=1055413470, csrc_list=[])

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 1
    assert msg.header.streamer.prev_sequence_num == 0
    assert msg.header.streamer.type == enum.VideoPayloadType.ClientHandshake

    assert msg.payload.initial_frame_id == 3715731054
    assert msg.payload.requested_format.fps == 30
    assert msg.payload.requested_format.width == 1280
    assert msg.payload.requested_format.height == 720
    assert msg.payload.requested_format.codec == 0

    assert len(packed) == len(data)
    assert packed == data
def test_audio_server_handshake(packets, channels):
    data = packets['tcp_audio_server_handshake']

    format = packet.audio.fmt(channels=2, sample_rate=48000, codec=1)
    ref_ts = datetime.datetime.utcfromtimestamp(1495315092424 / 1000)

    payload = factory.audio.server_handshake(protocol_version=4,
                                             reference_timestamp=ref_ts,
                                             formats=[format.container])
    msg = factory.streamer_tcp(
        sequence_num=1,
        prev_sequence_num=0,
        payload_type=enum.AudioPayloadType.ServerHandshake,
        payload=payload)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header.ssrc(channel_id=1025)
    msg.header(sequence_num=0, timestamp=0, csrc_list=[])

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 1
    assert msg.header.streamer.prev_sequence_num == 0
    assert msg.header.streamer.type == enum.AudioPayloadType.ServerHandshake

    assert msg.payload.protocol_version == 4
    assert msg.payload.reference_timestamp == ref_ts
    assert len(msg.payload.formats) == 1
    assert msg.payload.formats[0].channels == 2
    assert msg.payload.formats[0].sample_rate == 48000
    assert msg.payload.formats[0].codec == 1

    assert len(packed) == len(data)
    assert packed == data
def test_control_msg_with_header(packets, channels):
    data = packets['tcp_control_msg_with_header']

    payload = factory.control.realtime_telemetry(data=[
        Container(key=12, value=0),
        Container(key=7, value=0),
        Container(key=11, value=1),
        Container(key=6, value=0),
        Container(key=1, value=0),
        Container(key=5, value=52)
    ])
    control_header = factory.control.control_header(
        prev_seq_dup=0,
        unk1=1,
        unk2=1406,
        opcode=enum.ControlPayloadType.RealtimeTelemetry,
        payload=payload.container)
    msg = factory.streamer_tcp(sequence_num=1,
                               prev_sequence_num=0,
                               payload_type=0,
                               payload=control_header)
    msg.header.flags(csrc_count=0)
    msg.header.ssrc(channel_id=1027)

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 1
    assert msg.header.streamer.prev_sequence_num == 0
    assert msg.header.streamer.type == 0

    assert msg.payload.prev_seq_dup == 0
    assert msg.payload.unk1 == 1
    assert msg.payload.unk2 == 1406
    assert msg.payload.opcode == enum.ControlPayloadType.RealtimeTelemetry

    assert len(packed) == len(data)
    assert packed == data
def test_input_server_handshake(packets, channels):
    data = packets['tcp_input_server_handshake']

    payload = factory.input.server_handshake(protocol_version=3,
                                             desktop_width=1280,
                                             desktop_height=720,
                                             max_touches=0,
                                             initial_frame_id=672208545)
    msg = factory.streamer_tcp(
        sequence_num=1,
        prev_sequence_num=0,
        payload_type=enum.InputPayloadType.ServerHandshake,
        payload=payload.container)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header.ssrc(channel_id=1028)
    msg.header(sequence_num=0, timestamp=360018603, csrc_list=[])

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 1
    assert msg.header.streamer.prev_sequence_num == 0
    assert msg.header.streamer.type == enum.InputPayloadType.ServerHandshake

    assert msg.payload.protocol_version == 3
    assert msg.payload.desktop_width == 1280
    assert msg.payload.desktop_height == 720
    assert msg.payload.max_touches == 0
    assert msg.payload.initial_frame_id == 672208545

    assert len(packed) == len(data)
    assert packed == data
def test_audio_client_handshake(packets, channels):
    data = packets['tcp_audio_client_handshake']

    requested_format = packet.audio.fmt(channels=2, sample_rate=48000, codec=1)
    payload = factory.audio.client_handshake(
        initial_frame_id=693041842,
        requested_format=requested_format.container)
    msg = factory.streamer_tcp(
        sequence_num=1,
        prev_sequence_num=0,
        payload_type=enum.AudioPayloadType.ClientHandshake,
        payload=payload)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header.ssrc(channel_id=1025)
    msg.header(sequence_num=0, timestamp=1055413470, csrc_list=[])

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 1
    assert msg.header.streamer.prev_sequence_num == 0
    assert msg.header.streamer.type == enum.AudioPayloadType.ClientHandshake

    assert msg.payload.initial_frame_id == 693041842
    assert msg.payload.requested_format.channels == 2
    assert msg.payload.requested_format.sample_rate == 48000
    assert msg.payload.requested_format.codec == 1

    assert len(packed) == len(data)
    assert packed == data
def test_video_server_handshake(packets, channels):
    data = packets['tcp_video_server_handshake']

    ref_ts = datetime.datetime.utcfromtimestamp(1495315092425 / 1000)

    formats = [
        packet.video.fmt(fps=30, width=1280, height=720, codec=0).container,
        packet.video.fmt(fps=30, width=960, height=540, codec=0).container,
        packet.video.fmt(fps=30, width=640, height=360, codec=0).container,
        packet.video.fmt(fps=30, width=320, height=180, codec=0).container
    ]

    payload = factory.video.server_handshake(protocol_version=5,
                                             width=1280,
                                             height=720,
                                             fps=30,
                                             reference_timestamp=ref_ts,
                                             formats=formats)
    msg = factory.streamer_tcp(
        sequence_num=1,
        prev_sequence_num=0,
        payload_type=enum.VideoPayloadType.ServerHandshake,
        payload=payload.container)
    msg.header.flags(csrc_count=0,
                     version=2,
                     extension=False,
                     marker=False,
                     padding=False)
    msg.header.ssrc(channel_id=1024)
    msg.header(sequence_num=0, timestamp=0, csrc_list=[])

    packed = packer.pack(msg, channels)

    assert msg.header.flags.payload_type == enum.RtpPayloadType.Streamer

    assert msg.header.streamer.streamer_version == 3
    assert msg.header.streamer.sequence_num == 1
    assert msg.header.streamer.prev_sequence_num == 0
    assert msg.header.streamer.type == enum.VideoPayloadType.ServerHandshake

    assert msg.payload.protocol_version == 5
    assert msg.payload.width == 1280
    assert msg.payload.height == 720
    assert msg.payload.fps == 30
    assert msg.payload.reference_timestamp == ref_ts
    assert len(msg.payload.formats) == 4

    assert msg.payload.formats[0].fps == 30
    assert msg.payload.formats[0].width == 1280
    assert msg.payload.formats[0].height == 720
    assert msg.payload.formats[0].codec == 0
    assert msg.payload.formats[1].fps == 30
    assert msg.payload.formats[1].width == 960
    assert msg.payload.formats[1].height == 540
    assert msg.payload.formats[1].codec == 0
    assert msg.payload.formats[2].fps == 30
    assert msg.payload.formats[2].width == 640
    assert msg.payload.formats[2].height == 360
    assert msg.payload.formats[2].codec == 0
    assert msg.payload.formats[3].fps == 30
    assert msg.payload.formats[3].width == 320
    assert msg.payload.formats[3].height == 180
    assert msg.payload.formats[3].codec == 0

    assert len(packed) == len(data)
    assert packed == data