FFmpeg: libavutil/samplefmt.c Source File

FFmpeg

[フレーム]

libavutil

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 */

19 #include "error.h"

20 #include "macros.h"

21 #include "mem.h"

22 #include "samplefmt.h"

24 #include <limits.h>

25 #include <stdio.h>

26 #include <string.h>

28 typedef struct SampleFmtInfo {

29 char name[8];

30 int bits;

31 int planar;

32 enum AVSampleFormat altform; ///< planar<->packed alternative form

33 } SampleFmtInfo;

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 };

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 }

58 enum AVSampleFormat av_get_sample_fmt(const char *name)

59 {

60 int i;

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 }

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 }

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 }

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 }

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

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

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

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

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

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:262

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

planes

static const struct @386 planes[]

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)