FFmpeg: libavcodec/adxdec.c Source File

FFmpeg

[フレーム]

libavcodec

adxdec.c

Go to the documentation of this file.

1 /*

2 * ADX ADPCM codecs

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 #include "libavutil/intreadwrite.h"

23 #include "avcodec.h"

24 #include "adx.h"

25 #include "get_bits.h"

26 #include "internal.h"

28 /**

29 * @file

30 * SEGA CRI adx codecs.

31 *

32 * Reference documents:

33 * http://ku-www.ss.titech.ac.jp/~yatsushi/adx.html

34 * adx2wav & wav2adx http://www.geocities.co.jp/Playtown/2004/

35 */

37 static av_cold int adx_decode_init(AVCodecContext *avctx)

38 {

39 ADXContext *c = avctx->priv_data;

40 int ret, header_size;

42 if (avctx->extradata_size >= 24) {

43 if ((ret = ff_adx_decode_header(avctx, avctx->extradata,

44 avctx->extradata_size, &header_size,

45 c->coeff)) < 0) {

46 av_log(avctx, AV_LOG_ERROR, "error parsing ADX header\n");

47 return AVERROR_INVALIDDATA;

48 }

49 c->channels = avctx->channels;

50 c->header_parsed = 1;

51 }

53 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

55 return 0;

56 }

58 /**

59 * Decode 32 samples from 18 bytes.

60 *

61 * A 16-bit scalar value is applied to 32 residuals, which then have a

62 * 2nd-order LPC filter applied to it to form the output signal for a single

63 * channel.

64 */

65 static int adx_decode(ADXContext *c, int16_t *out, int offset,

66 const uint8_t *in, int ch)

67 {

68 ADXChannelState *prev = &c->prev[ch];

69 GetBitContext gb;

70 int scale = AV_RB16(in);

71 int i;

72 int s0, s1, s2, d;

74 /* check if this is an EOF packet */

75 if (scale & 0x8000)

76 return -1;

78 init_get_bits(&gb, in + 2, (BLOCK_SIZE - 2) * 8);

79 out += offset;

80 s1 = prev->s1;

81 s2 = prev->s2;

82 for (i = 0; i < BLOCK_SAMPLES; i++) {

83 d = get_sbits(&gb, 4);

84 s0 = ((d * (1 << COEFF_BITS)) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS;

85 s2 = s1;

86 s1 = av_clip_int16(s0);

87 *out++ = s1;

88 }

89 prev->s1 = s1;

90 prev->s2 = s2;

92 return 0;

93 }

95 static int adx_decode_frame(AVCodecContext *avctx, void *data,

96 int *got_frame_ptr, AVPacket *avpkt)

97 {

98 AVFrame *frame = data;

99 int buf_size = avpkt->size;

100 ADXContext *c = avctx->priv_data;

101 int16_t **samples;

102 int samples_offset;

103 const uint8_t *buf = avpkt->data;

104 const uint8_t *buf_end = buf + avpkt->size;

105 int num_blocks, ch, ret;

106

107 if (c->eof) {

108 *got_frame_ptr = 0;

109 return buf_size;

110 }

111

112 if (!c->header_parsed && buf_size >= 2 && AV_RB16(buf) == 0x8000) {

113 int header_size;

114 if ((ret = ff_adx_decode_header(avctx, buf, buf_size, &header_size,

115 c->coeff)) < 0) {

116 av_log(avctx, AV_LOG_ERROR, "error parsing ADX header\n");

117 return AVERROR_INVALIDDATA;

118 }

119 c->channels = avctx->channels;

120 c->header_parsed = 1;

121 if (buf_size < header_size)

122 return AVERROR_INVALIDDATA;

123 buf += header_size;

124 buf_size -= header_size;

125 }

126 if (!c->header_parsed)

127 return AVERROR_INVALIDDATA;

128

129 /* calculate number of blocks in the packet */

130 num_blocks = buf_size / (BLOCK_SIZE * c->channels);

131

132 /* if the packet is not an even multiple of BLOCK_SIZE, check for an EOF

133 packet */

134 if (!num_blocks || buf_size % (BLOCK_SIZE * avctx->channels)) {

135 if (buf_size >= 4 && (AV_RB16(buf) & 0x8000)) {

136 c->eof = 1;

137 *got_frame_ptr = 0;

138 return avpkt->size;

139 }

140 return AVERROR_INVALIDDATA;

141 }

142

143 /* get output buffer */

144 frame->nb_samples = num_blocks * BLOCK_SAMPLES;

145 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

146 return ret;

147 samples = (int16_t **)frame->extended_data;

148 samples_offset = 0;

149

150 while (num_blocks--) {

151 for (ch = 0; ch < c->channels; ch++) {

152 if (buf_end - buf < BLOCK_SIZE || adx_decode(c, samples[ch], samples_offset, buf, ch)) {

153 c->eof = 1;

154 buf = avpkt->data + avpkt->size;

155 break;

156 }

157 buf_size -= BLOCK_SIZE;

158 buf += BLOCK_SIZE;

159 }

160 if (!c->eof)

161 samples_offset += BLOCK_SAMPLES;

162 }

163

164 frame->nb_samples = samples_offset;

165 *got_frame_ptr = 1;

166

167 return buf - avpkt->data;

168 }

169

170 static void adx_decode_flush(AVCodecContext *avctx)

171 {

172 ADXContext *c = avctx->priv_data;

173 memset(c->prev, 0, sizeof(c->prev));

174 c->eof = 0;

175 }

176

177 AVCodec ff_adpcm_adx_decoder = {

178 .name = "adpcm_adx",

179 .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),

180 .type = AVMEDIA_TYPE_AUDIO,

181 .id = AV_CODEC_ID_ADPCM_ADX,

182 .priv_data_size = sizeof(ADXContext),

183 .init = adx_decode_init,

184 .decode = adx_decode_frame,

185 .flush = adx_decode_flush,

186 .capabilities = AV_CODEC_CAP_DR1,

187 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,

188 AV_SAMPLE_FMT_NONE },

189 };

ff_adx_decode_header

int ff_adx_decode_header(AVCodecContext *avctx, const uint8_t *buf, int bufsize, int *header_size, int *coeff)

Decode ADX stream header.

Definition: adx.c:38

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:218

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

flush

static void flush(AVCodecContext *avctx)

Definition: aacdec_template.c:500

adx_decode_init

static av_cold int adx_decode_init(AVCodecContext *avctx)

Definition: adxdec.c:37

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

AVPacket::size

int size

Definition: avcodec.h:1431

AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:59

ADXContext::coeff

int coeff[2]

Definition: adx.h:48

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:87

AVCodec

AVCodec.

Definition: avcodec.h:3408

BLOCK_SAMPLES

#define BLOCK_SAMPLES

Definition: adxdec.c:31

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:254

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:42

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:2181

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

ADXChannelState

Definition: adx.h:38

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:1618

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

get_bits.h

bitstream reader API header.

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

COEFF_BITS

#define COEFF_BITS

Definition: adx.h:51

#define s2

Definition: regdef.h:39

BLOCK_SIZE

#define BLOCK_SIZE

Definition: adxdec.c:30

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:186

#define s0

Definition: regdef.h:37

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3415

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

adx_decode_flush

static void adx_decode_flush(AVCodecContext *avctx)

Definition: adxdec.c:170

intreadwrite.h

ADXContext::header_parsed

int header_parsed

Definition: adx.h:45

adx_decode_frame

static int adx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)

Definition: adxdec.c:95

AV_CODEC_ID_ADPCM_ADX

Definition: avcodec.h:499

adx_decode

static int adx_decode(ADXContext *c, int16_t *out, int offset, const uint8_t *in, int ch)

Decode 32 samples from 18 bytes.

Definition: adxdec.c:65

avcodec.h

Libavcodec external API header.

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:58

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1891

uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in

Definition: audio_convert.c:194

buf

void * buf

Definition: avisynth_c.h:690

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:1619

ADXContext

Definition: adx.h:42

ADXChannelState::s2

int s2

Definition: adx.h:39

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:433

#define s1

Definition: regdef.h:38

GetBitContext

Definition: get_bits.h:56

internal.h

common internal api header.

static double c[64]

Definition: vsrc_mptestsrc.c:87

ff_adpcm_adx_decoder

AVCodec ff_adpcm_adx_decoder

Definition: adxdec.c:177

ADXContext::eof

int eof

Definition: adx.h:46

ADXChannelState::s1

int s1

Definition: adx.h:39

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

ADXContext::prev

ADXChannelState prev[2]

Definition: adx.h:44

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:2174

sample_fmts

static enum AVSampleFormat sample_fmts[]

Definition: adpcmenc.c:701

out

FILE * out

Definition: movenc.c:54

AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:67

adx.h

SEGA CRI adx codecs.

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:265

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:284

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() for allocating buffers and supports custom allocators.

Definition: avcodec.h:959

uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch

Definition: audioconvert.c:56

ADXContext::channels

int channels

Definition: adx.h:43

Generated on Sun May 13 2018 02:03:42 for FFmpeg by doxygen 1.8.6