Merge pull request #28 from danielpaulus/addAiffFileSupport

Add wav file support

Author: danielpaulus

README.md

@@ -18,8 +18,8 @@ So if you are just interested in the protocol or if you want to implement this i
 run `go run main.go --help` to see how it works
 
 Progress:
-1. ~~Make the `go run main.go dumpraw` work on the first execution (currently you have to run it twice and it will start recording on the second run)~~
-2. FIX: After running the dumpraw command and saving a video, you have to unplug the device to record another video currently
+1. ~~Make the `go run main.go record` work on the first execution (currently you have to run it twice and it will start recording on the second run)~~
+2. FIX: After running the record command and saving a video, you have to unplug the device to record another video currently
 3. Make a release :-D
 4. Generate GStreamer compatible x264 stream probably by wrapping the NaLus in RTP headers
 5. ~~Complete packet documentation~~
@@ -39,7 +39,7 @@ Extra Goals:
 
 2. What does not work
 
-This might be wrong, needs investigation--> `qvh dumpraw` won't work on MAC OS because the binary needs to be codesigned with `com.apple.ibridge.control`
+This might be wrong, needs investigation--> `qvh record` won't work on MAC OS because the binary needs to be codesigned with `com.apple.ibridge.control`
  apparently that is a protected Entitlement that I have no idea how to use or sign my binary with. 
 
 2. Make sure to use either this fork `https://github.com/GroundControl-Solutions/libusb`

log/core_media_research.md

@@ -20,4 +20,7 @@ cmTime.Value = 88200;
 https://github.com/xamarin/xamarin-macios/tree/master/src/CoreMedia
 
 ### Core Media Headers
-https://github.com/phracker/MacOSX-SDKs/tree/master/MacOSX10.9.sdk/System/Library/Frameworks/CoreMedia.framework
+https://github.com/phracker/MacOSX-SDKs/tree/master/MacOSX10.9.sdk/System/Library/Frameworks/CoreMedia.framework
+
+### what does packed mean
+https://developer.apple.com/library/archive/documentation/MusicAudio/Reference/CAFSpec/CAF_spec/CAF_spec.html#//apple_ref/doc/uid/TP40001862-CH210-BCGJEBBI

main.go

@@ -2,12 +2,13 @@ package main
 
 import (
 	"bufio"
+	"os"
+	"os/signal"
+
 	"github.com/danielpaulus/quicktime_video_hack/screencapture"
 	"github.com/danielpaulus/quicktime_video_hack/screencapture/coremedia"
 	"github.com/docopt/docopt-go"
 	log "github.com/sirupsen/logrus"
-	"os"
-	"os/signal"
 )
 
 func main() {
@@ -17,7 +18,7 @@ func main() {
 Usage:
   qvh devices
   qvh activate
-  qvh dumpraw <outfile>
+  qvh record <h264file> <wavfile>
  
 Options:
   -h --help     Show this screen.
@@ -28,8 +29,9 @@ Options:
 The commands work as following:
 	devices		lists iOS devices attached to this host and tells you if video streaming was activated for them
 	activate	only enables the video streaming config for the given device
-	dumpraw		will start video recording and dump it to a raw h264 file playable by VLC. 
-				Run like: "qvh dumpraw /home/yourname/out.h264"
+	record		will start video&audio recording. Video will be saved in a raw h264 file playable by VLC.
+				Audio will be saved in a uncompressed wav file.
+				Run like: "qvh record /home/yourname/out.h264 /home/yourname/out.wav"
   `
 	arguments, _ := docopt.ParseDoc(usage)
 	//TODO: add verbose switch to conf this
@@ -50,14 +52,19 @@ The commands work as following:
 		return
 	}
 
-	rawStreamCommand, _ := arguments.Bool("dumpraw")
+	rawStreamCommand, _ := arguments.Bool("record")
 	if rawStreamCommand {
-		outFilePath, err := arguments.String("<outfile>")
+		h264FilePath, err := arguments.String("<h264file>")
 		if err != nil {
-			log.Error("Missing outfile parameter. Please specify a valid path like '/home/me/out.h264'")
+			log.Error("Missing <h264file> parameter. Please specify a valid path like '/home/me/out.h264'")
 			return
 		}
-		dumpraw(outFilePath)
+		waveFilePath, err := arguments.String("<wavfile>")
+		if err != nil {
+			log.Error("Missing <wavfile> parameter. Please specify a valid path like '/home/me/out.raw'")
+			return
+		}
+		record(h264FilePath, waveFilePath)
 	}
 }
 
@@ -118,23 +125,49 @@ func activate() {
 	log.Info(qtOutput)
 }
 
-func dumpraw(outFilePath string) {
+func record(h264FilePath string, wavFilePath string) {
 	activate()
 	cleanup := screencapture.Init()
 	deviceList, err := screencapture.FindIosDevices()
 	defer cleanup()
 	if err != nil {
 		log.Fatal("Error finding iOS Devices", err)
 	}
-	log.Infof("Writing output to:%s", outFilePath)
+	log.Infof("Writing video output to:'%s' and audio to: %s", h264FilePath, wavFilePath)
 	dev := deviceList[0]
 
-	file, err := os.Create(outFilePath)
+	h264File, err := os.Create(h264FilePath)
 	if err != nil {
-		log.Debugf("Error creating file:%s", err)
-		log.Errorf("Could not open file '%s'", outFilePath)
+		log.Debugf("Error creating h264File:%s", err)
+		log.Errorf("Could not open h264File '%s'", h264FilePath)
 	}
-	writer := coremedia.NewNaluFileWriter(bufio.NewWriter(file))
+	wavFile, err := os.Create(wavFilePath)
+	if err != nil {
+		log.Debugf("Error creating wav file:%s", err)
+		log.Errorf("Could not open wav file '%s'", wavFilePath)
+	}
+
+	writer := coremedia.NewAVFileWriter(bufio.NewWriter(h264File), bufio.NewWriter(wavFile))
+
+	defer func() {
+		stat, err := wavFile.Stat()
+		if err != nil {
+			log.Fatal("Could not get wav file stats", err)
+		}
+		err = coremedia.WriteWavHeader(int(stat.Size()), wavFile)
+		if err != nil {
+			log.Fatalf("Error writing wave header %s might be invalid. %s", wavFilePath, err.Error())
+		}
+		err = wavFile.Close()
+		if err != nil {
+			log.Fatalf("Error closing wave file. '%s' might be invalid. %s", wavFilePath, err.Error())
+		}
+		err = h264File.Close()
+		if err != nil {
+			log.Fatalf("Error closing h264File '%s'. %s", h264FilePath, err.Error())
+		}
+
+	}()
 	adapter := screencapture.UsbAdapter{}
 	stopSignal := make(chan interface{})
 	waitForSigInt(stopSignal)

screencapture/coremedia/avfilewriter.go

@@ -0,0 +1,78 @@
+package coremedia
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+var startCode = []byte{00, 00, 00, 01}
+
+//AVFileWriter writes nalus into a file using 0x00000001 as a separator (h264 ANNEX B) and raw pcm audio into a wav file
+//Note that you will have to call WriteWavHeader() on the audiofile when you are done to write a wav header and get a valid file.
+type AVFileWriter struct {
+	h264FileWriter io.Writer
+	wavFileWriter  io.Writer
+	outFilePath    string
+}
+
+//NewAVFileWriter binary writes nalus in annex b format to the given writer and audio buffers into a wav file.
+//Note that you will have to call WriteWavHeader() on the audiofile when you are done to write a wav header and get a valid file.
+func NewAVFileWriter(h264FileWriter io.Writer, wavFileWriter io.Writer) AVFileWriter {
+	return AVFileWriter{h264FileWriter: h264FileWriter, wavFileWriter: wavFileWriter}
+}
+
+//Consume writes PPS and SPS as well as sample bufs into a annex b .h264 file and audio samples into a wav file
+//Note that you will have to call WriteWavHeader() on the audiofile when you are done to write a wav header and get a valid file.
+func (avfw AVFileWriter) Consume(buf CMSampleBuffer) error {
+	if buf.MediaType == MediaTypeSound {
+		return avfw.consumeAudio(buf)
+	}
+	return avfw.consumeVideo(buf)
+}
+
+func (avfw AVFileWriter) consumeVideo(buf CMSampleBuffer) error {
+	if buf.HasFormatDescription {
+		err := avfw.writeNalu(buf.FormatDescription.PPS)
+		if err != nil {
+			return err
+		}
+		err = avfw.writeNalu(buf.FormatDescription.SPS)
+		if err != nil {
+			return err
+		}
+	}
+	return avfw.writeNalus(buf.SampleData)
+}
+
+func (avfw AVFileWriter) writeNalus(bytes []byte) error {
+	slice := bytes
+	for len(slice) > 0 {
+		length := binary.BigEndian.Uint32(slice)
+		err := avfw.writeNalu(slice[4 : length+4])
+		if err != nil {
+			return err
+		}
+		slice = slice[length+4:]
+	}
+	return nil
+}
+
+func (avfw AVFileWriter) writeNalu(naluBytes []byte) error {
+	_, err := avfw.h264FileWriter.Write(startCode)
+	if err != nil {
+		return err
+	}
+	_, err = avfw.h264FileWriter.Write(naluBytes)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (avfw AVFileWriter) consumeAudio(buffer CMSampleBuffer) error {
+	_, err := avfw.wavFileWriter.Write(buffer.SampleData)
+	if err != nil {
+		return err
+	}
+	return nil
+}

…capture/coremedia/nalufilewriter_test.go …encapture/coremedia/avfilewriter_test.goscreencapture/coremedia/nalufilewriter_test.go renamed to screencapture/coremedia/avfilewriter_test.go screencapture/coremedia/nalufilewriter_test.go renamed to screencapture/coremedia/avfilewriter_test.go

@@ -17,24 +17,40 @@ var startCode = []byte{00, 00, 00, 01}
 func TestFileWriter(t *testing.T) {
 	buf := bytes.NewBuffer(make([]byte, 100))
 	buf.Reset()
-	nfw := coremedia.NewNaluFileWriter(buf)
-	err := nfw.Consume(cmSampleBufWithAFewBytes())
+	avfw := coremedia.NewAVFileWriter(buf, nil)
+	err := avfw.Consume(cmSampleBufWithAFewBytes())
 	assert.NoError(t, err)
 	assert.Equal(t, 6, buf.Len())
 	assert.Equal(t, []byte{00, 00, 00, 01, 00, 00}, buf.Bytes())
 	buf.Reset()
-	err = nfw.Consume(cmSampleBufWithFdscAndAFewBytes())
+	err = avfw.Consume(cmSampleBufWithFdscAndAFewBytes())
 	assert.NoError(t, err)
 	expectedBytes := append(startCode, fakePPS...)
 	expectedBytes = append(expectedBytes, startCode...)
 	expectedBytes = append(expectedBytes, fakeSPS...)
 	expectedBytes = append(expectedBytes, []byte{00, 00, 00, 01, 00, 00}...)
 	assert.Equal(t, expectedBytes, buf.Bytes())
 
-	nfw = coremedia.NewNaluFileWriter(failingWriter{})
-	err = nfw.Consume(cmSampleBufWithFdscAndAFewBytes())
+	avfw = coremedia.NewAVFileWriter(failingWriter{}, nil)
+	err = avfw.Consume(cmSampleBufWithFdscAndAFewBytes())
 	assert.Error(t, err)
-	err = nfw.Consume(cmSampleBufWithAFewBytes())
+	err = avfw.Consume(cmSampleBufWithAFewBytes())
+	assert.Error(t, err)
+}
+
+func TestFileWriterForAudio(t *testing.T) {
+	buf := bytes.NewBuffer(make([]byte, 100))
+	buf.Reset()
+	avfw := coremedia.NewAVFileWriter(nil, buf)
+	sampleBuffer := cmSampleBufWithFdscAndAFewBytes()
+	sampleBuffer.MediaType = coremedia.MediaTypeSound
+	err := avfw.Consume(sampleBuffer)
+	if assert.NoError(t, err) {
+		assert.Equal(t, sampleBuffer.SampleData, buf.Bytes())
+	}
+
+	avfw = coremedia.NewAVFileWriter(nil, failingWriter{})
+	err = avfw.Consume(sampleBuffer)
 	assert.Error(t, err)
 }