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/intreadwrite.h"

26 #include "avcodec.h"

27 #include "bytestream.h"

28 #include "internal.h"

29 #include "mathops.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->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, void *data,

108 int *got_frame, AVPacket *pkt)

109 {

110 FastAudioContext *s = avctx->priv_data;

111 GetByteContext gb;

112 AVFrame *frame = data;

113 int subframes;

114 int ret;

115

116 subframes = pkt->size / (40 * avctx->channels);

117 frame->nb_samples = subframes * 256;

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

119 return ret;

120

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

122

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

124 for (int channel = 0; channel < avctx->channels; channel++) {

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

126 float result[256] = { 0 };

127 unsigned src[10];

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

129 float m[8];

130 int pos = 0;

131

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

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

134

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

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

137

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

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

140

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

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

143

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

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

146

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

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

149 if (j % 10 == 9)

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

151 if (j == 20)

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

153 }

154

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

156 }

157

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

159 float x = result[i];

160

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

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

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

164 }

165

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

167 ch->f[7] = x;

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

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

170 }

171

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

173 }

174 }

175

176 *got_frame = 1;

177

178 return pkt->size;

179 }

180

181 static av_cold int fastaudio_close(AVCodecContext *avctx)

182 {

183 FastAudioContext *s = avctx->priv_data;

184

185 av_freep(&s->ch);

186

187 return 0;

188 }

189

190 const AVCodec ff_fastaudio_decoder = {

191 .name = "fastaudio",

192 .long_name = NULL_IF_CONFIG_SMALL("MobiClip FastAudio"),

193 .type = AVMEDIA_TYPE_AUDIO,

194 .id = AV_CODEC_ID_FASTAUDIO,

195 .priv_data_size = sizeof(FastAudioContext),

196 .init = fastaudio_init,

197 .decode = fastaudio_decode,

198 .close = fastaudio_close,

199 .capabilities = AV_CODEC_CAP_DR1,

200 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

201 AV_SAMPLE_FMT_NONE },

202 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

203 };

AVCodec

AVCodec.

Definition: codec.h:202

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:69

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: internal.h:42

const char * r

Definition: vf_curves.c:116

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

sample_fmts

static enum AVSampleFormat sample_fmts[]

Definition: adpcmenc.c:948

fastaudio_close

static av_cold int fastaudio_close(AVCodecContext *avctx)

Definition: fastaudio.c:181

AV_CODEC_ID_FASTAUDIO

@ AV_CODEC_ID_FASTAUDIO

Definition: codec_id.h:517

AVFrame

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

Definition: frame.h:317

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

FastAudioContext::ch

ChannelItems * ch

Definition: fastaudio.c:39

data

const char data[16]

Definition: mxf.c:143

FastAudioContext

Definition: fastaudio.c:36

init

static int init

Definition: av_tx.c:47

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

av_cold

#define av_cold

Definition: attributes.h:90

set_sample

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

Definition: fastaudio.c:102

decode

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

Definition: decode_audio.c:71

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:257

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

#define f(width, name)

Definition: cbs_vp9.c:255

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

fastaudio_decode

static int fastaudio_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)

Definition: fastaudio.c:107

src

#define src

Definition: vp8dsp.c:255

mathops.h

FastAudioContext::table

float table[8][64]

Definition: fastaudio.c:37

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1652

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

ChannelItems::f

float f[8]

Definition: fastaudio.c:32

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

powf

#define powf(x, y)

Definition: libm.h:50

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1000

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:59

read_bits

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

Definition: fastaudio.c:88

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:993

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

Definition: cbs_h2645.c:271

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:58

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

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:271

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

pos

unsigned int pos

Definition: spdifenc.c:412

ChannelItems

Definition: fastaudio.c:31

ff_fastaudio_decoder

const AVCodec ff_fastaudio_decoder

Definition: fastaudio.c:190

AVCodecContext

main external API structure.

Definition: avcodec.h:383