FFmpeg: libavcodec/8svx.c Source File

FFmpeg

[フレーム]

libavcodec

8svx.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 /**

23 * @file

24 * 8svx audio decoder

25 * @author Jaikrishnan Menon

26 *

27 * supports: fibonacci delta encoding

28 * : exponential encoding

29 *

30 * For more information about the 8SVX format:

31 * http://netghost.narod.ru/gff/vendspec/iff/iff.txt

32 * http://sox.sourceforge.net/AudioFormats-11.html

33 * http://aminet.net/package/mus/misc/wavepak

34 * http://amigan.1emu.net/reg/8SVX.txt

35 *

36 * Samples can be found here:

37 * http://aminet.net/mods/smpl/

38 */

40 #include "config_components.h"

42 #include "libavutil/avassert.h"

43 #include "libavutil/mem.h"

44 #include "avcodec.h"

45 #include "codec_internal.h"

46 #include "decode.h"

47 #include "libavutil/common.h"

49 /** decoder context */

50 typedef struct EightSvxContext {

51 uint8_t fib_acc[2];

52 const int8_t *table;

54 /* buffer used to store the whole first packet.

55 data is only sent as one large packet */

56 uint8_t *data[2];

57 int data_size;

58 int data_idx;

59 } EightSvxContext;

61 static const int8_t fibonacci[16] = { -34, -21, -13, -8, -5, -3, -2, -1, 0, 1, 2, 3, 5, 8, 13, 21 };

62 static const int8_t exponential[16] = { -128, -64, -32, -16, -8, -4, -2, -1, 0, 1, 2, 4, 8, 16, 32, 64 };

64 #define MAX_FRAME_SIZE 2048

66 /**

67 * Delta decode the compressed values in src, and put the resulting

68 * decoded samples in dst.

69 *

70 * @param[in,out] state starting value. it is saved for use in the next call.

71 * @param table delta sequence table

72 */

73 static void delta_decode(uint8_t *dst, const uint8_t *src, int src_size,

74 uint8_t *state, const int8_t *table)

75 {

76 uint8_t val = *state;

78 while (src_size--) {

79 uint8_t d = *src++;

80 val = av_clip_uint8(val + table[d & 0xF]);

81 *dst++ = val;

82 val = av_clip_uint8(val + table[d >> 4]);

83 *dst++ = val;

84 }

86 *state = val;

87 }

89 /** decode a frame */

90 static int eightsvx_decode_frame(AVCodecContext *avctx, AVFrame *frame,

91 int *got_frame_ptr, AVPacket *avpkt)

92 {

93 EightSvxContext *esc = avctx->priv_data;

94 int channels = avctx->ch_layout.nb_channels;

95 int buf_size;

96 int ch, ret;

97 int hdr_size = 2;

99 /* decode and interleave the first packet */

100 if (!esc->data[0] && avpkt) {

101 int chan_size = avpkt->size / channels - hdr_size;

102

103 if (avpkt->size % channels) {

104 av_log(avctx, AV_LOG_WARNING, "Packet with odd size, ignoring last byte\n");

105 }

106 if (avpkt->size < (hdr_size + 1) * channels) {

107 av_log(avctx, AV_LOG_ERROR, "packet size is too small\n");

108 return AVERROR_INVALIDDATA;

109 }

110

111 esc->fib_acc[0] = avpkt->data[1] + 128;

112 if (channels == 2)

113 esc->fib_acc[1] = avpkt->data[2+chan_size+1] + 128;

114

115 esc->data_idx = 0;

116 esc->data_size = chan_size;

117 if (!(esc->data[0] = av_malloc(chan_size)))

118 return AVERROR(ENOMEM);

119 if (channels == 2) {

120 if (!(esc->data[1] = av_malloc(chan_size))) {

121 av_freep(&esc->data[0]);

122 return AVERROR(ENOMEM);

123 }

124 }

125 memcpy(esc->data[0], &avpkt->data[hdr_size], chan_size);

126 if (channels == 2)

127 memcpy(esc->data[1], &avpkt->data[2*hdr_size+chan_size], chan_size);

128 }

129 if (!esc->data[0]) {

130 av_log(avctx, AV_LOG_ERROR, "unexpected empty packet\n");

131 return AVERROR_INVALIDDATA;

132 }

133

134 /* decode next piece of data from the buffer */

135 buf_size = FFMIN(MAX_FRAME_SIZE, esc->data_size - esc->data_idx);

136 if (buf_size <= 0) {

137 *got_frame_ptr = 0;

138 return avpkt->size;

139 }

140

141 /* get output buffer */

142 frame->nb_samples = buf_size * 2;

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

144 return ret;

145

146 for (ch = 0; ch < channels; ch++) {

147 delta_decode(frame->data[ch], &esc->data[ch][esc->data_idx],

148 buf_size, &esc->fib_acc[ch], esc->table);

149 }

150

151 esc->data_idx += buf_size;

152

153 *got_frame_ptr = 1;

154

155 return ((avctx->frame_num == 0) * hdr_size + buf_size) * channels;

156 }

157

158 static av_cold int eightsvx_decode_init(AVCodecContext *avctx)

159 {

160 EightSvxContext *esc = avctx->priv_data;

161

162 if (avctx->ch_layout.nb_channels < 1 || avctx->ch_layout.nb_channels > 2) {

163 av_log(avctx, AV_LOG_ERROR, "8SVX does not support more than 2 channels\n");

164 return AVERROR_INVALIDDATA;

165 }

166

167 switch (avctx->codec->id) {

168 case AV_CODEC_ID_8SVX_FIB: esc->table = fibonacci; break;

169 case AV_CODEC_ID_8SVX_EXP: esc->table = exponential; break;

170 default:

171 av_assert1(0);

172 }

173 avctx->sample_fmt = AV_SAMPLE_FMT_U8P;

174

175 return 0;

176 }

177

178 static av_cold int eightsvx_decode_close(AVCodecContext *avctx)

179 {

180 EightSvxContext *esc = avctx->priv_data;

181

182 av_freep(&esc->data[0]);

183 av_freep(&esc->data[1]);

184 esc->data_size = 0;

185 esc->data_idx = 0;

186

187 return 0;

188 }

189

190 #if CONFIG_EIGHTSVX_FIB_DECODER

191 const FFCodec ff_eightsvx_fib_decoder = {

192 .p.name = "8svx_fib",

193 CODEC_LONG_NAME("8SVX fibonacci"),

194 .p.type = AVMEDIA_TYPE_AUDIO,

195 .p.id = AV_CODEC_ID_8SVX_FIB,

196 .priv_data_size = sizeof (EightSvxContext),

197 .init = eightsvx_decode_init,

198 FF_CODEC_DECODE_CB(eightsvx_decode_frame),

199 .close = eightsvx_decode_close,

200 .p.capabilities = AV_CODEC_CAP_DR1,

201 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P),

202 };

203 #endif

204 #if CONFIG_EIGHTSVX_EXP_DECODER

205 const FFCodec ff_eightsvx_exp_decoder = {

206 .p.name = "8svx_exp",

207 CODEC_LONG_NAME("8SVX exponential"),

208 .p.type = AVMEDIA_TYPE_AUDIO,

209 .p.id = AV_CODEC_ID_8SVX_EXP,

210 .priv_data_size = sizeof (EightSvxContext),

211 .init = eightsvx_decode_init,

212 FF_CODEC_DECODE_CB(eightsvx_decode_frame),

213 .close = eightsvx_decode_close,

214 .p.capabilities = AV_CODEC_CAP_DR1,

215 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P),

216 };

217 #endif

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

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

AV_CODEC_ID_8SVX_EXP

@ AV_CODEC_ID_8SVX_EXP

Definition: codec_id.h:513

AVFrame

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

Definition: frame.h:427

AVPacket::data

uint8_t * data

Definition: packet.h:558

table

static const uint16_t table[]

Definition: prosumer.c:203

FFCodec

Definition: codec_internal.h:127

exponential

static const int8_t exponential[16]

Definition: 8svx.c:62

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

MAX_FRAME_SIZE

#define MAX_FRAME_SIZE

Definition: 8svx.c:64

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:440

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

eightsvx_decode_init

static av_cold int eightsvx_decode_init(AVCodecContext *avctx)

Definition: 8svx.c:158

val

static double val(void *priv, double ch)

Definition: aeval.c:77

ff_eightsvx_exp_decoder

const FFCodec ff_eightsvx_exp_decoder

AV_CODEC_ID_8SVX_FIB

@ AV_CODEC_ID_8SVX_FIB

Definition: codec_id.h:514

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

EightSvxContext

decoder context

Definition: 8svx.c:50

channels

Definition: aptx.h:31

decode.h

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

ff_eightsvx_fib_decoder

const FFCodec ff_eightsvx_fib_decoder

EightSvxContext::data_idx

int data_idx

Definition: 8svx.c:58

EightSvxContext::table

const int8_t * table

Definition: 8svx.c:52

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

AV_SAMPLE_FMT_U8P

@ AV_SAMPLE_FMT_U8P

unsigned 8 bits, planar

Definition: samplefmt.h:63

codec_internal.h

dst

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

Definition: dsp.h:87

EightSvxContext::fib_acc

uint8_t fib_acc[2]

Definition: 8svx.c:51

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

eightsvx_decode_close

static av_cold int eightsvx_decode_close(AVCodecContext *avctx)

Definition: 8svx.c:178

CODEC_SAMPLEFMTS

#define CODEC_SAMPLEFMTS(...)

Definition: codec_internal.h:385

AVCodec::id

enum AVCodecID id

Definition: codec.h:186

delta_decode

static void delta_decode(uint8_t *dst, const uint8_t *src, int src_size, uint8_t *state, const int8_t *table)

Delta decode the compressed values in src, and put the resulting decoded samples in dst.

Definition: 8svx.c:73

common.h

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:57

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

fibonacci

static const int8_t fibonacci[16]

Definition: 8svx.c:61

avcodec.h

AVCodecContext::frame_num

int64_t frame_num

Frame counter, set by libavcodec.

Definition: avcodec.h:1878

state

static struct @531 state

ret

Definition: filter_design.txt:187

eightsvx_decode_frame

static int eightsvx_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

decode a frame

Definition: 8svx.c:90

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

EightSvxContext::data_size

int data_size

Definition: 8svx.c:57

AVCodecContext

main external API structure.

Definition: avcodec.h:431

EightSvxContext::data

uint8_t * data[2]

Definition: 8svx.c:56

av_clip_uint8

#define av_clip_uint8