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