simplify sync packets

Author: Daniel Paulus

screencapture/packet/sync_afmt.go

@@ -3,15 +3,14 @@ package packet
 import (
 	"encoding/binary"
 	"fmt"
+
 	"github.com/danielpaulus/quicktime_video_hack/screencapture/common"
 	"github.com/danielpaulus/quicktime_video_hack/screencapture/coremedia"
 )
 
 // SyncAfmtPacket contains what I think is information about the audio format
 type SyncAfmtPacket struct {
-	SyncMagic                   uint32
 	ClockRef                    CFTypeID
-	MessageType                 uint32
 	CorrelationID               uint64
 	AudioStreamBasicDescription coremedia.AudioStreamBasicDescription
 }
@@ -23,20 +22,13 @@ func (sp SyncAfmtPacket) String() string {
 
 // NewSyncAfmtPacketFromBytes parses a new AsynFmtPacket from byte array
 func NewSyncAfmtPacketFromBytes(data []byte) (SyncAfmtPacket, error) {
-	var packet = SyncAfmtPacket{}
-	packet.SyncMagic = binary.LittleEndian.Uint32(data)
-	if packet.SyncMagic != SyncPacketMagic {
-		return packet, fmt.Errorf("invalid sync magic: %x", data)
-	}
-	packet.ClockRef = binary.LittleEndian.Uint64(data[4:])
-	packet.MessageType = binary.LittleEndian.Uint32(data[12:])
-	if packet.MessageType != AFMT {
-		return packet, fmt.Errorf("invalid packet type in sync afmt:%x", data)
+	remainingBytes, clockRef, correlationID, err := ParseSyncHeader(data, AFMT)
+	if err != nil {
+		return SyncAfmtPacket{}, err
 	}
-	packet.CorrelationID = binary.LittleEndian.Uint64(data[16:])
+	packet := SyncAfmtPacket{ClockRef: clockRef, CorrelationID: correlationID}
 
-	var err error
-	packet.AudioStreamBasicDescription, err = coremedia.NewAudioStreamBasicDescriptionFromBytes(data[24:])
+	packet.AudioStreamBasicDescription, err = coremedia.NewAudioStreamBasicDescriptionFromBytes(remainingBytes)
 	if err != nil {
 		return packet, fmt.Errorf("Error parsing AudioStreamBasicDescription data in asyn afmt: %s, ", err)
 	}

screencapture/packet/sync_afmt_test.go

@@ -18,15 +18,16 @@ func TestAfmt(t *testing.T) {
 	afmtPacket, err := packet.NewSyncAfmtPacketFromBytes(dat[4:])
 	if assert.NoError(t, err) {
 		assert.Equal(t, uint64(0x7fa66ce20cb0), afmtPacket.ClockRef)
-		assert.Equal(t, packet.SyncPacketMagic, afmtPacket.SyncMagic)
-		assert.Equal(t, packet.AFMT, afmtPacket.MessageType)
 		expectedAsbd := coremedia.DefaultAudioStreamBasicDescription()
 		expectedAsbd.FormatFlags = 0x4C
 		assert.Equal(t, expectedAsbd, afmtPacket.AudioStreamBasicDescription)
 		expectedString := "SYNC_AFMT{ClockRef:7fa66ce20cb0, CorrelationID:113229d80, AudioStreamBasicDescription:{SampleRate:48000.000000,FormatFlags:76,BytesPerPacket:4,FramesPerPacket:1,BytesPerFrame:4,ChannelsPerFrame:2,BitsPerChannel:16,Reserved:0}}"
 		assert.Equal(t, expectedString, afmtPacket.String())
 		testSerializationOfAfmtReply(afmtPacket, t)
 	}
+
+	_, err = packet.NewSyncAfmtPacketFromBytes(dat)
+	assert.Error(t, err)
 }
 
 func testSerializationOfAfmtReply(clok packet.SyncAfmtPacket, t *testing.T) {

screencapture/packet/sync_clok.go

@@ -1,32 +1,22 @@
 package packet
 
 import (
-	"encoding/binary"
 	"fmt"
 )
 
 //SyncClokPacket contains a decoded Clok packet from the device
 type SyncClokPacket struct {
-	SyncMagic     uint32
 	ClockRef      CFTypeID
-	MessageType   uint32
 	CorrelationID uint64
 }
 
 //NewSyncClokPacketFromBytes parses a SynClokPacket from bytes
 func NewSyncClokPacketFromBytes(data []byte) (SyncClokPacket, error) {
-	packet := SyncClokPacket{}
-	packet.SyncMagic = binary.LittleEndian.Uint32(data)
-	if packet.SyncMagic != SyncPacketMagic {
-		return packet, fmt.Errorf("invalid SYNC Clok Packet: %x", data)
+	_, clockRef, correlationID, err := ParseSyncHeader(data, CLOK)
+	if err != nil {
+		return SyncClokPacket{}, err
 	}
-
-	packet.ClockRef = binary.LittleEndian.Uint64(data[4:])
-	packet.MessageType = binary.LittleEndian.Uint32(data[12:])
-	if packet.MessageType != CLOK {
-		return packet, fmt.Errorf("wrong message type for Clok message: %x", packet.MessageType)
-	}
-	packet.CorrelationID = binary.LittleEndian.Uint64(data[16:])
+	packet := SyncClokPacket{ClockRef: clockRef, CorrelationID: correlationID}
 	return packet, nil
 }
 

screencapture/packet/sync_clok_test.go

@@ -1,11 +1,12 @@
 package packet_test
 
 import (
-	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
-	"github.com/stretchr/testify/assert"
 	"io/ioutil"
 	"log"
 	"testing"
+
+	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestClok(t *testing.T) {
@@ -16,11 +17,12 @@ func TestClok(t *testing.T) {
 	clok, err := packet.NewSyncClokPacketFromBytes(dat[4:])
 	if assert.NoError(t, err) {
 		assert.Equal(t, uint64(0x7fa66cd10250), clok.ClockRef)
-		assert.Equal(t, packet.SyncPacketMagic, clok.SyncMagic)
-		assert.Equal(t, packet.CLOK, clok.MessageType)
 		assert.Equal(t, uint64(0x113584970), clok.CorrelationID)
+		assert.Equal(t, "SYNC_CLOK{ClockRef:7fa66cd10250, CorrelationID:113584970}", clok.String())
 	}
 	testSerializationOfClokReply(clok, t)
+	_, err = packet.NewSyncClokPacketFromBytes(dat)
+	assert.Error(t, err)
 }
 
 func testSerializationOfClokReply(clok packet.SyncClokPacket, t *testing.T) {

screencapture/packet/sync_cvrp.go

@@ -3,38 +3,33 @@ package packet
 import (
 	"encoding/binary"
 	"fmt"
+
 	"github.com/danielpaulus/quicktime_video_hack/screencapture/coremedia"
 )
 
 //SyncCvrpPacket contains all info from a CVRP packet sent by the device
 type SyncCvrpPacket struct {
-	SyncMagic      uint32
 	ClockRef       CFTypeID
-	MessageType    uint32
 	CorrelationID  uint64
 	DeviceClockRef CFTypeID
 	Payload        coremedia.StringKeyDict
 }
 
 //NewSyncCvrpPacketFromBytes parses a SyncCvrpPacket from a []byte
 func NewSyncCvrpPacketFromBytes(data []byte) (SyncCvrpPacket, error) {
-	packet := SyncCvrpPacket{}
-	packet.SyncMagic = binary.LittleEndian.Uint32(data)
-	if packet.SyncMagic != SyncPacketMagic {
-		return packet, fmt.Errorf("invalid SYNC Cvrp Packet: %x", data)
+	remainingBytes, clockRef, correlationID, err := ParseSyncHeader(data, CVRP)
+	if err != nil {
+		return SyncCvrpPacket{}, err
 	}
-
+	packet := SyncCvrpPacket{ClockRef: clockRef, CorrelationID: correlationID}
 	packet.ClockRef = binary.LittleEndian.Uint64(data[4:])
 	if packet.ClockRef != EmptyCFType {
-		return packet, fmt.Errorf("Cvrp packet should have empty CFTypeID for ClockRef but has:%x", packet.ClockRef)
+		return packet, fmt.Errorf("CVRP packet should have empty CFTypeID for ClockRef but has:%x", packet.ClockRef)
 	}
-	packet.MessageType = binary.LittleEndian.Uint32(data[12:])
-	if packet.MessageType != CVRP {
-		return packet, fmt.Errorf("wrong message type for Cvrp message: %x", packet.MessageType)
-	}
-	packet.CorrelationID = binary.LittleEndian.Uint64(data[16:])
-	packet.DeviceClockRef = binary.LittleEndian.Uint64(data[24:])
-	payloadDict, err := coremedia.NewStringDictFromBytes(data[32:])
+
+	packet.DeviceClockRef = binary.LittleEndian.Uint64(remainingBytes)
+
+	payloadDict, err := coremedia.NewStringDictFromBytes(remainingBytes[8:])
 	if err != nil {
 		return packet, err
 	}

screencapture/packet/sync_cvrp_test.go

@@ -1,13 +1,16 @@
 package packet_test
 
 import (
-	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
-	"github.com/stretchr/testify/assert"
 	"io/ioutil"
 	"log"
 	"testing"
+
+	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
+	"github.com/stretchr/testify/assert"
 )
 
+const expectedCvrpString = "SYNC_CVRP{ClockRef:1, CorrelationID:1135659d0, DeviceClockRef:113538da0, Payload:StringKeyDict:[{PreparedQueueHighWaterLevel : StringKeyDict:[{flags : Int32[1]},{value : UInt64[5]},{timescale : Int32[30]},{epoch : UInt64[0]},]},{PreparedQueueLowWaterLevel : StringKeyDict:[{flags : Int32[1]},{value : UInt64[3]},{timescale : Int32[30]},{epoch : UInt64[0]},]},{FormatDescription : fdsc:{MediaType:Video, VideoDimension:(1126x2436), Codec:AVC-1, PPS:27640033ac5680470133e69e6e04040404, SPS:28ee3cb0, Extensions:IndexKeyDict:[{49 : IndexKeyDict:[{105 : 0x01640033ffe1001127640033ac5680470133e69e6e0404040401000428ee3cb0fdf8f800},]},{52 : H.264},]}},]}"
+
 func TestCvrp(t *testing.T) {
 	dat, err := ioutil.ReadFile("fixtures/cvrp-request")
 	if err != nil {
@@ -17,12 +20,13 @@ func TestCvrp(t *testing.T) {
 	if assert.NoError(t, err) {
 		assert.Equal(t, 3, len(cvrp.Payload.Entries))
 		assert.Equal(t, packet.EmptyCFType, cvrp.ClockRef)
-		assert.Equal(t, packet.SyncPacketMagic, cvrp.SyncMagic)
-		assert.Equal(t, packet.CVRP, cvrp.MessageType)
 		assert.Equal(t, uint64(0x113538da0), cvrp.DeviceClockRef)
 		assert.Equal(t, uint64(0x1135659d0), cvrp.CorrelationID)
+		assert.Equal(t, expectedCvrpString, cvrp.String())
 	}
 	testSerializationOfCvrpReply(cvrp, t)
+	_, err = packet.NewSyncCvrpPacketFromBytes(dat)
+	assert.Error(t, err)
 }
 
 func testSerializationOfCvrpReply(cvrp packet.SyncCvrpPacket, t *testing.T) {

screencapture/packet/sync_cwpa.go

@@ -7,32 +7,24 @@ import (
 
 //SyncCwpaPacket contains all info from a CWPA packet sent by the device
 type SyncCwpaPacket struct {
-	SyncMagic      uint32
 	ClockRef       CFTypeID
-	MessageType    uint32
 	CorrelationID  uint64
 	DeviceClockRef CFTypeID
 }
 
 //NewSyncCwpaPacketFromBytes parses a SyncCwpaPacket from a []byte
 func NewSyncCwpaPacketFromBytes(data []byte) (SyncCwpaPacket, error) {
-	var packet = SyncCwpaPacket{}
-
-	packet.SyncMagic = binary.LittleEndian.Uint32(data)
-	if packet.SyncMagic != SyncPacketMagic {
-		return packet, fmt.Errorf("invalid SYNC CWPA Packet: %x", data)
+	remainingBytes, clockRef, correlationID, err := ParseSyncHeader(data, CWPA)
+	if err != nil {
+		return SyncCwpaPacket{}, err
 	}
-
+	packet := SyncCwpaPacket{ClockRef: clockRef, CorrelationID: correlationID}
 	packet.ClockRef = binary.LittleEndian.Uint64(data[4:])
 	if packet.ClockRef != EmptyCFType {
 		return packet, fmt.Errorf("CWPA packet should have empty CFTypeID for ClockRef but has:%x", packet.ClockRef)
 	}
-	packet.MessageType = binary.LittleEndian.Uint32(data[12:])
-	if packet.MessageType != CWPA {
-		return packet, fmt.Errorf("wrong message type for CWPA message: %x", packet.MessageType)
-	}
-	packet.CorrelationID = binary.LittleEndian.Uint64(data[16:])
-	packet.DeviceClockRef = binary.LittleEndian.Uint64(data[24:])
+
+	packet.DeviceClockRef = binary.LittleEndian.Uint64(remainingBytes)
 	return packet, nil
 }
 

screencapture/packet/sync_cwpa_test.go

@@ -1,11 +1,12 @@
 package packet_test
 
 import (
-	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
-	"github.com/stretchr/testify/assert"
 	"io/ioutil"
 	"log"
 	"testing"
+
+	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCwpa(t *testing.T) {
@@ -16,10 +17,9 @@ func TestCwpa(t *testing.T) {
 	cwpa, err := packet.NewSyncCwpaPacketFromBytes(dat[4:])
 	if assert.NoError(t, err) {
 		assert.Equal(t, packet.EmptyCFType, cwpa.ClockRef)
-		assert.Equal(t, packet.SyncPacketMagic, cwpa.SyncMagic)
-		assert.Equal(t, packet.CWPA, cwpa.MessageType)
 		assert.Equal(t, uint64(0x1135a74e0), cwpa.DeviceClockRef)
 		assert.Equal(t, uint64(0x113573de0), cwpa.CorrelationID)
+		assert.Equal(t, "SYNC_CWPA{ClockRef:1, CorrelationID:113573de0, DeviceClockRef:1135a74e0}", cwpa.String())
 	}
 	_, err = packet.NewSyncCwpaPacketFromBytes(dat)
 	assert.Error(t, err)

screencapture/packet/sync_og.go

@@ -7,28 +7,20 @@ import (
 
 //SyncOgPacket represents the OG Message. I do not know what these messages mean.
 type SyncOgPacket struct {
-	SyncMagic     uint32
 	ClockRef      CFTypeID
-	MessageType   uint32
 	CorrelationID uint64
 	Unknown       uint32
 }
 
 //NewSyncOgPacketFromBytes parses a SyncOgPacket form bytes assuming it starts with SYNC magic and has the correct length.
 func NewSyncOgPacketFromBytes(data []byte) (SyncOgPacket, error) {
-	packet := SyncOgPacket{}
-	packet.SyncMagic = binary.LittleEndian.Uint32(data)
-	if packet.SyncMagic != SyncPacketMagic {
-		return packet, fmt.Errorf("invalid SYNC Og Packet: %x", data)
+	remainingBytes, clockRef, correlationID, err := ParseSyncHeader(data, OG)
+	if err != nil {
+		return SyncOgPacket{}, err
 	}
+	packet := SyncOgPacket{ClockRef: clockRef, CorrelationID: correlationID}
 
-	packet.ClockRef = binary.LittleEndian.Uint64(data[4:])
-	packet.MessageType = binary.LittleEndian.Uint32(data[12:])
-	if packet.MessageType != OG {
-		return packet, fmt.Errorf("wrong message type for OG message: %x", packet.MessageType)
-	}
-	packet.CorrelationID = binary.LittleEndian.Uint64(data[16:])
-	packet.Unknown = binary.LittleEndian.Uint32(data[24:])
+	packet.Unknown = binary.LittleEndian.Uint32(remainingBytes)
 	return packet, nil
 }
 

screencapture/packet/sync_og_test.go

@@ -1,26 +1,28 @@
 package packet_test
 
 import (
-	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
-	"github.com/stretchr/testify/assert"
 	"io/ioutil"
 	"log"
 	"testing"
+
+	"github.com/danielpaulus/quicktime_video_hack/screencapture/packet"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestOg(t *testing.T) {
 	dat, err := ioutil.ReadFile("fixtures/og-request")
 	if err != nil {
 		log.Fatal(err)
 	}
-	clok, err := packet.NewSyncOgPacketFromBytes(dat[4:])
+	og, err := packet.NewSyncOgPacketFromBytes(dat[4:])
 	if assert.NoError(t, err) {
-		assert.Equal(t, uint64(0x7fba35425ff0), clok.ClockRef)
-		assert.Equal(t, packet.SyncPacketMagic, clok.SyncMagic)
-		assert.Equal(t, packet.OG, clok.MessageType)
-		assert.Equal(t, uint64(0x102d32f30), clok.CorrelationID)
+		assert.Equal(t, uint64(0x7fba35425ff0), og.ClockRef)
+		assert.Equal(t, uint64(0x102d32f30), og.CorrelationID)
+		assert.Equal(t, "SYNC_OG{ClockRef:7fba35425ff0, CorrelationID:102d32f30, Unknown:1}", og.String())
 	}
-	testSerializationOfOgReply(clok, t)
+	testSerializationOfOgReply(og, t)
+	_, err = packet.NewSyncOgPacketFromBytes(dat)
+	assert.Error(t, err)
 }
 
 func testSerializationOfOgReply(clok packet.SyncOgPacket, t *testing.T) {