FFmpeg: libavcodec/fastaudio.c Source File

FFmpeg

[フレーム]

libavcodec

fastaudio.c

Go to the documentation of this file.

1 /*

2 * MOFLEX Fast Audio decoder

6 *

7 * This file is part of FFmpeg.

8 *

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

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

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

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

13 *

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

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

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

17 * Lesser General Public License for more details.

18 *

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

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

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

22 */

24 #include "libavutil/intfloat.h"

25 #include "libavutil/mem.h"

26 #include "avcodec.h"

27 #include "bytestream.h"

28 #include "codec_internal.h"

29 #include "decode.h"

31 typedef struct ChannelItems {

32 float f[8];

33 float last;

34 } ChannelItems;

36 typedef struct FastAudioContext {

37 float table[8][64];

39 ChannelItems *ch;

40 } FastAudioContext;

42 static av_cold int fastaudio_init(AVCodecContext *avctx)

43 {

44 FastAudioContext *s = avctx->priv_data;

46 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

48 for (int i = 0; i < 8; i++)

49 s->table[0][i] = (i - 159.5f) / 160.f;

50 for (int i = 0; i < 11; i++)

51 s->table[0][i + 8] = (i - 37.5f) / 40.f;

52 for (int i = 0; i < 27; i++)

53 s->table[0][i + 8 + 11] = (i - 13.f) / 20.f;

54 for (int i = 0; i < 11; i++)

55 s->table[0][i + 8 + 11 + 27] = (i + 27.5f) / 40.f;

56 for (int i = 0; i < 7; i++)

57 s->table[0][i + 8 + 11 + 27 + 11] = (i + 152.5f) / 160.f;

59 memcpy(s->table[1], s->table[0], sizeof(s->table[0]));

61 for (int i = 0; i < 7; i++)

62 s->table[2][i] = (i - 33.5f) / 40.f;

63 for (int i = 0; i < 25; i++)

64 s->table[2][i + 7] = (i - 13.f) / 20.f;

66 for (int i = 0; i < 32; i++)

67 s->table[3][i] = -s->table[2][31 - i];

69 for (int i = 0; i < 16; i++)

70 s->table[4][i] = i * 0.22f / 3.f - 0.6f;

72 for (int i = 0; i < 16; i++)

73 s->table[5][i] = i * 0.20f / 3.f - 0.3f;

75 for (int i = 0; i < 8; i++)

76 s->table[6][i] = i * 0.36f / 3.f - 0.4f;

78 for (int i = 0; i < 8; i++)

79 s->table[7][i] = i * 0.34f / 3.f - 0.2f;

81 s->ch = av_calloc(avctx->ch_layout.nb_channels, sizeof(*s->ch));

82 if (!s->ch)

83 return AVERROR(ENOMEM);

85 return 0;

86 }

88 static int read_bits(int bits, int *ppos, unsigned *src)

89 {

90 int r, pos;

92 pos = *ppos;

93 pos += bits;

94 r = src[(pos - 1) / 32] >> ((-pos) & 31);

95 *ppos = pos;

97 return r & ((1 << bits) - 1);

98 }

100 static const uint8_t bits[8] = { 6, 6, 5, 5, 4, 0, 3, 3, };

101

102 static void set_sample(int i, int j, int v, float *result, int *pads, float value)

103 {

104 result[i * 64 + pads[i] + j * 3] = value * (2 * v - 7);

105 }

106

107 static int fastaudio_decode(AVCodecContext *avctx, AVFrame *frame,

108 int *got_frame, AVPacket *pkt)

109 {

110 FastAudioContext *s = avctx->priv_data;

111 GetByteContext gb;

112 int subframes;

113 int ret;

114

115 subframes = pkt->size / (40 * avctx->ch_layout.nb_channels);

116 frame->nb_samples = subframes * 256;

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

118 return ret;

119

120 bytestream2_init(&gb, pkt->data, pkt->size);

121

122 for (int subframe = 0; subframe < subframes; subframe++) {

123 for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) {

124 ChannelItems *ch = &s->ch[channel];

125 float result[256] = { 0 };

126 unsigned src[10];

127 int inds[4], pads[4];

128 float m[8];

129 int pos = 0;

130

131 for (int i = 0; i < 10; i++)

132 src[i] = bytestream2_get_le32(&gb);

133

134 for (int i = 0; i < 8; i++)

135 m[7 - i] = s->table[i][read_bits(bits[i], &pos, src)];

136

137 for (int i = 0; i < 4; i++)

138 inds[3 - i] = read_bits(6, &pos, src);

139

140 for (int i = 0; i < 4; i++)

141 pads[3 - i] = read_bits(2, &pos, src);

142

143 for (int i = 0, index5 = 0; i < 4; i++) {

144 float value = av_int2float((inds[i] + 1) << 20) * powf(2.f, 116.f);

145

146 for (int j = 0, tmp = 0; j < 21; j++) {

147 set_sample(i, j, j == 20 ? tmp / 2 : read_bits(3, &pos, src), result, pads, value);

148 if (j % 10 == 9)

149 tmp = 4 * tmp + read_bits(2, &pos, src);

150 if (j == 20)

151 index5 = FFMIN(2 * index5 + tmp % 2, 63);

152 }

153

154 m[2] = s->table[5][index5];

155 }

156

157 for (int i = 0; i < 256; i++) {

158 float x = result[i];

159

160 for (int j = 0; j < 8; j++) {

161 x -= m[j] * ch->f[j];

162 ch->f[j] += m[j] * x;

163 }

164

165 memmove(&ch->f[0], &ch->f[1], sizeof(float) * 7);

166 ch->f[7] = x;

167 ch->last = x + ch->last * 0.86f;

168 result[i] = ch->last * 2.f;

169 }

170

171 memcpy(frame->extended_data[channel] + 1024 * subframe, result, 256 * sizeof(float));

172 }

173 }

174

175 *got_frame = 1;

176

177 return pkt->size;

178 }

179

180 static av_cold int fastaudio_close(AVCodecContext *avctx)

181 {

182 FastAudioContext *s = avctx->priv_data;

183

184 av_freep(&s->ch);

185

186 return 0;

187 }

188

189 const FFCodec ff_fastaudio_decoder = {

190 .p.name = "fastaudio",

191 CODEC_LONG_NAME("MobiClip FastAudio"),

192 .p.type = AVMEDIA_TYPE_AUDIO,

193 .p.id = AV_CODEC_ID_FASTAUDIO,

194 .priv_data_size = sizeof(FastAudioContext),

195 .init = fastaudio_init,

196 FF_CODEC_DECODE_CB(fastaudio_decode),

197 .close = fastaudio_close,

198 .p.capabilities = AV_CODEC_CAP_DR1,

199 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),

200 };

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

const char * r

Definition: vf_curves.c:127

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

GetByteContext

Definition: bytestream.h:33

fastaudio_close

static av_cold int fastaudio_close(AVCodecContext *avctx)

Definition: fastaudio.c:180

AV_CODEC_ID_FASTAUDIO

@ AV_CODEC_ID_FASTAUDIO

Definition: codec_id.h:553

AVFrame

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

Definition: frame.h:427

AVPacket::data

uint8_t * data

Definition: packet.h:558

FastAudioContext::ch

ChannelItems * ch

Definition: fastaudio.c:39

FFCodec

Definition: codec_internal.h:127

FastAudioContext

Definition: fastaudio.c:36

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

intfloat.h

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

av_int2float

static av_always_inline float av_int2float(uint32_t i)

Reinterpret a 32-bit integer as a float.

Definition: intfloat.h:40

fastaudio_init

static av_cold int fastaudio_init(AVCodecContext *avctx)

Definition: fastaudio.c:42

pkt

AVPacket * pkt

Definition: movenc.c:60

av_cold

#define av_cold

Definition: attributes.h:106

set_sample

static void set_sample(int i, int j, int v, float *result, int *pads, float value)

Definition: fastaudio.c:102

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

#define s(width, name)

Definition: cbs_vp9.c:198

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

decode.h

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

ff_fastaudio_decoder

const FFCodec ff_fastaudio_decoder

Definition: fastaudio.c:189

ChannelItems::last

float last

Definition: fastaudio.c:33

result

and forward the result(frame or status change) to the corresponding input. If nothing is possible

FastAudioContext::table

float table[8][64]

Definition: fastaudio.c:37

Definition: af_crystalizer.c:122

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1720

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

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

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:559

ChannelItems::f

float f[8]

Definition: fastaudio.c:32

powf

#define powf(x, y)

Definition: libm.h:52

codec_internal.h

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

read_bits

static int read_bits(int bits, int *ppos, unsigned *src)

Definition: fastaudio.c:88

CODEC_SAMPLEFMTS

#define CODEC_SAMPLEFMTS(...)

Definition: codec_internal.h:385

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

Definition: cbs_h2645.c:256

value

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 value

Definition: writing_filters.txt:86

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

avcodec.h

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

pos

unsigned int pos

Definition: spdifenc.c:414

ChannelItems

Definition: fastaudio.c:31

AVCodecContext

main external API structure.

Definition: avcodec.h:431

mem.h

AVPacket

This structure stores compressed data.