FFmpeg
alsa.c
Go to the documentation of this file.
1 /*
2  * ALSA input and output
3  * Copyright (c) 2007 Luca Abeni ( lucabe72 email it )
4  * Copyright (c) 2007 Benoit Fouet ( benoit fouet free fr )
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * ALSA input and output: common code
26  * @author Luca Abeni ( lucabe72 email it )
27  * @author Benoit Fouet ( benoit fouet free fr )
28  * @author Nicolas George ( nicolas george normalesup org )
29  */
30 
31 #include "config_components.h"
32 
33 #include <alsa/asoundlib.h>
34 #include "avdevice.h"
35 #include "libavutil/avassert.h"
37 #include "libavutil/mem.h"
38 
39 #include "alsa.h"
40 
41 static av_cold snd_pcm_format_t codec_id_to_pcm_format(int codec_id)
42 {
43  switch(codec_id) {
44  case AV_CODEC_ID_PCM_F64LE: return SND_PCM_FORMAT_FLOAT64_LE;
45  case AV_CODEC_ID_PCM_F64BE: return SND_PCM_FORMAT_FLOAT64_BE;
46  case AV_CODEC_ID_PCM_F32LE: return SND_PCM_FORMAT_FLOAT_LE;
47  case AV_CODEC_ID_PCM_F32BE: return SND_PCM_FORMAT_FLOAT_BE;
48  case AV_CODEC_ID_PCM_S32LE: return SND_PCM_FORMAT_S32_LE;
49  case AV_CODEC_ID_PCM_S32BE: return SND_PCM_FORMAT_S32_BE;
50  case AV_CODEC_ID_PCM_U32LE: return SND_PCM_FORMAT_U32_LE;
51  case AV_CODEC_ID_PCM_U32BE: return SND_PCM_FORMAT_U32_BE;
52  case AV_CODEC_ID_PCM_S24LE: return SND_PCM_FORMAT_S24_3LE;
53  case AV_CODEC_ID_PCM_S24BE: return SND_PCM_FORMAT_S24_3BE;
54  case AV_CODEC_ID_PCM_U24LE: return SND_PCM_FORMAT_U24_3LE;
55  case AV_CODEC_ID_PCM_U24BE: return SND_PCM_FORMAT_U24_3BE;
56  case AV_CODEC_ID_PCM_S16LE: return SND_PCM_FORMAT_S16_LE;
57  case AV_CODEC_ID_PCM_S16BE: return SND_PCM_FORMAT_S16_BE;
58  case AV_CODEC_ID_PCM_U16LE: return SND_PCM_FORMAT_U16_LE;
59  case AV_CODEC_ID_PCM_U16BE: return SND_PCM_FORMAT_U16_BE;
60  case AV_CODEC_ID_PCM_S8: return SND_PCM_FORMAT_S8;
61  case AV_CODEC_ID_PCM_U8: return SND_PCM_FORMAT_U8;
62  case AV_CODEC_ID_PCM_MULAW: return SND_PCM_FORMAT_MU_LAW;
63  case AV_CODEC_ID_PCM_ALAW: return SND_PCM_FORMAT_A_LAW;
64  default: return SND_PCM_FORMAT_UNKNOWN;
65  }
66 }
67 
68 #define MAKE_REORDER_FUNC(NAME, TYPE, CHANNELS, LAYOUT, MAP) \
69 static void alsa_reorder_ ## NAME ## _ ## LAYOUT(const void *in_v, \
70  void *out_v, \
71  int n) \
72 { \
73  const TYPE *in = in_v; \
74  TYPE *out = out_v; \
75  \
76  while (n-- > 0) { \
77  MAP \
78  in += CHANNELS; \
79  out += CHANNELS; \
80  } \
81 }
82 
83 #define MAKE_REORDER_FUNCS(CHANNELS, LAYOUT, MAP) \
84  MAKE_REORDER_FUNC(int8, int8_t, CHANNELS, LAYOUT, MAP) \
85  MAKE_REORDER_FUNC(int16, int16_t, CHANNELS, LAYOUT, MAP) \
86  MAKE_REORDER_FUNC(int32, int32_t, CHANNELS, LAYOUT, MAP) \
87  MAKE_REORDER_FUNC(f32, float, CHANNELS, LAYOUT, MAP)
88 
89 MAKE_REORDER_FUNCS(5, out_50, \
90  out[0] = in[0]; \
91  out[1] = in[1]; \
92  out[2] = in[3]; \
93  out[3] = in[4]; \
94  out[4] = in[2]; \
95  )
96 
97 MAKE_REORDER_FUNCS(6, out_51, \
98  out[0] = in[0]; \
99  out[1] = in[1]; \
100  out[2] = in[4]; \
101  out[3] = in[5]; \
102  out[4] = in[2]; \
103  out[5] = in[3]; \
104  )
105 
106 MAKE_REORDER_FUNCS(8, out_71, \
107  out[0] = in[0]; \
108  out[1] = in[1]; \
109  out[2] = in[4]; \
110  out[3] = in[5]; \
111  out[4] = in[2]; \
112  out[5] = in[3]; \
113  out[6] = in[6]; \
114  out[7] = in[7]; \
115  )
116 
117 #define FORMAT_I8 0
118 #define FORMAT_I16 1
119 #define FORMAT_I32 2
120 #define FORMAT_F32 3
121 
122 #define PICK_REORDER(layout)\
123 switch(format) {\
124  case FORMAT_I8: s->reorder_func = alsa_reorder_int8_out_ ##layout; break;\
125  case FORMAT_I16: s->reorder_func = alsa_reorder_int16_out_ ##layout; break;\
126  case FORMAT_I32: s->reorder_func = alsa_reorder_int32_out_ ##layout; break;\
127  case FORMAT_F32: s->reorder_func = alsa_reorder_f32_out_ ##layout; break;\
128 }
129 
130 static av_cold int find_reorder_func(AlsaData *s, int codec_id, AVChannelLayout *layout, int out)
131 {
132  int format;
133 
134  /* reordering input is not currently supported */
135  if (!out)
136  return AVERROR(ENOSYS);
137 
138  /* reordering is not needed for QUAD or 2_2 layout */
141  return 0;
142 
143  switch (codec_id) {
144  case AV_CODEC_ID_PCM_S8:
145  case AV_CODEC_ID_PCM_U8:
147  case AV_CODEC_ID_PCM_MULAW: format = FORMAT_I8; break;
151  case AV_CODEC_ID_PCM_U16BE: format = FORMAT_I16; break;
155  case AV_CODEC_ID_PCM_U32BE: format = FORMAT_I32; break;
157  case AV_CODEC_ID_PCM_F32BE: format = FORMAT_F32; break;
158  default: return AVERROR(ENOSYS);
159  }
160 
163  PICK_REORDER(50)
166  PICK_REORDER(51)
168  PICK_REORDER(71)
169 
170  return s->reorder_func ? 0 : AVERROR(ENOSYS);
171 }
172 
173 av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode,
174  unsigned int *sample_rate,
175  int channels, enum AVCodecID *codec_id)
176 {
177  AlsaData *s = ctx->priv_data;
179  const char *audio_device;
180  int res, flags = 0;
181  snd_pcm_format_t format;
182  snd_pcm_t *h;
183  snd_pcm_hw_params_t *hw_params;
184  snd_pcm_uframes_t buffer_size, period_size;
185 
186  if (ctx->url[0] == 0) audio_device = "default";
187  else audio_device = ctx->url;
188 
189  if (*codec_id == AV_CODEC_ID_NONE)
192  if (format == SND_PCM_FORMAT_UNKNOWN) {
193  av_log(ctx, AV_LOG_ERROR, "sample format 0x%04x is not supported\n", *codec_id);
194  return AVERROR(ENOSYS);
195  }
196  s->frame_size = av_get_bits_per_sample(*codec_id) / 8 * channels;
197 
198  if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
199  flags = SND_PCM_NONBLOCK;
200  }
201  res = snd_pcm_open(&h, audio_device, mode, flags);
202  if (res < 0) {
203  av_log(ctx, AV_LOG_ERROR, "cannot open audio device %s (%s)\n",
204  audio_device, snd_strerror(res));
205  return AVERROR(EIO);
206  }
207 
208  res = snd_pcm_hw_params_malloc(&hw_params);
209  if (res < 0) {
210  av_log(ctx, AV_LOG_ERROR, "cannot allocate hardware parameter structure (%s)\n",
211  snd_strerror(res));
212  goto fail1;
213  }
214 
215  res = snd_pcm_hw_params_any(h, hw_params);
216  if (res < 0) {
217  av_log(ctx, AV_LOG_ERROR, "cannot initialize hardware parameter structure (%s)\n",
218  snd_strerror(res));
219  goto fail;
220  }
221 
222  res = snd_pcm_hw_params_set_access(h, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
223  if (res < 0) {
224  av_log(ctx, AV_LOG_ERROR, "cannot set access type (%s)\n",
225  snd_strerror(res));
226  goto fail;
227  }
228 
229  res = snd_pcm_hw_params_set_format(h, hw_params, format);
230  if (res < 0) {
231  av_log(ctx, AV_LOG_ERROR, "cannot set sample format 0x%04x %d (%s)\n",
232  *codec_id, format, snd_strerror(res));
233  goto fail;
234  }
235 
236  res = snd_pcm_hw_params_set_rate_near(h, hw_params, sample_rate, 0);
237  if (res < 0) {
238  av_log(ctx, AV_LOG_ERROR, "cannot set sample rate (%s)\n",
239  snd_strerror(res));
240  goto fail;
241  }
242 
243  res = snd_pcm_hw_params_set_channels(h, hw_params, channels);
244  if (res < 0) {
245  av_log(ctx, AV_LOG_ERROR, "cannot set channel count to %d (%s)\n",
246  channels, snd_strerror(res));
247  goto fail;
248  }
249 
250  snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size);
251  buffer_size = FFMIN(buffer_size, ALSA_BUFFER_SIZE_MAX);
252  /* TODO: maybe use ctx->max_picture_buffer somehow */
253  res = snd_pcm_hw_params_set_buffer_size_near(h, hw_params, &buffer_size);
254  if (res < 0) {
255  av_log(ctx, AV_LOG_ERROR, "cannot set ALSA buffer size (%s)\n",
256  snd_strerror(res));
257  goto fail;
258  }
259 
260  snd_pcm_hw_params_get_period_size_min(hw_params, &period_size, NULL);
261  if (!period_size)
262  period_size = buffer_size / 4;
263  res = snd_pcm_hw_params_set_period_size_near(h, hw_params, &period_size, NULL);
264  if (res < 0) {
265  av_log(ctx, AV_LOG_ERROR, "cannot set ALSA period size (%s)\n",
266  snd_strerror(res));
267  goto fail;
268  }
269  s->period_size = period_size;
270 
271  res = snd_pcm_hw_params(h, hw_params);
272  if (res < 0) {
273  av_log(ctx, AV_LOG_ERROR, "cannot set parameters (%s)\n",
274  snd_strerror(res));
275  goto fail;
276  }
277 
278  snd_pcm_hw_params_free(hw_params);
279 
280  if (channels > 2 && layout->order != AV_CHANNEL_ORDER_UNSPEC) {
281  if (find_reorder_func(s, *codec_id, layout, mode == SND_PCM_STREAM_PLAYBACK) < 0) {
282  char name[128];
284  av_log(ctx, AV_LOG_WARNING, "ALSA channel layout unknown or unimplemented for %s %s.\n",
285  name, mode == SND_PCM_STREAM_PLAYBACK ? "playback" : "capture");
286  }
287  if (s->reorder_func) {
288  s->reorder_buf_size = buffer_size;
289  s->reorder_buf = av_malloc_array(s->reorder_buf_size, s->frame_size);
290  if (!s->reorder_buf)
291  goto fail1;
292  }
293  }
294 
295  s->pkt = av_packet_alloc();
296  if (!s->pkt)
297  goto fail1;
298 
299  s->h = h;
300  return 0;
301 
302 fail:
303  snd_pcm_hw_params_free(hw_params);
304 fail1:
305  snd_pcm_close(h);
306  return AVERROR(EIO);
307 }
308 
310 {
311  AlsaData *s = s1->priv_data;
312 
313  if (snd_pcm_stream(s->h) == SND_PCM_STREAM_PLAYBACK) {
314  snd_pcm_nonblock(s->h, 0);
315  snd_pcm_drain(s->h);
316  }
317  av_freep(&s->reorder_buf);
318  if (CONFIG_ALSA_INDEV)
319  ff_timefilter_destroy(s->timefilter);
320  snd_pcm_close(s->h);
321  av_packet_free(&s->pkt);
322  return 0;
323 }
324 
326 {
327  AlsaData *s = s1->priv_data;
328  snd_pcm_t *handle = s->h;
329 
330  av_log(s1, AV_LOG_WARNING, "ALSA buffer xrun.\n");
331  if (err == -EPIPE) {
332  err = snd_pcm_prepare(handle);
333  if (err < 0) {
334  av_log(s1, AV_LOG_ERROR, "cannot recover from underrun (snd_pcm_prepare failed: %s)\n", snd_strerror(err));
335 
336  return AVERROR(EIO);
337  }
338  } else if (err == -ESTRPIPE) {
339  av_log(s1, AV_LOG_ERROR, "-ESTRPIPE... Unsupported!\n");
340 
341  return -1;
342  }
343  return err;
344 }
345 
347 {
348  int size = s->reorder_buf_size;
349  void *r;
350 
351  av_assert0(size != 0);
352  while (size < min_size)
353  size *= 2;
354  r = av_realloc_array(s->reorder_buf, size, s->frame_size);
355  if (!r)
356  return AVERROR(ENOMEM);
357  s->reorder_buf = r;
358  s->reorder_buf_size = size;
359  return 0;
360 }
361 
362 /* ported from alsa-utils/aplay.c */
363 int ff_alsa_get_device_list(AVDeviceInfoList *device_list, snd_pcm_stream_t stream_type)
364 {
365  int ret = 0;
366  void **hints, **n;
367  char *name = NULL, *descr = NULL, *io = NULL, *tmp;
368  AVDeviceInfo *new_device = NULL;
369  const char *filter = stream_type == SND_PCM_STREAM_PLAYBACK ? "Output" : "Input";
370 
371  if (snd_device_name_hint(-1, "pcm", &hints) < 0)
372  return AVERROR_EXTERNAL;
373  n = hints;
374  while (*n && !ret) {
375  name = snd_device_name_get_hint(*n, "NAME");
376  descr = snd_device_name_get_hint(*n, "DESC");
377  io = snd_device_name_get_hint(*n, "IOID");
378  if (!io || !strcmp(io, filter)) {
379  new_device = av_mallocz(sizeof(AVDeviceInfo));
380  if (!new_device) {
381  ret = AVERROR(ENOMEM);
382  goto fail;
383  }
384  new_device->device_name = av_strdup(name);
385  if ((tmp = strrchr(descr, '\n')) && tmp[1])
386  new_device->device_description = av_strdup(&tmp[1]);
387  else
388  new_device->device_description = av_strdup(descr);
389  if (!new_device->device_description || !new_device->device_name) {
390  ret = AVERROR(ENOMEM);
391  goto fail;
392  }
393  if ((ret = av_dynarray_add_nofree(&device_list->devices,
394  &device_list->nb_devices, new_device)) < 0) {
395  goto fail;
396  }
397  if (!strcmp(new_device->device_name, "default"))
398  device_list->default_device = device_list->nb_devices - 1;
399  new_device = NULL;
400  }
401  fail:
402  free(io);
403  free(name);
404  free(descr);
405  n++;
406  }
407  if (new_device) {
408  av_free(new_device->device_description);
409  av_free(new_device->device_name);
410  av_free(new_device);
411  }
412  snd_device_name_free_hint(hints);
413  return ret;
414 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
PICK_REORDER
#define PICK_REORDER(layout)
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:348
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
FORMAT_I32
#define FORMAT_I32
out
FILE * out
Definition: movenc.c:55
AVDeviceInfo::device_name
char * device_name
device name, format depends on device
Definition: avdevice.h:334
ALSA_BUFFER_SIZE_MAX
#define ALSA_BUFFER_SIZE_MAX
Definition: alsa.h:46
AV_CHANNEL_LAYOUT_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:386
AVDeviceInfoList::nb_devices
int nb_devices
number of autodetected devices
Definition: avdevice.h:345
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
FORMAT_I8
#define FORMAT_I8
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:342
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
return
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a it should return
Definition: filter_design.txt:264
DEFAULT_CODEC_ID
#define DEFAULT_CODEC_ID
Definition: alsa.h:42
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:329
fail
#define fail()
Definition: checkasm.h:182
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:547
AVDeviceInfoList::devices
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:344
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:332
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:645
AV_CHANNEL_LAYOUT_7POINT1
#define AV_CHANNEL_LAYOUT_7POINT1
Definition: channel_layout.h:401
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
s1
#define s1
Definition: regdef.h:38
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:390
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ctx
AVFormatContext * ctx
Definition: movenc.c:49
MAKE_REORDER_FUNCS
#define MAKE_REORDER_FUNCS(CHANNELS, LAYOUT, MAP)
Definition: alsa.c:83
channels
channels
Definition: aptx.h:31
ff_alsa_open
av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode, unsigned int *sample_rate, int channels, enum AVCodecID *codec_id)
Open an ALSA PCM.
Definition: alsa.c:173
ff_alsa_extend_reorder_buf
int ff_alsa_extend_reorder_buf(AlsaData *s, int min_size)
Definition: alsa.c:346
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:334
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:331
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:387
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:335
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
NULL
#define NULL
Definition: coverity.c:32
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:343
AlsaData
Definition: alsa.h:48
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:339
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
ff_alsa_close
av_cold int ff_alsa_close(AVFormatContext *s1)
Close the ALSA PCM.
Definition: alsa.c:309
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:340
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1371
size
int size
Definition: twinvq_data.h:10344
AVDeviceInfo
Structure describes basic parameters of the device.
Definition: avdevice.h:333
avdevice.h
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:335
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:801
FORMAT_F32
#define FORMAT_F32
codec_id_to_pcm_format
static av_cold snd_pcm_format_t codec_id_to_pcm_format(int codec_id)
Definition: alsa.c:41
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
ff_timefilter_destroy
void ff_timefilter_destroy(TimeFilter *self)
Free all resources associated with the filter.
Definition: timefilter.c:66
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:387
FORMAT_I16
#define FORMAT_I16
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:350
else
else
Definition: snow.txt:125
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:337
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVFMT_FLAG_NONBLOCK
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1409
alsa.h
ret
ret
Definition: filter_design.txt:187
AVDeviceInfoList
List of devices.
Definition: avdevice.h:343
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:315
AVDeviceInfoList::default_device
int default_device
index of default device or -1 if no default
Definition: avdevice.h:346
channel_layout.h
mode
mode
Definition: ebur128.h:83
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:338
ff_alsa_xrun_recover
int ff_alsa_xrun_recover(AVFormatContext *s1, int err)
Try to recover from ALSA buffer underrun.
Definition: alsa.c:325
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:336
mem.h
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:333
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:351
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
ff_alsa_get_device_list
int ff_alsa_get_device_list(AVDeviceInfoList *device_list, snd_pcm_stream_t stream_type)
Definition: alsa.c:363
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:391
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:330
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:349
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:388
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:389
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:341