Add audio recording mode (#61)

* add audio command

* finished audio only commands, refactor gstadapter into separate pipelinebuilders for mac and linux

* gitignore ogg,wav and mp3

* fix unit test, we send messages in a different order now

* bump up version to 0.5-beta

Author: danielpaulus

.gitignore

@@ -1,5 +1,8 @@
 .vscode
 quicktime_video_hack
+*.wav
+*.ogg
+*.mp3
 # Binaries for programs and plugins
 main
 *.h264

main.go

@@ -14,16 +14,17 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-const version = "v0.3-beta"
+const version = "v0.5-beta"
 
 func main() {
 	usage := fmt.Sprintf(`Q.uickTime V.ideo H.ack (qvh) %s
 
 Usage:
   qvh devices [-v]
   qvh activate [--udid=<udid>] [-v]
-  qvh record <h264file> <wavfile> [-v] [--udid=<udid>]
-  qvh gstreamer [--pipeline=<pipeline>] [--examples] [-v]
+  qvh record <h264file> <wavfile> [--udid=<udid>] [-v]
+  qvh audio <outfile> (--mp3 | --ogg | --wav) [--udid=<udid>] [-v]
+  qvh gstreamer [--pipeline=<pipeline>] [--examples] [--udid=<udid>] [-v]
   qvh --version | version
 
 
@@ -35,14 +36,20 @@ 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	enables the video streaming config for the device specified by --udid
+
 	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"
+	            	Audio will be saved in a uncompressed wav file. Run like: "qvh record /home/yourname/out.h264 /home/yourname/out.wav"
+
+	audio		Records only audio from the device. It does not change the status bar like the video recording mode does.
+			The recorded audio will be saved in <outfile> with the selected format. Currently (--mp3 | --ogg | --wav) are supported.
+			Adding more formats is trivial though so create an issue or a PR if you need something :-)
 
-	gstreamer   If no additional param is provided, qvh will open a new window and push AV data to gstreamer.
-				If "qvh gstreamer --examples" is provided, qvh will print some common gstreamer pipeline examples.
-				If --pipeline is provided, qvh will use the provided gstreamer pipeline instead of 
-				displaying audio and video in a window. 
+	gstreamer	If no additional param is provided, qvh will open a new window and push AV data to gstreamer.
+			If "qvh gstreamer --examples" is provided, qvh will print some common gstreamer pipeline examples.
+			If --pipeline is provided, qvh will use the provided gstreamer pipeline instead of 
+			displaying audio and video in a window. 
   `, version)
 	arguments, _ := docopt.ParseDoc(usage)
 	log.SetFormatter(&log.JSONFormatter{})
@@ -73,7 +80,29 @@ The commands work as following:
 		activate(udid)
 		return
 	}
-
+	audioCommand, _ := arguments.Bool("audio")
+	if audioCommand {
+		outfile, err := arguments.String("<outfile>")
+		if err != nil {
+			printErrJSON(err, "Missing <outfile> parameter. Please specify a valid path like '/home/me/out.h264'")
+			return
+		}
+		log.Infof("Recording audio only to file: %s", outfile)
+		mp3, _ := arguments.Bool("--mp3")
+		ogg, _ := arguments.Bool("--ogg")
+		wav, _ := arguments.Bool("--wav")
+		log.Debugf("recording audio only format mp3:%t ogg: %t wav:%t to file: %s", mp3, ogg, wav, outfile)
+		if wav {
+			recordAudioWav(outfile, udid)
+			return
+		}
+		if ogg {
+			recordAudioGst(outfile, udid, gstadapter.OGG)
+			return
+		}
+		recordAudioGst(outfile, udid, gstadapter.MP3)
+		return
+	}
 	recordCommand, _ := arguments.Bool("record")
 	if recordCommand {
 		h264FilePath, err := arguments.String("<h264file>")
@@ -137,20 +166,57 @@ func printExamples() {
 	fmt.Print(examples)
 }
 
+func recordAudioGst(outfile string, udid string, audiotype string) {
+	log.Debug("Starting Gstreamer with audio pipeline")
+	gStreamer, err := gstadapter.NewWithAudioPipeline(outfile, audiotype)
+	if err != nil {
+		printErrJSON(err, "Failed creating custom pipeline")
+		return
+	}
+	startWithConsumer(gStreamer, udid, true)
+}
+
+func recordAudioWav(outfile string, udid string) {
+	log.Debug("Starting Gstreamer with audio pipeline")
+	wavFile, err := os.Create(outfile)
+	if err != nil {
+		log.Debugf("Error creating wav file:%s", err)
+		log.Errorf("Could not open wav file '%s'", outfile)
+	}
+	wavFileWriter := coremedia.NewAVFileWriterAudioOnly(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", outfile, err.Error())
+		}
+		err = wavFile.Close()
+		if err != nil {
+			log.Fatalf("Error closing wave file. '%s' might be invalid. %s", outfile, err.Error())
+		}
+
+	}()
+	startWithConsumer(wavFileWriter, udid, true)
+}
+
 func startGStreamerWithCustomPipeline(udid string, pipelineString string) {
 	log.Debug("Starting Gstreamer with custom pipeline")
 	gStreamer, err := gstadapter.NewWithCustomPipeline(pipelineString)
 	if err != nil {
 		printErrJSON(err, "Failed creating custom pipeline")
 		return
 	}
-	startWithConsumer(gStreamer, udid)
+	startWithConsumer(gStreamer, udid, false)
 }
 
 func startGStreamer(udid string) {
 	log.Debug("Starting Gstreamer")
 	gStreamer := gstadapter.New()
-	startWithConsumer(gStreamer, udid)
+	startWithConsumer(gStreamer, udid, false)
 }
 
 // Just dump a list of what was discovered to the console
@@ -224,10 +290,10 @@ func record(h264FilePath string, wavFilePath string, udid string) {
 		}
 
 	}()
-	startWithConsumer(writer, udid)
+	startWithConsumer(writer, udid, false)
 }
 
-func startWithConsumer(consumer screencapture.CmSampleBufConsumer, udid string) {
+func startWithConsumer(consumer screencapture.CmSampleBufConsumer, udid string, audioOnly bool) {
 	device, err := screencapture.FindIosDevice(udid)
 	if err != nil {
 		printErrJSON(err, "no device found to activate")
@@ -244,7 +310,7 @@ func startWithConsumer(consumer screencapture.CmSampleBufConsumer, udid string)
 	stopSignal := make(chan interface{})
 	waitForSigInt(stopSignal)
 
-	mp := screencapture.NewMessageProcessor(&adapter, stopSignal, consumer)
+	mp := screencapture.NewMessageProcessor(&adapter, stopSignal, consumer, audioOnly)
 
 	err = adapter.StartReading(device, &mp, stopSignal)
 	consumer.Stop()

screencapture/coremedia/avfilewriter.go

@@ -13,12 +13,17 @@ type AVFileWriter struct {
 	h264FileWriter io.Writer
 	wavFileWriter  io.Writer
 	outFilePath    string
+	audioOnly      bool
 }
 
 //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}
+	return AVFileWriter{h264FileWriter: h264FileWriter, wavFileWriter: wavFileWriter, audioOnly: false}
+}
+
+func NewAVFileWriterAudioOnly(wavFileWriter io.Writer) AVFileWriter {
+	return AVFileWriter{h264FileWriter: nil, wavFileWriter: wavFileWriter, audioOnly: true}
 }
 
 //Consume writes PPS and SPS as well as sample bufs into a annex b .h264 file and audio samples into a wav file
@@ -27,6 +32,9 @@ func (avfw AVFileWriter) Consume(buf CMSampleBuffer) error {
 	if buf.MediaType == MediaTypeSound {
 		return avfw.consumeAudio(buf)
 	}
+	if avfw.audioOnly {
+		return nil
+	}
 	return avfw.consumeVideo(buf)
 }
 

…ncapture/gstadapter/gst_adapter_macos.go screencapture/gstadapter/gst_adapter.goscreencapture/gstadapter/gst_adapter_macos.go renamed to screencapture/gstadapter/gst_adapter.go screencapture/gstadapter/gst_adapter_macos.go renamed to screencapture/gstadapter/gst_adapter.go

@@ -1,5 +1,3 @@
-// +build darwin
-
 package gstadapter
 
 import (
@@ -25,14 +23,18 @@ type GstAdapter struct {
 const audioAppSrcTargetElementName = "audio_target"
 const videoAppSrcTargetElementName = "video_target"
 
+const MP3 = "mp3"
+const OGG = "ogg"
+
 //New creates a new MAC OSX compatible gstreamer pipeline that will play device video and audio
 //in a nice little window :-D
 func New() *GstAdapter {
 	log.Info("Starting Gstreamer..")
 	pl := gst.NewPipeline("QT_Hack_Pipeline")
 
 	videoAppSrc := setUpVideoPipeline(pl)
-	audioAppSrc := setUpAudioPipeline(pl)
+	audioAppSrc := setUpAudioPipelineBase(pl)
+	setupLivePlayAudio(pl)
 
 	pl.SetState(gst.STATE_PLAYING)
 	runGlibMainLoop()
@@ -43,6 +45,29 @@ func New() *GstAdapter {
 	return &gsta
 }
 
+func NewWithAudioPipeline(outfile string, audiotype string) (*GstAdapter, error) {
+	log.Info("Starting Gstreamer..")
+	pl := gst.NewPipeline("QT_Hack_Pipeline")
+
+	audioAppSrc := setUpAudioPipelineBase(pl)
+	switch audiotype {
+	case MP3:
+		setupMp3(pl, outfile)
+	case OGG:
+		setupVorbis(pl, outfile)
+	default:
+		log.Fatalf("Unrecognized Audio type:%s", audiotype)
+	}
+
+	pl.SetState(gst.STATE_PLAYING)
+	runGlibMainLoop()
+
+	log.Info("Gstreamer is running!")
+	gsta := GstAdapter{audioAppSrc: audioAppSrc, firstAudioSample: true}
+
+	return &gsta, nil
+}
+
 //NewWithCustomPipeline will parse the given pipelineString, connect the videoAppSrc to whatever element has the name "video_target" and the audioAppSrc to "audio_target"
 //see also: https://gstreamer.freedesktop.org/documentation/application-development/appendix/programs.html?gi-language=c
 func NewWithCustomPipeline(pipelineString string) (*GstAdapter, error) {
@@ -89,13 +114,17 @@ func NewWithCustomPipeline(pipelineString string) (*GstAdapter, error) {
 //sending EOS will result in a broken mp4 file
 func (gsta GstAdapter) Stop() {
 	log.Info("Stopping Gstreamer..")
-	success := gsta.audioAppSrc.SendEvent(gst.Eos())
-	if !success {
-		log.Warn("Failed sending EOS signal for audio app source")
+	if gsta.audioAppSrc != nil {
+		success := gsta.audioAppSrc.SendEvent(gst.Eos())
+		if !success {
+			log.Warn("Failed sending EOS signal for audio app source")
+		}
 	}
-	success = gsta.videoAppSrc.SendEvent(gst.Eos())
-	if !success {
-		log.Warn("Failed sending EOS signal for video app source")
+	if gsta.videoAppSrc != nil {
+		success := gsta.videoAppSrc.SendEvent(gst.Eos())
+		if !success {
+			log.Warn("Failed sending EOS signal for video app source")
+		}
 	}
 
 	if gsta.pipeline == nil {
@@ -126,8 +155,7 @@ func runGlibMainLoop() {
 		glib.NewMainLoop(nil).Run()
 	}()
 }
-
-func setUpAudioPipeline(pl *gst.Pipeline) *gst.AppSrc {
+func setUpAudioPipelineBase(pl *gst.Pipeline) *gst.AppSrc {
 	asrc := gst.NewAppSrc("my-audio-src")
 	asrc.SetProperty("is-live", true)
 
@@ -144,59 +172,43 @@ func setUpAudioPipeline(pl *gst.Pipeline) *gst.AppSrc {
 	audioconvert := gst.ElementFactoryMake("audioconvert", "audioconvert_01")
 	checkElem(audioconvert, "audioconvert_01")
 
-	autoaudiosink := gst.ElementFactoryMake("autoaudiosink", "autoaudiosink_01")
-	checkElem(autoaudiosink, "autoaudiosink_01")
-	autoaudiosink.SetProperty("sync", false)
-
-	pl.Add(asrc.AsElement(), queue1, wavparse, audioconvert, queue2, autoaudiosink)
+	pl.Add(asrc.AsElement(), queue1, wavparse, audioconvert, queue2)
 	asrc.Link(queue1)
 	queue1.Link(wavparse)
 	wavparse.Link(audioconvert)
 
 	audioconvert.Link(queue2)
-	queue2.Link(autoaudiosink)
 
 	return asrc
 }
-
-func setUpVideoPipeline(pl *gst.Pipeline) *gst.AppSrc {
-	asrc := gst.NewAppSrc("my-video-src")
-	asrc.SetProperty("is-live", true)
-
-	queue1 := gst.ElementFactoryMake("queue", "queue_11")
-	checkElem(queue1, "queue_11")
-
-	h264parse := gst.ElementFactoryMake("h264parse", "h264parse_01")
-	checkElem(h264parse, "h264parse")
-
-	avdecH264 := gst.ElementFactoryMake("vtdec", "vtdec_01")
-	checkElem(avdecH264, "vtdec_01")
-
-	queue2 := gst.ElementFactoryMake("queue", "queue_12")
-	checkElem(queue2, "queue_12")
-
-	videoconvert := gst.ElementFactoryMake("videoconvert", "videoconvert_01")
-	checkElem(videoconvert, "videoconvert_01")
-
-	queue3 := gst.ElementFactoryMake("queue", "queue_13")
-	checkElem(queue3, "queue_13")
-
-	sink := gst.ElementFactoryMake("autovideosink", "autovideosink_01")
-	// setting this to true, creates extremely choppy video
-	// I probably messed up something regarding the time stamps
-	sink.SetProperty("sync", false)
-	checkElem(sink, "autovideosink_01")
-
-	pl.Add(asrc.AsElement(), queue1, h264parse, avdecH264, queue2, videoconvert, queue3, sink)
-
-	asrc.Link(queue1)
-	queue1.Link(h264parse)
-	h264parse.Link(avdecH264)
-	avdecH264.Link(queue2)
-	queue2.Link(videoconvert)
-	videoconvert.Link(queue3)
-	queue3.Link(sink)
-	return asrc
+func setupVorbis(pl *gst.Pipeline, filepath string) {
+	//vorbisenc ! oggmux ! filesink location=alsasrc.ogg
+	vorbisEnc := gst.ElementFactoryMake("vorbisenc", "vorbisenc_01")
+	checkElem(vorbisEnc, "vorbisenc_01")
+	oggMux := gst.ElementFactoryMake("oggmux", "oggmux_01")
+	checkElem(oggMux, "oggmux_01")
+
+	filesink := gst.ElementFactoryMake("filesink", "filesink_01")
+	filesink.SetProperty("location", filepath)
+	checkElem(filesink, "filesink_01")
+
+	pl.Add(vorbisEnc, oggMux, filesink)
+
+	pl.GetByName("queue2").Link(vorbisEnc)
+	vorbisEnc.Link(oggMux)
+	oggMux.Link(filesink)
+}
+func setupMp3(pl *gst.Pipeline, filepath string) {
+	// lamemp3enc ! filesink location=sine.mp3
+	lameEnc := gst.ElementFactoryMake("lamemp3enc", "lamemp3enc_01")
+	checkElem(lameEnc, "lamemp3enc_01")
+
+	filesink := gst.ElementFactoryMake("filesink", "filesink_01")
+	filesink.SetProperty("location", filepath)
+	checkElem(filesink, "filesink_01")
+	pl.Add(lameEnc, filesink)
+	pl.GetByName("queue2").Link(lameEnc)
+	lameEnc.Link(filesink)
 }
 
 func checkElem(e *gst.Element, name string) {