FFmpeg: libavutil/float_dsp.c Source File

FFmpeg

[フレーム]

libavutil

float_dsp.c

Go to the documentation of this file.

1 /*

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 "config.h"

23 #include "attributes.h"

24 #include "float_dsp.h"

25 #include "mem.h"

27 static void vector_fmul_c(float *dst, const float *src0, const float *src1,

28 int len)

29 {

30 int i;

31 for (i = 0; i < len; i++)

32 dst[i] = src0[i] * src1[i];

33 }

35 static void vector_dmul_c(double *dst, const double *src0, const double *src1,

36 int len)

37 {

38 int i;

39 for (i = 0; i < len; i++)

40 dst[i] = src0[i] * src1[i];

41 }

43 static void vector_fmac_scalar_c(float *dst, const float *src, float mul,

44 int len)

45 {

46 int i;

47 for (i = 0; i < len; i++)

48 dst[i] += src[i] * mul;

49 }

51 static void vector_dmac_scalar_c(double *dst, const double *src, double mul,

52 int len)

53 {

54 int i;

55 for (i = 0; i < len; i++)

56 dst[i] += src[i] * mul;

57 }

59 static void vector_fmul_scalar_c(float *dst, const float *src, float mul,

60 int len)

61 {

62 int i;

63 for (i = 0; i < len; i++)

64 dst[i] = src[i] * mul;

65 }

67 static void vector_dmul_scalar_c(double *dst, const double *src, double mul,

68 int len)

69 {

70 int i;

71 for (i = 0; i < len; i++)

72 dst[i] = src[i] * mul;

73 }

75 static void vector_fmul_window_c(float *dst, const float *src0,

76 const float *src1, const float *win, int len)

77 {

78 int i, j;

80 dst += len;

81 win += len;

82 src0 += len;

84 for (i = -len, j = len - 1; i < 0; i++, j--) {

85 float s0 = src0[i];

86 float s1 = src1[j];

87 float wi = win[i];

88 float wj = win[j];

89 dst[i] = s0 * wj - s1 * wi;

90 dst[j] = s0 * wi + s1 * wj;

91 }

92 }

94 static void vector_fmul_add_c(float *dst, const float *src0, const float *src1,

95 const float *src2, int len){

96 int i;

98 for (i = 0; i < len; i++)

99 dst[i] = src0[i] * src1[i] + src2[i];

100 }

101

102 static void vector_fmul_reverse_c(float *dst, const float *src0,

103 const float *src1, int len)

104 {

105 int i;

106

107 src1 += len-1;

108 for (i = 0; i < len; i++)

109 dst[i] = src0[i] * src1[-i];

110 }

111

112 static void butterflies_float_c(float *restrict v1, float *restrict v2,

113 int len)

114 {

115 int i;

116

117 for (i = 0; i < len; i++) {

118 float t = v1[i] - v2[i];

119 v1[i] += v2[i];

120 v2[i] = t;

121 }

122 }

123

124 double ff_scalarproduct_double_c(const double *v1, const double *v2,

125 size_t len)

126 {

127 double p = 0.0;

128

129 for (size_t i = 0; i < len; i++)

130 p += v1[i] * v2[i];

131

132 return p;

133 }

134

135 av_cold AVFloatDSPContext *avpriv_float_dsp_alloc(int bit_exact)

136 {

137 AVFloatDSPContext *fdsp = av_mallocz(sizeof(AVFloatDSPContext));

138 if (!fdsp)

139 return NULL;

140

141 fdsp->vector_fmul = vector_fmul_c;

142 fdsp->vector_dmul = vector_dmul_c;

143 fdsp->vector_fmac_scalar = vector_fmac_scalar_c;

144 fdsp->vector_fmul_scalar = vector_fmul_scalar_c;

145 fdsp->vector_dmac_scalar = vector_dmac_scalar_c;

146 fdsp->vector_dmul_scalar = vector_dmul_scalar_c;

147 fdsp->vector_fmul_window = vector_fmul_window_c;

148 fdsp->vector_fmul_add = vector_fmul_add_c;

149 fdsp->vector_fmul_reverse = vector_fmul_reverse_c;

150 fdsp->butterflies_float = butterflies_float_c;

151 fdsp->scalarproduct_float = ff_scalarproduct_float_c;

152 fdsp->scalarproduct_double = ff_scalarproduct_double_c;

153

154 #if ARCH_AARCH64

155 ff_float_dsp_init_aarch64(fdsp);

156 #elif ARCH_ARM

157 ff_float_dsp_init_arm(fdsp);

158 #elif ARCH_PPC

159 ff_float_dsp_init_ppc(fdsp, bit_exact);

160 #elif ARCH_RISCV

161 ff_float_dsp_init_riscv(fdsp);

162 #elif ARCH_X86

163 ff_float_dsp_init_x86(fdsp);

164 #elif ARCH_MIPS

165 ff_float_dsp_init_mips(fdsp);

166 #endif

167 return fdsp;

168 }

vector_fmul_add_c

static void vector_fmul_add_c(float *dst, const float *src0, const float *src1, const float *src2, int len)

Definition: float_dsp.c:94

AVFloatDSPContext::butterflies_float

void(* butterflies_float)(float *restrict v1, float *restrict v2, int len)

Calculate the sum and difference of two vectors of floats.

Definition: float_dsp.h:164

vector_dmul_c

static void vector_dmul_c(double *dst, const double *src0, const double *src1, int len)

Definition: float_dsp.c:35

vector_dmul_scalar_c

static void vector_dmul_scalar_c(double *dst, const double *src, double mul, int len)

Definition: float_dsp.c:67

ff_scalarproduct_double_c

double ff_scalarproduct_double_c(const double *v1, const double *v2, size_t len)

Return the scalar product of two vectors of doubles.

Definition: float_dsp.c:124

src1

const pixel * src1

Definition: h264pred_template.c:420

AVFloatDSPContext::vector_fmul_reverse

void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)

Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...

Definition: float_dsp.h:154

AVFloatDSPContext::vector_dmul

void(* vector_dmul)(double *dst, const double *src0, const double *src1, int len)

Calculate the entry wise product of two vectors of doubles and store the result in a vector of double...

Definition: float_dsp.h:190

win

static float win(SuperEqualizerContext *s, float n, int N)

Definition: af_superequalizer.c:119

ff_float_dsp_init_ppc

void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int strict)

Definition: float_dsp_init.c:29

ff_float_dsp_init_arm

av_cold void ff_float_dsp_init_arm(AVFloatDSPContext *fdsp)

Definition: float_dsp_init_arm.c:24

vector_dmac_scalar_c

static void vector_dmac_scalar_c(double *dst, const double *src, double mul, int len)

Definition: float_dsp.c:51

av_cold

#define av_cold

Definition: attributes.h:106

AVFloatDSPContext::scalarproduct_float

float(* scalarproduct_float)(const float *v1, const float *v2, int len)

Calculate the scalar product of two vectors of floats.

Definition: float_dsp.h:175

vector_fmul_reverse_c

static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len)

Definition: float_dsp.c:102

vector_fmul_c

static void vector_fmul_c(float *dst, const float *src0, const float *src1, int len)

Definition: float_dsp.c:27

NULL

#define NULL

Definition: coverity.c:32

AVFloatDSPContext::vector_fmul_scalar

void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)

Multiply a vector of floats by a scalar float.

Definition: float_dsp.h:85

ff_float_dsp_init_riscv

void ff_float_dsp_init_riscv(AVFloatDSPContext *fdsp)

Definition: float_dsp_init.c:52

AVFloatDSPContext::scalarproduct_double

double(* scalarproduct_double)(const double *v1, const double *v2, size_t len)

Calculate the scalar product of two vectors of doubles.

Definition: float_dsp.h:205

butterflies_float_c

static void butterflies_float_c(float *restrict v1, float *restrict v2, int len)

Definition: float_dsp.c:112

float_dsp.h

ff_scalarproduct_float_c

float ff_scalarproduct_float_c(const float *v1, const float *v2, int len)

Return the scalar product of two vectors of floats.

Definition: float_scalarproduct.c:24

vector_fmac_scalar_c

static void vector_fmac_scalar_c(float *dst, const float *src, float mul, int len)

Definition: float_dsp.c:43

vector_fmul_scalar_c

static void vector_fmul_scalar_c(float *dst, const float *src, float mul, int len)

Definition: float_dsp.c:59

AVFloatDSPContext::vector_fmul

void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)

Calculate the entry wise product of two vectors of floats and store the result in a vector of floats.

Definition: float_dsp.h:38

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

ff_float_dsp_init_mips

void ff_float_dsp_init_mips(AVFloatDSPContext *fdsp)

Definition: float_dsp_mips.c:346

AVFloatDSPContext

Definition: float_dsp.h:24

vector_fmul_window_c

static void vector_fmul_window_c(float *dst, const float *src0, const float *src1, const float *win, int len)

Definition: float_dsp.c:75

attributes.h

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

Definition: cbs_h2645.c:256

AVFloatDSPContext::vector_fmac_scalar

void(* vector_fmac_scalar)(float *dst, const float *src, float mul, int len)

Multiply a vector of floats by a scalar float and add to destination vector.

Definition: float_dsp.h:54

src2

const pixel * src2

Definition: h264pred_template.c:421

AVFloatDSPContext::vector_fmul_add

void(* vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len)

Calculate the entry wise product of two vectors of floats, add a third vector of floats and store the...

Definition: float_dsp.h:137

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

len

int len

Definition: vorbis_enc_data.h:426

AVFloatDSPContext::vector_dmul_scalar

void(* vector_dmul_scalar)(double *dst, const double *src, double mul, int len)

Multiply a vector of double by a scalar double.

Definition: float_dsp.h:100

ff_float_dsp_init_x86

void ff_float_dsp_init_x86(AVFloatDSPContext *fdsp)

Definition: float_dsp_init.c:81

ff_float_dsp_init_aarch64

av_cold void ff_float_dsp_init_aarch64(AVFloatDSPContext *fdsp)

Definition: float_dsp_init.c:54

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

src0

const pixel *const src0

Definition: h264pred_template.c:419

mem.h

AVFloatDSPContext::vector_fmul_window

void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)

Overlap/add with window function.

Definition: float_dsp.h:119

avpriv_float_dsp_alloc

av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)

Allocate a float DSP context.

Definition: float_dsp.c:135

AVFloatDSPContext::vector_dmac_scalar

void(* vector_dmac_scalar)(double *dst, const double *src, double mul, int len)

Multiply a vector of doubles by a scalar double and add to destination vector.

Definition: float_dsp.h:70

src

#define src

Definition: vp8dsp.c:248

Generated on Sat Oct 18 2025 19:23:33 for FFmpeg by doxygen 1.8.17