FFmpeg
samplefmt.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "error.h"
20 #include "macros.h"
21 #include "mem.h"
22 #include "samplefmt.h"
23 
24 #include <limits.h>
25 #include <stdio.h>
26 #include <string.h>
27 
28 typedef struct SampleFmtInfo {
29  char name[8];
30  int bits;
31  int planar;
32  enum AVSampleFormat altform; ///< planar<->packed alternative form
33 } SampleFmtInfo;
34 
35 /** this table gives more information about formats */
36 static const SampleFmtInfo sample_fmt_info[AV_SAMPLE_FMT_NB] = {
37  [AV_SAMPLE_FMT_U8] = { .name = "u8", .bits = 8, .planar = 0, .altform = AV_SAMPLE_FMT_U8P },
38  [AV_SAMPLE_FMT_S16] = { .name = "s16", .bits = 16, .planar = 0, .altform = AV_SAMPLE_FMT_S16P },
39  [AV_SAMPLE_FMT_S32] = { .name = "s32", .bits = 32, .planar = 0, .altform = AV_SAMPLE_FMT_S32P },
40  [AV_SAMPLE_FMT_S64] = { .name = "s64", .bits = 64, .planar = 0, .altform = AV_SAMPLE_FMT_S64P },
41  [AV_SAMPLE_FMT_FLT] = { .name = "flt", .bits = 32, .planar = 0, .altform = AV_SAMPLE_FMT_FLTP },
42  [AV_SAMPLE_FMT_DBL] = { .name = "dbl", .bits = 64, .planar = 0, .altform = AV_SAMPLE_FMT_DBLP },
43  [AV_SAMPLE_FMT_U8P] = { .name = "u8p", .bits = 8, .planar = 1, .altform = AV_SAMPLE_FMT_U8 },
44  [AV_SAMPLE_FMT_S16P] = { .name = "s16p", .bits = 16, .planar = 1, .altform = AV_SAMPLE_FMT_S16 },
45  [AV_SAMPLE_FMT_S32P] = { .name = "s32p", .bits = 32, .planar = 1, .altform = AV_SAMPLE_FMT_S32 },
46  [AV_SAMPLE_FMT_S64P] = { .name = "s64p", .bits = 64, .planar = 1, .altform = AV_SAMPLE_FMT_S64 },
47  [AV_SAMPLE_FMT_FLTP] = { .name = "fltp", .bits = 32, .planar = 1, .altform = AV_SAMPLE_FMT_FLT },
48  [AV_SAMPLE_FMT_DBLP] = { .name = "dblp", .bits = 64, .planar = 1, .altform = AV_SAMPLE_FMT_DBL },
49 };
50 
51 const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
52 {
53  if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
54  return NULL;
55  return sample_fmt_info[sample_fmt].name;
56 }
57 
58 enum AVSampleFormat av_get_sample_fmt(const char *name)
59 {
60  int i;
61 
62  for (i = 0; i < AV_SAMPLE_FMT_NB; i++)
63  if (!strcmp(sample_fmt_info[i].name, name))
64  return i;
65  return AV_SAMPLE_FMT_NONE;
66 }
67 
68 enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar)
69 {
70  if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
71  return AV_SAMPLE_FMT_NONE;
72  if (sample_fmt_info[sample_fmt].planar == planar)
73  return sample_fmt;
74  return sample_fmt_info[sample_fmt].altform;
75 }
76 
77 enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
78 {
79  if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
80  return AV_SAMPLE_FMT_NONE;
81  if (sample_fmt_info[sample_fmt].planar)
82  return sample_fmt_info[sample_fmt].altform;
83  return sample_fmt;
84 }
85 
86 enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
87 {
88  if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
89  return AV_SAMPLE_FMT_NONE;
90  if (sample_fmt_info[sample_fmt].planar)
91  return sample_fmt;
92  return sample_fmt_info[sample_fmt].altform;
93 }
94 
95 char *av_get_sample_fmt_string (char *buf, int buf_size, enum AVSampleFormat sample_fmt)
96 {
97  /* print header */
98  if (sample_fmt < 0)
99  snprintf(buf, buf_size, "name " " depth");
100  else if (sample_fmt < AV_SAMPLE_FMT_NB) {
101  SampleFmtInfo info = sample_fmt_info[sample_fmt];
102  snprintf (buf, buf_size, "%-6s" " %2d ", info.name, info.bits);
103  }
104 
105  return buf;
106 }
107 
108 int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
109 {
110  return sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB ?
111  0 : sample_fmt_info[sample_fmt].bits >> 3;
112 }
113 
114 int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
115 {
116  if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)
117  return 0;
118  return sample_fmt_info[sample_fmt].planar;
119 }
120 
121 int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
122  enum AVSampleFormat sample_fmt, int align)
123 {
124  int line_size;
125  int sample_size = av_get_bytes_per_sample(sample_fmt);
126  int planar = av_sample_fmt_is_planar(sample_fmt);
127 
128  /* validate parameter ranges */
129  if (!sample_size || nb_samples <= 0 || nb_channels <= 0)
130  return AVERROR(EINVAL);
131 
132  /* auto-select alignment if not specified */
133  if (!align) {
134  if (nb_samples > INT_MAX - 31)
135  return AVERROR(EINVAL);
136  align = 1;
137  nb_samples = FFALIGN(nb_samples, 32);
138  }
139 
140  /* check for integer overflow */
141  if (nb_channels > INT_MAX / align ||
142  (int64_t)nb_channels * nb_samples > (INT_MAX - (align * nb_channels)) / sample_size)
143  return AVERROR(EINVAL);
144 
145  line_size = planar ? FFALIGN(nb_samples * sample_size, align) :
146  FFALIGN(nb_samples * sample_size * nb_channels, align);
147  if (linesize)
148  *linesize = line_size;
149 
150  return planar ? line_size * nb_channels : line_size;
151 }
152 
153 int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
154  const uint8_t *buf, int nb_channels, int nb_samples,
155  enum AVSampleFormat sample_fmt, int align)
156 {
157  int ch, planar, buf_size, line_size;
158 
159  planar = av_sample_fmt_is_planar(sample_fmt);
160  buf_size = av_samples_get_buffer_size(&line_size, nb_channels, nb_samples,
161  sample_fmt, align);
162  if (buf_size < 0)
163  return buf_size;
164 
165  if (linesize)
166  *linesize = line_size;
167 
168  memset(audio_data, 0, planar
169  ? sizeof(*audio_data) * nb_channels
170  : sizeof(*audio_data));
171 
172  if (!buf)
173  return buf_size;
174 
175  audio_data[0] = (uint8_t *)buf;
176  for (ch = 1; planar && ch < nb_channels; ch++)
177  audio_data[ch] = audio_data[ch-1] + line_size;
178 
179  return buf_size;
180 }
181 
182 int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
183  int nb_samples, enum AVSampleFormat sample_fmt, int align)
184 {
185  uint8_t *buf;
186  int size = av_samples_get_buffer_size(NULL, nb_channels, nb_samples,
187  sample_fmt, align);
188  if (size < 0)
189  return size;
190 
191  buf = av_malloc(size);
192  if (!buf)
193  return AVERROR(ENOMEM);
194 
195  size = av_samples_fill_arrays(audio_data, linesize, buf, nb_channels,
196  nb_samples, sample_fmt, align);
197  if (size < 0) {
198  av_free(buf);
199  return size;
200  }
201 
202  av_samples_set_silence(audio_data, 0, nb_samples, nb_channels, sample_fmt);
203 
204  return size;
205 }
206 
207 int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels,
208  int nb_samples, enum AVSampleFormat sample_fmt, int align)
209 {
210  int ret, nb_planes = av_sample_fmt_is_planar(sample_fmt) ? nb_channels : 1;
211 
212  *audio_data = av_calloc(nb_planes, sizeof(**audio_data));
213  if (!*audio_data)
214  return AVERROR(ENOMEM);
215  ret = av_samples_alloc(*audio_data, linesize, nb_channels,
216  nb_samples, sample_fmt, align);
217  if (ret < 0)
218  av_freep(audio_data);
219  return ret;
220 }
221 
222 int av_samples_copy(uint8_t * const *dst, uint8_t * const *src, int dst_offset,
223  int src_offset, int nb_samples, int nb_channels,
224  enum AVSampleFormat sample_fmt)
225 {
226  int planar = av_sample_fmt_is_planar(sample_fmt);
227  int planes = planar ? nb_channels : 1;
228  int block_align = av_get_bytes_per_sample(sample_fmt) * (planar ? 1 : nb_channels);
229  int data_size = nb_samples * block_align;
230  int i;
231 
232  dst_offset *= block_align;
233  src_offset *= block_align;
234 
235  if((dst[0] < src[0] ? src[0] - dst[0] : dst[0] - src[0]) >= data_size) {
236  for (i = 0; i < planes; i++)
237  memcpy(dst[i] + dst_offset, src[i] + src_offset, data_size);
238  } else {
239  for (i = 0; i < planes; i++)
240  memmove(dst[i] + dst_offset, src[i] + src_offset, data_size);
241  }
242 
243  return 0;
244 }
245 
246 int av_samples_set_silence(uint8_t * const *audio_data, int offset, int nb_samples,
247  int nb_channels, enum AVSampleFormat sample_fmt)
248 {
249  int planar = av_sample_fmt_is_planar(sample_fmt);
250  int planes = planar ? nb_channels : 1;
251  int block_align = av_get_bytes_per_sample(sample_fmt) * (planar ? 1 : nb_channels);
252  int data_size = nb_samples * block_align;
253  int fill_char = (sample_fmt == AV_SAMPLE_FMT_U8 ||
254  sample_fmt == AV_SAMPLE_FMT_U8P) ? 0x80 : 0x00;
255  int i;
256 
257  offset *= block_align;
258 
259  for (i = 0; i < planes; i++)
260  memset(audio_data[i] + offset, fill_char, data_size);
261 
262  return 0;
263 }
av_samples_copy
int av_samples_copy(uint8_t *const *dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
Definition: samplefmt.c:222
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
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
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
av_get_sample_fmt_string
char * av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt)
Generate a string corresponding to the sample format with sample_fmt, or a header if sample_fmt is ne...
Definition: samplefmt.c:95
int64_t
long long int64_t
Definition: coverity.c:34
av_samples_fill_arrays
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill plane data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:153
av_samples_set_silence
int av_samples_set_silence(uint8_t *const *audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Fill an audio buffer with silence.
Definition: samplefmt.c:246
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
SampleFmtInfo
Definition: samplefmt.c:28
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
macros.h
samplefmt.h
av_samples_alloc
int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Allocate a samples buffer for nb_samples samples, and fill data pointers and linesize accordingly.
Definition: samplefmt.c:182
AV_SAMPLE_FMT_S64P
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
Definition: samplefmt.h:69
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
av_get_planar_sample_fmt
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
Definition: samplefmt.c:86
info
MIPS optimizations info
Definition: mips.txt:2
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
limits.h
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:51
planes
static const struct @465 planes[]
NULL
#define NULL
Definition: coverity.c:32
SampleFmtInfo::planar
int planar
Definition: samplefmt.c:31
error.h
AV_SAMPLE_FMT_NB
@ AV_SAMPLE_FMT_NB
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:71
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
SampleFmtInfo::name
char name[8]
Definition: samplefmt.c:29
sample_fmt_info
static const SampleFmtInfo sample_fmt_info[AV_SAMPLE_FMT_NB]
this table gives more information about formats
Definition: samplefmt.c:36
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:411
offset
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 offset
Definition: writing_filters.txt:86
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AV_SAMPLE_FMT_U8
@ AV_SAMPLE_FMT_U8
unsigned 8 bits
Definition: samplefmt.h:57
av_get_sample_fmt
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
Definition: samplefmt.c:58
SampleFmtInfo::bits
int bits
Definition: samplefmt.c:30
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
av_samples_get_buffer_size
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:121
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
ret
ret
Definition: filter_design.txt:187
SampleFmtInfo::altform
enum AVSampleFormat altform
planar<->packed alternative form
Definition: samplefmt.c:32
av_get_packed_sample_fmt
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
Definition: samplefmt.c:77
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
av_get_alt_sample_fmt
enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar)
Return the planar<->packed alternative form of the given sample format, or AV_SAMPLE_FMT_NONE on erro...
Definition: samplefmt.c:68
mem.h
av_samples_alloc_array_and_samples
int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Allocate a data pointers array, samples buffer for nb_samples samples, and fill data pointers and lin...
Definition: samplefmt.c:207
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:61
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:59
snprintf
#define snprintf
Definition: snprintf.h:34
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
src
#define src
Definition: vp8dsp.c:248
AV_SAMPLE_FMT_S64
@ AV_SAMPLE_FMT_S64
signed 64 bits
Definition: samplefmt.h:68
Generated on Wed Nov 20 2024 19:22:48 for FFmpeg by   doxygen 1.8.17