Rewrite CMSampleBufParser to fix #38 (#41)

* added testcase to repro TTAS FEED packet issue

* fixed broken TTAS

* add checks for sample buffers without sample data in consumers

Co-authored-by: DanielPaulusContentful <[email protected]>

Author: danielpaulus

screencapture/coremedia/avfilewriter.go

@@ -44,6 +44,9 @@ func (avfw AVFileWriter) consumeVideo(buf CMSampleBuffer) error {
 			return err
 		}
 	}
+	if !buf.HasSampleData() {
+		return nil
+	}
 	return avfw.writeNalus(buf.SampleData)
 }
 
@@ -73,6 +76,9 @@ func (avfw AVFileWriter) writeNalu(naluBytes []byte) error {
 }
 
 func (avfw AVFileWriter) consumeAudio(buffer CMSampleBuffer) error {
+	if !buffer.HasSampleData() {
+		return nil
+	}
 	_, err := avfw.wavFileWriter.Write(buffer.SampleData)
 	if err != nil {
 		return err

screencapture/coremedia/cmsamplebuf.go

@@ -2,6 +2,7 @@ package coremedia
 
 import (
 	"encoding/binary"
+	"encoding/hex"
 	"fmt"
 
 	"github.com/danielpaulus/quicktime_video_hack/screencapture/common"
@@ -44,6 +45,10 @@ func (info CMSampleTimingInfo) String() string {
 		info.Duration, info.PresentationTimeStamp, info.DecodeTimeStamp)
 }
 
+func (buffer CMSampleBuffer) HasSampleData() bool {
+	return buffer.SampleData != nil
+}
+
 //CMSampleBuffer represents the CoreMedia class used to exchange AV SampleData and contains meta information like timestamps or
 //optional FormatDescriptors
 type CMSampleBuffer struct {
@@ -98,75 +103,69 @@ func NewCMSampleBufferFromBytes(data []byte, mediaType uint32) (CMSampleBuffer,
 	if length > len(data) {
 		return sbuffer, fmt.Errorf("less data (%d bytes) in buffer than expected (%d bytes)", len(data), length)
 	}
-
-	_, remainingBytes, err = common.ParseLengthAndMagic(remainingBytes, opts)
-	if err != nil {
-		return sbuffer, err
-	}
-	cmtime, err := NewCMTimeFromBytes(remainingBytes)
-	if err != nil {
-		return sbuffer, err
-	}
-	sbuffer.OutputPresentationTimestamp = cmtime
-	sbuffer.SampleTimingInfoArray, remainingBytes, err = parseStia(remainingBytes[24:])
-	if err != nil {
-		return sbuffer, err
-	}
-
-	length, remainingBytes, err = common.ParseLengthAndMagic(remainingBytes, sdat)
-	if err != nil {
-		return sbuffer, err
-	}
-	sbuffer.SampleData = remainingBytes[:length-8]
-	length, remainingBytes, err = common.ParseLengthAndMagic(remainingBytes[length-8:], nsmp)
-	if err != nil {
-		return sbuffer, err
-	}
-	if length != 12 {
-		return sbuffer, fmt.Errorf("invalid length for nsmp %d, should be 12", length)
-	}
-	sbuffer.NumSamples = int(binary.LittleEndian.Uint32(remainingBytes))
-
-	sbuffer.SampleSizes, remainingBytes, err = parseSampleSizeArray(remainingBytes[4:])
-	if err != nil {
-		return sbuffer, err
-	}
-
-	//audio buffers usually end after samplesize
-	if len(remainingBytes) == 0 {
-		return sbuffer, nil
-	}
-	if binary.LittleEndian.Uint32(remainingBytes[4:]) == FormatDescriptorMagic {
-		sbuffer.HasFormatDescription = true
-		fdscLength := binary.LittleEndian.Uint32(remainingBytes)
-		sbuffer.FormatDescription, err = NewFormatDescriptorFromBytes(remainingBytes[:fdscLength])
-		if err != nil {
-			return sbuffer, err
+	for len(remainingBytes) > 0 {
+		switch binary.LittleEndian.Uint32(remainingBytes[4:]) {
+		case opts:
+			cmtime, err := NewCMTimeFromBytes(remainingBytes[8:])
+			if err != nil {
+				return sbuffer, err
+			}
+			sbuffer.OutputPresentationTimestamp = cmtime
+			remainingBytes = remainingBytes[32:]
+		case stia:
+			sbuffer.SampleTimingInfoArray, remainingBytes, err = parseStia(remainingBytes)
+			if err != nil {
+				return sbuffer, err
+			}
+		case sdat:
+			length, remainingBytes, err = common.ParseLengthAndMagic(remainingBytes, sdat)
+			if err != nil {
+				return sbuffer, err
+			}
+			sbuffer.SampleData = remainingBytes[:length-8]
+			remainingBytes = remainingBytes[length-8:]
+		case nsmp:
+
+			length, remainingBytes, err = common.ParseLengthAndMagic(remainingBytes, nsmp)
+			if err != nil {
+				return sbuffer, err
+			}
+			if length != 12 {
+				return sbuffer, fmt.Errorf("invalid length for nsmp %d, should be 12", length)
+			}
+			sbuffer.NumSamples = int(binary.LittleEndian.Uint32(remainingBytes))
+			remainingBytes = remainingBytes[4:]
+		case ssiz:
+			sbuffer.SampleSizes, remainingBytes, err = parseSampleSizeArray(remainingBytes)
+			if err != nil {
+				return sbuffer, err
+			}
+		case FormatDescriptorMagic:
+			sbuffer.HasFormatDescription = true
+			fdscLength := binary.LittleEndian.Uint32(remainingBytes)
+			sbuffer.FormatDescription, err = NewFormatDescriptorFromBytes(remainingBytes[:fdscLength])
+			if err != nil {
+				return sbuffer, err
+			}
+			remainingBytes = remainingBytes[fdscLength:]
+		case satt:
+			attachmentsLength := binary.LittleEndian.Uint32(remainingBytes)
+			sbuffer.Attachments, err = NewIndexDictFromBytesWithCustomMarker(remainingBytes[:attachmentsLength], satt)
+			if err != nil {
+				return sbuffer, err
+			}
+			remainingBytes = remainingBytes[attachmentsLength:]
+		case sary:
+			saryLength := binary.LittleEndian.Uint32(remainingBytes)
+			sbuffer.Sary, err = NewIndexDictFromBytes(remainingBytes[8:saryLength])
+			remainingBytes = remainingBytes[saryLength:]
+		default:
+			unknownMagic := string(remainingBytes[4:8])
+			return sbuffer, fmt.Errorf("unknown magic type:%s (0x%x), cannot parse value %s", unknownMagic, remainingBytes[4:8], hex.Dump(remainingBytes))
 		}
-		remainingBytes = remainingBytes[fdscLength:]
-	}
-	//audio buffers usually end after samplesize
-	if len(remainingBytes) == 0 {
-		return sbuffer, nil
-	}
 
-	attachmentsLength := binary.LittleEndian.Uint32(remainingBytes)
-	sbuffer.Attachments, err = NewIndexDictFromBytesWithCustomMarker(remainingBytes[:attachmentsLength], satt)
-	if err != nil {
-		return sbuffer, err
-	}
-	remainingBytes = remainingBytes[attachmentsLength:]
-	saryLength := binary.LittleEndian.Uint32(remainingBytes)
-	if binary.LittleEndian.Uint32(remainingBytes[4:]) != sary {
-		return sbuffer, fmt.Errorf("wrong magic, expected sary got:%x", remainingBytes[4:8])
-	}
-	sbuffer.Sary, err = NewIndexDictFromBytes(remainingBytes[8:saryLength])
-	if err != nil {
-		return sbuffer, err
-	}
-	if len(remainingBytes[saryLength:]) != 0 {
-		return sbuffer, fmt.Errorf("CmSampleBuf should have been read completely but still contains bytes: %x", remainingBytes[saryLength:])
 	}
+
 	return sbuffer, nil
 }
 

screencapture/coremedia/cmsamplebuf_test.go

@@ -1,6 +1,7 @@
 package coremedia_test
 
 import (
+	"encoding/binary"
 	"io/ioutil"
 	"log"
 	"testing"
@@ -9,6 +10,35 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestFeedNoSdat(t *testing.T) {
+	dat, err := ioutil.ReadFile("../packet/fixtures/asyn-feed-ttas-only")
+	if err != nil {
+		log.Fatal(err)
+	}
+	sbufPacket, err := coremedia.NewCMSampleBufferFromBytesVideo(dat[20:])
+
+	if assert.NoError(t, err) {
+		assert.Equal(t, false, sbufPacket.HasFormatDescription)
+
+	}
+	print(sbufPacket.String())
+}
+
+func TestUnknownMagic(t *testing.T) {
+	dat, err := ioutil.ReadFile("../packet/fixtures/asyn-feed-ttas-only")
+	if err != nil {
+		log.Fatal(err)
+	}
+	binary.LittleEndian.PutUint32(dat[32:], 0x75756c6c)
+
+	_, err = coremedia.NewCMSampleBufferFromBytesVideo(dat[20:])
+
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "lluu")
+	}
+
+}
+
 func TestCMSampleBuffer(t *testing.T) {
 	dat, err := ioutil.ReadFile("../packet/fixtures/asyn-feed")
 	if err != nil {

screencapture/gstadapter/gst_adapter_linux.go

@@ -227,6 +227,9 @@ func checkElem(e *gst.Element, name string) {
 //Consume will transfer AV data into a Gstreamer AppSrc
 func (gsta *GstAdapter) Consume(buf coremedia.CMSampleBuffer) error {
 	if buf.MediaType == coremedia.MediaTypeSound {
+		if !buf.HasSampleData() {
+			return nil
+		}
 		if gsta.firstAudioSample {
 			gsta.firstAudioSample = false
 			gsta.sendWavHeader()
@@ -252,6 +255,9 @@ func (gsta *GstAdapter) Consume(buf coremedia.CMSampleBuffer) error {
 			return err
 		}
 	}
+	if !buf.HasSampleData() {
+		return nil
+	}
 	gsta.writeNalus(buf)
 
 	return nil