Audio buffer support in filter graph

av/audio/frame.pyx

@@ -87,6 +87,7 @@ cdef class AudioFrame(Frame):
         self.layout = get_audio_layout(0, self.ptr.channel_layout)
         self.format = get_audio_format(<lib.AVSampleFormat>self.ptr.format)
         self.nb_channels = lib.av_get_channel_layout_nb_channels(self.ptr.channel_layout)
+        self.ptr.channels  = self.nb_channels
         self.nb_planes = self.nb_channels if lib.av_sample_fmt_is_planar(<lib.AVSampleFormat>self.ptr.format) else 1
         self._init_planes(AudioPlane)
 
@@ -130,8 +131,16 @@ cdef class AudioFrame(Frame):
         # map avcodec type to numpy type
         try:
             dtype = np.dtype({
+                'u8'  : 'u1',
+                'u8p' : 'u1',
+                's16' :'<i2',
                 's16p':'<i2',
+                's32' :'<i4',
+                's32p':'<i4',
+                'flt' :'<f4',
                 'fltp':'<f4',
+                'dbl' :'<f8',
+                'dblp':'<f8'
             }[self.format.name])
         except:
             raise AssertionError("Don't know how to convert data type.", self.format.name)

av/filter/graph.pyx

@@ -5,6 +5,8 @@ from av.filter.filter cimport Filter, wrap_filter
 from av.utils cimport err_check
 from av.video.frame cimport VideoFrame, alloc_video_frame
 from av.video.format cimport VideoFormat
+from av.audio.frame cimport AudioFrame, alloc_audio_frame
+from av.audio.format cimport AudioFormat
 
 cdef class Graph(object):
 
@@ -143,10 +145,46 @@ cdef class Graph(object):
 
         return self.add('buffer', args, name=name)
 
+    def add_abuffer(self, template=None, sample_rate=None, format=None, layout=None, channels=None, name=None):
+        """
+        Convenient method for adding `abuffer <https://ffmpeg.org/ffmpeg-filters.html#abuffer>`_.
+        """
+
+        if template is not None:
+            if sample_rate is None:
+                sample_rate = template.sample_rate
+            if format is None:
+                format = template.format
+            if layout is None:
+                layout = template.layout.name
+            if channels is None:
+                channels = template.channels
+
+        if sample_rate is None:
+            raise ValueError('missing sample_rate')
+        if format is None:
+            raise ValueError('missing format')
+        if layout is None:
+            raise ValueError('missing layout')
+        if channels is None:
+            raise ValueError('missing channels')
+
+        args = "sample_rate=%d:sample_fmt=%s:channel_layout=%s:channels=%d:time_base=%d/%d" % (
+            sample_rate, AudioFormat(format).name,
+            layout,
+            channels,
+            1, 1000,
+        )
+
+        return self.add('abuffer', args, name=name)
+
+
     def push(self, frame):
 
         if isinstance(frame, VideoFrame):
             contexts = self._context_by_type.get('buffer', [])
+        if isinstance(frame, AudioFrame):
+            contexts = self._context_by_type.get('abuffer', [])
         else:
             raise ValueError('can only push VideoFrame', type(frame))
 

setup.py

@@ -289,8 +289,10 @@ def compile_check(code, name, includes=None, include_dirs=None, libraries=None,
     try:
         objects = cc.compile([source_path], include_dirs=include_dirs)
         if link:
-            cc.link_executable(objects, exec_path, libraries=libraries,
-                library_dirs=library_dirs, runtime_library_dirs=runtime_library_dirs)
+            cc.link_executable(objects, exec_path,
+                               libraries=libraries,
+                               library_dirs=library_dirs,
+                               runtime_library_dirs=runtime_library_dirs)
     except (CompileError, LinkError, TypeError):
         res = False
     else:
@@ -540,6 +542,17 @@ def run(self):
         config['libraries'] += self.libraries
         config['library_dirs'] += self.library_dirs
 
+        compile_options = dict(
+            includes=reflection_includes,
+            libraries=config['libraries'],
+            library_dirs=config['library_dirs'],
+            include_dirs=config['include_dirs'],
+            runtime_library_dirs=config['runtime_library_dirs'],
+            compiler=self.compiler,
+            force=self.force,
+            verbose=self.debug,
+        )
+
         # Check for some specific functions.
         for func_name in (
 
@@ -557,13 +570,8 @@ def run(self):
             print("looking for %s... " % func_name, end='\n' if self.debug else '')
             results[func_name] = compile_check(
                 name=os.path.join(tmp_dir, func_name),
-                code='%s()' % func_name,
-                libraries=config['libraries'],
-                library_dirs=config['library_dirs'],
-                runtime_library_dirs=config['runtime_library_dirs'],
-                compiler=self.compiler,
-                force=self.force,
-                verbose=self.debug,
+                code='typedef void void_f(void); void_f *foo = *%s;' % func_name,
+                **compile_options
             )
             print('found' if results[func_name] else 'missing')
 
@@ -579,12 +587,8 @@ def run(self):
             results[enum_name] = compile_check(
                 name=os.path.join(tmp_dir, enum_name),
                 code='int x = %s' % enum_name,
-                includes=reflection_includes,
-                include_dirs=config['include_dirs'],
                 link=False,
-                compiler=self.compiler,
-                force=self.force,
-                verbose=self.debug,
+                **compile_options
             )
             print("found" if results[enum_name] else "missing")
 
@@ -602,12 +606,8 @@ def run(self):
             results[name] = compile_check(
                 name=os.path.join(tmp_dir, name),
                 code='struct %s x; x.%s;' % (struct_name, member_name),
-                includes=reflection_includes,
-                include_dirs=config['include_dirs'],
                 link=False,
-                compiler=self.compiler,
-                force=self.force,
-                verbose=self.debug,
+                **compile_options
             )
             print('found' if results[name] else 'missing')