FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/wmaenc.c	Lines:	203	233	87.1 %
Date:	2021-04-18 10:33:33	Branches:	98	142	69.0 %


/*
 * WMA compatible encoder
 * Copyright (c) 2007 Michael Niedermayer
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/attributes.h"
#include "libavutil/ffmath.h"

#include "avcodec.h"
#include "internal.h"
#include "wma.h"
#include "libavutil/avassert.h"


static av_cold int encode_init(AVCodecContext *avctx)
{
    WMACodecContext *s = avctx->priv_data;
    int i, flags1, flags2, block_align;
    uint8_t *extradata;
    int ret;

    s->avctx = avctx;

    if (avctx->channels > MAX_CHANNELS) {
        av_log(avctx, AV_LOG_ERROR,
               "too many channels: got %i, need %i or fewer\n",
               avctx->channels, MAX_CHANNELS);
        return AVERROR(EINVAL);
    }

    if (avctx->sample_rate > 48000) {
        av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz\n",
               avctx->sample_rate);
        return AVERROR(EINVAL);
    }

    if (avctx->bit_rate < 24 * 1000) {
        av_log(avctx, AV_LOG_ERROR,
               "bitrate too low: got %"PRId64", need 24000 or higher\n",
               avctx->bit_rate);
        return AVERROR(EINVAL);
    }

    /* extract flag info */
    flags1 = 0;
    flags2 = 1;
    if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
        extradata             = av_malloc(4);
        if (!extradata)
            return AVERROR(ENOMEM);
        avctx->extradata_size = 4;
        AV_WL16(extradata, flags1);
        AV_WL16(extradata + 2, flags2);
    } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
        extradata             = av_mallocz(10);
        if (!extradata)
            return AVERROR(ENOMEM);
        avctx->extradata_size = 10;
        AV_WL32(extradata, flags1);
        AV_WL16(extradata + 4, flags2);
    } else {
        av_assert0(0);
    }
    avctx->extradata          = extradata;
    s->use_exp_vlc            = flags2 & 0x0001;
    s->use_bit_reservoir      = flags2 & 0x0002;
    s->use_variable_block_len = flags2 & 0x0004;
    if (avctx->channels == 2)
        s->ms_stereo = 1;

    if ((ret = ff_wma_init(avctx, flags2)) < 0)
        return ret;

    /* init MDCT */
    for (i = 0; i < s->nb_block_sizes; i++)
        ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);

    block_align        = avctx->bit_rate * (int64_t) s->frame_len /
                         (avctx->sample_rate * 8);
    block_align        = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
    avctx->block_align = block_align;
    avctx->frame_size = avctx->initial_padding = s->frame_len;

    return 0;
}

static int apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
{
    WMACodecContext *s = avctx->priv_data;
    float **audio      = (float **) frame->extended_data;
    int len            = frame->nb_samples;
    int window_index   = s->frame_len_bits - s->block_len_bits;
    FFTContext *mdct   = &s->mdct_ctx[window_index];
    int ch;
    const float *win   = s->windows[window_index];
    int window_len     = 1 << s->block_len_bits;
    float n            = 2.0 * 32768.0 / window_len;

    for (ch = 0; ch < avctx->channels; ch++) {
        memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
        s->fdsp->vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
        s->fdsp->vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
                                    win, len);
        s->fdsp->vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
        mdct->mdct_calc(mdct, s->coefs[ch], s->output);
        if (!isfinite(s->coefs[ch][0])) {
            av_log(avctx, AV_LOG_ERROR, "Input contains NaN/+-Inf\n");
            return AVERROR(EINVAL);
        }
    }

    return 0;
}

// FIXME use for decoding too
static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
{
    int n;
    const uint16_t *ptr;
    float v, *q, max_scale, *q_end;

    ptr       = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
    q         = s->exponents[ch];
    q_end     = q + s->block_len;
    max_scale = 0;
    while (q < q_end) {
        /* XXX: use a table */
        v         = ff_exp10(*exp_param++ *(1.0 / 16.0));
        max_scale = FFMAX(max_scale, v);
        n         = *ptr++;
        do {
            *q++ = v;
        } while (--n);
    }
    s->max_exponent[ch] = max_scale;
}

static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
{
    int last_exp;
    const uint16_t *ptr;
    float *q, *q_end;

    ptr   = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
    q     = s->exponents[ch];
    q_end = q + s->block_len;
    if (s->version == 1) {
        last_exp = *exp_param++;
        av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
        put_bits(&s->pb, 5, last_exp - 10);
        q += *ptr++;
    } else
        last_exp = 36;
    while (q < q_end) {
        int exp  = *exp_param++;
        int code = exp - last_exp + 60;
        av_assert1(code >= 0 && code < 120);
        put_bits(&s->pb, ff_aac_scalefactor_bits[code],
                 ff_aac_scalefactor_code[code]);
        /* XXX: use a table */
        q       += *ptr++;
        last_exp = exp;
    }
}

static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
                        int total_gain)
{
    int v, bsize, ch, coef_nb_bits, parse_exponents;
    float mdct_norm;
    int nb_coefs[MAX_CHANNELS];
    static const int fixed_exp[25] = {
        20, 20, 20, 20, 20,
        20, 20, 20, 20, 20,
        20, 20, 20, 20, 20,
        20, 20, 20, 20, 20,
        20, 20, 20, 20, 20
    };

    // FIXME remove duplication relative to decoder
    if (s->use_variable_block_len) {
        av_assert0(0); // FIXME not implemented
    } else {
        /* fixed block len */
        s->next_block_len_bits = s->frame_len_bits;
        s->prev_block_len_bits = s->frame_len_bits;
        s->block_len_bits      = s->frame_len_bits;
    }

    s->block_len = 1 << s->block_len_bits;
//     av_assert0((s->block_pos + s->block_len) <= s->frame_len);
    bsize = s->frame_len_bits - s->block_len_bits;

    // FIXME factor
    v = s->coefs_end[bsize] - s->coefs_start;
    for (ch = 0; ch < s->avctx->channels; ch++)
        nb_coefs[ch] = v;
    {
        int n4 = s->block_len / 2;
        mdct_norm = 1.0 / (float) n4;
        if (s->version == 1)
            mdct_norm *= sqrt(n4);
    }

    if (s->avctx->channels == 2)
        put_bits(&s->pb, 1, !!s->ms_stereo);

    for (ch = 0; ch < s->avctx->channels; ch++) {
        // FIXME only set channel_coded when needed, instead of always
        s->channel_coded[ch] = 1;
        if (s->channel_coded[ch])
            init_exp(s, ch, fixed_exp);
    }

    for (ch = 0; ch < s->avctx->channels; ch++) {
        if (s->channel_coded[ch]) {
            WMACoef *coefs1;
            float *coefs, *exponents, mult;
            int i, n;

            coefs1    = s->coefs1[ch];
            exponents = s->exponents[ch];
            mult      = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
            mult     *= mdct_norm;
            coefs     = src_coefs[ch];
            if (s->use_noise_coding && 0) {
                av_assert0(0); // FIXME not implemented
            } else {
                coefs += s->coefs_start;
                n      = nb_coefs[ch];
                for (i = 0; i < n; i++) {
                    double t = *coefs++ / (exponents[i] * mult);
                    if (t < -32768 || t > 32767)
                        return -1;

                    coefs1[i] = lrint(t);
                }
            }
        }
    }

    v = 0;
    for (ch = 0; ch < s->avctx->channels; ch++) {
        int a = s->channel_coded[ch];
        put_bits(&s->pb, 1, a);
        v |= a;
    }

    if (!v)
        return 1;

    for (v = total_gain - 1; v >= 127; v -= 127)
        put_bits(&s->pb, 7, 127);
    put_bits(&s->pb, 7, v);

    coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);

    if (s->use_noise_coding) {
        for (ch = 0; ch < s->avctx->channels; ch++) {
            if (s->channel_coded[ch]) {
                int i, n;
                n = s->exponent_high_sizes[bsize];
                for (i = 0; i < n; i++) {
                    put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
                    if (0)
                        nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
                }
            }
        }
    }

    parse_exponents = 1;
    if (s->block_len_bits != s->frame_len_bits)
        put_bits(&s->pb, 1, parse_exponents);

    if (parse_exponents) {
        for (ch = 0; ch < s->avctx->channels; ch++) {
            if (s->channel_coded[ch]) {
                if (s->use_exp_vlc) {
                    encode_exp_vlc(s, ch, fixed_exp);
                } else {
                    av_assert0(0); // FIXME not implemented
//                    encode_exp_lsp(s, ch);
                }
            }
        }
    } else
        av_assert0(0); // FIXME not implemented

    for (ch = 0; ch < s->avctx->channels; ch++) {
        if (s->channel_coded[ch]) {
            int run, tindex;
            WMACoef *ptr, *eptr;
            tindex = (ch == 1 && s->ms_stereo);
            ptr    = &s->coefs1[ch][0];
            eptr   = ptr + nb_coefs[ch];

            run = 0;
            for (; ptr < eptr; ptr++) {
                if (*ptr) {
                    int level     = *ptr;
                    int abs_level = FFABS(level);
                    int code      = 0;
                    if (abs_level <= s->coef_vlcs[tindex]->max_level)
                        if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
                            code = run + s->int_table[tindex][abs_level - 1];

                    av_assert2(code < s->coef_vlcs[tindex]->n);
                    put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
                             s->coef_vlcs[tindex]->huffcodes[code]);

                    if (code == 0) {
                        if (1 << coef_nb_bits <= abs_level)
                            return -1;

                        put_bits(&s->pb, coef_nb_bits, abs_level);
                        put_bits(&s->pb, s->frame_len_bits, run);
                    }
                    // FIXME the sign is flipped somewhere
                    put_bits(&s->pb, 1, level < 0);
                    run = 0;
                } else
                    run++;
            }
            if (run)
                put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
                         s->coef_vlcs[tindex]->huffcodes[1]);
        }
        if (s->version == 1 && s->avctx->channels >= 2)
            align_put_bits(&s->pb);
    }
    return 0;
}

static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
                        uint8_t *buf, int buf_size, int total_gain)
{
    init_put_bits(&s->pb, buf, buf_size);

    if (s->use_bit_reservoir)
        av_assert0(0); // FIXME not implemented
    else if (encode_block(s, src_coefs, total_gain) < 0)
        return INT_MAX;

    align_put_bits(&s->pb);

    return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
}

static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
                             const AVFrame *frame, int *got_packet_ptr)
{
    WMACodecContext *s = avctx->priv_data;
    int i, total_gain, ret, error;

    s->block_len_bits = s->frame_len_bits; // required by non variable block len
    s->block_len      = 1 << s->block_len_bits;

    ret = apply_window_and_mdct(avctx, frame);

    if (ret < 0)
        return ret;

    if (s->ms_stereo) {
        float a, b;
        int i;

        for (i = 0; i < s->block_len; i++) {
            a              = s->coefs[0][i] * 0.5;
            b              = s->coefs[1][i] * 0.5;
            s->coefs[0][i] = a + b;
            s->coefs[1][i] = a - b;
        }
    }

    if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE, 0)) < 0)
        return ret;

    total_gain = 128;
    for (i = 64; i; i >>= 1) {
        error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
                                 total_gain - i);
        if (error <= 0)
            total_gain -= i;
    }

    while(total_gain <= 128 && error > 0)
        error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
    if (error > 0) {
        av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n");
        avpkt->size = 0;
        return AVERROR(EINVAL);
    }
    av_assert0((put_bits_count(&s->pb) & 7) == 0);
    i = avctx->block_align - put_bytes_count(&s->pb, 0);
    av_assert0(i>=0);
    while(i--)
        put_bits(&s->pb, 8, 'N');

    flush_put_bits(&s->pb);
    av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);

    if (frame->pts != AV_NOPTS_VALUE)
        avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);

    avpkt->size     = avctx->block_align;
    *got_packet_ptr = 1;
    return 0;
}

#if CONFIG_WMAV1_ENCODER
AVCodec ff_wmav1_encoder = {
    .name           = "wmav1",
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_WMAV1,
    .priv_data_size = sizeof(WMACodecContext),
    .init           = encode_init,
    .encode2        = encode_superframe,
    .close          = ff_wma_end,
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                      AV_SAMPLE_FMT_NONE },
};
#endif
#if CONFIG_WMAV2_ENCODER
AVCodec ff_wmav2_encoder = {
    .name           = "wmav2",
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_WMAV2,
    .priv_data_size = sizeof(WMACodecContext),
    .init           = encode_init,
    .encode2        = encode_superframe,
    .close          = ff_wma_end,
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                      AV_SAMPLE_FMT_NONE },
};
#endif


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* WMA compatible encoder
3			* Copyright (c) 2007 Michael Niedermayer
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 "libavutil/attributes.h"
23			#include "libavutil/ffmath.h"
24
25			#include "avcodec.h"
26			#include "internal.h"
27			#include "wma.h"
28			#include "libavutil/avassert.h"
29
30
31		2	static av_cold int encode_init(AVCodecContext *avctx)
32			{
33		2	WMACodecContext *s = avctx->priv_data;
34			int i, flags1, flags2, block_align;
35			uint8_t *extradata;
36			int ret;
37
38		2	s->avctx = avctx;
39
40	✗✓	2	if (avctx->channels > MAX_CHANNELS) {
41			av_log(avctx, AV_LOG_ERROR,
42			"too many channels: got %i, need %i or fewer\n",
43			avctx->channels, MAX_CHANNELS);
44			return AVERROR(EINVAL);
45			}
46
47	✗✓	2	if (avctx->sample_rate > 48000) {
48			av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz\n",
49			avctx->sample_rate);
50			return AVERROR(EINVAL);
51			}
52
53	✗✓	2	if (avctx->bit_rate < 24 * 1000) {
54			av_log(avctx, AV_LOG_ERROR,
55			"bitrate too low: got %"PRId64", need 24000 or higher\n",
56			avctx->bit_rate);
57			return AVERROR(EINVAL);
58			}
59
60			/* extract flag info */
61		2	flags1 = 0;
62		2	flags2 = 1;
63	✓✓	2	if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
64		1	extradata = av_malloc(4);
65	✗✓	1	if (!extradata)
66			return AVERROR(ENOMEM);
67		1	avctx->extradata_size = 4;
68		1	AV_WL16(extradata, flags1);
69		1	AV_WL16(extradata + 2, flags2);
70	✓✗	1	} else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
71		1	extradata = av_mallocz(10);
72	✗✓	1	if (!extradata)
73			return AVERROR(ENOMEM);
74		1	avctx->extradata_size = 10;
75		1	AV_WL32(extradata, flags1);
76		1	AV_WL16(extradata + 4, flags2);
77			} else {
78			av_assert0(0);
79			}
80		2	avctx->extradata = extradata;
81		2	s->use_exp_vlc = flags2 & 0x0001;
82		2	s->use_bit_reservoir = flags2 & 0x0002;
83		2	s->use_variable_block_len = flags2 & 0x0004;
84	✓✗	2	if (avctx->channels == 2)
85		2	s->ms_stereo = 1;
86
87	✗✓	2	if ((ret = ff_wma_init(avctx, flags2)) < 0)
88			return ret;
89
90			/* init MDCT */
91	✓✓	4	for (i = 0; i < s->nb_block_sizes; i++)
92		2	ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
93
94		2	block_align = avctx->bit_rate * (int64_t) s->frame_len /
95		2	(avctx->sample_rate * 8);
96		2	block_align = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
97		2	avctx->block_align = block_align;
98		2	avctx->frame_size = avctx->initial_padding = s->frame_len;
99
100		2	return 0;
101			}
102
103		410	static int apply_window_and_mdct(AVCodecContext avctx, const AVFrame frame)
104			{
105		410	WMACodecContext *s = avctx->priv_data;
106		410	float audio = (float ) frame->extended_data;
107		410	int len = frame->nb_samples;
108		410	int window_index = s->frame_len_bits - s->block_len_bits;
109		410	FFTContext *mdct = &s->mdct_ctx[window_index];
110			int ch;
111		410	const float *win = s->windows[window_index];
112		410	int window_len = 1 << s->block_len_bits;
113		410	float n = 2.0 * 32768.0 / window_len;
114
115	✓✓	1230	for (ch = 0; ch < avctx->channels; ch++) {
116		820	memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
117		820	s->fdsp->vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
118		820	s->fdsp->vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
119			win, len);
120		820	s->fdsp->vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
121		820	mdct->mdct_calc(mdct, s->coefs[ch], s->output);
122	✗✓	820	if (!isfinite(s->coefs[ch][0])) {
123			av_log(avctx, AV_LOG_ERROR, "Input contains NaN/+-Inf\n");
124			return AVERROR(EINVAL);
125			}
126			}
127
128		410	return 0;
129			}
130
131			// FIXME use for decoding too
132		6128	static void init_exp(WMACodecContext s, int ch, const int exp_param)
133			{
134			int n;
135			const uint16_t *ptr;
136			float v, q, max_scale, q_end;
137
138		6128	ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
139		6128	q = s->exponents[ch];
140		6128	q_end = q + s->block_len;
141		6128	max_scale = 0;
142	✓✓	159328	while (q < q_end) {
143			/* XXX: use a table */
144		153200	v = ff_exp10(exp_param++ (1.0 / 16.0));
145	✗✓	153200	max_scale = FFMAX(max_scale, v);
146		153200	n = *ptr++;
147			do {
148		12550144	*q++ = v;
149	✓✓	12550144	} while (--n);
150			}
151		6128	s->max_exponent[ch] = max_scale;
152		6128	}
153
154		6128	static void encode_exp_vlc(WMACodecContext s, int ch, const int exp_param)
155			{
156			int last_exp;
157			const uint16_t *ptr;
158			float q, q_end;
159
160		6128	ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
161		6128	q = s->exponents[ch];
162		6128	q_end = q + s->block_len;
163	✓✓	6128	if (s->version == 1) {
164		3064	last_exp = *exp_param++;
165	✓✗✗✓	3064	av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
166		3064	put_bits(&s->pb, 5, last_exp - 10);
167		3064	q += *ptr++;
168			} else
169		3064	last_exp = 36;
170	✓✓	156264	while (q < q_end) {
171		150136	int exp = *exp_param++;
172		150136	int code = exp - last_exp + 60;
173			av_assert1(code >= 0 && code < 120);
174		150136	put_bits(&s->pb, ff_aac_scalefactor_bits[code],
175		150136	ff_aac_scalefactor_code[code]);
176			/* XXX: use a table */
177		150136	q += *ptr++;
178		150136	last_exp = exp;
179			}
180		6128	}
181
182		3064	static int encode_block(WMACodecContext s, float (src_coefs)[BLOCK_MAX_SIZE],
183			int total_gain)
184			{
185			int v, bsize, ch, coef_nb_bits, parse_exponents;
186			float mdct_norm;
187			int nb_coefs[MAX_CHANNELS];
188			static const int fixed_exp[25] = {
189			20, 20, 20, 20, 20,
190			20, 20, 20, 20, 20,
191			20, 20, 20, 20, 20,
192			20, 20, 20, 20, 20,
193			20, 20, 20, 20, 20
194			};
195
196			// FIXME remove duplication relative to decoder
197	✗✓	3064	if (s->use_variable_block_len) {
198			av_assert0(0); // FIXME not implemented
199			} else {
200			/* fixed block len */
201		3064	s->next_block_len_bits = s->frame_len_bits;
202		3064	s->prev_block_len_bits = s->frame_len_bits;
203		3064	s->block_len_bits = s->frame_len_bits;
204			}
205
206		3064	s->block_len = 1 << s->block_len_bits;
207			// av_assert0((s->block_pos + s->block_len) <= s->frame_len);
208		3064	bsize = s->frame_len_bits - s->block_len_bits;
209
210			// FIXME factor
211		3064	v = s->coefs_end[bsize] - s->coefs_start;
212	✓✓	9192	for (ch = 0; ch < s->avctx->channels; ch++)
213		6128	nb_coefs[ch] = v;
214			{
215		3064	int n4 = s->block_len / 2;
216		3064	mdct_norm = 1.0 / (float) n4;
217	✓✓	3064	if (s->version == 1)
218		1532	mdct_norm *= sqrt(n4);
219			}
220
221	✓✗	3064	if (s->avctx->channels == 2)
222		3064	put_bits(&s->pb, 1, !!s->ms_stereo);
223
224	✓✓	9192	for (ch = 0; ch < s->avctx->channels; ch++) {
225			// FIXME only set channel_coded when needed, instead of always
226		6128	s->channel_coded[ch] = 1;
227	✓✗	6128	if (s->channel_coded[ch])
228		6128	init_exp(s, ch, fixed_exp);
229			}
230
231	✓✓	9192	for (ch = 0; ch < s->avctx->channels; ch++) {
232	✓✗	6128	if (s->channel_coded[ch]) {
233			WMACoef *coefs1;
234			float coefs, exponents, mult;
235			int i, n;
236
237		6128	coefs1 = s->coefs1[ch];
238		6128	exponents = s->exponents[ch];
239		6128	mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
240		6128	mult *= mdct_norm;
241		6128	coefs = src_coefs[ch];
242			if (s->use_noise_coding && 0) {
243			av_assert0(0); // FIXME not implemented
244			} else {
245		6128	coefs += s->coefs_start;
246		6128	n = nb_coefs[ch];
247	✓✓	11419528	for (i = 0; i < n; i++) {
248		11413400	double t = coefs++ / (exponents[i] mult);
249	✓✗✗✓	11413400	if (t < -32768 \|\| t > 32767)
250			return -1;
251
252		11413400	coefs1[i] = lrint(t);
253			}
254			}
255			}
256			}
257
258		3064	v = 0;
259	✓✓	9192	for (ch = 0; ch < s->avctx->channels; ch++) {
260		6128	int a = s->channel_coded[ch];
261		6128	put_bits(&s->pb, 1, a);
262		6128	v \|= a;
263			}
264
265	✗✓	3064	if (!v)
266			return 1;
267
268	✗✓	3064	for (v = total_gain - 1; v >= 127; v -= 127)
269			put_bits(&s->pb, 7, 127);
270		3064	put_bits(&s->pb, 7, v);
271
272		3064	coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
273
274	✗✓	3064	if (s->use_noise_coding) {
275			for (ch = 0; ch < s->avctx->channels; ch++) {
276			if (s->channel_coded[ch]) {
277			int i, n;
278			n = s->exponent_high_sizes[bsize];
279			for (i = 0; i < n; i++) {
280			put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
281			if (0)
282			nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
283			}
284			}
285			}
286			}
287
288		3064	parse_exponents = 1;
289	✗✓	3064	if (s->block_len_bits != s->frame_len_bits)
290			put_bits(&s->pb, 1, parse_exponents);
291
292	✓✗	3064	if (parse_exponents) {
293	✓✓	9192	for (ch = 0; ch < s->avctx->channels; ch++) {
294	✓✗	6128	if (s->channel_coded[ch]) {
295	✓✗	6128	if (s->use_exp_vlc) {
296		6128	encode_exp_vlc(s, ch, fixed_exp);
297			} else {
298			av_assert0(0); // FIXME not implemented
299			// encode_exp_lsp(s, ch);
300			}
301			}
302			}
303			} else
304			av_assert0(0); // FIXME not implemented
305
306	✓✓	8435	for (ch = 0; ch < s->avctx->channels; ch++) {
307	✓✗	5755	if (s->channel_coded[ch]) {
308			int run, tindex;
309			WMACoef ptr, eptr;
310	✓✓✓✗	5755	tindex = (ch == 1 && s->ms_stereo);
311		5755	ptr = &s->coefs1[ch][0];
312		5755	eptr = ptr + nb_coefs[ch];
313
314		5755	run = 0;
315	✓✓	10012817	for (; ptr < eptr; ptr++) {
316	✓✓	10007446	if (*ptr) {
317		2918406	int level = *ptr;
318		2918406	int abs_level = FFABS(level);
319		2918406	int code = 0;
320	✓✓	2918406	if (abs_level <= s->coef_vlcs[tindex]->max_level)
321	✓✓	2889049	if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
322		2884295	code = run + s->int_table[tindex][abs_level - 1];
323
324			av_assert2(code < s->coef_vlcs[tindex]->n);
325		2918406	put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
326		2918406	s->coef_vlcs[tindex]->huffcodes[code]);
327
328	✓✓	2918406	if (code == 0) {
329	✓✓	34111	if (1 << coef_nb_bits <= abs_level)
330		384	return -1;
331
332		33727	put_bits(&s->pb, coef_nb_bits, abs_level);
333		33727	put_bits(&s->pb, s->frame_len_bits, run);
334			}
335			// FIXME the sign is flipped somewhere
336		2918022	put_bits(&s->pb, 1, level < 0);
337		2918022	run = 0;
338			} else
339		7089040	run++;
340			}
341	✓✓	5371	if (run)
342		5152	put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
343		5152	s->coef_vlcs[tindex]->huffcodes[1]);
344			}
345	✓✓✓✗	5371	if (s->version == 1 && s->avctx->channels >= 2)
346		2803	align_put_bits(&s->pb);
347			}
348		2680	return 0;
349			}
350
351		3064	static int encode_frame(WMACodecContext s, float (src_coefs)[BLOCK_MAX_SIZE],
352			uint8_t *buf, int buf_size, int total_gain)
353			{
354		3064	init_put_bits(&s->pb, buf, buf_size);
355
356	✗✓	3064	if (s->use_bit_reservoir)
357			av_assert0(0); // FIXME not implemented
358	✓✓	3064	else if (encode_block(s, src_coefs, total_gain) < 0)
359		384	return INT_MAX;
360
361		2680	align_put_bits(&s->pb);
362
363		2680	return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
364			}
365
366		410	static int encode_superframe(AVCodecContext avctx, AVPacket avpkt,
367			const AVFrame frame, int got_packet_ptr)
368			{
369		410	WMACodecContext *s = avctx->priv_data;
370			int i, total_gain, ret, error;
371
372		410	s->block_len_bits = s->frame_len_bits; // required by non variable block len
373		410	s->block_len = 1 << s->block_len_bits;
374
375		410	ret = apply_window_and_mdct(avctx, frame);
376
377	✗✓	410	if (ret < 0)
378			return ret;
379
380	✓✗	410	if (s->ms_stereo) {
381			float a, b;
382			int i;
383
384	✓✓	840090	for (i = 0; i < s->block_len; i++) {
385		839680	a = s->coefs[0][i] * 0.5;
386		839680	b = s->coefs[1][i] * 0.5;
387		839680	s->coefs[0][i] = a + b;
388		839680	s->coefs[1][i] = a - b;
389			}
390			}
391
392	✗✓	410	if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE, 0)) < 0)
393			return ret;
394
395		410	total_gain = 128;
396	✓✓	3280	for (i = 64; i; i >>= 1) {
397		2870	error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
398			total_gain - i);
399	✓✓	2870	if (error <= 0)
400		1331	total_gain -= i;
401			}
402
403	✓✗✓✓	604	while(total_gain <= 128 && error > 0)
404		194	error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
405	✗✓	410	if (error > 0) {
406			av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n");
407			avpkt->size = 0;
408			return AVERROR(EINVAL);
409			}
410	✗✓	410	av_assert0((put_bits_count(&s->pb) & 7) == 0);
411		410	i = avctx->block_align - put_bytes_count(&s->pb, 0);
412	✗✓	410	av_assert0(i>=0);
413	✓✓	22160	while(i--)
414		21750	put_bits(&s->pb, 8, 'N');
415
416		410	flush_put_bits(&s->pb);
417	✗✓	410	av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
418
419	✓✗	410	if (frame->pts != AV_NOPTS_VALUE)
420		410	avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
421
422		410	avpkt->size = avctx->block_align;
423		410	*got_packet_ptr = 1;
424		410	return 0;
425			}
426
427			#if CONFIG_WMAV1_ENCODER
428			AVCodec ff_wmav1_encoder = {
429			.name = "wmav1",
430			.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
431			.type = AVMEDIA_TYPE_AUDIO,
432			.id = AV_CODEC_ID_WMAV1,
433			.priv_data_size = sizeof(WMACodecContext),
434			.init = encode_init,
435			.encode2 = encode_superframe,
436			.close = ff_wma_end,
437			.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
438			AV_SAMPLE_FMT_NONE },
439			};
440			#endif
441			#if CONFIG_WMAV2_ENCODER
442			AVCodec ff_wmav2_encoder = {
443			.name = "wmav2",
444			.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
445			.type = AVMEDIA_TYPE_AUDIO,
446			.id = AV_CODEC_ID_WMAV2,
447			.priv_data_size = sizeof(WMACodecContext),
448			.init = encode_init,
449			.encode2 = encode_superframe,
450			.close = ff_wma_end,
451			.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
452			AV_SAMPLE_FMT_NONE },
453			};
454			#endif