FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/adxenc.c
Date: 2021-09-22 05:58:22
Exec Total Coverage
Lines: 89 99 89.9%
Branches: 33 38 86.8%

Line Branch Exec Source
1 /*
2 * ADX ADPCM codecs
3 * Copyright (c) 2001,2003 BERO
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 */
21
22 #include "avcodec.h"
23 #include "adx.h"
24 #include "bytestream.h"
25 #include "encode.h"
26 #include "internal.h"
27 #include "put_bits.h"
28
29 /**
30 * @file
31 * SEGA CRI adx codecs.
32 *
33 * Reference documents:
34 * http://ku-www.ss.titech.ac.jp/~yatsushi/adx.html
35 * adx2wav & wav2adx http://www.geocities.co.jp/Playtown/2004/
36 */
37
38 33076 static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav,
39 ADXChannelState *prev, int channels)
40 {
41 PutBitContext pb;
42 int scale;
43 int i, j;
44 int s0, s1, s2, d;
45 33076 int max = 0;
46 33076 int min = 0;
47
48 33076 s1 = prev->s1;
49 33076 s2 = prev->s2;
50
2/2
✓ Branch 0 taken 1058432 times.
✓ Branch 1 taken 33076 times.
1091508 for (i = 0, j = 0; j < 32; i += channels, j++) {
51 1058432 s0 = wav[i];
52 1058432 d = s0 + ((-c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS);
53
2/2
✓ Branch 0 taken 189764 times.
✓ Branch 1 taken 868668 times.
1058432 if (max < d)
54 189764 max = d;
55
2/2
✓ Branch 0 taken 192954 times.
✓ Branch 1 taken 865478 times.
1058432 if (min > d)
56 192954 min = d;
57 1058432 s2 = s1;
58 1058432 s1 = s0;
59 }
60
61
3/4
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 32926 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 150 times.
33076 if (max == 0 && min == 0) {
62 prev->s1 = s1;
63 prev->s2 = s2;
64 memset(adx, 0, BLOCK_SIZE);
65 return;
66 }
67
68
2/2
✓ Branch 0 taken 27914 times.
✓ Branch 1 taken 5162 times.
33076 if (max / 7 > -min / 8)
69 27914 scale = max / 7;
70 else
71 5162 scale = -min / 8;
72
73
2/2
✓ Branch 0 taken 998 times.
✓ Branch 1 taken 32078 times.
33076 if (scale == 0)
74 998 scale = 1;
75
76 33076 AV_WB16(adx, scale);
77
78 33076 init_put_bits(&pb, adx + 2, 16);
79
80 33076 s1 = prev->s1;
81 33076 s2 = prev->s2;
82
2/2
✓ Branch 0 taken 1058432 times.
✓ Branch 1 taken 33076 times.
1091508 for (i = 0, j = 0; j < 32; i += channels, j++) {
83 1058432 d = wav[i] + ((-c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS);
84
85
2/2
✓ Branch 0 taken 538502 times.
✓ Branch 1 taken 519930 times.
1058432 d = av_clip_intp2(ROUNDED_DIV(d, scale), 3);
86
87 1058432 put_sbits(&pb, 4, d);
88
89 1058432 s0 = d * scale + ((c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS);
90 1058432 s2 = s1;
91 1058432 s1 = s0;
92 }
93 33076 prev->s1 = s1;
94 33076 prev->s2 = s2;
95
96 33076 flush_put_bits(&pb);
97 }
98
99 #define HEADER_SIZE 36
100
101 2 static int adx_encode_header(AVCodecContext *avctx, uint8_t *buf, int bufsize)
102 {
103 2 ADXContext *c = avctx->priv_data;
104
105 2 bytestream_put_be16(&buf, 0x8000); /* header signature */
106 2 bytestream_put_be16(&buf, HEADER_SIZE - 4); /* copyright offset */
107 2 bytestream_put_byte(&buf, 3); /* encoding */
108 2 bytestream_put_byte(&buf, BLOCK_SIZE); /* block size */
109 2 bytestream_put_byte(&buf, 4); /* sample size */
110 2 bytestream_put_byte(&buf, avctx->channels); /* channels */
111 2 bytestream_put_be32(&buf, avctx->sample_rate); /* sample rate */
112 2 bytestream_put_be32(&buf, 0); /* total sample count */
113 2 bytestream_put_be16(&buf, c->cutoff); /* cutoff frequency */
114 2 bytestream_put_byte(&buf, 3); /* version */
115 2 bytestream_put_byte(&buf, 0); /* flags */
116 2 bytestream_put_be32(&buf, 0); /* unknown */
117 2 bytestream_put_be32(&buf, 0); /* loop enabled */
118 2 bytestream_put_be16(&buf, 0); /* padding */
119 2 bytestream_put_buffer(&buf, "(c)CRI", 6); /* copyright signature */
120
121 2 return HEADER_SIZE;
122 }
123
124 2 static av_cold int adx_encode_init(AVCodecContext *avctx)
125 {
126 2 ADXContext *c = avctx->priv_data;
127
128
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (avctx->channels > 2) {
129 av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
130 return AVERROR(EINVAL);
131 }
132 2 avctx->frame_size = BLOCK_SAMPLES;
133
134 /* the cutoff can be adjusted, but this seems to work pretty well */
135 2 c->cutoff = 500;
136 2 ff_adx_calculate_coeffs(c->cutoff, avctx->sample_rate, COEFF_BITS, c->coeff);
137
138 2 return 0;
139 }
140
141 16542 static int adx_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
142 const AVFrame *frame, int *got_packet_ptr)
143 {
144 16542 ADXContext *c = avctx->priv_data;
145
2/2
✓ Branch 0 taken 16538 times.
✓ Branch 1 taken 4 times.
16542 const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;
146 uint8_t *dst;
147 int ch, out_size, ret;
148
149
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 16538 times.
16542 if (!samples) {
150
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
4 if (c->eof)
151 2 return 0;
152
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
2 if ((ret = ff_get_encode_buffer(avctx, avpkt, 18, 0)) < 0)
153 return ret;
154 2 c->eof = 1;
155 2 dst = avpkt->data;
156 2 bytestream_put_be16(&dst, 0x8001);
157 2 bytestream_put_be16(&dst, 0x000E);
158 2 bytestream_put_be64(&dst, 0x0);
159 2 bytestream_put_be32(&dst, 0x0);
160 2 bytestream_put_be16(&dst, 0x0);
161 2 *got_packet_ptr = 1;
162 2 return 0;
163 }
164
165
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 16536 times.
16538 out_size = BLOCK_SIZE * avctx->channels + !c->header_parsed * HEADER_SIZE;
166
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16538 times.
16538 if ((ret = ff_get_encode_buffer(avctx, avpkt, out_size, 0)) < 0)
167 return ret;
168 16538 dst = avpkt->data;
169
170
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 16536 times.
16538 if (!c->header_parsed) {
171 int hdrsize;
172
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
2 if ((hdrsize = adx_encode_header(avctx, dst, avpkt->size)) < 0) {
173 av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
174 return AVERROR(EINVAL);
175 }
176 2 dst += hdrsize;
177 2 c->header_parsed = 1;
178 }
179
180
2/2
✓ Branch 0 taken 33076 times.
✓ Branch 1 taken 16538 times.
49614 for (ch = 0; ch < avctx->channels; ch++) {
181 33076 adx_encode(c, dst, samples + ch, &c->prev[ch], avctx->channels);
182 33076 dst += BLOCK_SIZE;
183 }
184
185 16538 avpkt->pts = frame->pts;
186 16538 avpkt->duration = frame->nb_samples;
187 16538 *got_packet_ptr = 1;
188 16538 return 0;
189 }
190
191 const AVCodec ff_adpcm_adx_encoder = {
192 .name = "adpcm_adx",
193 .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
194 .type = AVMEDIA_TYPE_AUDIO,
195 .id = AV_CODEC_ID_ADPCM_ADX,
196 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
197 .priv_data_size = sizeof(ADXContext),
198 .init = adx_encode_init,
199 .encode2 = adx_encode_frame,
200 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
201 AV_SAMPLE_FMT_NONE },
202 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
203 };
204