Handle empty VP8 headers.

Only the first byte of the VP8 header is mandatory, but we
used to reject packets smaller than 4 bytes.  The major part
of the fix is actually in pion/rtp.

codecs/codecs.go

@@ -233,7 +233,7 @@ type Flags struct {
 	Start           bool
 	End             bool
 	Keyframe        bool
-	Pid             uint16	// only returned for VP8
+	Pid             uint16 // only returned for VP8
 	Tid             uint8
 	Sid             uint8
 	TidUpSync       bool
@@ -243,7 +243,7 @@ type Flags struct {
 }
 
 func PacketFlags(codec string, buf []byte) (Flags, error) {
-	if len(buf) < 12 {
+	if len(buf) < 4 {
 		return Flags{}, errTruncated
 	}
 
@@ -309,7 +309,7 @@ func RewritePacket(codec string, data []byte, setMarker bool, seqno uint16, delt
 		return errTruncated
 	}
 
-	if(setMarker) {
+	if setMarker {
 		data[1] |= 0x80
 	}
 
@@ -321,7 +321,7 @@ func RewritePacket(codec string, data []byte, setMarker bool, seqno uint16, delt
 
 	offset := 12
 	offset += int(data[0]&0x0F) * 4
-	if len(data) < offset+4 {
+	if len(data) <= offset {
 		return errTruncated
 	}
 
@@ -339,19 +339,30 @@ func RewritePacket(codec string, data []byte, setMarker bool, seqno uint16, delt
 		if !x {
 			return nil
 		}
-		i := (data[offset+1] & 0x80) != 0
+		offset++
+		if len(data) <= offset {
+			return errTruncated
+		}
+		i := (data[offset] & 0x80) != 0
 		if !i {
 			return nil
 		}
-		m := (data[offset+2] & 0x80) != 0
+		offset++
+		if len(data) <= offset {
+			return errTruncated
+		}
+		m := (data[offset] & 0x80) != 0
 		if m {
-			pid := (uint16(data[offset+2]&0x7F) << 8) |
-				uint16(data[offset+3])
+			if len(data) <= offset+1 {
+				return errTruncated
+			}
+			pid := (uint16(data[offset]&0x7F) << 8) |
+				uint16(data[offset+1])
 			pid = (pid + delta) & 0x7FFF
-			data[offset+2] = 0x80 | byte((pid>>8)&0x7F)
-			data[offset+3] = byte(pid & 0xFF)
+			data[offset] = 0x80 | byte((pid>>8)&0x7F)
+			data[offset+1] = byte(pid & 0xFF)
 		} else {
-			data[offset+2] = (data[offset+2] + uint8(delta)) & 0x7F
+			data[offset] = (data[offset] + uint8(delta)) & 0x7F
 		}
 		return nil
 	}

codecs/codecs_test.go

@@ -138,6 +138,14 @@ var vp8 = []byte{
 	0, 0, 0, 0,
 }
 
+var emptyVP8 = []byte{
+	0x80, 0, 0, 42,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+
+	0x00,
+}
+
 func TestPacketFlagsVP8(t *testing.T) {
 	buf := append([]byte{}, vp8...)
 	flags, err := PacketFlags("video/vp8", buf)
@@ -151,6 +159,19 @@ func TestPacketFlagsVP8(t *testing.T) {
 	}
 }
 
+func TestEmptyPacketFlagsVP8(t *testing.T) {
+	buf := append([]byte{}, emptyVP8...)
+	flags, err := PacketFlags("video/vp8", buf)
+	if flags.Seqno != 42 || flags.Start ||
+		flags.Sid != 0 || flags.Tid != 0 ||
+		flags.TidUpSync || flags.Discardable || err != nil {
+		t.Errorf("Got %v, %v, %v, %v, %v, %v (%v)",
+			flags.Seqno, flags.Start, flags.Pid, flags.Sid,
+			flags.TidUpSync, flags.Discardable, err,
+		)
+	}
+}
+
 func TestRewriteVP8(t *testing.T) {
 	for i := uint16(0); i < 0x7fff; i++ {
 		buf := append([]byte{}, vp8...)
@@ -169,6 +190,24 @@ func TestRewriteVP8(t *testing.T) {
 	}
 }
 
+func TestRewriteEmptyVP8(t *testing.T) {
+	for i := uint16(0); i < 0x7fff; i++ {
+		buf := append([]byte{}, emptyVP8...)
+		err := RewritePacket("video/vp8", buf, true, i, i)
+		if err != nil {
+			t.Errorf("rewrite: %v", err)
+			continue
+		}
+		flags, err := PacketFlags("video/vp8", buf)
+		if err != nil || flags.Seqno != i ||
+			!flags.Marker {
+			t.Errorf("Expected %v %v, got %v %v (%v)",
+				i, (57+i)&0x7FFF,
+				flags.Seqno, flags.Pid, err)
+		}
+	}
+}
+
 var vp9 = []byte{
 	0x80, 0, 0, 42,
 	0, 0, 0, 0,