First version of MovieRecorder.

This is meant to be used with the Unity video/recorder_with_audio branch.

It introduces an audio input, which is quite simple for now (enable/disable
audio capture). There is disabled functionality in there that we still need
to discuss: it allows capturing the output of arbitrary mixers at the same
time as the main output.

The movie recorder allows to record video and audio into a mp4 or webm
file. Because Unity imports these video files very quickly (no transcoding
by default), the default output path is inside the Assets folder so users
can immediately see and browse their recorded videos using Unity.

Author: Dominique Leroux

source/FrameRecorder/Inputs/Audio.meta

@@ -0,0 +1,69 @@
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.FrameRecorder;
+using UnityEngine.FrameRecorder.Input;
+
+namespace UnityEditor.FrameRecorder.Input
+{
+    [CustomEditor(typeof(AudioInputSettings))]
+    public class AudioInputSettingsEditor : Editor
+    {
+        SerializedProperty m_PreserveAudio;
+#if RECORD_AUDIO_MIXERS
+        SerializedProperty m_AudioMixerGroups;
+        ReorderableList    m_AudioMixerGroupsList;
+#endif
+
+        protected void OnEnable()
+        {
+            if (target == null)
+                return;
+
+            var pf = new PropertyFinder<AudioInputSettings>(serializedObject);
+            m_PreserveAudio = pf.Find(w => w.m_PreserveAudio);
+
+#if RECORD_AUDIO_MIXERS
+	    m_AudioMixerGroups = serializedObject.FindProperty<AudioInputSettings>(x => x.m_AudioMixerGroups);
+	    m_AudioMixerGroupsList = new ReorderableList(serializedObject, m_AudioMixerGroups, true, true, true, true);
+	    m_AudioMixerGroupsList.drawElementCallback =
+		(Rect rect, int index, bool isActive, bool isFocused) =>
+		{
+		    var element = m_AudioMixerGroupsList.serializedProperty.GetArrayElementAtIndex(index);
+		    rect.y += 2;
+		    EditorGUI.PropertyField(
+			new Rect(rect.x - 25,                   rect.y, rect.width - 90, EditorGUIUtility.singleLineHeight),
+			element.FindPropertyRelative("m_MixerGroup"), GUIContent.none);
+		    EditorGUI.PropertyField(
+			new Rect(rect.x + rect.width - 85, rect.y, 20,              EditorGUIUtility.singleLineHeight),
+			element.FindPropertyRelative("m_Isolate"),    GUIContent.none);
+		    EditorGUI.LabelField(
+			new Rect(rect.x + rect.width - 65, rect.y, 60,              EditorGUIUtility.singleLineHeight),
+			new GUIContent ("Isolate", "Isolate group from mix"));
+		};
+
+	    m_AudioMixerGroupsList.drawHeaderCallback = (Rect rect) =>
+            {
+                EditorGUI.LabelField(rect, "Audio Mixer Groups");
+            };
+#endif
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_PreserveAudio, new GUIContent("Preserve audio"));
+
+#if RECORD_AUDIO_MIXERS
+            if (m_AudioMixerGroups != null)
+            {
+                serializedObject.Update();
+                m_AudioMixerGroupsList.DoLayoutList();
+            }
+#endif
+ 
+            serializedObject.ApplyModifiedProperties();
+
+            if (!(target as AudioInputSettings).isValid)
+                EditorGUILayout.HelpBox("Incomplete/Invalid settings", MessageType.Warning);
+        }
+    }
+}

source/FrameRecorder/Inputs/Audio/Editor.meta

@@ -0,0 +1,130 @@
+using System;
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditorInternal;
+
+#endif
+using UnityEngine.Collections;
+using UnityEngine.FrameRecorder.Input;
+
+namespace UnityEngine.FrameRecorder
+{
+    public class AudioInput : RecorderInput
+    {
+        private class BufferManager : IDisposable
+        {
+            NativeArray<float>[] buffers;
+            uint m_Length;
+	    ushort m_ChannelCount;
+    
+            public BufferManager(ushort numBuffers, uint length, ushort channelCount)
+            {
+                buffers = new NativeArray<float>[numBuffers];
+		m_ChannelCount = channelCount;
+                m_Length = length;
+            }
+    
+            public NativeArray<float> GetBuffer(int index)
+            {
+                if (buffers[index].Length == 0)
+		    buffers[index] = new NativeArray<float>(
+			(int)m_Length * (int)m_ChannelCount, Allocator.Temp);
+		return buffers[index];
+            }
+    
+            public void Dispose()
+            {
+                foreach (var a in buffers)
+		    a.Dispose();
+            }
+        }
+
+        public ushort channelCount { get { return m_ChannelCount; } }
+	private ushort m_ChannelCount;
+	public int sampleRate { get { return AudioSettings.outputSampleRate; } }
+	public NativeArray<float> mainBuffer { get { return m_BufferManager.GetBuffer(0); } }
+	public NativeArray<float> GetMixerGroupBuffer(int n)
+        { return m_BufferManager.GetBuffer(n + 1); }
+	
+        private BufferManager m_BufferManager;
+
+        public AudioInputSettings audioSettings
+        { get { return (AudioInputSettings)settings; } }
+
+        public override void BeginRecording(RecordingSession session)
+        {
+	    m_ChannelCount = new Func<ushort>(() => {
+		    switch (AudioSettings.speakerMode)
+		    {
+		    case AudioSpeakerMode.Mono:        return 1;
+		    case AudioSpeakerMode.Stereo:      return 2;
+		    case AudioSpeakerMode.Quad:        return 4;
+		    case AudioSpeakerMode.Surround:    return 5;
+		    case AudioSpeakerMode.Mode5point1: return 6;
+		    case AudioSpeakerMode.Mode7point1: return 7;
+		    case AudioSpeakerMode.Prologic:    return 2;		    
+		    default: return 1;
+		    }
+            })();
+
+            if (session.settings.m_Verbose)
+                Debug.Log(string.Format(
+			      "AudioInput.BeginRecording for capture frame rate {0}", Time.captureFramerate));
+
+	    if (audioSettings.m_PreserveAudio)
+		AudioRecorder.StartOutputRecording();
+	}
+
+        public override void NewFrameReady(RecordingSession session)
+	{
+	    if (!audioSettings.m_PreserveAudio)
+		return;
+
+	    var sampleFrameCount = (uint)AudioRecorder.GetRecordSamplesAvailable();
+            if (session.settings.m_Verbose)
+                Debug.Log(string.Format("AudioInput.NewFrameReady {0} audio sample frames @ {1} ch",
+                                        sampleFrameCount, m_ChannelCount));
+
+	    ushort bufferCount = 
+#if RECORD_AUDIO_MIXERS
+		(ushort)(audioSettings.m_AudioMixerGroups.Length + 1)
+#else
+		1
+#endif
+            ;
+
+	    m_BufferManager = new BufferManager(bufferCount, sampleFrameCount, m_ChannelCount);
+	    var mainBuffer = m_BufferManager.GetBuffer(0);
+
+#if RECORD_AUDIO_MIXERS
+	    for (int n = 1; n < bufferCount; n++)
+	    {
+		var group = audioSettings.m_AudioMixerGroups[n - 1];
+		if (group.m_MixerGroup == null)
+		    continue;
+
+		var buffer = m_BufferManager.GetBuffer(n);
+		AudioRecorder.AddMixerGroupRecorder(group.m_MixerGroup, buffer, group.m_Isolate);
+	    }
+#endif
+
+	    AudioRecorder.RecordOutput(mainBuffer);
+	}
+
+        public override void FrameDone(RecordingSession session)
+        {
+	    if (!audioSettings.m_PreserveAudio)
+		return;
+
+	    m_BufferManager.Dispose();
+	    m_BufferManager = null;
+	}
+
+        public override void EndRecording(RecordingSession session)
+        {
+	    if (audioSettings.m_PreserveAudio)
+		AudioRecorder.StopOutputRecording();
+        }
+    }
+}
+

source/FrameRecorder/Inputs/Audio/Editor/AudioInputSettingsEditor.cs

@@ -0,0 +1,24 @@
+using UnityEngine.Audio;
+
+namespace UnityEngine.FrameRecorder.Input
+{
+    public class AudioInputSettings : InputSettings<AudioInput>
+    {
+        public bool                         m_PreserveAudio = true;
+
+#if RECORD_AUDIO_MIXERS
+        [System.Serializable]
+        public struct MixerGroupRecorderListItem
+        {
+            [SerializeField]
+            public AudioMixerGroup m_MixerGroup;
+            
+            [SerializeField]
+            public bool m_Isolate;
+        }
+        public MixerGroupRecorderListItem[] m_AudioMixerGroups;
+#endif
+
+        public override bool isValid { get { return true; } }
+    }
+}