FFmpeg: libavresample/audio_data.c Source File

FFmpeg

[フレーム]

libavresample

audio_data.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include <stdint.h>

22 #include <string.h>

24 #include "libavutil/mem.h"

25 #include "audio_data.h"

27 static const AVClass audio_data_class = {

28 .class_name = "AudioData",

29 .item_name = av_default_item_name,

30 .version = LIBAVUTIL_VERSION_INT,

31 };

33 /*

34 * Calculate alignment for data pointers.

35 */

36 static void calc_ptr_alignment(AudioData *a)

37 {

38 int p;

39 int min_align = 128;

41 for (p = 0; p < a->planes; p++) {

42 int cur_align = 128;

43 while ((intptr_t)a->data[p] % cur_align)

44 cur_align >>= 1;

45 if (cur_align < min_align)

46 min_align = cur_align;

47 }

48 a->ptr_align = min_align;

49 }

51 int ff_sample_fmt_is_planar(enum AVSampleFormat sample_fmt, int channels)

52 {

53 if (channels == 1)

54 return 1;

55 else

56 return av_sample_fmt_is_planar(sample_fmt);

57 }

59 int ff_audio_data_set_channels(AudioData *a, int channels)

60 {

61 if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS ||

62 channels > a->allocated_channels)

63 return AVERROR(EINVAL);

65 a->channels = channels;

66 a->planes = a->is_planar ? channels : 1;

68 calc_ptr_alignment(a);

70 return 0;

71 }

73 int ff_audio_data_init(AudioData *a, uint8_t * const *src, int plane_size,

74 int channels, int nb_samples,

75 enum AVSampleFormat sample_fmt, int read_only,

76 const char *name)

77 {

78 int p;

80 memset(a, 0, sizeof(*a));

81 a->class = &audio_data_class;

83 if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS) {

84 av_log(a, AV_LOG_ERROR, "invalid channel count: %d\n", channels);

85 return AVERROR(EINVAL);

86 }

88 a->sample_size = av_get_bytes_per_sample(sample_fmt);

89 if (!a->sample_size) {

90 av_log(a, AV_LOG_ERROR, "invalid sample format\n");

91 return AVERROR(EINVAL);

92 }

93 a->is_planar = ff_sample_fmt_is_planar(sample_fmt, channels);

94 a->planes = a->is_planar ? channels : 1;

95 a->stride = a->sample_size * (a->is_planar ? 1 : channels);

97 for (p = 0; p < (a->is_planar ? channels : 1); p++) {

98 if (!src[p]) {

99 av_log(a, AV_LOG_ERROR, "invalid NULL pointer for src[%d]\n", p);

100 return AVERROR(EINVAL);

101 }

102 a->data[p] = src[p];

103 }

104 a->allocated_samples = nb_samples * !read_only;

105 a->nb_samples = nb_samples;

106 a->sample_fmt = sample_fmt;

107 a->channels = channels;

108 a->allocated_channels = channels;

109 a->read_only = read_only;

110 a->allow_realloc = 0;

111 a->name = name ? name : "{no name}";

112

113 calc_ptr_alignment(a);

114 a->samples_align = plane_size / a->stride;

115

116 return 0;

117 }

118

119 AudioData *ff_audio_data_alloc(int channels, int nb_samples,

120 enum AVSampleFormat sample_fmt, const char *name)

121 {

122 AudioData *a;

123 int ret;

124

125 if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS)

126 return NULL;

127

128 a = av_mallocz(sizeof(*a));

129 if (!a)

130 return NULL;

131

132 a->sample_size = av_get_bytes_per_sample(sample_fmt);

133 if (!a->sample_size) {

134 av_free(a);

135 return NULL;

136 }

137 a->is_planar = ff_sample_fmt_is_planar(sample_fmt, channels);

138 a->planes = a->is_planar ? channels : 1;

139 a->stride = a->sample_size * (a->is_planar ? 1 : channels);

140

141 a->class = &audio_data_class;

142 a->sample_fmt = sample_fmt;

143 a->channels = channels;

144 a->allocated_channels = channels;

145 a->read_only = 0;

146 a->allow_realloc = 1;

147 a->name = name ? name : "{no name}";

148

149 if (nb_samples > 0) {

150 ret = ff_audio_data_realloc(a, nb_samples);

151 if (ret < 0) {

152 av_free(a);

153 return NULL;

154 }

155 return a;

156 } else {

157 calc_ptr_alignment(a);

158 return a;

159 }

160 }

161

162 int ff_audio_data_realloc(AudioData *a, int nb_samples)

163 {

164 int ret, new_buf_size, plane_size, p;

165

166 /* check if buffer is already large enough */

167 if (a->allocated_samples >= nb_samples)

168 return 0;

169

170 /* validate that the output is not read-only and realloc is allowed */

171 if (a->read_only || !a->allow_realloc)

172 return AVERROR(EINVAL);

173

174 new_buf_size = av_samples_get_buffer_size(&plane_size,

175 a->allocated_channels, nb_samples,

176 a->sample_fmt, 0);

177 if (new_buf_size < 0)

178 return new_buf_size;

179

180 /* if there is already data in the buffer and the sample format is planar,

181 allocate a new buffer and copy the data, otherwise just realloc the

182 internal buffer and set new data pointers */

183 if (a->nb_samples > 0 && a->is_planar) {

184 uint8_t *new_data[AVRESAMPLE_MAX_CHANNELS] = { NULL };

185

186 ret = av_samples_alloc(new_data, &plane_size, a->allocated_channels,

187 nb_samples, a->sample_fmt, 0);

188 if (ret < 0)

189 return ret;

190

191 for (p = 0; p < a->planes; p++)

192 memcpy(new_data[p], a->data[p], a->nb_samples * a->stride);

193

194 av_freep(&a->buffer);

195 memcpy(a->data, new_data, sizeof(new_data));

196 a->buffer = a->data[0];

197 } else {

198 av_freep(&a->buffer);

199 a->buffer = av_malloc(new_buf_size);

200 if (!a->buffer)

201 return AVERROR(ENOMEM);

202 ret = av_samples_fill_arrays(a->data, &plane_size, a->buffer,

203 a->allocated_channels, nb_samples,

204 a->sample_fmt, 0);

205 if (ret < 0)

206 return ret;

207 }

208 a->buffer_size = new_buf_size;

209 a->allocated_samples = nb_samples;

210

211 calc_ptr_alignment(a);

212 a->samples_align = plane_size / a->stride;

213

214 return 0;

215 }

216

217 void ff_audio_data_free(AudioData **a)

218 {

219 if (!*a)

220 return;

221 av_free((*a)->buffer);

222 av_freep(a);

223 }

224

225 int ff_audio_data_copy(AudioData *dst, AudioData *src, ChannelMapInfo *map)

226 {

227 int ret, p;

228

229 /* validate input/output compatibility */

230 if (dst->sample_fmt != src->sample_fmt || dst->channels < src->channels)

231 return AVERROR(EINVAL);

232

233 if (map && !src->is_planar) {

234 av_log(src, AV_LOG_ERROR, "cannot remap packed format during copy\n");

235 return AVERROR(EINVAL);

236 }

237

238 /* if the input is empty, just empty the output */

239 if (!src->nb_samples) {

240 dst->nb_samples = 0;

241 return 0;

242 }

243

244 /* reallocate output if necessary */

245 ret = ff_audio_data_realloc(dst, src->nb_samples);

246 if (ret < 0)

247 return ret;

248

249 /* copy data */

250 if (map) {

251 if (map->do_remap) {

252 for (p = 0; p < src->planes; p++) {

253 if (map->channel_map[p] >= 0)

254 memcpy(dst->data[p], src->data[map->channel_map[p]],

255 src->nb_samples * src->stride);

256 }

257 }

258 if (map->do_copy || map->do_zero) {

259 for (p = 0; p < src->planes; p++) {

260 if (map->channel_copy[p])

261 memcpy(dst->data[p], dst->data[map->channel_copy[p]],

262 src->nb_samples * src->stride);

263 else if (map->channel_zero[p])

264 av_samples_set_silence(&dst->data[p], 0, src->nb_samples,

265 1, dst->sample_fmt);

266 }

267 }

268 } else {

269 for (p = 0; p < src->planes; p++)

270 memcpy(dst->data[p], src->data[p], src->nb_samples * src->stride);

271 }

272

273 dst->nb_samples = src->nb_samples;

274

275 return 0;

276 }

277

278 int ff_audio_data_combine(AudioData *dst, int dst_offset, AudioData *src,

279 int src_offset, int nb_samples)

280 {

281 int ret, p, dst_offset2, dst_move_size;

282

283 /* validate input/output compatibility */

284 if (dst->sample_fmt != src->sample_fmt || dst->channels != src->channels) {

285 av_log(src, AV_LOG_ERROR, "sample format mismatch\n");

286 return AVERROR(EINVAL);

287 }

288

289 /* validate offsets are within the buffer bounds */

290 if (dst_offset < 0 || dst_offset > dst->nb_samples ||

291 src_offset < 0 || src_offset > src->nb_samples) {

292 av_log(src, AV_LOG_ERROR, "offset out-of-bounds: src=%d dst=%d\n",

293 src_offset, dst_offset);

294 return AVERROR(EINVAL);

295 }

296

297 /* check offsets and sizes to see if we can just do nothing and return */

298 if (nb_samples > src->nb_samples - src_offset)

299 nb_samples = src->nb_samples - src_offset;

300 if (nb_samples <= 0)

301 return 0;

302

303 /* validate that the output is not read-only */

304 if (dst->read_only) {

305 av_log(dst, AV_LOG_ERROR, "dst is read-only\n");

306 return AVERROR(EINVAL);

307 }

308

309 /* reallocate output if necessary */

310 ret = ff_audio_data_realloc(dst, dst->nb_samples + nb_samples);

311 if (ret < 0) {

312 av_log(dst, AV_LOG_ERROR, "error reallocating dst\n");

313 return ret;

314 }

315

316 dst_offset2 = dst_offset + nb_samples;

317 dst_move_size = dst->nb_samples - dst_offset;

318

319 for (p = 0; p < src->planes; p++) {

320 if (dst_move_size > 0) {

321 memmove(dst->data[p] + dst_offset2 * dst->stride,

322 dst->data[p] + dst_offset * dst->stride,

323 dst_move_size * dst->stride);

324 }

325 memcpy(dst->data[p] + dst_offset * dst->stride,

326 src->data[p] + src_offset * src->stride,

327 nb_samples * src->stride);

328 }

329 dst->nb_samples += nb_samples;

330

331 return 0;

332 }

333

334 void ff_audio_data_drain(AudioData *a, int nb_samples)

335 {

336 if (a->nb_samples <= nb_samples) {

337 /* drain the whole buffer */

338 a->nb_samples = 0;

339 } else {

340 int p;

341 int move_offset = a->stride * nb_samples;

342 int move_size = a->stride * (a->nb_samples - nb_samples);

343

344 for (p = 0; p < a->planes; p++)

345 memmove(a->data[p], a->data[p] + move_offset, move_size);

346

347 a->nb_samples -= nb_samples;

348 }

349 }

350

351 int ff_audio_data_add_to_fifo(AVAudioFifo *af, AudioData *a, int offset,

352 int nb_samples)

353 {

354 uint8_t *offset_data[AVRESAMPLE_MAX_CHANNELS];

355 int offset_size, p;

356

357 if (offset >= a->nb_samples)

358 return 0;

359 offset_size = offset * a->stride;

360 for (p = 0; p < a->planes; p++)

361 offset_data[p] = a->data[p] + offset_size;

362

363 return av_audio_fifo_write(af, (void **)offset_data, nb_samples);

364 }

365

366 int ff_audio_data_read_from_fifo(AVAudioFifo *af, AudioData *a, int nb_samples)

367 {

368 int ret;

369

370 if (a->read_only)

371 return AVERROR(EINVAL);

372

373 ret = ff_audio_data_realloc(a, nb_samples);

374 if (ret < 0)

375 return ret;

376

377 ret = av_audio_fifo_read(af, (void **)a->data, nb_samples);

378 if (ret >= 0)

379 a->nb_samples = ret;

380 return ret;

381 }

AudioData::buffer_size

unsigned int buffer_size

allocated buffer size

Definition: audio_data.h:41

NULL

#define NULL

Definition: coverity.c:32

calc_ptr_alignment

static void calc_ptr_alignment(AudioData *a)

Definition: audio_data.c:36

AudioData::name

const char * name

name for debug logging

Definition: audio_data.h:55

av_audio_fifo_read

int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)

Read data from an AVAudioFifo.

Definition: audio_fifo.c:158

ff_audio_data_realloc

int ff_audio_data_realloc(AudioData *a, int nb_samples)

Reallocate AudioData.

Definition: audio_data.c:162

AudioData

Audio buffer used for intermediate storage between conversion phases.

Definition: audio_data.h:37

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:70

mem.h

memory handling functions

ff_audio_data_add_to_fifo

int ff_audio_data_add_to_fifo(AVAudioFifo *af, AudioData *a, int offset, int nb_samples)

Add samples in AudioData to an AVAudioFifo.

Definition: audio_data.c:351

ChannelMapInfo::do_zero

int do_zero

zeroing needed

Definition: internal.h:49

ff_audio_data_alloc

AudioData * ff_audio_data_alloc(int channels, int nb_samples, enum AVSampleFormat sample_fmt, const char *name)

Allocate AudioData.

Definition: audio_data.c:119

AudioData::allow_realloc

int allow_realloc

realloc is allowed

Definition: audio_data.h:52

ChannelMapInfo::channel_zero

int channel_zero[AVRESAMPLE_MAX_CHANNELS]

dest index to zero

Definition: internal.h:48

AudioData::nb_samples

int nb_samples

current number of samples

Definition: audio_data.h:43

audio_data_class

static const AVClass audio_data_class

Definition: audio_data.c:27

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:72

AudioData::sample_size

int sample_size

bytes per sample

Definition: audio_data.h:49

AudioData::allocated_channels

int allocated_channels

allocated channel count

Definition: audio_data.h:46

uint8_t

Definition: audio_convert.c:194

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

AudioData::read_only

int read_only

data is read-only

Definition: audio_data.h:51

ff_sample_fmt_is_planar

int ff_sample_fmt_is_planar(enum AVSampleFormat sample_fmt, int channels)

Definition: audio_data.c:51

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

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

ff_audio_data_set_channels

int ff_audio_data_set_channels(AudioData *a, int channels)

Definition: audio_data.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

ChannelMapInfo

Definition: internal.h:43

av_samples_set_silence

int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)

Fill an audio buffer with silence.

Definition: samplefmt.c:235

AudioData::stride

int stride

sample byte offset within a plane

Definition: audio_data.h:50

av_default_item_name

Definition: libopenh264enc.c:68

AVERROR

#define AVERROR(e)

Definition: error.h:43

AudioData::channels

int channels

channel count

Definition: audio_data.h:45

ff_audio_data_init

int ff_audio_data_init(AudioData *a, uint8_t *const *src, int plane_size, int channels, int nb_samples, enum AVSampleFormat sample_fmt, int read_only, const char *name)

Initialize AudioData using a given source.

Definition: audio_data.c:73

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

ff_audio_data_read_from_fifo

int ff_audio_data_read_from_fifo(AVAudioFifo *af, AudioData *a, int nb_samples)

Read samples from an AVAudioFifo to AudioData.

Definition: audio_data.c:366

AudioData::is_planar

int is_planar

sample format is planar

Definition: audio_data.h:47

AudioData::buffer

uint8_t * buffer

data buffer

Definition: audio_data.h:40

AVAudioFifo

Context for an Audio FIFO Buffer.

Definition: audio_fifo.c:34

AudioData::class

const AVClass * class

AVClass for logging.

Definition: audio_data.h:38

ChannelMapInfo::channel_copy

int channel_copy[AVRESAMPLE_MAX_CHANNELS]

dest index to copy from

Definition: internal.h:46

ChannelMapInfo::do_remap

int do_remap

remap needed

Definition: internal.h:45

ff_audio_data_combine

int ff_audio_data_combine(AudioData *dst, int dst_offset, AudioData *src, int src_offset, int nb_samples)

Append data from one AudioData to the end of another.

Definition: audio_data.c:278

ff_audio_data_drain

void ff_audio_data_drain(AudioData *a, int nb_samples)

Drain samples from the start of the AudioData.

Definition: audio_data.c:334

audio_data.h

src

#define src

Definition: vp9dsp.c:530

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

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:59

AudioData::data

uint8_t * data[AVRESAMPLE_MAX_CHANNELS]

data plane pointers

Definition: audio_data.h:39

AVRESAMPLE_MAX_CHANNELS

#define AVRESAMPLE_MAX_CHANNELS

Definition: avresample.h:104

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

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

ChannelMapInfo::channel_map

int channel_map[AVRESAMPLE_MAX_CHANNELS]

source index of each output channel, -1 if not remapped

Definition: internal.h:44

av_audio_fifo_write

int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)

Write data to an AVAudioFifo.

Definition: audio_fifo.c:113

av_get_bytes_per_sample

int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)

Return number of bytes per sample.

Definition: samplefmt.c:104

AudioData::samples_align

int samples_align

allocated samples alignment

Definition: audio_data.h:54

ff_audio_data_copy

int ff_audio_data_copy(AudioData *dst, AudioData *src, ChannelMapInfo *map)

Copy data from one AudioData to another.

Definition: audio_data.c:225

ChannelMapInfo::do_copy

int do_copy

copy needed

Definition: internal.h:47

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

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AudioData::allocated_samples

int allocated_samples

number of samples the buffer can hold

Definition: audio_data.h:42

AudioData::sample_fmt

enum AVSampleFormat sample_fmt

sample format