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 
38 #include "alsa.h"
39 
40 static av_cold snd_pcm_format_t codec_id_to_pcm_format(int codec_id)
41 {
42  switch(codec_id) {
43  case AV_CODEC_ID_PCM_F64LE: return SND_PCM_FORMAT_FLOAT64_LE;
44  case AV_CODEC_ID_PCM_F64BE: return SND_PCM_FORMAT_FLOAT64_BE;
45  case AV_CODEC_ID_PCM_F32LE: return SND_PCM_FORMAT_FLOAT_LE;
46  case AV_CODEC_ID_PCM_F32BE: return SND_PCM_FORMAT_FLOAT_BE;
47  case AV_CODEC_ID_PCM_S32LE: return SND_PCM_FORMAT_S32_LE;
48  case AV_CODEC_ID_PCM_S32BE: return SND_PCM_FORMAT_S32_BE;
49  case AV_CODEC_ID_PCM_U32LE: return SND_PCM_FORMAT_U32_LE;
50  case AV_CODEC_ID_PCM_U32BE: return SND_PCM_FORMAT_U32_BE;
51  case AV_CODEC_ID_PCM_S24LE: return SND_PCM_FORMAT_S24_3LE;
52  case AV_CODEC_ID_PCM_S24BE: return SND_PCM_FORMAT_S24_3BE;
53  case AV_CODEC_ID_PCM_U24LE: return SND_PCM_FORMAT_U24_3LE;
54  case AV_CODEC_ID_PCM_U24BE: return SND_PCM_FORMAT_U24_3BE;
55  case AV_CODEC_ID_PCM_S16LE: return SND_PCM_FORMAT_S16_LE;
56  case AV_CODEC_ID_PCM_S16BE: return SND_PCM_FORMAT_S16_BE;
57  case AV_CODEC_ID_PCM_U16LE: return SND_PCM_FORMAT_U16_LE;
58  case AV_CODEC_ID_PCM_U16BE: return SND_PCM_FORMAT_U16_BE;
59  case AV_CODEC_ID_PCM_S8: return SND_PCM_FORMAT_S8;
60  case AV_CODEC_ID_PCM_U8: return SND_PCM_FORMAT_U8;
61  case AV_CODEC_ID_PCM_MULAW: return SND_PCM_FORMAT_MU_LAW;
62  case AV_CODEC_ID_PCM_ALAW: return SND_PCM_FORMAT_A_LAW;
63  default: return SND_PCM_FORMAT_UNKNOWN;
64  }
65 }
66 
67 #define MAKE_REORDER_FUNC(NAME, TYPE, CHANNELS, LAYOUT, MAP) \
68 static void alsa_reorder_ ## NAME ## _ ## LAYOUT(const void *in_v, \
69  void *out_v, \
70  int n) \
71 { \
72  const TYPE *in = in_v; \
73  TYPE *out = out_v; \
74  \
75  while (n-- > 0) { \
76  MAP \
77  in += CHANNELS; \
78  out += CHANNELS; \
79  } \
80 }
81 
82 #define MAKE_REORDER_FUNCS(CHANNELS, LAYOUT, MAP) \
83  MAKE_REORDER_FUNC(int8, int8_t, CHANNELS, LAYOUT, MAP) \
84  MAKE_REORDER_FUNC(int16, int16_t, CHANNELS, LAYOUT, MAP) \
85  MAKE_REORDER_FUNC(int32, int32_t, CHANNELS, LAYOUT, MAP) \
86  MAKE_REORDER_FUNC(f32, float, CHANNELS, LAYOUT, MAP)
87 
88 MAKE_REORDER_FUNCS(5, out_50, \
89  out[0] = in[0]; \
90  out[1] = in[1]; \
91  out[2] = in[3]; \
92  out[3] = in[4]; \
93  out[4] = in[2]; \
94  )
95 
96 MAKE_REORDER_FUNCS(6, out_51, \
97  out[0] = in[0]; \
98  out[1] = in[1]; \
99  out[2] = in[4]; \
100  out[3] = in[5]; \
101  out[4] = in[2]; \
102  out[5] = in[3]; \
103  )
104 
105 MAKE_REORDER_FUNCS(8, out_71, \
106  out[0] = in[0]; \
107  out[1] = in[1]; \
108  out[2] = in[4]; \
109  out[3] = in[5]; \
110  out[4] = in[2]; \
111  out[5] = in[3]; \
112  out[6] = in[6]; \
113  out[7] = in[7]; \
114  )
115 
116 #define FORMAT_I8 0
117 #define FORMAT_I16 1
118 #define FORMAT_I32 2
119 #define FORMAT_F32 3
120 
121 #define PICK_REORDER(layout)\
122 switch(format) {\
123  case FORMAT_I8: s->reorder_func = alsa_reorder_int8_out_ ##layout; break;\
124  case FORMAT_I16: s->reorder_func = alsa_reorder_int16_out_ ##layout; break;\
125  case FORMAT_I32: s->reorder_func = alsa_reorder_int32_out_ ##layout; break;\
126  case FORMAT_F32: s->reorder_func = alsa_reorder_f32_out_ ##layout; break;\
127 }
128 
129 static av_cold int find_reorder_func(AlsaData *s, int codec_id, AVChannelLayout *layout, int out)
130 {
131  int format;
132 
133  /* reordering input is not currently supported */
134  if (!out)
135  return AVERROR(ENOSYS);
136 
137  /* reordering is not needed for QUAD or 2_2 layout */
140  return 0;
141 
142  switch (codec_id) {
143  case AV_CODEC_ID_PCM_S8:
144  case AV_CODEC_ID_PCM_U8:
146  case AV_CODEC_ID_PCM_MULAW: format = FORMAT_I8; break;
150  case AV_CODEC_ID_PCM_U16BE: format = FORMAT_I16; break;
154  case AV_CODEC_ID_PCM_U32BE: format = FORMAT_I32; break;
156  case AV_CODEC_ID_PCM_F32BE: format = FORMAT_F32; break;
157  default: return AVERROR(ENOSYS);
158  }
159 
162  PICK_REORDER(50)
165  PICK_REORDER(51)
167  PICK_REORDER(71)
168 
169  return s->reorder_func ? 0 : AVERROR(ENOSYS);
170 }
171 
172 av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode,
173  unsigned int *sample_rate,
174  int channels, enum AVCodecID *codec_id)
175 {
176  AlsaData *s = ctx->priv_data;
178  const char *audio_device;
179  int res, flags = 0;
180  snd_pcm_format_t format;
181  snd_pcm_t *h;
182  snd_pcm_hw_params_t *hw_params;
183  snd_pcm_uframes_t buffer_size, period_size;
184 
185  if (ctx->url[0] == 0) audio_device = "default";
186  else audio_device = ctx->url;
187 
188  if (*codec_id == AV_CODEC_ID_NONE)
191  if (format == SND_PCM_FORMAT_UNKNOWN) {
192  av_log(ctx, AV_LOG_ERROR, "sample format 0x%04x is not supported\n", *codec_id);
193  return AVERROR(ENOSYS);
194  }
195  s->frame_size = av_get_bits_per_sample(*codec_id) / 8 * channels;
196 
197  if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
198  flags = SND_PCM_NONBLOCK;
199  }
200  res = snd_pcm_open(&h, audio_device, mode, flags);
201  if (res < 0) {
202  av_log(ctx, AV_LOG_ERROR, "cannot open audio device %s (%s)\n",
203  audio_device, snd_strerror(res));
204  return AVERROR(EIO);
205  }
206 
207  res = snd_pcm_hw_params_malloc(&hw_params);
208  if (res < 0) {
209  av_log(ctx, AV_LOG_ERROR, "cannot allocate hardware parameter structure (%s)\n",
210  snd_strerror(res));
211  goto fail1;
212  }
213 
214  res = snd_pcm_hw_params_any(h, hw_params);
215  if (res < 0) {
216  av_log(ctx, AV_LOG_ERROR, "cannot initialize hardware parameter structure (%s)\n",
217  snd_strerror(res));
218  goto fail;
219  }
220 
221  res = snd_pcm_hw_params_set_access(h, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
222  if (res < 0) {
223  av_log(ctx, AV_LOG_ERROR, "cannot set access type (%s)\n",
224  snd_strerror(res));
225  goto fail;
226  }
227 
228  res = snd_pcm_hw_params_set_format(h, hw_params, format);
229  if (res < 0) {
230  av_log(ctx, AV_LOG_ERROR, "cannot set sample format 0x%04x %d (%s)\n",
231  *codec_id, format, snd_strerror(res));
232  goto fail;
233  }
234 
235  res = snd_pcm_hw_params_set_rate_near(h, hw_params, sample_rate, 0);
236  if (res < 0) {
237  av_log(ctx, AV_LOG_ERROR, "cannot set sample rate (%s)\n",
238  snd_strerror(res));
239  goto fail;
240  }
241 
242  res = snd_pcm_hw_params_set_channels(h, hw_params, channels);
243  if (res < 0) {
244  av_log(ctx, AV_LOG_ERROR, "cannot set channel count to %d (%s)\n",
245  channels, snd_strerror(res));
246  goto fail;
247  }
248 
249  snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size);
250  buffer_size = FFMIN(buffer_size, ALSA_BUFFER_SIZE_MAX);
251  /* TODO: maybe use ctx->max_picture_buffer somehow */
252  res = snd_pcm_hw_params_set_buffer_size_near(h, hw_params, &buffer_size);
253  if (res < 0) {
254  av_log(ctx, AV_LOG_ERROR, "cannot set ALSA buffer size (%s)\n",
255  snd_strerror(res));
256  goto fail;
257  }
258 
259  snd_pcm_hw_params_get_period_size_min(hw_params, &period_size, NULL);
260  if (!period_size)
261  period_size = buffer_size / 4;
262  res = snd_pcm_hw_params_set_period_size_near(h, hw_params, &period_size, NULL);
263  if (res < 0) {
264  av_log(ctx, AV_LOG_ERROR, "cannot set ALSA period size (%s)\n",
265  snd_strerror(res));
266  goto fail;
267  }
268  s->period_size = period_size;
269 
270  res = snd_pcm_hw_params(h, hw_params);
271  if (res < 0) {
272  av_log(ctx, AV_LOG_ERROR, "cannot set parameters (%s)\n",
273  snd_strerror(res));
274  goto fail;
275  }
276 
277  snd_pcm_hw_params_free(hw_params);
278 
279  if (channels > 2 && layout->order != AV_CHANNEL_ORDER_UNSPEC) {
280  if (find_reorder_func(s, *codec_id, layout, mode == SND_PCM_STREAM_PLAYBACK) < 0) {
281  char name[128];
283  av_log(ctx, AV_LOG_WARNING, "ALSA channel layout unknown or unimplemented for %s %s.\n",
284  name, mode == SND_PCM_STREAM_PLAYBACK ? "playback" : "capture");
285  }
286  if (s->reorder_func) {
287  s->reorder_buf_size = buffer_size;
288  s->reorder_buf = av_malloc_array(s->reorder_buf_size, s->frame_size);
289  if (!s->reorder_buf)
290  goto fail1;
291  }
292  }
293 
294  s->pkt = av_packet_alloc();
295  if (!s->pkt)
296  goto fail1;
297 
298  s->h = h;
299  return 0;
300 
301 fail:
302  snd_pcm_hw_params_free(hw_params);
303 fail1:
304  snd_pcm_close(h);
305  return AVERROR(EIO);
306 }
307 
309 {
310  AlsaData *s = s1->priv_data;
311 
312  if (snd_pcm_stream(s->h) == SND_PCM_STREAM_PLAYBACK) {
313  snd_pcm_nonblock(s->h, 0);
314  snd_pcm_drain(s->h);
315  }
316  av_freep(&s->reorder_buf);
317  if (CONFIG_ALSA_INDEV)
318  ff_timefilter_destroy(s->timefilter);
319  snd_pcm_close(s->h);
320  av_packet_free(&s->pkt);
321  return 0;
322 }
323 
325 {
326  AlsaData *s = s1->priv_data;
327  snd_pcm_t *handle = s->h;
328 
329  av_log(s1, AV_LOG_WARNING, "ALSA buffer xrun.\n");
330  if (err == -EPIPE) {
331  err = snd_pcm_prepare(handle);
332  if (err < 0) {
333  av_log(s1, AV_LOG_ERROR, "cannot recover from underrun (snd_pcm_prepare failed: %s)\n", snd_strerror(err));
334 
335  return AVERROR(EIO);
336  }
337  } else if (err == -ESTRPIPE) {
338  av_log(s1, AV_LOG_ERROR, "-ESTRPIPE... Unsupported!\n");
339 
340  return -1;
341  }
342  return err;
343 }
344 
346 {
347  int size = s->reorder_buf_size;
348  void *r;
349 
350  av_assert0(size != 0);
351  while (size < min_size)
352  size *= 2;
353  r = av_realloc_array(s->reorder_buf, size, s->frame_size);
354  if (!r)
355  return AVERROR(ENOMEM);
356  s->reorder_buf = r;
357  s->reorder_buf_size = size;
358  return 0;
359 }
360 
361 /* ported from alsa-utils/aplay.c */
362 int ff_alsa_get_device_list(AVDeviceInfoList *device_list, snd_pcm_stream_t stream_type)
363 {
364  int ret = 0;
365  void **hints, **n;
366  char *name = NULL, *descr = NULL, *io = NULL, *tmp;
367  AVDeviceInfo *new_device = NULL;
368  const char *filter = stream_type == SND_PCM_STREAM_PLAYBACK ? "Output" : "Input";
369 
370  if (snd_device_name_hint(-1, "pcm", &hints) < 0)
371  return AVERROR_EXTERNAL;
372  n = hints;
373  while (*n && !ret) {
374  name = snd_device_name_get_hint(*n, "NAME");
375  descr = snd_device_name_get_hint(*n, "DESC");
376  io = snd_device_name_get_hint(*n, "IOID");
377  if (!io || !strcmp(io, filter)) {
378  new_device = av_mallocz(sizeof(AVDeviceInfo));
379  if (!new_device) {
380  ret = AVERROR(ENOMEM);
381  goto fail;
382  }
383  new_device->device_name = av_strdup(name);
384  if ((tmp = strrchr(descr, '\n')) && tmp[1])
385  new_device->device_description = av_strdup(&tmp[1]);
386  else
387  new_device->device_description = av_strdup(descr);
388  if (!new_device->device_description || !new_device->device_name) {
389  ret = AVERROR(ENOMEM);
390  goto fail;
391  }
392  if ((ret = av_dynarray_add_nofree(&device_list->devices,
393  &device_list->nb_devices, new_device)) < 0) {
394  goto fail;
395  }
396  if (!strcmp(new_device->device_name, "default"))
397  device_list->default_device = device_list->nb_devices - 1;
398  new_device = NULL;
399  }
400  fail:
401  free(io);
402  free(name);
403  free(descr);
404  n++;
405  }
406  if (new_device) {
407  av_free(new_device->device_description);
408  av_free(new_device->device_name);
409  av_free(new_device);
410  }
411  snd_device_name_free_hint(hints);
412  return ret;
413 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:320
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:340
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:116
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:54
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:364
AVDeviceInfo::device_name
char * device_name
device name, format depends on device
Definition: avdevice.h:464
ALSA_BUFFER_SIZE_MAX
#define ALSA_BUFFER_SIZE_MAX
Definition: alsa.h:46
AVDeviceInfoList::nb_devices
int nb_devices
number of autodetected devices
Definition: avdevice.h:475
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:1281
FORMAT_I8
#define FORMAT_I8
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:334
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:155
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:73
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:363
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:321
fail
#define fail()
Definition: checkasm.h:131
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:586
AVDeviceInfoList::devices
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:474
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:324
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_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:361
s
#define s(width, name)
Definition: cbs_vp9.c:256
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:225
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1331
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
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:106
s1
#define s1
Definition: regdef.h:38
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ctx
AVFormatContext * ctx
Definition: movenc.c:48
MAKE_REORDER_FUNCS
#define MAKE_REORDER_FUNCS(CHANNELS, LAYOUT, MAP)
Definition: alsa.c:82
channels
channels
Definition: aptx.h:32
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:172
ff_alsa_extend_reorder_buf
int ff_alsa_extend_reorder_buf(AlsaData *s, int min_size)
Definition: alsa.c:345
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:326
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:323
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:372
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:327
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
NULL
#define NULL
Definition: coverity.c:32
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:335
AlsaData
Definition: alsa.h:48
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:331
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:930
AV_CHANNEL_LAYOUT_7POINT1
#define AV_CHANNEL_LAYOUT_7POINT1
Definition: channel_layout.h:375
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
ff_alsa_close
av_cold int ff_alsa_close(AVFormatContext *s1)
Close the ALSA PCM.
Definition: alsa.c:308
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:332
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1296
size
int size
Definition: twinvq_data.h:10344
AVDeviceInfo
Structure describes basic parameters of the device.
Definition: avdevice.h:463
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: avpacket.c:62
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:465
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:40
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:48
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:342
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:329
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:264
AVFMT_FLAG_NONBLOCK
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1334
alsa.h
ret
ret
Definition: filter_design.txt:187
AVDeviceInfoList
List of devices.
Definition: avdevice.h:473
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:365
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:323
AVDeviceInfoList::default_device
int default_device
index of default device or -1 if no default
Definition: avdevice.h:476
channel_layout.h
mode
mode
Definition: ebur128.h:83
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:330
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:776
ff_alsa_xrun_recover
int ff_alsa_xrun_recover(AVFormatContext *s1, int err)
Try to recover from ALSA buffer underrun.
Definition: alsa.c:324
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:328
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:325
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:343
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:362
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:322
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:341
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:362
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:366
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1241
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:333