Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Download
52868 views
Tweet
Share
Share
1
/*

2
 * Copyright (C) 2012 Michael Niedermayer ([email protected])

3
 *

4
 * This file is part of libswresample

5
 *

6
 * libswresample 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
 * libswresample 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 libswresample; if not, write to the Free Software

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

19
 */

20


21
#include "libavutil/x86/cpu.h"

22
#include "libswresample/swresample_internal.h"

23
#include "libswresample/audioconvert.h"

24


25
#define PROTO(pre, in, out, cap) void ff ## pre ## in## _to_ ##out## _a_ ##cap(uint8_t **dst, const uint8_t **src, int len);

26
#define PROTO2(pre, out, cap) PROTO(pre, int16, out, cap) PROTO(pre, int32, out, cap) PROTO(pre, float, out, cap)

27
#define PROTO3(pre, cap) PROTO2(pre, int16, cap) PROTO2(pre, int32, cap) PROTO2(pre, float, cap)

28
#define PROTO4(pre) PROTO3(pre, mmx) PROTO3(pre, sse) PROTO3(pre, sse2) PROTO3(pre, ssse3) PROTO3(pre, sse4) PROTO3(pre, avx) PROTO3(pre, avx2)

29
PROTO4(_)

30
PROTO4(_pack_2ch_)

31
PROTO4(_pack_6ch_)

32
PROTO4(_pack_8ch_)

33
PROTO4(_unpack_2ch_)

34
PROTO4(_unpack_6ch_)

35


36
av_cold void swri_audio_convert_init_x86(struct AudioConvert *ac,

37
                                 enum AVSampleFormat out_fmt,

38
                                 enum AVSampleFormat in_fmt,

39
                                 int channels){

40
    int mm_flags = av_get_cpu_flags();

41


42
    ac->simd_f= NULL;

43


44
//FIXME add memcpy case

45


46
#define MULTI_CAPS_FUNC(flag, cap) \

47
    if (EXTERNAL_##flag(mm_flags)) {\

48
        if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_S16 || out_fmt == AV_SAMPLE_FMT_S32P && in_fmt == AV_SAMPLE_FMT_S16P)\

49
            ac->simd_f =  ff_int16_to_int32_a_ ## cap;\

50
        if(   out_fmt == AV_SAMPLE_FMT_S16  && in_fmt == AV_SAMPLE_FMT_S32 || out_fmt == AV_SAMPLE_FMT_S16P && in_fmt == AV_SAMPLE_FMT_S32P)\

51
            ac->simd_f =  ff_int32_to_int16_a_ ## cap;\

52
    }

53


54
MULTI_CAPS_FUNC(MMX, mmx)

55
MULTI_CAPS_FUNC(SSE2, sse2)

56


57
    if(EXTERNAL_MMX(mm_flags)) {

58
        if(channels == 6) {

59
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_FLTP || out_fmt == AV_SAMPLE_FMT_S32 && in_fmt == AV_SAMPLE_FMT_S32P)

60
                ac->simd_f =  ff_pack_6ch_float_to_float_a_mmx;

61
        }

62
    }

63
    if(EXTERNAL_SSE(mm_flags)) {

64
        if(channels == 6) {

65
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_FLTP || out_fmt == AV_SAMPLE_FMT_S32 && in_fmt == AV_SAMPLE_FMT_S32P)

66
                ac->simd_f =  ff_pack_6ch_float_to_float_a_sse;

67


68
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_FLT || out_fmt == AV_SAMPLE_FMT_S32P && in_fmt == AV_SAMPLE_FMT_S32)

69
                ac->simd_f =  ff_unpack_6ch_float_to_float_a_sse;

70
        }

71
    }

72
    if(EXTERNAL_SSE2(mm_flags)) {

73
        if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S32 || out_fmt == AV_SAMPLE_FMT_FLTP && in_fmt == AV_SAMPLE_FMT_S32P)

74
            ac->simd_f =  ff_int32_to_float_a_sse2;

75
        if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S16 || out_fmt == AV_SAMPLE_FMT_FLTP && in_fmt == AV_SAMPLE_FMT_S16P)

76
            ac->simd_f =  ff_int16_to_float_a_sse2;

77
        if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLT || out_fmt == AV_SAMPLE_FMT_S32P && in_fmt == AV_SAMPLE_FMT_FLTP)

78
            ac->simd_f =  ff_float_to_int32_a_sse2;

79
        if(   out_fmt == AV_SAMPLE_FMT_S16  && in_fmt == AV_SAMPLE_FMT_FLT || out_fmt == AV_SAMPLE_FMT_S16P && in_fmt == AV_SAMPLE_FMT_FLTP)

80
            ac->simd_f =  ff_float_to_int16_a_sse2;

81


82
        if(channels == 2) {

83
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_FLTP || out_fmt == AV_SAMPLE_FMT_S32 && in_fmt == AV_SAMPLE_FMT_S32P)

84
                ac->simd_f =  ff_pack_2ch_int32_to_int32_a_sse2;

85
            if(   out_fmt == AV_SAMPLE_FMT_S16  && in_fmt == AV_SAMPLE_FMT_S16P)

86
                ac->simd_f =  ff_pack_2ch_int16_to_int16_a_sse2;

87
            if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_S16P)

88
                ac->simd_f =  ff_pack_2ch_int16_to_int32_a_sse2;

89
            if(   out_fmt == AV_SAMPLE_FMT_S16  && in_fmt == AV_SAMPLE_FMT_S32P)

90
                ac->simd_f =  ff_pack_2ch_int32_to_int16_a_sse2;

91


92
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_FLT || out_fmt == AV_SAMPLE_FMT_S32P && in_fmt == AV_SAMPLE_FMT_S32)

93
                ac->simd_f =  ff_unpack_2ch_int32_to_int32_a_sse2;

94
            if(   out_fmt == AV_SAMPLE_FMT_S16P  && in_fmt == AV_SAMPLE_FMT_S16)

95
                ac->simd_f =  ff_unpack_2ch_int16_to_int16_a_sse2;

96
            if(   out_fmt == AV_SAMPLE_FMT_S32P  && in_fmt == AV_SAMPLE_FMT_S16)

97
                ac->simd_f =  ff_unpack_2ch_int16_to_int32_a_sse2;

98
            if(   out_fmt == AV_SAMPLE_FMT_S16P  && in_fmt == AV_SAMPLE_FMT_S32)

99
                ac->simd_f =  ff_unpack_2ch_int32_to_int16_a_sse2;

100


101
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S32P)

102
                ac->simd_f =  ff_pack_2ch_int32_to_float_a_sse2;

103
            if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLTP)

104
                ac->simd_f =  ff_pack_2ch_float_to_int32_a_sse2;

105
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S16P)

106
                ac->simd_f =  ff_pack_2ch_int16_to_float_a_sse2;

107
            if(   out_fmt == AV_SAMPLE_FMT_S16  && in_fmt == AV_SAMPLE_FMT_FLTP)

108
                ac->simd_f =  ff_pack_2ch_float_to_int16_a_sse2;

109
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_S32)

110
                ac->simd_f =  ff_unpack_2ch_int32_to_float_a_sse2;

111
            if(   out_fmt == AV_SAMPLE_FMT_S32P  && in_fmt == AV_SAMPLE_FMT_FLT)

112
                ac->simd_f =  ff_unpack_2ch_float_to_int32_a_sse2;

113
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_S16)

114
                ac->simd_f =  ff_unpack_2ch_int16_to_float_a_sse2;

115
            if(   out_fmt == AV_SAMPLE_FMT_S16P  && in_fmt == AV_SAMPLE_FMT_FLT)

116
                ac->simd_f =  ff_unpack_2ch_float_to_int16_a_sse2;

117
        }

118
        if(channels == 6) {

119
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S32P)

120
                ac->simd_f =  ff_pack_6ch_int32_to_float_a_sse2;

121
            if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLTP)

122
                ac->simd_f =  ff_pack_6ch_float_to_int32_a_sse2;

123


124
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_S32)

125
                ac->simd_f =  ff_unpack_6ch_int32_to_float_a_sse2;

126
            if(   out_fmt == AV_SAMPLE_FMT_S32P  && in_fmt == AV_SAMPLE_FMT_FLT)

127
                ac->simd_f =  ff_unpack_6ch_float_to_int32_a_sse2;

128
        }

129
        if(channels == 8) {

130
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_FLTP || out_fmt == AV_SAMPLE_FMT_S32 && in_fmt == AV_SAMPLE_FMT_S32P)

131
                ac->simd_f =  ff_pack_8ch_float_to_float_a_sse2;

132
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S32P)

133
                ac->simd_f =  ff_pack_8ch_int32_to_float_a_sse2;

134
            if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLTP)

135
                ac->simd_f =  ff_pack_8ch_float_to_int32_a_sse2;

136
        }

137
    }

138
    if(EXTERNAL_SSSE3(mm_flags)) {

139
        if(channels == 2) {

140
            if(   out_fmt == AV_SAMPLE_FMT_S16P  && in_fmt == AV_SAMPLE_FMT_S16)

141
                ac->simd_f =  ff_unpack_2ch_int16_to_int16_a_ssse3;

142
            if(   out_fmt == AV_SAMPLE_FMT_S32P  && in_fmt == AV_SAMPLE_FMT_S16)

143
                ac->simd_f =  ff_unpack_2ch_int16_to_int32_a_ssse3;

144
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_S16)

145
                ac->simd_f =  ff_unpack_2ch_int16_to_float_a_ssse3;

146
        }

147
    }

148
    if(EXTERNAL_AVX_FAST(mm_flags)) {

149
        if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S32 || out_fmt == AV_SAMPLE_FMT_FLTP && in_fmt == AV_SAMPLE_FMT_S32P)

150
            ac->simd_f =  ff_int32_to_float_a_avx;

151
    }

152
    if(EXTERNAL_AVX(mm_flags)) {

153
        if(channels == 6) {

154
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_FLTP || out_fmt == AV_SAMPLE_FMT_S32 && in_fmt == AV_SAMPLE_FMT_S32P)

155
                ac->simd_f =  ff_pack_6ch_float_to_float_a_avx;

156
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S32P)

157
                ac->simd_f =  ff_pack_6ch_int32_to_float_a_avx;

158
            if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLTP)

159
                ac->simd_f =  ff_pack_6ch_float_to_int32_a_avx;

160


161
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_FLT || out_fmt == AV_SAMPLE_FMT_S32P && in_fmt == AV_SAMPLE_FMT_S32)

162
                ac->simd_f =  ff_unpack_6ch_float_to_float_a_avx;

163
            if(   out_fmt == AV_SAMPLE_FMT_FLTP  && in_fmt == AV_SAMPLE_FMT_S32)

164
                ac->simd_f =  ff_unpack_6ch_int32_to_float_a_avx;

165
            if(   out_fmt == AV_SAMPLE_FMT_S32P  && in_fmt == AV_SAMPLE_FMT_FLT)

166
                ac->simd_f =  ff_unpack_6ch_float_to_int32_a_avx;

167
        }

168
        if(channels == 8) {

169
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_FLTP || out_fmt == AV_SAMPLE_FMT_S32 && in_fmt == AV_SAMPLE_FMT_S32P)

170
                ac->simd_f =  ff_pack_8ch_float_to_float_a_avx;

171
            if(   out_fmt == AV_SAMPLE_FMT_FLT  && in_fmt == AV_SAMPLE_FMT_S32P)

172
                ac->simd_f =  ff_pack_8ch_int32_to_float_a_avx;

173
            if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLTP)

174
                ac->simd_f =  ff_pack_8ch_float_to_int32_a_avx;

175
        }

176
    }

177
    if(EXTERNAL_AVX2_FAST(mm_flags)) {

178
        if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLT || out_fmt == AV_SAMPLE_FMT_S32P && in_fmt == AV_SAMPLE_FMT_FLTP)

179
            ac->simd_f =  ff_float_to_int32_a_avx2;

180
    }

181
}

182


183