FFmpeg coverage

Line	Branch	Exec	Source
1			/**
2			* MLP encoder
3			* Copyright (c) 2008 Ramiro Polla
4			* Copyright (c) 2016-2019 Jai Luthra
5			*
6			* This file is part of FFmpeg.
7			*
8			* FFmpeg is free software; you can redistribute it and/or
9			* modify it under the terms of the GNU Lesser General Public
10			* License as published by the Free Software Foundation; either
11			* version 2.1 of the License, or (at your option) any later version.
12			*
13			* FFmpeg is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16			* Lesser General Public License for more details.
17			*
18			* You should have received a copy of the GNU Lesser General Public
19			* License along with FFmpeg; if not, write to the Free Software
20			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21			*/
22
23			#include "config_components.h"
24
25			#include "avcodec.h"
26			#include "codec_internal.h"
27			#include "encode.h"
28			#include "put_bits.h"
29			#include "audio_frame_queue.h"
30			#include "libavutil/avassert.h"
31			#include "libavutil/channel_layout.h"
32			#include "libavutil/crc.h"
33			#include "libavutil/avstring.h"
34			#include "libavutil/intmath.h"
35			#include "libavutil/opt.h"
36			#include "libavutil/samplefmt.h"
37			#include "libavutil/thread.h"
38			#include "mlp_parse.h"
39			#include "mlp.h"
40			#include "lpc.h"
41
42			#define MAX_NCHANNELS (MAX_CHANNELS + 2)
43
44			#define MIN_HEADER_INTERVAL 8
45			#define MAX_HEADER_INTERVAL 128
46
47			#define MLP_MIN_LPC_ORDER 1
48			#define MLP_MAX_LPC_ORDER 8
49			#define MLP_MIN_LPC_SHIFT 0
50			#define MLP_MAX_LPC_SHIFT 15
51
52			typedef struct RestartHeader {
53			uint8_t min_channel; ///< The index of the first channel coded in this substream.
54			uint8_t max_channel; ///< The index of the last channel coded in this substream.
55			uint8_t max_matrix_channel; ///< The number of channels input into the rematrix stage.
56
57			int8_t max_shift;
58			uint8_t noise_shift; ///< The left shift applied to random noise in 0x31ea substreams.
59			uint32_t noisegen_seed; ///< The current seed value for the pseudorandom noise generator(s).
60
61			uint8_t data_check_present; ///< Set if the substream contains extra info to check the size of VLC blocks.
62
63			int32_t lossless_check_data; ///< XOR of all output samples
64
65			uint8_t max_huff_lsbs; ///< largest huff_lsbs
66			uint8_t max_output_bits; ///< largest output bit-depth
67			} RestartHeader;
68
69			typedef struct MatrixParams {
70			uint8_t count; ///< number of matrices to apply
71
72			uint8_t outch[MAX_MATRICES]; ///< output channel for each matrix
73			int32_t forco[MAX_MATRICES][MAX_NCHANNELS]; ///< forward coefficients
74			int32_t coeff[MAX_MATRICES][MAX_NCHANNELS]; ///< decoding coefficients
75			uint8_t fbits[MAX_MATRICES]; ///< fraction bits
76
77			int8_t noise_shift[MAX_CHANNELS];
78			uint8_t lsb_bypass[MAX_MATRICES];
79			int8_t bypassed_lsbs[MAX_MATRICES][MAX_BLOCKSIZE];
80			} MatrixParams;
81
82			#define PARAMS_DEFAULT (0xff)
83			#define PARAM_PRESENCE_FLAGS (1 << 8)
84
85			typedef struct DecodingParams {
86			uint16_t blocksize; ///< number of PCM samples in current audio block
87			uint8_t quant_step_size[MAX_CHANNELS]; ///< left shift to apply to Huffman-decoded residuals
88			int8_t output_shift[MAX_CHANNELS]; ///< Left shift to apply to decoded PCM values to get final 24-bit output.
89			uint8_t max_order[MAX_CHANNELS];
90
91			MatrixParams matrix_params;
92
93			uint8_t param_presence_flags; ///< Bitmask of which parameter sets are conveyed in a decoding parameter block.
94			int32_t sample_buffer[MAX_NCHANNELS][MAX_BLOCKSIZE];
95			} DecodingParams;
96
97			typedef struct BestOffset {
98			int32_t offset;
99			uint32_t bitcount;
100			uint8_t lsb_bits;
101			int32_t min;
102			int32_t max;
103			} BestOffset;
104
105			#define HUFF_OFFSET_MIN (-16384)
106			#define HUFF_OFFSET_MAX ( 16383)
107
108			/** Number of possible codebooks (counting "no codebooks") */
109			#define NUM_CODEBOOKS 4
110
111			typedef struct MLPBlock {
112			unsigned int seq_size;
113			ChannelParams channel_params[MAX_CHANNELS];
114			DecodingParams decoding_params;
115			int32_t lossless_check_data;
116			unsigned int max_output_bits; ///< largest output bit-depth
117			BestOffset best_offset[MAX_CHANNELS][NUM_CODEBOOKS];
118			ChannelParams major_channel_params[MAX_CHANNELS]; ///< ChannelParams to be written to bitstream.
119			DecodingParams major_decoding_params; ///< DecodingParams to be written to bitstream.
120			int major_params_changed; ///< params_changed to be written to bitstream.
121			int32_t inout_buffer[MAX_NCHANNELS][MAX_BLOCKSIZE];
122			} MLPBlock;
123
124			typedef struct MLPSubstream {
125			RestartHeader restart_header;
126			RestartHeader *cur_restart_header;
127			MLPBlock b[MAX_HEADER_INTERVAL + 1];
128			unsigned int major_cur_subblock_index;
129			unsigned int major_filter_state_subblock;
130			int32_t coefs[MAX_CHANNELS][MAX_LPC_ORDER][MAX_LPC_ORDER];
131			} MLPSubstream;
132
133			typedef struct MLPEncodeContext {
134			AVClass *class;
135			AVCodecContext *avctx;
136
137			int max_restart_interval; ///< Max interval of access units in between two major frames.
138			int min_restart_interval; ///< Min interval of access units in between two major frames.
139			int cur_restart_interval;
140			int lpc_coeff_precision;
141			int rematrix_precision;
142			int lpc_type;
143			int lpc_passes;
144			int prediction_order;
145			int max_codebook_search;
146
147			int num_substreams; ///< Number of substreams contained within this stream.
148
149			int num_channels; /**< Number of channels in major_scratch_buffer.
150			* Normal channels + noise channels. */
151
152			int coded_sample_fmt [2]; ///< sample format encoded for MLP
153			int coded_sample_rate[2]; ///< sample rate encoded for MLP
154			int coded_peak_bitrate; ///< peak bitrate for this major sync header
155
156			int flags; ///< major sync info flags
157
158			/* channel_meaning */
159			int substream_info;
160			int thd_substream_info;
161			int fs;
162			int wordlength;
163			int channel_occupancy;
164			int summary_info;
165
166			int32_t last_frames; ///< Signal last frames.
167
168			unsigned int major_number_of_frames;
169			unsigned int next_major_number_of_frames;
170
171			unsigned int major_frame_size; ///< Number of samples in current major frame being encoded.
172			unsigned int next_major_frame_size; ///< Counter of number of samples for next major frame.
173
174			unsigned int frame_index; ///< Index of current frame being encoded.
175
176			unsigned int restart_intervals; ///< Number of possible major frame sizes.
177
178			uint16_t output_timing; ///< Timestamp of current access unit.
179			uint16_t input_timing; ///< Decoding timestamp of current access unit.
180
181			uint8_t noise_type;
182			uint8_t channel_arrangement; ///< channel arrangement for MLP streams
183			uint16_t channel_arrangement8; ///< 8 channel arrangement for THD streams
184
185			uint8_t multichannel_type6ch; ///< channel modifier for TrueHD stream 0
186			uint8_t multichannel_type8ch; ///< channel modifier for TrueHD stream 0
187			uint8_t ch2_presentation_mod; ///< channel modifier for TrueHD stream 0
188			uint8_t ch6_presentation_mod; ///< channel modifier for TrueHD stream 1
189			uint8_t ch8_presentation_mod; ///< channel modifier for TrueHD stream 2
190
191			MLPSubstream s[2];
192			int32_t filter_state[NUM_FILTERS][MAX_HEADER_INTERVAL * MAX_BLOCKSIZE];
193			int32_t lpc_sample_buffer[MAX_HEADER_INTERVAL * MAX_BLOCKSIZE];
194
195			AudioFrameQueue afq;
196
197			/* Analysis stage. */
198			unsigned int number_of_frames;
199			unsigned int number_of_subblocks;
200
201			int shorten_by;
202
203			LPCContext lpc_ctx;
204			} MLPEncodeContext;
205
206			static ChannelParams restart_channel_params[MAX_CHANNELS];
207			static DecodingParams restart_decoding_params[MAX_SUBSTREAMS];
208			static const BestOffset restart_best_offset[NUM_CODEBOOKS] = {{0}};
209
210			#define SYNC_MAJOR 0xf8726f
211			#define MAJOR_SYNC_INFO_SIGNATURE 0xB752
212
213			/* must be set for DVD-A */
214			#define FLAGS_DVDA 0x4000
215			/* FIFO delay must be constant */
216			#define FLAGS_CONST 0x8000
217
218			#define SUBSTREAM_INFO_MAX_2_CHAN 0x01
219			#define SUBSTREAM_INFO_HIGH_RATE 0x02
220			#define SUBSTREAM_INFO_ALWAYS_SET 0x04
221			#define SUBSTREAM_INFO_2_SUBSTREAMS 0x08
222
223			/****************************************************************************
224			************ Functions that copy, clear, or compare parameters *************
225			****************************************************************************/
226
227			/** Compares two FilterParams structures and returns 1 if anything has
228			* changed. Returns 0 if they are both equal.
229			*/
230		✗	static int compare_filter_params(const ChannelParams *prev_cp, const ChannelParams *cp, int filter)
231			{
232		✗	const FilterParams *prev = &prev_cp->filter_params[filter];
233		✗	const FilterParams *fp = &cp->filter_params[filter];
234
235		✗	if (prev->order != fp->order)
236		✗	return 1;
237
238		✗	if (!fp->order)
239		✗	return 0;
240
241		✗	if (prev->shift != fp->shift)
242		✗	return 1;
243
244		✗	for (int i = 0; i < fp->order; i++)
245		✗	if (prev_cp->coeff[filter][i] != cp->coeff[filter][i])
246		✗	return 1;
247
248		✗	return 0;
249			}
250
251			/** Compare two primitive matrices and returns 1 if anything has changed.
252			* Returns 0 if they are both equal.
253			*/
254		✗	static int compare_matrix_params(MLPEncodeContext *ctx, MLPSubstream *s,
255			const MatrixParams *prev, const MatrixParams *mp)
256			{
257		✗	RestartHeader *rh = s->cur_restart_header;
258
259		✗	if (prev->count != mp->count)
260		✗	return 1;
261
262		✗	if (!mp->count)
263		✗	return 0;
264
265		✗	for (unsigned int mat = 0; mat < mp->count; mat++) {
266		✗	if (prev->outch[mat] != mp->outch[mat])
267		✗	return 1;
268
269		✗	if (prev->fbits[mat] != mp->fbits[mat])
270		✗	return 1;
271
272		✗	if (prev->noise_shift[mat] != mp->noise_shift[mat])
273		✗	return 1;
274
275		✗	if (prev->lsb_bypass[mat] != mp->lsb_bypass[mat])
276		✗	return 1;
277
278		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
279		✗	if (prev->coeff[mat][ch] != mp->coeff[mat][ch])
280		✗	return 1;
281			}
282
283		✗	return 0;
284			}
285
286			/** Compares two DecodingParams and ChannelParams structures to decide if a
287			* new decoding params header has to be written.
288			*/
289		✗	static int compare_decoding_params(MLPEncodeContext *ctx,
290			MLPSubstream *s,
291			unsigned int index)
292			{
293		✗	const DecodingParams *prev = index ? &s->b[index-1].major_decoding_params : restart_decoding_params;
294		✗	DecodingParams *dp = &s->b[index].major_decoding_params;
295		✗	const MatrixParams *prev_mp = &prev->matrix_params;
296		✗	MatrixParams *mp = &dp->matrix_params;
297		✗	RestartHeader *rh = s->cur_restart_header;
298		✗	int retval = 0;
299
300		✗	if (prev->param_presence_flags != dp->param_presence_flags)
301		✗	retval |= PARAM_PRESENCE_FLAGS;
302
303		✗	if (prev->blocksize != dp->blocksize)
304		✗	retval |= PARAM_BLOCKSIZE;
305
306		✗	if (compare_matrix_params(ctx, s, prev_mp, mp))
307		✗	retval |= PARAM_MATRIX;
308
309		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
310		✗	if (prev->output_shift[ch] != dp->output_shift[ch]) {
311		✗	retval |= PARAM_OUTSHIFT;
312		✗	break;
313			}
314
315		✗	for (int ch = 0; ch <= rh->max_channel; ch++)
316		✗	if (prev->quant_step_size[ch] != dp->quant_step_size[ch]) {
317		✗	retval |= PARAM_QUANTSTEP;
318		✗	break;
319			}
320
321		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
322		✗	const ChannelParams *prev_cp = index ? &s->b[index-1].major_channel_params[ch] : &restart_channel_params[ch];
323		✗	ChannelParams *cp = &s->b[index].major_channel_params[ch];
324
325		✗	if (!(retval & PARAM_FIR) &&
326		✗	compare_filter_params(prev_cp, cp, FIR))
327		✗	retval |= PARAM_FIR;
328
329		✗	if (!(retval & PARAM_IIR) &&
330		✗	compare_filter_params(prev_cp, cp, IIR))
331		✗	retval |= PARAM_IIR;
332
333		✗	if (prev_cp->huff_offset != cp->huff_offset)
334		✗	retval |= PARAM_HUFFOFFSET;
335
336		✗	if (prev_cp->codebook != cp->codebook ||
337		✗	prev_cp->huff_lsbs != cp->huff_lsbs )
338		✗	retval |= PARAM_PRESENCE;
339			}
340
341		✗	return retval;
342			}
343
344		✗	static void copy_filter_params(ChannelParams *dst_cp, ChannelParams *src_cp, int filter)
345			{
346		✗	FilterParams *dst = &dst_cp->filter_params[filter];
347		✗	FilterParams *src = &src_cp->filter_params[filter];
348
349		✗	dst->order = src->order;
350
351		✗	if (dst->order) {
352		✗	dst->shift = src->shift;
353
354		✗	dst->coeff_shift = src->coeff_shift;
355		✗	dst->coeff_bits = src->coeff_bits;
356			}
357
358		✗	for (int order = 0; order < dst->order; order++)
359		✗	dst_cp->coeff[filter][order] = src_cp->coeff[filter][order];
360		✗	}
361
362		✗	static void copy_matrix_params(MatrixParams *dst, MatrixParams *src)
363			{
364		✗	dst->count = src->count;
365
366		✗	if (!dst->count)
367		✗	return;
368
369		✗	for (int count = 0; count < MAX_MATRICES; count++) {
370		✗	dst->outch[count] = src->outch[count];
371		✗	dst->fbits[count] = src->fbits[count];
372		✗	dst->noise_shift[count] = src->noise_shift[count];
373		✗	dst->lsb_bypass[count] = src->lsb_bypass[count];
374
375		✗	for (int channel = 0; channel < MAX_NCHANNELS; channel++)
376		✗	dst->coeff[count][channel] = src->coeff[count][channel];
377			}
378			}
379
380		✗	static void copy_restart_frame_params(MLPEncodeContext *ctx, MLPSubstream *s)
381			{
382		✗	RestartHeader *rh = s->cur_restart_header;
383
384		✗	for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
385		✗	DecodingParams *dp = &s->b[index].decoding_params;
386
387		✗	copy_matrix_params(&dp->matrix_params, &s->b[1].decoding_params.matrix_params);
388
389		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
390		✗	dp->output_shift[ch] = s->b[1].decoding_params.output_shift[ch];
391
392		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
393		✗	ChannelParams *cp = &s->b[index].channel_params[ch];
394
395		✗	dp->quant_step_size[ch] = s->b[1].decoding_params.quant_step_size[ch];
396
397		✗	if (index)
398		✗	for (unsigned int filter = 0; filter < NUM_FILTERS; filter++)
399		✗	copy_filter_params(cp, &s->b[1].channel_params[ch], filter);
400			}
401			}
402		✗	}
403
404			/** Clears a DecodingParams struct the way it should be after a restart header. */
405		✗	static void clear_decoding_params(DecodingParams *decoding_params)
406			{
407		✗	DecodingParams *dp = decoding_params;
408
409		✗	dp->param_presence_flags = 0xff;
410		✗	dp->blocksize = 0;
411
412		✗	memset(&dp->matrix_params, 0, sizeof(dp->matrix_params ));
413		✗	memset(dp->quant_step_size, 0, sizeof(dp->quant_step_size));
414		✗	memset(dp->sample_buffer, 0, sizeof(dp->sample_buffer ));
415		✗	memset(dp->output_shift, 0, sizeof(dp->output_shift ));
416		✗	memset(dp->max_order, MAX_FIR_ORDER, sizeof(dp->max_order));
417		✗	}
418
419			/** Clears a ChannelParams struct the way it should be after a restart header. */
420		✗	static void clear_channel_params(ChannelParams *channel_params, int nb_channels)
421			{
422		✗	for (unsigned channel = 0; channel < nb_channels; channel++) {
423		✗	ChannelParams *cp = &channel_params[channel];
424
425		✗	memset(&cp->filter_params, 0, sizeof(cp->filter_params));
426
427			/* Default audio coding is 24-bit raw PCM. */
428		✗	cp->huff_offset = 0;
429		✗	cp->codebook = 0;
430		✗	cp->huff_lsbs = 24;
431			}
432		✗	}
433
434			/** Sets default vales in our encoder for a DecodingParams struct. */
435		✗	static void default_decoding_params(MLPEncodeContext *ctx, DecodingParams *dp)
436			{
437		✗	uint8_t param_presence_flags = 0;
438
439		✗	clear_decoding_params(dp);
440
441		✗	param_presence_flags |= PARAM_BLOCKSIZE;
442		✗	param_presence_flags |= PARAM_MATRIX;
443		✗	param_presence_flags |= PARAM_OUTSHIFT;
444		✗	param_presence_flags |= PARAM_QUANTSTEP;
445		✗	param_presence_flags |= PARAM_FIR;
446		✗	param_presence_flags |= PARAM_IIR;
447		✗	param_presence_flags |= PARAM_HUFFOFFSET;
448		✗	param_presence_flags |= PARAM_PRESENCE;
449
450		✗	dp->param_presence_flags = param_presence_flags;
451		✗	}
452
453			/****************************************************************************/
454
455			/** Calculates the smallest number of bits it takes to encode a given signed
456			* value in two's complement.
457			*/
458		✗	static int inline number_sbits(int32_t n)
459			{
460		✗	return 33 - ff_clz(FFABS(n)|1) - !n;
461			}
462
463			enum InputBitDepth {
464			BITS_16,
465			BITS_20,
466			BITS_24,
467			};
468
469		✗	static int mlp_peak_bitrate(int peak_bitrate, int sample_rate)
470			{
471		✗	return ((peak_bitrate << 4) - 8) / sample_rate;
472			}
473
474		✗	static av_cold void mlp_encode_init_static(void)
475			{
476		✗	clear_channel_params (restart_channel_params, MAX_CHANNELS);
477		✗	clear_decoding_params(restart_decoding_params);
478		✗	ff_mlp_init_crc();
479		✗	}
480
481		✗	static av_cold int mlp_encode_init(AVCodecContext *avctx)
482			{
483			static AVOnce init_static_once = AV_ONCE_INIT;
484		✗	MLPEncodeContext *ctx = avctx->priv_data;
485			uint64_t channels_present;
486			int ret;
487
488		✗	ctx->avctx = avctx;
489
490		✗	switch (avctx->sample_rate) {
491		✗	case 44100 << 0:
492		✗	avctx->frame_size = 40 << 0;
493		✗	ctx->coded_sample_rate[0] = 0x08 + 0;
494		✗	ctx->fs = 0x08 + 1;
495		✗	break;
496		✗	case 44100 << 1:
497		✗	avctx->frame_size = 40 << 1;
498		✗	ctx->coded_sample_rate[0] = 0x08 + 1;
499		✗	ctx->fs = 0x0C + 1;
500		✗	break;
501		✗	case 44100 << 2:
502		✗	ctx->substream_info |= SUBSTREAM_INFO_HIGH_RATE;
503		✗	avctx->frame_size = 40 << 2;
504		✗	ctx->coded_sample_rate[0] = 0x08 + 2;
505		✗	ctx->fs = 0x10 + 1;
506		✗	break;
507		✗	case 48000 << 0:
508		✗	avctx->frame_size = 40 << 0;
509		✗	ctx->coded_sample_rate[0] = 0x00 + 0;
510		✗	ctx->fs = 0x08 + 2;
511		✗	break;
512		✗	case 48000 << 1:
513		✗	avctx->frame_size = 40 << 1;
514		✗	ctx->coded_sample_rate[0] = 0x00 + 1;
515		✗	ctx->fs = 0x0C + 2;
516		✗	break;
517		✗	case 48000 << 2:
518		✗	ctx->substream_info |= SUBSTREAM_INFO_HIGH_RATE;
519		✗	avctx->frame_size = 40 << 2;
520		✗	ctx->coded_sample_rate[0] = 0x00 + 2;
521		✗	ctx->fs = 0x10 + 2;
522		✗	break;
523		✗	default:
524		✗	av_unreachable("Checked via CODEC_SAMPLERATES");
525			}
526		✗	ctx->coded_sample_rate[1] = -1 & 0xf;
527
528		✗	ctx->coded_peak_bitrate = mlp_peak_bitrate(9600000, avctx->sample_rate);
529
530		✗	ctx->substream_info |= SUBSTREAM_INFO_ALWAYS_SET;
531		✗	if (avctx->ch_layout.nb_channels <= 2)
532		✗	ctx->substream_info |= SUBSTREAM_INFO_MAX_2_CHAN;
533
534		✗	switch (avctx->sample_fmt) {
535		✗	case AV_SAMPLE_FMT_S16P:
536		✗	ctx->coded_sample_fmt[0] = BITS_16;
537		✗	ctx->wordlength = 16;
538		✗	avctx->bits_per_raw_sample = 16;
539		✗	break;
540			/* TODO 20 bits: */
541		✗	case AV_SAMPLE_FMT_S32P:
542		✗	ctx->coded_sample_fmt[0] = BITS_24;
543		✗	ctx->wordlength = 24;
544		✗	avctx->bits_per_raw_sample = 24;
545		✗	break;
546		✗	default:
547		✗	av_unreachable("Checked via CODEC_SAMPLEFMTS");
548			}
549		✗	ctx->coded_sample_fmt[1] = -1 & 0xf;
550
551		✗	ctx->input_timing = -avctx->frame_size;
552
553		✗	ctx->num_channels = avctx->ch_layout.nb_channels + 2; /* +2 noise channels */
554
555		✗	ctx->min_restart_interval = ctx->cur_restart_interval = ctx->max_restart_interval;
556		✗	ctx->restart_intervals = ctx->max_restart_interval / ctx->min_restart_interval;
557
558		✗	ctx->num_substreams = 1;
559
560		✗	channels_present = av_channel_layout_subset(&avctx->ch_layout, ~(uint64_t)0);
561		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
562			static const uint64_t layout_arrangement[] = {
563			AV_CH_LAYOUT_MONO, AV_CH_LAYOUT_STEREO,
564			AV_CH_LAYOUT_2_1, AV_CH_LAYOUT_QUAD,
565			AV_CH_LAYOUT_2POINT1, 0, 0,
566			AV_CH_LAYOUT_SURROUND, AV_CH_LAYOUT_4POINT0,
567			AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_3POINT1,
568			AV_CH_LAYOUT_4POINT1, AV_CH_LAYOUT_5POINT1_BACK,
569			};
570			int i;
571
572		✗	for (i = 0;; i++) {
573		✗	av_assert1(i < FF_ARRAY_ELEMS(layout_arrangement) ||
574			!"Impossible channel layout");
575		✗	if (channels_present == layout_arrangement[i])
576		✗	break;
577			}
578		✗	ctx->channel_arrangement = i;
579		✗	ctx->flags = FLAGS_DVDA;
580		✗	ctx->channel_occupancy = ff_mlp_ch_info[ctx->channel_arrangement].channel_occupancy;
581		✗	ctx->summary_info = ff_mlp_ch_info[ctx->channel_arrangement].summary_info ;
582			} else {
583			/* TrueHD */
584		✗	ctx->num_substreams = 1 + (avctx->ch_layout.nb_channels > 2);
585		✗	switch (channels_present) {
586		✗	case AV_CH_LAYOUT_MONO:
587		✗	ctx->ch2_presentation_mod= 3;
588		✗	ctx->ch6_presentation_mod= 3;
589		✗	ctx->ch8_presentation_mod= 3;
590		✗	ctx->thd_substream_info = 0x14;
591		✗	break;
592		✗	case AV_CH_LAYOUT_STEREO:
593		✗	ctx->ch2_presentation_mod= 1;
594		✗	ctx->ch6_presentation_mod= 1;
595		✗	ctx->ch8_presentation_mod= 1;
596		✗	ctx->thd_substream_info = 0x14;
597		✗	break;
598		✗	case AV_CH_LAYOUT_2POINT1:
599			case AV_CH_LAYOUT_SURROUND:
600			case AV_CH_LAYOUT_3POINT1:
601			case AV_CH_LAYOUT_4POINT0:
602			case AV_CH_LAYOUT_4POINT1:
603			case AV_CH_LAYOUT_5POINT0:
604			case AV_CH_LAYOUT_5POINT1:
605		✗	ctx->ch2_presentation_mod= 0;
606		✗	ctx->ch6_presentation_mod= 0;
607		✗	ctx->ch8_presentation_mod= 0;
608		✗	ctx->thd_substream_info = 0x3C;
609		✗	break;
610		✗	default:
611		✗	av_unreachable("Checked via CODEC_CH_LAYOUTS");
612			}
613		✗	ctx->flags = 0;
614		✗	ctx->channel_occupancy = 0;
615		✗	ctx->summary_info = 0;
616		✗	ctx->channel_arrangement =
617		✗	ctx->channel_arrangement8 = layout_truehd(channels_present);
618			}
619
620		✗	for (unsigned int index = 0; index < ctx->restart_intervals; index++) {
621		✗	for (int n = 0; n < ctx->num_substreams; n++)
622		✗	ctx->s[n].b[index].seq_size = ((index + 1) * ctx->min_restart_interval) + 1;
623			}
624
625
626			/* TODO see if noisegen_seed is really worth it. */
627		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
628		✗	RestartHeader *const rh = &ctx->s[0].restart_header;
629
630		✗	rh->noisegen_seed = 0;
631		✗	rh->min_channel = 0;
632		✗	rh->max_channel = avctx->ch_layout.nb_channels - 1;
633		✗	rh->max_matrix_channel = rh->max_channel;
634			} else {
635		✗	RestartHeader *rh = &ctx->s[0].restart_header;
636
637		✗	rh->noisegen_seed = 0;
638		✗	rh->min_channel = 0;
639		✗	rh->max_channel = FFMIN(avctx->ch_layout.nb_channels, 2) - 1;
640		✗	rh->max_matrix_channel = rh->max_channel;
641
642		✗	if (avctx->ch_layout.nb_channels > 2) {
643		✗	rh = &ctx->s[1].restart_header;
644
645		✗	rh->noisegen_seed = 0;
646		✗	rh->min_channel = 2;
647		✗	rh->max_channel = avctx->ch_layout.nb_channels - 1;
648		✗	rh->max_matrix_channel = rh->max_channel;
649			}
650			}
651
652		✗	if ((ret = ff_lpc_init(&ctx->lpc_ctx, ctx->avctx->frame_size,
653		✗	MLP_MAX_LPC_ORDER, ctx->lpc_type)) < 0)
654		✗	return ret;
655
656		✗	ff_af_queue_init(avctx, &ctx->afq);
657
658		✗	ff_thread_once(&init_static_once, mlp_encode_init_static);
659
660		✗	return 0;
661			}
662
663			/****************************************************************************
664			****************** Functions that write to the bitstream *******************
665			****************************************************************************/
666
667			/** Writes a major sync header to the bitstream. */
668		✗	static void write_major_sync(MLPEncodeContext *ctx, uint8_t *buf, int buf_size)
669			{
670			PutBitContext pb;
671
672		✗	init_put_bits(&pb, buf, buf_size);
673
674		✗	put_bits(&pb, 24, SYNC_MAJOR );
675
676		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
677		✗	put_bits(&pb, 8, SYNC_MLP );
678		✗	put_bits(&pb, 4, ctx->coded_sample_fmt [0]);
679		✗	put_bits(&pb, 4, ctx->coded_sample_fmt [1]);
680		✗	put_bits(&pb, 4, ctx->coded_sample_rate[0]);
681		✗	put_bits(&pb, 4, ctx->coded_sample_rate[1]);
682		✗	put_bits(&pb, 4, 0 ); /* ignored */
683		✗	put_bits(&pb, 4, 0 ); /* multi_channel_type */
684		✗	put_bits(&pb, 3, 0 ); /* ignored */
685		✗	put_bits(&pb, 5, ctx->channel_arrangement );
686		✗	} else if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
687		✗	put_bits(&pb, 8, SYNC_TRUEHD );
688		✗	put_bits(&pb, 4, ctx->coded_sample_rate[0]);
689		✗	put_bits(&pb, 1, ctx->multichannel_type6ch);
690		✗	put_bits(&pb, 1, ctx->multichannel_type8ch);
691		✗	put_bits(&pb, 2, 0 ); /* ignored */
692		✗	put_bits(&pb, 2, ctx->ch2_presentation_mod);
693		✗	put_bits(&pb, 2, ctx->ch6_presentation_mod);
694		✗	put_bits(&pb, 5, ctx->channel_arrangement );
695		✗	put_bits(&pb, 2, ctx->ch8_presentation_mod);
696		✗	put_bits(&pb, 13, ctx->channel_arrangement8);
697			}
698
699		✗	put_bits(&pb, 16, MAJOR_SYNC_INFO_SIGNATURE);
700		✗	put_bits(&pb, 16, ctx->flags );
701		✗	put_bits(&pb, 16, 0 ); /* ignored */
702		✗	put_bits(&pb, 1, 1 ); /* is_vbr */
703		✗	put_bits(&pb, 15, ctx->coded_peak_bitrate );
704		✗	put_bits(&pb, 4, ctx->num_substreams );
705		✗	put_bits(&pb, 2, 0 ); /* ignored */
706		✗	put_bits(&pb, 2, 0 ); /* extended substream info */
707
708			/* channel_meaning */
709		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
710		✗	put_bits(&pb, 8, ctx->substream_info );
711		✗	put_bits(&pb, 5, ctx->fs );
712		✗	put_bits(&pb, 5, ctx->wordlength );
713		✗	put_bits(&pb, 6, ctx->channel_occupancy );
714		✗	put_bits(&pb, 3, 0 ); /* ignored */
715		✗	put_bits(&pb, 10, 0 ); /* speaker_layout */
716		✗	put_bits(&pb, 3, 0 ); /* copy_protection */
717		✗	put_bits(&pb, 16, 0x8080 ); /* ignored */
718		✗	put_bits(&pb, 7, 0 ); /* ignored */
719		✗	put_bits(&pb, 4, 0 ); /* source_format */
720		✗	put_bits(&pb, 5, ctx->summary_info );
721		✗	} else if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
722		✗	put_bits(&pb, 8, ctx->thd_substream_info );
723		✗	put_bits(&pb, 6, 0 ); /* reserved */
724		✗	put_bits(&pb, 1, 0 ); /* 2ch control enabled */
725		✗	put_bits(&pb, 1, 0 ); /* 6ch control enabled */
726		✗	put_bits(&pb, 1, 0 ); /* 8ch control enabled */
727		✗	put_bits(&pb, 1, 0 ); /* reserved */
728		✗	put_bits(&pb, 7, 0 ); /* drc start up gain */
729		✗	put_bits(&pb, 6, 0 ); /* 2ch dialogue norm */
730		✗	put_bits(&pb, 6, 0 ); /* 2ch mix level */
731		✗	put_bits(&pb, 5, 0 ); /* 6ch dialogue norm */
732		✗	put_bits(&pb, 6, 0 ); /* 6ch mix level */
733		✗	put_bits(&pb, 5, 0 ); /* 6ch source format */
734		✗	put_bits(&pb, 5, 0 ); /* 8ch dialogue norm */
735		✗	put_bits(&pb, 6, 0 ); /* 8ch mix level */
736		✗	put_bits(&pb, 6, 0 ); /* 8ch source format */
737		✗	put_bits(&pb, 1, 0 ); /* reserved */
738		✗	put_bits(&pb, 1, 0 ); /* extra channel meaning present */
739			}
740
741		✗	flush_put_bits(&pb);
742
743		✗	AV_WL16(buf+26, ff_mlp_checksum16(buf, 26));
744		✗	}
745
746			/** Writes a restart header to the bitstream. Damaged streams can start being
747			* decoded losslessly again after such a header and the subsequent decoding
748			* params header.
749			*/
750		✗	static void write_restart_header(MLPEncodeContext *ctx, MLPSubstream *s,
751			PutBitContext *pb)
752			{
753		✗	RestartHeader *rh = s->cur_restart_header;
754		✗	uint8_t lossless_check = xor_32_to_8(rh->lossless_check_data);
755		✗	unsigned int start_count = put_bits_count(pb);
756			PutBitContext tmpb;
757			uint8_t checksum;
758
759		✗	put_bits(pb, 14, 0x31ea ); /* TODO 0x31eb */
760		✗	put_bits(pb, 16, ctx->output_timing );
761		✗	put_bits(pb, 4, rh->min_channel );
762		✗	put_bits(pb, 4, rh->max_channel );
763		✗	put_bits(pb, 4, rh->max_matrix_channel);
764		✗	put_bits(pb, 4, rh->noise_shift );
765		✗	put_bits(pb, 23, rh->noisegen_seed );
766		✗	put_bits(pb, 4, rh->max_shift );
767		✗	put_bits(pb, 5, rh->max_huff_lsbs );
768		✗	put_bits(pb, 5, rh->max_output_bits );
769		✗	put_bits(pb, 5, rh->max_output_bits );
770		✗	put_bits(pb, 1, rh->data_check_present);
771		✗	put_bits(pb, 8, lossless_check );
772		✗	put_bits(pb, 16, 0 ); /* ignored */
773
774		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
775		✗	put_bits(pb, 6, ch);
776
777			/* Data must be flushed for the checksum to be correct. */
778		✗	tmpb = *pb;
779		✗	flush_put_bits(&tmpb);
780
781		✗	checksum = ff_mlp_restart_checksum(pb->buf, put_bits_count(pb) - start_count);
782
783		✗	put_bits(pb, 8, checksum);
784		✗	}
785
786			/** Writes matrix params for all primitive matrices to the bitstream. */
787		✗	static void write_matrix_params(MLPEncodeContext *ctx,
788			MLPSubstream *s,
789			DecodingParams *dp,
790			PutBitContext *pb)
791			{
792		✗	RestartHeader *rh = s->cur_restart_header;
793		✗	MatrixParams *mp = &dp->matrix_params;
794		✗	int max_channel = rh->max_matrix_channel;
795
796		✗	put_bits(pb, 4, mp->count);
797
798		✗	if (!ctx->noise_type)
799		✗	max_channel += 2;
800
801		✗	for (unsigned int mat = 0; mat < mp->count; mat++) {
802		✗	put_bits(pb, 4, mp->outch[mat]); /* matrix_out_ch */
803		✗	put_bits(pb, 4, mp->fbits[mat]);
804		✗	put_bits(pb, 1, mp->lsb_bypass[mat]);
805
806		✗	for (int ch = 0; ch <= max_channel; ch++) {
807		✗	int32_t coeff = mp->coeff[mat][ch];
808
809		✗	if (coeff) {
810		✗	put_bits(pb, 1, 1);
811
812		✗	coeff >>= 14 - mp->fbits[mat];
813
814		✗	put_sbits(pb, mp->fbits[mat] + 2, coeff);
815			} else {
816		✗	put_bits(pb, 1, 0);
817			}
818			}
819			}
820		✗	}
821
822			/** Writes filter parameters for one filter to the bitstream. */
823		✗	static void write_filter_params(MLPEncodeContext *ctx,
824			ChannelParams *cp,
825			PutBitContext *pb,
826			int channel, unsigned int filter)
827			{
828		✗	FilterParams *fp = &cp->filter_params[filter];
829
830		✗	put_bits(pb, 4, fp->order);
831
832		✗	if (fp->order > 0) {
833		✗	int32_t *fcoeff = cp->coeff[filter];
834
835		✗	put_bits(pb, 4, fp->shift );
836		✗	put_bits(pb, 5, fp->coeff_bits );
837		✗	put_bits(pb, 3, fp->coeff_shift);
838
839		✗	for (int i = 0; i < fp->order; i++) {
840		✗	put_sbits(pb, fp->coeff_bits, fcoeff[i] >> fp->coeff_shift);
841			}
842
843			/* TODO state data for IIR filter. */
844		✗	put_bits(pb, 1, 0);
845			}
846		✗	}
847
848			/** Writes decoding parameters to the bitstream. These change very often,
849			* usually at almost every frame.
850			*/
851		✗	static void write_decoding_params(MLPEncodeContext *ctx, MLPSubstream *s,
852			PutBitContext *pb, int params_changed,
853			unsigned int subblock_index)
854			{
855		✗	DecodingParams *dp = &s->b[subblock_index].major_decoding_params;
856		✗	RestartHeader *rh = s->cur_restart_header;
857
858		✗	if (dp->param_presence_flags != PARAMS_DEFAULT &&
859		✗	params_changed & PARAM_PRESENCE_FLAGS) {
860		✗	put_bits(pb, 1, 1);
861		✗	put_bits(pb, 8, dp->param_presence_flags);
862			} else {
863		✗	put_bits(pb, 1, 0);
864			}
865
866		✗	if (dp->param_presence_flags & PARAM_BLOCKSIZE) {
867		✗	if (params_changed & PARAM_BLOCKSIZE) {
868		✗	put_bits(pb, 1, 1);
869		✗	put_bits(pb, 9, dp->blocksize);
870			} else {
871		✗	put_bits(pb, 1, 0);
872			}
873			}
874
875		✗	if (dp->param_presence_flags & PARAM_MATRIX) {
876		✗	if (params_changed & PARAM_MATRIX) {
877		✗	put_bits(pb, 1, 1);
878		✗	write_matrix_params(ctx, s, dp, pb);
879			} else {
880		✗	put_bits(pb, 1, 0);
881			}
882			}
883
884		✗	if (dp->param_presence_flags & PARAM_OUTSHIFT) {
885		✗	if (params_changed & PARAM_OUTSHIFT) {
886		✗	put_bits(pb, 1, 1);
887		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
888		✗	put_sbits(pb, 4, dp->output_shift[ch]);
889			} else {
890		✗	put_bits(pb, 1, 0);
891			}
892			}
893
894		✗	if (dp->param_presence_flags & PARAM_QUANTSTEP) {
895		✗	if (params_changed & PARAM_QUANTSTEP) {
896		✗	put_bits(pb, 1, 1);
897		✗	for (int ch = 0; ch <= rh->max_channel; ch++)
898		✗	put_bits(pb, 4, dp->quant_step_size[ch]);
899			} else {
900		✗	put_bits(pb, 1, 0);
901			}
902			}
903
904		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
905		✗	ChannelParams *cp = &s->b[subblock_index].major_channel_params[ch];
906
907		✗	if (dp->param_presence_flags & 0xF) {
908		✗	put_bits(pb, 1, 1);
909
910		✗	if (dp->param_presence_flags & PARAM_FIR) {
911		✗	if (params_changed & PARAM_FIR) {
912		✗	put_bits(pb, 1, 1);
913		✗	write_filter_params(ctx, cp, pb, ch, FIR);
914			} else {
915		✗	put_bits(pb, 1, 0);
916			}
917			}
918
919		✗	if (dp->param_presence_flags & PARAM_IIR) {
920		✗	if (params_changed & PARAM_IIR) {
921		✗	put_bits(pb, 1, 1);
922		✗	write_filter_params(ctx, cp, pb, ch, IIR);
923			} else {
924		✗	put_bits(pb, 1, 0);
925			}
926			}
927
928		✗	if (dp->param_presence_flags & PARAM_HUFFOFFSET) {
929		✗	if (params_changed & PARAM_HUFFOFFSET) {
930		✗	put_bits (pb, 1, 1);
931		✗	put_sbits(pb, 15, cp->huff_offset);
932			} else {
933		✗	put_bits(pb, 1, 0);
934			}
935			}
936		✗	if (cp->codebook > 0 && cp->huff_lsbs > 24) {
937		✗	av_log(ctx->avctx, AV_LOG_ERROR, "Invalid Huff LSBs %d\n", cp->huff_lsbs);
938			}
939
940		✗	put_bits(pb, 2, cp->codebook );
941		✗	put_bits(pb, 5, cp->huff_lsbs);
942			} else {
943		✗	put_bits(pb, 1, 0);
944			}
945			}
946		✗	}
947
948			/** Writes the residuals to the bitstream. That is, the VLC codes from the
949			* codebooks (if any is used), and then the residual.
950			*/
951		✗	static void write_block_data(MLPEncodeContext *ctx, MLPSubstream *s,
952			PutBitContext *pb, unsigned int subblock_index)
953			{
954		✗	RestartHeader *rh = s->cur_restart_header;
955		✗	DecodingParams *dp = &s->b[subblock_index].major_decoding_params;
956		✗	MatrixParams *mp = &dp->matrix_params;
957			int32_t sign_huff_offset[MAX_CHANNELS];
958			int codebook_index [MAX_CHANNELS];
959			int lsb_bits [MAX_CHANNELS];
960
961		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
962		✗	ChannelParams *cp = &s->b[subblock_index].major_channel_params[ch];
963			int sign_shift;
964
965		✗	lsb_bits [ch] = cp->huff_lsbs - dp->quant_step_size[ch];
966		✗	codebook_index [ch] = cp->codebook - 1;
967		✗	sign_huff_offset[ch] = cp->huff_offset;
968
969		✗	sign_shift = lsb_bits[ch] + (cp->codebook ? 2 - cp->codebook : -1);
970
971		✗	if (cp->codebook > 0)
972		✗	sign_huff_offset[ch] -= 7 << lsb_bits[ch];
973
974			/* Unsign if needed. */
975		✗	if (sign_shift >= 0)
976		✗	sign_huff_offset[ch] -= 1 << sign_shift;
977			}
978
979		✗	for (unsigned int i = 0; i < dp->blocksize; i++) {
980		✗	for (unsigned int mat = 0; mat < mp->count; mat++) {
981		✗	if (mp->lsb_bypass[mat]) {
982		✗	const int8_t *bypassed_lsbs = mp->bypassed_lsbs[mat];
983
984		✗	put_bits(pb, 1, bypassed_lsbs[i]);
985			}
986			}
987
988		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
989		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
990		✗	int32_t sample = sample_buffer[i] >> dp->quant_step_size[ch];
991		✗	sample -= sign_huff_offset[ch];
992
993		✗	if (codebook_index[ch] >= 0) {
994		✗	int vlc = sample >> lsb_bits[ch];
995		✗	put_bits(pb, ff_mlp_huffman_tables[codebook_index[ch]][vlc][1],
996		✗	ff_mlp_huffman_tables[codebook_index[ch]][vlc][0]);
997		✗	sample &= ((1 << lsb_bits[ch]) - 1);
998			}
999
1000		✗	put_bits(pb, lsb_bits[ch], sample);
1001			}
1002			}
1003		✗	}
1004
1005			/** Writes the substream data to the bitstream. */
1006		✗	static uint8_t *write_substr(MLPEncodeContext *ctx,
1007			MLPSubstream *s,
1008			uint8_t *buf, int buf_size,
1009			int restart_frame,
1010			uint16_t *substream_data_len)
1011			{
1012		✗	int32_t *lossless_check_data = &s->b[ctx->frame_index].lossless_check_data;
1013		✗	unsigned int cur_subblock_index = s->major_cur_subblock_index;
1014		✗	unsigned int num_subblocks = s->major_filter_state_subblock;
1015		✗	RestartHeader *rh = &s->restart_header;
1016		✗	int substr_restart_frame = restart_frame;
1017			uint8_t parity, checksum;
1018			PutBitContext pb;
1019			int params_changed;
1020
1021		✗	s->cur_restart_header = rh;
1022
1023		✗	init_put_bits(&pb, buf, buf_size);
1024
1025		✗	for (unsigned int subblock = 0; subblock <= num_subblocks; subblock++) {
1026		✗	unsigned int subblock_index = cur_subblock_index++;
1027
1028		✗	params_changed = s->b[subblock_index].major_params_changed;
1029
1030		✗	if (substr_restart_frame || params_changed) {
1031		✗	put_bits(&pb, 1, 1);
1032
1033		✗	if (substr_restart_frame) {
1034		✗	put_bits(&pb, 1, 1);
1035
1036		✗	write_restart_header(ctx, s, &pb);
1037		✗	rh->lossless_check_data = 0;
1038			} else {
1039		✗	put_bits(&pb, 1, 0);
1040			}
1041
1042		✗	write_decoding_params(ctx, s, &pb, params_changed,
1043			subblock_index);
1044			} else {
1045		✗	put_bits(&pb, 1, 0);
1046			}
1047
1048		✗	write_block_data(ctx, s, &pb, subblock_index);
1049
1050		✗	put_bits(&pb, 1, !substr_restart_frame);
1051
1052		✗	substr_restart_frame = 0;
1053			}
1054
1055		✗	put_bits(&pb, (-put_bits_count(&pb)) & 15, 0);
1056
1057		✗	rh->lossless_check_data ^= lossless_check_data[0];
1058
1059		✗	if (ctx->last_frames == 0 && ctx->shorten_by) {
1060		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
1061		✗	put_bits(&pb, 16, END_OF_STREAM & 0xFFFF);
1062		✗	put_bits(&pb, 16, (ctx->shorten_by & 0x1FFF) | 0xE000);
1063			} else {
1064		✗	put_bits32(&pb, END_OF_STREAM);
1065			}
1066			}
1067
1068			/* Data must be flushed for the checksum and parity to be correct;
1069			* notice that we already are word-aligned here. */
1070		✗	flush_put_bits(&pb);
1071
1072		✗	parity = ff_mlp_calculate_parity(buf, put_bytes_output(&pb)) ^ 0xa9;
1073		✗	checksum = ff_mlp_checksum8 (buf, put_bytes_output(&pb));
1074
1075		✗	put_bits(&pb, 8, parity );
1076		✗	put_bits(&pb, 8, checksum);
1077
1078		✗	flush_put_bits(&pb);
1079
1080		✗	substream_data_len[0] = put_bytes_output(&pb);
1081
1082		✗	buf += substream_data_len[0];
1083
1084		✗	s->major_cur_subblock_index += s->major_filter_state_subblock + 1;
1085		✗	s->major_filter_state_subblock = 0;
1086
1087		✗	return buf;
1088			}
1089
1090			/** Writes the access unit and substream headers to the bitstream. */
1091		✗	static void write_frame_headers(MLPEncodeContext *ctx, uint8_t *frame_header,
1092			uint8_t *substream_headers, unsigned int length,
1093			int restart_frame,
1094			uint16_t substream_data_len[MAX_SUBSTREAMS])
1095			{
1096		✗	uint16_t access_unit_header = 0;
1097		✗	uint16_t substream_data_end = 0;
1098		✗	uint16_t parity_nibble = 0;
1099
1100		✗	parity_nibble = ctx->input_timing;
1101		✗	parity_nibble ^= length;
1102
1103		✗	for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
1104		✗	uint16_t substr_hdr = 0;
1105
1106		✗	substream_data_end += substream_data_len[substr];
1107
1108		✗	substr_hdr |= (0 << 15); /* extraword */
1109		✗	substr_hdr |= (!restart_frame << 14); /* !restart_frame */
1110		✗	substr_hdr |= (1 << 13); /* checkdata */
1111		✗	substr_hdr |= (0 << 12); /* ??? */
1112		✗	substr_hdr |= (substream_data_end / 2) & 0x0FFF;
1113
1114		✗	AV_WB16(substream_headers, substr_hdr);
1115
1116		✗	parity_nibble ^= *substream_headers++;
1117		✗	parity_nibble ^= *substream_headers++;
1118			}
1119
1120		✗	parity_nibble ^= parity_nibble >> 8;
1121		✗	parity_nibble ^= parity_nibble >> 4;
1122		✗	parity_nibble &= 0xF;
1123
1124		✗	access_unit_header |= (parity_nibble ^ 0xF) << 12;
1125		✗	access_unit_header |= length & 0xFFF;
1126
1127		✗	AV_WB16(frame_header , access_unit_header);
1128		✗	AV_WB16(frame_header+2, ctx->input_timing );
1129		✗	}
1130
1131			/** Writes an entire access unit to the bitstream. */
1132		✗	static int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf,
1133			int buf_size, int restart_frame)
1134			{
1135			uint16_t substream_data_len[MAX_SUBSTREAMS];
1136		✗	uint8_t *buf1, *buf0 = buf;
1137			int total_length;
1138
1139			/* Frame header will be written at the end. */
1140		✗	buf += 4;
1141		✗	buf_size -= 4;
1142
1143		✗	if (restart_frame) {
1144		✗	write_major_sync(ctx, buf, buf_size);
1145		✗	buf += 28;
1146		✗	buf_size -= 28;
1147			}
1148
1149		✗	buf1 = buf;
1150
1151			/* Substream headers will be written at the end. */
1152		✗	for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
1153		✗	buf += 2;
1154		✗	buf_size -= 2;
1155			}
1156
1157		✗	for (int substr = 0; substr < ctx->num_substreams; substr++) {
1158		✗	MLPSubstream *s = &ctx->s[substr];
1159		✗	uint8_t *buf0 = buf;
1160
1161		✗	buf = write_substr(ctx, s, buf, buf_size, restart_frame, &substream_data_len[substr]);
1162		✗	buf_size -= buf - buf0;
1163			}
1164
1165		✗	total_length = buf - buf0;
1166
1167		✗	write_frame_headers(ctx, buf0, buf1, total_length / 2, restart_frame, substream_data_len);
1168
1169		✗	return total_length;
1170			}
1171
1172			/****************************************************************************
1173			****************** Functions that input data to context ********************
1174			****************************************************************************/
1175
1176			/** Inputs data from the samples passed by lavc into the context, shifts them
1177			* appropriately depending on the bit-depth, and calculates the
1178			* lossless_check_data that will be written to the restart header.
1179			*/
1180		✗	static void input_data_internal(MLPEncodeContext *ctx, MLPSubstream *s,
1181			uint8_t **const samples,
1182			int nb_samples, int is24)
1183			{
1184		✗	int32_t *lossless_check_data = &s->b[ctx->frame_index].lossless_check_data;
1185		✗	RestartHeader *rh = &s->restart_header;
1186		✗	int32_t temp_lossless_check_data = 0;
1187		✗	uint32_t bits = 0;
1188
1189		✗	for (int i = 0; i < nb_samples; i++) {
1190		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1191		✗	const int32_t *samples_32 = (const int32_t *)samples[ch];
1192		✗	const int16_t *samples_16 = (const int16_t *)samples[ch];
1193		✗	int32_t *sample_buffer = s->b[ctx->frame_index].inout_buffer[ch];
1194			int32_t sample;
1195
1196		✗	sample = is24 ? samples_32[i] >> 8 : samples_16[i] * 256;
1197
1198		✗	bits = FFMAX(number_sbits(sample), bits);
1199
1200		✗	temp_lossless_check_data ^= (sample & 0x00ffffff) << ch;
1201		✗	sample_buffer[i] = sample;
1202			}
1203			}
1204
1205		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1206		✗	for (int i = nb_samples; i < ctx->avctx->frame_size; i++) {
1207		✗	int32_t *sample_buffer = s->b[ctx->frame_index].inout_buffer[ch];
1208
1209		✗	sample_buffer[i] = 0;
1210			}
1211			}
1212
1213		✗	s->b[ctx->frame_index].max_output_bits = bits;
1214
1215		✗	lossless_check_data[0] = temp_lossless_check_data;
1216		✗	}
1217
1218			/** Wrapper function for inputting data in two different bit-depths. */
1219		✗	static void input_data(MLPEncodeContext *ctx, MLPSubstream *s, uint8_t **const samples, int nb_samples)
1220			{
1221		✗	input_data_internal(ctx, s, samples, nb_samples, ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S32P);
1222		✗	}
1223
1224		✗	static void input_to_sample_buffer(MLPEncodeContext *ctx, MLPSubstream *s)
1225			{
1226		✗	RestartHeader *rh = &s->restart_header;
1227
1228		✗	for (unsigned int index = 0; index < ctx->number_of_frames; index++) {
1229		✗	unsigned int cur_index = (ctx->frame_index + index + 1) % ctx->cur_restart_interval;
1230		✗	DecodingParams *dp = &s->b[index+1].decoding_params;
1231
1232		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1233		✗	const int32_t *input_buffer = s->b[cur_index].inout_buffer[ch];
1234		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1235		✗	int off = 0;
1236
1237		✗	if (dp->blocksize < ctx->avctx->frame_size) {
1238		✗	DecodingParams *dp = &s->b[index].decoding_params;
1239		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1240		✗	for (unsigned int i = 0; i < dp->blocksize; i++)
1241		✗	sample_buffer[i] = input_buffer[i];
1242		✗	off = dp->blocksize;
1243			}
1244
1245		✗	for (unsigned int i = 0; i < dp->blocksize; i++)
1246		✗	sample_buffer[i] = input_buffer[i + off];
1247			}
1248			}
1249		✗	}
1250
1251			/****************************************************************************
1252			********* Functions that analyze the data and set the parameters ***********
1253			****************************************************************************/
1254
1255			/** Counts the number of trailing zeroes in a value */
1256		✗	static int number_trailing_zeroes(int32_t sample, unsigned int max, unsigned int def)
1257			{
1258		✗	return sample ? FFMIN(max, ff_ctz(sample)) : def;
1259			}
1260
1261		✗	static void determine_output_shift(MLPEncodeContext *ctx, MLPSubstream *s)
1262			{
1263		✗	RestartHeader *rh = s->cur_restart_header;
1264		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1265			int32_t sample_mask[MAX_CHANNELS];
1266
1267		✗	memset(sample_mask, 0, sizeof(sample_mask));
1268
1269		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1270		✗	DecodingParams *dp = &s->b[j].decoding_params;
1271
1272		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++) {
1273		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1274
1275		✗	for (int i = 0; i < dp->blocksize; i++)
1276		✗	sample_mask[ch] |= sample_buffer[i];
1277			}
1278			}
1279
1280		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
1281		✗	dp1->output_shift[ch] = number_trailing_zeroes(sample_mask[ch], 7, 0);
1282
1283		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1284		✗	DecodingParams *dp = &s->b[j].decoding_params;
1285
1286		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++) {
1287		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1288		✗	const int shift = dp1->output_shift[ch];
1289
1290		✗	for (int i = 0; i < dp->blocksize; i++)
1291		✗	sample_buffer[i] >>= shift;
1292			}
1293			}
1294		✗	}
1295
1296			/** Determines how many bits are zero at the end of all samples so they can be
1297			* shifted out.
1298			*/
1299		✗	static void determine_quant_step_size(MLPEncodeContext *ctx, MLPSubstream *s)
1300			{
1301		✗	RestartHeader *rh = s->cur_restart_header;
1302		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1303			int32_t sample_mask[MAX_CHANNELS];
1304
1305		✗	memset(sample_mask, 0, sizeof(sample_mask));
1306
1307		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1308		✗	DecodingParams *dp = &s->b[j].decoding_params;
1309
1310		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1311		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1312
1313		✗	for (int i = 0; i < dp->blocksize; i++)
1314		✗	sample_mask[ch] |= sample_buffer[i];
1315			}
1316			}
1317
1318		✗	for (int ch = 0; ch <= rh->max_channel; ch++)
1319		✗	dp1->quant_step_size[ch] = number_trailing_zeroes(sample_mask[ch], 15, 0);
1320		✗	}
1321
1322			/** Determines the smallest number of bits needed to encode the filter
1323			* coefficients, and if it's possible to right-shift their values without
1324			* losing any precision.
1325			*/
1326		✗	static void code_filter_coeffs(MLPEncodeContext *ctx, FilterParams *fp, const int32_t *fcoeff)
1327			{
1328		✗	uint32_t coeff_mask = 0;
1329		✗	int bits = 0, shift;
1330
1331		✗	for (int order = 0; order < fp->order; order++) {
1332		✗	int32_t coeff = fcoeff[order];
1333
1334		✗	bits = FFMAX(number_sbits(coeff), bits);
1335
1336		✗	coeff_mask |= coeff;
1337			}
1338
1339		✗	shift = FFMIN(7, coeff_mask ? ff_ctz(coeff_mask) : 0);
1340
1341		✗	fp->coeff_bits = FFMAX(1, bits - shift);
1342		✗	fp->coeff_shift = FFMIN(shift, 16 - fp->coeff_bits);
1343		✗	}
1344
1345			/** Determines the best filter parameters for the given data and writes the
1346			* necessary information to the context.
1347			*/
1348		✗	static void set_filter(MLPEncodeContext *ctx, MLPSubstream *s,
1349			int channel, int retry_filter)
1350			{
1351		✗	ChannelParams *cp = &s->b[1].channel_params[channel];
1352		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1353		✗	FilterParams *fp = &cp->filter_params[FIR];
1354
1355		✗	if (retry_filter)
1356		✗	dp1->max_order[channel]--;
1357
1358		✗	if (dp1->max_order[channel] == 0) {
1359		✗	fp->order = 0;
1360			} else {
1361		✗	int32_t *lpc_samples = ctx->lpc_sample_buffer;
1362		✗	int32_t *fcoeff = cp->coeff[FIR];
1363			int shift[MAX_LPC_ORDER];
1364			int order;
1365
1366		✗	for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) {
1367		✗	DecodingParams *dp = &s->b[j].decoding_params;
1368		✗	int32_t *sample_buffer = dp->sample_buffer[channel];
1369
1370		✗	for (unsigned int i = 0; i < dp->blocksize; i++)
1371		✗	lpc_samples[i] = sample_buffer[i];
1372		✗	lpc_samples += dp->blocksize;
1373			}
1374
1375		✗	order = ff_lpc_calc_coefs(&ctx->lpc_ctx, ctx->lpc_sample_buffer,
1376		✗	lpc_samples - ctx->lpc_sample_buffer,
1377		✗	MLP_MIN_LPC_ORDER, dp1->max_order[channel],
1378			ctx->lpc_coeff_precision,
1379		✗	s->coefs[channel], shift, ctx->lpc_type, ctx->lpc_passes,
1380			ctx->prediction_order, MLP_MIN_LPC_SHIFT,
1381			MLP_MAX_LPC_SHIFT, 0);
1382
1383		✗	fp->order = order;
1384		✗	fp->shift = order ? shift[order-1] : 0;
1385
1386		✗	for (unsigned int i = 0; i < order; i++)
1387		✗	fcoeff[i] = s->coefs[channel][order-1][i];
1388
1389		✗	code_filter_coeffs(ctx, fp, fcoeff);
1390			}
1391		✗	}
1392
1393			/** Tries to determine a good prediction filter, and applies it to the samples
1394			* buffer if the filter is good enough. Sets the filter data to be cleared if
1395			* no good filter was found.
1396			*/
1397		✗	static void determine_filters(MLPEncodeContext *ctx, MLPSubstream *s)
1398			{
1399		✗	RestartHeader *rh = s->cur_restart_header;
1400
1401		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++)
1402		✗	set_filter(ctx, s, ch, 0);
1403		✗	}
1404
1405		✗	static int estimate_coeff(MLPEncodeContext *ctx, MLPSubstream *s,
1406			MatrixParams *mp,
1407			int ch0, int ch1)
1408			{
1409		✗	int32_t maxl = INT32_MIN, maxr = INT32_MIN, minl = INT32_MAX, minr = INT32_MAX;
1410		✗	int64_t summ = 0, sums = 0, suml = 0, sumr = 0, enl = 0, enr = 0;
1411		✗	const int shift = 14 - ctx->rematrix_precision;
1412			int32_t cf0, cf1, e[4], d[4];
1413			int64_t ml, mr;
1414		✗	int i, count = 0;
1415
1416		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1417		✗	DecodingParams *dp = &s->b[j].decoding_params;
1418			const int32_t *ch[2];
1419
1420		✗	ch[0] = dp->sample_buffer[ch0];
1421		✗	ch[1] = dp->sample_buffer[ch1];
1422
1423		✗	for (int i = 0; i < dp->blocksize; i++) {
1424		✗	int32_t lm = ch[0][i], rm = ch[1][i];
1425
1426		✗	enl += FFABS(lm);
1427		✗	enr += FFABS(rm);
1428
1429		✗	summ += FFABS(lm + rm);
1430		✗	sums += FFABS(lm - rm);
1431
1432		✗	suml += lm;
1433		✗	sumr += rm;
1434
1435		✗	maxl = FFMAX(maxl, lm);
1436		✗	maxr = FFMAX(maxr, rm);
1437
1438		✗	minl = FFMIN(minl, lm);
1439		✗	minr = FFMIN(minr, rm);
1440			}
1441			}
1442
1443		✗	summ -= FFABS(suml + sumr);
1444		✗	sums -= FFABS(suml - sumr);
1445
1446		✗	ml = maxl - (int64_t)minl;
1447		✗	mr = maxr - (int64_t)minr;
1448
1449		✗	if (!summ && !sums)
1450		✗	return 0;
1451
1452		✗	if (!ml || !mr)
1453		✗	return 0;
1454
1455		✗	if ((FFABS(ml) + FFABS(mr)) >= (1 << 24))
1456		✗	return 0;
1457
1458		✗	cf0 = (FFMIN(FFABS(mr), FFABS(ml)) * (1LL << 14)) / FFMAX(FFABS(ml), FFABS(mr));
1459		✗	cf0 = (cf0 >> shift) << shift;
1460		✗	cf1 = -cf0;
1461
1462		✗	if (sums > summ)
1463		✗	FFSWAP(int32_t, cf0, cf1);
1464
1465		✗	count = 1;
1466		✗	i = enl < enr;
1467		✗	mp->outch[0] = ch0 + i;
1468
1469		✗	d[!i] = cf0;
1470		✗	d[ i] = 1 << 14;
1471		✗	e[!i] = cf1;
1472		✗	e[ i] = 1 << 14;
1473
1474		✗	mp->coeff[0][ch0] = av_clip_intp2(d[0], 15);
1475		✗	mp->coeff[0][ch1] = av_clip_intp2(d[1], 15);
1476
1477		✗	mp->forco[0][ch0] = av_clip_intp2(e[0], 15);
1478		✗	mp->forco[0][ch1] = av_clip_intp2(e[1], 15);
1479
1480		✗	return count;
1481			}
1482
1483			/** Determines how many fractional bits are needed to encode matrix
1484			* coefficients. Also shifts the coefficients to fit within 2.14 bits.
1485			*/
1486		✗	static void code_matrix_coeffs(MLPEncodeContext *ctx, MLPSubstream *s,
1487			DecodingParams *dp,
1488			unsigned int mat)
1489			{
1490		✗	RestartHeader *rh = s->cur_restart_header;
1491		✗	MatrixParams *mp = &dp->matrix_params;
1492		✗	int32_t coeff_mask = 0;
1493
1494		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
1495		✗	coeff_mask |= mp->coeff[mat][ch];
1496
1497		✗	mp->fbits[mat] = 14 - number_trailing_zeroes(coeff_mask, 14, 14);
1498		✗	}
1499
1500			/** Determines best coefficients to use for the lossless matrix. */
1501		✗	static void lossless_matrix_coeffs(MLPEncodeContext *ctx, MLPSubstream *s)
1502			{
1503		✗	RestartHeader *rh = s->cur_restart_header;
1504		✗	DecodingParams *dp = &s->b[1].decoding_params;
1505		✗	MatrixParams *mp = &dp->matrix_params;
1506
1507		✗	mp->count = 0;
1508		✗	if (ctx->num_channels - 2 != 2)
1509		✗	return;
1510
1511		✗	mp->count = estimate_coeff(ctx, s, mp,
1512		✗	rh->min_channel, rh->max_channel);
1513
1514		✗	for (int mat = 0; mat < mp->count; mat++)
1515		✗	code_matrix_coeffs(ctx, s, dp, mat);
1516			}
1517
1518			/** Min and max values that can be encoded with each codebook. The values for
1519			* the third codebook take into account the fact that the sign shift for this
1520			* codebook is outside the coded value, so it has one more bit of precision.
1521			* It should actually be -7 -> 7, shifted down by 0.5.
1522			*/
1523			static const int8_t codebook_extremes[3][2] = {
1524			{-9, 8}, {-8, 7}, {-15, 14},
1525			};
1526
1527			/** Determines the amount of bits needed to encode the samples using no
1528			* codebooks and a specified offset.
1529			*/
1530		✗	static void no_codebook_bits_offset(MLPEncodeContext *ctx,
1531			DecodingParams *dp,
1532			int channel, int32_t offset,
1533			int32_t min, int32_t max,
1534			BestOffset *bo)
1535			{
1536		✗	int32_t unsign = 0;
1537			int lsb_bits;
1538
1539		✗	min -= offset;
1540		✗	max -= offset;
1541
1542		✗	lsb_bits = FFMAX(number_sbits(min), number_sbits(max)) - 1;
1543
1544		✗	lsb_bits += !!lsb_bits;
1545
1546		✗	if (lsb_bits > 0)
1547		✗	unsign = 1U << (lsb_bits - 1);
1548
1549		✗	bo->offset = offset;
1550		✗	bo->lsb_bits = lsb_bits;
1551		✗	bo->bitcount = lsb_bits * dp->blocksize;
1552		✗	bo->min = offset - unsign + 1;
1553		✗	bo->max = offset + unsign;
1554		✗	}
1555
1556			/** Determines the least amount of bits needed to encode the samples using no
1557			* codebooks.
1558			*/
1559		✗	static void no_codebook_bits(MLPEncodeContext *ctx,
1560			DecodingParams *dp,
1561			int channel,
1562			int32_t min, int32_t max,
1563			BestOffset *bo)
1564			{
1565		✗	int32_t offset, unsign = 0;
1566			uint8_t lsb_bits;
1567
1568			/* Set offset inside huffoffset's boundaries by adjusting extremes
1569			* so that more bits are used, thus shifting the offset. */
1570		✗	if (min < HUFF_OFFSET_MIN)
1571		✗	max = FFMAX(max, 2 * HUFF_OFFSET_MIN - min + 1);
1572		✗	if (max > HUFF_OFFSET_MAX)
1573		✗	min = FFMIN(min, 2 * HUFF_OFFSET_MAX - max - 1);
1574
1575		✗	lsb_bits = FFMAX(number_sbits(min), number_sbits(max));
1576
1577		✗	if (lsb_bits > 0)
1578		✗	unsign = 1 << (lsb_bits - 1);
1579
1580			/* If all samples are the same (lsb_bits == 0), offset must be
1581			* adjusted because of sign_shift. */
1582		✗	offset = min + (max - min) / 2 + !!lsb_bits;
1583
1584		✗	bo->offset = offset;
1585		✗	bo->lsb_bits = lsb_bits;
1586		✗	bo->bitcount = lsb_bits * dp->blocksize;
1587		✗	bo->min = max - unsign + 1;
1588		✗	bo->max = min + unsign;
1589		✗	bo->min = FFMAX(bo->min, HUFF_OFFSET_MIN);
1590		✗	bo->max = FFMIN(bo->max, HUFF_OFFSET_MAX);
1591		✗	}
1592
1593			/** Determines the least amount of bits needed to encode the samples using a
1594			* given codebook and a given offset.
1595			*/
1596		✗	static inline void codebook_bits_offset(MLPEncodeContext *ctx,
1597			DecodingParams *dp,
1598			int channel, int codebook,
1599			int32_t sample_min, int32_t sample_max,
1600			int32_t offset, BestOffset *bo)
1601			{
1602		✗	int32_t codebook_min = codebook_extremes[codebook][0];
1603		✗	int32_t codebook_max = codebook_extremes[codebook][1];
1604		✗	int32_t *sample_buffer = dp->sample_buffer[channel];
1605		✗	int codebook_offset = 7 + (2 - codebook);
1606		✗	int32_t unsign_offset = offset;
1607		✗	uint32_t bitcount = 0;
1608		✗	int lsb_bits = 0;
1609		✗	int offset_min = INT_MAX, offset_max = INT_MAX;
1610			int unsign, mask;
1611
1612		✗	sample_min -= offset;
1613		✗	sample_max -= offset;
1614
1615		✗	while (sample_min < codebook_min || sample_max > codebook_max) {
1616		✗	lsb_bits++;
1617		✗	sample_min >>= 1;
1618		✗	sample_max >>= 1;
1619			}
1620
1621		✗	unsign = 1 << lsb_bits;
1622		✗	mask = unsign - 1;
1623
1624		✗	if (codebook == 2) {
1625		✗	unsign_offset -= unsign;
1626		✗	lsb_bits++;
1627			}
1628
1629		✗	for (int i = 0; i < dp->blocksize; i++) {
1630		✗	int32_t sample = sample_buffer[i] >> dp->quant_step_size[channel];
1631			int temp_min, temp_max;
1632
1633		✗	sample -= unsign_offset;
1634
1635		✗	temp_min = sample & mask;
1636		✗	if (temp_min < offset_min)
1637		✗	offset_min = temp_min;
1638
1639		✗	temp_max = unsign - temp_min - 1;
1640		✗	if (temp_max < offset_max)
1641		✗	offset_max = temp_max;
1642
1643		✗	sample >>= lsb_bits;
1644
1645		✗	bitcount += ff_mlp_huffman_tables[codebook][sample + codebook_offset][1];
1646			}
1647
1648		✗	bo->offset = offset;
1649		✗	bo->lsb_bits = lsb_bits;
1650		✗	bo->bitcount = lsb_bits * dp->blocksize + bitcount;
1651		✗	bo->min = FFMAX(offset - offset_min, HUFF_OFFSET_MIN);
1652		✗	bo->max = FFMIN(offset + offset_max, HUFF_OFFSET_MAX);
1653		✗	}
1654
1655			/** Determines the least amount of bits needed to encode the samples using a
1656			* given codebook. Searches for the best offset to minimize the bits.
1657			*/
1658		✗	static inline void codebook_bits(MLPEncodeContext *ctx,
1659			DecodingParams *dp,
1660			int channel, int codebook,
1661			int offset, int32_t min, int32_t max,
1662			BestOffset *bo, int direction)
1663			{
1664		✗	uint32_t previous_count = UINT32_MAX;
1665			int offset_min, offset_max;
1666		✗	int is_greater = 0;
1667
1668		✗	offset_min = FFMAX(min, HUFF_OFFSET_MIN);
1669		✗	offset_max = FFMIN(max, HUFF_OFFSET_MAX);
1670
1671		✗	while (offset <= offset_max && offset >= offset_min) {
1672			BestOffset temp_bo;
1673
1674		✗	codebook_bits_offset(ctx, dp, channel, codebook,
1675			min, max, offset,
1676			&temp_bo);
1677
1678		✗	if (temp_bo.bitcount < previous_count) {
1679		✗	if (temp_bo.bitcount < bo->bitcount)
1680		✗	*bo = temp_bo;
1681
1682		✗	is_greater = 0;
1683		✗	} else if (++is_greater >= ctx->max_codebook_search)
1684		✗	break;
1685
1686		✗	previous_count = temp_bo.bitcount;
1687
1688		✗	if (direction) {
1689		✗	offset = temp_bo.max + 1;
1690			} else {
1691		✗	offset = temp_bo.min - 1;
1692			}
1693			}
1694		✗	}
1695
1696			/** Determines the least amount of bits needed to encode the samples using
1697			* any or no codebook.
1698			*/
1699		✗	static void determine_bits(MLPEncodeContext *ctx, MLPSubstream *s)
1700			{
1701		✗	RestartHeader *rh = s->cur_restart_header;
1702		✗	for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
1703		✗	DecodingParams *dp = &s->b[index].decoding_params;
1704
1705		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
1706		✗	ChannelParams *cp = &s->b[index].channel_params[ch];
1707		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1708		✗	int32_t min = INT32_MAX, max = INT32_MIN;
1709		✗	int no_filters_used = !cp->filter_params[FIR].order;
1710		✗	int average = 0;
1711		✗	int offset = 0;
1712
1713			/* Determine extremes and average. */
1714		✗	for (int i = 0; i < dp->blocksize; i++) {
1715		✗	int32_t sample = sample_buffer[i] >> dp->quant_step_size[ch];
1716		✗	if (sample < min)
1717		✗	min = sample;
1718		✗	if (sample > max)
1719		✗	max = sample;
1720		✗	average += sample;
1721			}
1722		✗	average /= dp->blocksize;
1723
1724			/* If filtering is used, we always set the offset to zero, otherwise
1725			* we search for the offset that minimizes the bitcount. */
1726		✗	if (no_filters_used) {
1727		✗	no_codebook_bits(ctx, dp, ch, min, max, &s->b[index].best_offset[ch][0]);
1728		✗	offset = av_clip(average, HUFF_OFFSET_MIN, HUFF_OFFSET_MAX);
1729			} else {
1730		✗	no_codebook_bits_offset(ctx, dp, ch, offset, min, max, &s->b[index].best_offset[ch][0]);
1731			}
1732
1733		✗	for (int i = 1; i < NUM_CODEBOOKS; i++) {
1734		✗	BestOffset temp_bo = { 0, UINT32_MAX, 0, 0, 0, };
1735			int32_t offset_max;
1736
1737		✗	codebook_bits_offset(ctx, dp, ch, i - 1,
1738			min, max, offset,
1739			&temp_bo);
1740
1741		✗	if (no_filters_used) {
1742		✗	offset_max = temp_bo.max;
1743
1744		✗	codebook_bits(ctx, dp, ch, i - 1, temp_bo.min - 1,
1745			min, max, &temp_bo, 0);
1746		✗	codebook_bits(ctx, dp, ch, i - 1, offset_max + 1,
1747			min, max, &temp_bo, 1);
1748			}
1749
1750		✗	s->b[index].best_offset[ch][i] = temp_bo;
1751			}
1752			}
1753			}
1754		✗	}
1755
1756			/****************************************************************************
1757			*************** Functions that process the data in some way ****************
1758			****************************************************************************/
1759
1760			#define SAMPLE_MAX(bitdepth) ((1 << (bitdepth - 1)) - 1)
1761			#define SAMPLE_MIN(bitdepth) (~SAMPLE_MAX(bitdepth))
1762
1763			#define MSB_MASK(bits) (-(int)(1u << (bits)))
1764
1765			/** Applies the filter to the current samples, and saves the residual back
1766			* into the samples buffer. If the filter is too bad and overflows the
1767			* maximum amount of bits allowed (24), the samples buffer is left as is and
1768			* the function returns -1.
1769			*/
1770		✗	static int apply_filter(MLPEncodeContext *ctx, MLPSubstream *s, int channel)
1771			{
1772		✗	DecodingParams *dp = &s->b[1].decoding_params;
1773		✗	ChannelParams *cp = &s->b[1].channel_params[channel];
1774		✗	FilterParams *fp[NUM_FILTERS] = { &cp->filter_params[FIR],
1775		✗	&cp->filter_params[IIR], };
1776		✗	const uint8_t codebook = cp->codebook;
1777		✗	int32_t mask = MSB_MASK(dp->quant_step_size[channel]);
1778		✗	int32_t *sample_buffer = s->b[0].decoding_params.sample_buffer[channel];
1779		✗	unsigned int filter_shift = fp[FIR]->shift;
1780		✗	int32_t *filter_state[NUM_FILTERS] = { ctx->filter_state[FIR],
1781		✗	ctx->filter_state[IIR], };
1782		✗	int i, j = 1, k = 0;
1783
1784		✗	for (i = 0; i < 8; i++) {
1785		✗	filter_state[FIR][i] = sample_buffer[i];
1786		✗	filter_state[IIR][i] = sample_buffer[i];
1787			}
1788
1789		✗	while (1) {
1790		✗	int32_t *sample_buffer = s->b[j].decoding_params.sample_buffer[channel];
1791		✗	unsigned int blocksize = s->b[j].decoding_params.blocksize;
1792			int32_t sample, residual;
1793		✗	int64_t accum = 0;
1794
1795		✗	if (!blocksize)
1796		✗	break;
1797
1798		✗	for (int filter = 0; filter < NUM_FILTERS; filter++) {
1799		✗	int32_t *fcoeff = cp->coeff[filter];
1800		✗	for (unsigned int order = 0; order < fp[filter]->order; order++)
1801		✗	accum += (int64_t)filter_state[filter][i - 1 - order] *
1802		✗	fcoeff[order];
1803			}
1804
1805		✗	sample = sample_buffer[k];
1806		✗	accum >>= filter_shift;
1807		✗	residual = sample - (accum & mask);
1808
1809		✗	if ((codebook > 0) &&
1810		✗	(residual < SAMPLE_MIN(24) ||
1811			residual > SAMPLE_MAX(24)))
1812		✗	return -1;
1813
1814		✗	filter_state[FIR][i] = sample;
1815		✗	filter_state[IIR][i] = residual;
1816
1817		✗	i++;
1818		✗	k++;
1819		✗	if (k >= blocksize) {
1820		✗	k = 0;
1821		✗	j++;
1822		✗	if (j > ctx->cur_restart_interval)
1823		✗	break;
1824			}
1825			}
1826
1827		✗	for (int l = 0, j = 0; j <= ctx->cur_restart_interval; j++) {
1828		✗	int32_t *sample_buffer = s->b[j].decoding_params.sample_buffer[channel];
1829		✗	unsigned int blocksize = s->b[j].decoding_params.blocksize;
1830
1831		✗	for (int i = 0; i < blocksize; i++, l++)
1832		✗	sample_buffer[i] = filter_state[IIR][l];
1833			}
1834
1835		✗	return 0;
1836			}
1837
1838		✗	static void apply_filters(MLPEncodeContext *ctx, MLPSubstream *s)
1839			{
1840		✗	RestartHeader *rh = s->cur_restart_header;
1841
1842		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
1843		✗	while (apply_filter(ctx, s, ch) < 0) {
1844			/* Filter is horribly wrong. Retry. */
1845		✗	set_filter(ctx, s, ch, 1);
1846			}
1847			}
1848		✗	}
1849
1850			/** Generates two noise channels worth of data. */
1851		✗	static void generate_2_noise_channels(MLPEncodeContext *ctx, MLPSubstream *s)
1852			{
1853		✗	RestartHeader *rh = s->cur_restart_header;
1854		✗	uint32_t seed = rh->noisegen_seed;
1855
1856		✗	for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) {
1857		✗	DecodingParams *dp = &s->b[j].decoding_params;
1858		✗	int32_t *sample_buffer2 = dp->sample_buffer[ctx->num_channels-2];
1859		✗	int32_t *sample_buffer1 = dp->sample_buffer[ctx->num_channels-1];
1860
1861		✗	for (unsigned int i = 0; i < dp->blocksize; i++) {
1862		✗	uint16_t seed_shr7 = seed >> 7;
1863		✗	sample_buffer2[i] = ((int8_t)(seed >> 15)) * (1 << rh->noise_shift);
1864		✗	sample_buffer1[i] = ((int8_t) seed_shr7) * (1 << rh->noise_shift);
1865
1866		✗	seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1867			}
1868			}
1869
1870		✗	rh->noisegen_seed = seed & ((1 << 24)-1);
1871		✗	}
1872
1873			/** Rematrixes all channels using chosen coefficients. */
1874		✗	static void rematrix_channels(MLPEncodeContext *ctx, MLPSubstream *s)
1875			{
1876		✗	RestartHeader *rh = s->cur_restart_header;
1877		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1878		✗	MatrixParams *mp1 = &dp1->matrix_params;
1879		✗	const int maxchan = rh->max_matrix_channel;
1880			int32_t orig_samples[MAX_NCHANNELS];
1881			int32_t rematrix_samples[MAX_NCHANNELS];
1882		✗	uint8_t lsb_bypass[MAX_MATRICES] = { 0 };
1883
1884		✗	for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) {
1885		✗	DecodingParams *dp = &s->b[j].decoding_params;
1886		✗	MatrixParams *mp = &dp->matrix_params;
1887
1888		✗	for (unsigned int i = 0; i < dp->blocksize; i++) {
1889		✗	for (int ch = 0; ch <= maxchan; ch++)
1890		✗	orig_samples[ch] = rematrix_samples[ch] = dp->sample_buffer[ch][i];
1891
1892		✗	for (int mat = 0; mat < mp1->count; mat++) {
1893		✗	unsigned int outch = mp1->outch[mat];
1894		✗	int64_t accum = 0;
1895
1896		✗	for (int ch = 0; ch <= maxchan; ch++) {
1897		✗	int32_t sample = rematrix_samples[ch];
1898
1899		✗	accum += (int64_t)sample * mp1->forco[mat][ch];
1900			}
1901
1902		✗	rematrix_samples[outch] = accum >> 14;
1903			}
1904
1905		✗	for (int ch = 0; ch <= maxchan; ch++)
1906		✗	dp->sample_buffer[ch][i] = rematrix_samples[ch];
1907
1908		✗	for (unsigned int mat = 0; mat < mp1->count; mat++) {
1909		✗	int8_t *bypassed_lsbs = mp->bypassed_lsbs[mat];
1910		✗	unsigned int outch = mp1->outch[mat];
1911		✗	int64_t accum = 0;
1912			int8_t bit;
1913
1914		✗	for (int ch = 0; ch <= maxchan; ch++) {
1915		✗	int32_t sample = rematrix_samples[ch];
1916
1917		✗	accum += (int64_t)sample * mp1->coeff[mat][ch];
1918			}
1919
1920		✗	rematrix_samples[outch] = accum >> 14;
1921		✗	bit = rematrix_samples[outch] != orig_samples[outch];
1922
1923		✗	bypassed_lsbs[i] = bit;
1924		✗	lsb_bypass[mat] |= bit;
1925			}
1926			}
1927			}
1928
1929		✗	for (unsigned int mat = 0; mat < mp1->count; mat++)
1930		✗	mp1->lsb_bypass[mat] = lsb_bypass[mat];
1931		✗	}
1932
1933			/****************************************************************************
1934			**** Functions that deal with determining the best parameters and output ***
1935			****************************************************************************/
1936
1937			typedef struct PathCounter {
1938			char path[MAX_HEADER_INTERVAL + 2];
1939			int cur_idx;
1940			uint32_t bitcount;
1941			} PathCounter;
1942
1943			#define CODEBOOK_CHANGE_BITS 21
1944
1945		✗	static void clear_path_counter(PathCounter *path_counter)
1946			{
1947		✗	memset(path_counter, 0, (NUM_CODEBOOKS + 1) * sizeof(*path_counter));
1948		✗	}
1949
1950		✗	static int compare_best_offset(const BestOffset *prev, const BestOffset *cur)
1951			{
1952		✗	return prev->lsb_bits != cur->lsb_bits;
1953			}
1954
1955		✗	static uint32_t best_codebook_path_cost(MLPEncodeContext *ctx, MLPSubstream *s,
1956			int channel,
1957			PathCounter *src, int cur_codebook)
1958			{
1959		✗	int idx = src->cur_idx;
1960		✗	const BestOffset *cur_bo = s->b[idx].best_offset[channel],
1961		✗	*prev_bo = idx ? s->b[idx - 1].best_offset[channel] :
1962			restart_best_offset;
1963		✗	uint32_t bitcount = src->bitcount;
1964		✗	int prev_codebook = src->path[idx];
1965
1966		✗	bitcount += cur_bo[cur_codebook].bitcount;
1967
1968		✗	if (prev_codebook != cur_codebook ||
1969		✗	compare_best_offset(&prev_bo[prev_codebook], &cur_bo[cur_codebook]))
1970		✗	bitcount += CODEBOOK_CHANGE_BITS;
1971
1972		✗	return bitcount;
1973			}
1974
1975		✗	static void set_best_codebook(MLPEncodeContext *ctx, MLPSubstream *s)
1976			{
1977		✗	RestartHeader *rh = s->cur_restart_header;
1978
1979		✗	for (int channel = rh->min_channel; channel <= rh->max_channel; channel++) {
1980		✗	const BestOffset *prev_bo = restart_best_offset;
1981			BestOffset *cur_bo;
1982			PathCounter path_counter[NUM_CODEBOOKS + 1];
1983			unsigned int best_codebook;
1984			char *best_path;
1985
1986		✗	clear_path_counter(path_counter);
1987
1988		✗	for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
1989		✗	uint32_t best_bitcount = UINT32_MAX;
1990
1991		✗	cur_bo = s->b[index].best_offset[channel];
1992
1993		✗	for (unsigned int codebook = 0; codebook < NUM_CODEBOOKS; codebook++) {
1994		✗	uint32_t prev_best_bitcount = UINT32_MAX;
1995
1996		✗	for (unsigned int last_best = 0; last_best < 2; last_best++) {
1997		✗	PathCounter *dst_path = &path_counter[codebook];
1998			PathCounter *src_path;
1999			uint32_t temp_bitcount;
2000
2001			/* First test last path with same headers,
2002			* then with last best. */
2003		✗	if (last_best) {
2004		✗	src_path = &path_counter[NUM_CODEBOOKS];
2005			} else {
2006		✗	if (compare_best_offset(&prev_bo[codebook], &cur_bo[codebook]))
2007		✗	continue;
2008			else
2009		✗	src_path = &path_counter[codebook];
2010			}
2011
2012		✗	temp_bitcount = best_codebook_path_cost(ctx, s, channel, src_path, codebook);
2013
2014		✗	if (temp_bitcount < best_bitcount) {
2015		✗	best_bitcount = temp_bitcount;
2016		✗	best_codebook = codebook;
2017			}
2018
2019		✗	if (temp_bitcount < prev_best_bitcount) {
2020		✗	prev_best_bitcount = temp_bitcount;
2021		✗	if (src_path != dst_path)
2022		✗	memcpy(dst_path, src_path, sizeof(PathCounter));
2023		✗	if (dst_path->cur_idx < FF_ARRAY_ELEMS(dst_path->path) - 1)
2024		✗	dst_path->path[++dst_path->cur_idx] = codebook;
2025		✗	dst_path->bitcount = temp_bitcount;
2026			}
2027			}
2028			}
2029
2030		✗	prev_bo = cur_bo;
2031
2032		✗	memcpy(&path_counter[NUM_CODEBOOKS], &path_counter[best_codebook], sizeof(PathCounter));
2033			}
2034
2035		✗	best_path = path_counter[NUM_CODEBOOKS].path + 1;
2036
2037			/* Update context. */
2038		✗	for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
2039		✗	ChannelParams *cp = &s->b[index].channel_params[channel];
2040		✗	DecodingParams *dp = &s->b[index].decoding_params;
2041
2042		✗	best_codebook = *best_path++;
2043		✗	cur_bo = &s->b[index].best_offset[channel][best_codebook];
2044
2045		✗	cp->huff_offset = cur_bo->offset;
2046		✗	cp->huff_lsbs = cur_bo->lsb_bits + dp->quant_step_size[channel];
2047		✗	cp->codebook = best_codebook;
2048			}
2049			}
2050		✗	}
2051
2052			/** Analyzes all collected bitcounts and selects the best parameters for each
2053			* individual access unit.
2054			* TODO This is just a stub!
2055			*/
2056		✗	static void set_major_params(MLPEncodeContext *ctx, MLPSubstream *s)
2057			{
2058		✗	RestartHeader *rh = s->cur_restart_header;
2059		✗	uint8_t max_huff_lsbs = 0, max_output_bits = 0;
2060		✗	int8_t max_shift = 0;
2061
2062		✗	for (int index = 0; index < s->b[ctx->restart_intervals-1].seq_size; index++) {
2063		✗	memcpy(&s->b[index].major_decoding_params,
2064		✗	&s->b[index].decoding_params, sizeof(DecodingParams));
2065		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++) {
2066		✗	int8_t shift = s->b[index].decoding_params.output_shift[ch];
2067
2068		✗	max_shift = FFMAX(max_shift, shift);
2069			}
2070		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
2071		✗	uint8_t huff_lsbs = s->b[index].channel_params[ch].huff_lsbs;
2072
2073		✗	max_huff_lsbs = FFMAX(max_huff_lsbs, huff_lsbs);
2074
2075		✗	memcpy(&s->b[index].major_channel_params[ch],
2076		✗	&s->b[index].channel_params[ch],
2077			sizeof(ChannelParams));
2078			}
2079			}
2080
2081		✗	rh->max_huff_lsbs = max_huff_lsbs;
2082		✗	rh->max_shift = max_shift;
2083
2084		✗	for (int index = 0; index < ctx->number_of_frames; index++)
2085		✗	if (max_output_bits < s->b[index].max_output_bits)
2086		✗	max_output_bits = s->b[index].max_output_bits;
2087		✗	rh->max_output_bits = max_output_bits;
2088
2089		✗	s->cur_restart_header = &s->restart_header;
2090
2091		✗	for (int index = 0; index <= ctx->cur_restart_interval; index++)
2092		✗	s->b[index].major_params_changed = compare_decoding_params(ctx, s, index);
2093
2094		✗	s->major_filter_state_subblock = 1;
2095		✗	s->major_cur_subblock_index = 0;
2096		✗	}
2097
2098		✗	static void analyze_sample_buffer(MLPEncodeContext *ctx, MLPSubstream *s)
2099			{
2100		✗	s->cur_restart_header = &s->restart_header;
2101
2102			/* Copy frame_size from frames 0...max to decoding_params 1...max + 1
2103			* decoding_params[0] is for the filter state subblock.
2104			*/
2105		✗	for (unsigned int index = 0; index < ctx->number_of_frames; index++) {
2106		✗	DecodingParams *dp = &s->b[index+1].decoding_params;
2107		✗	dp->blocksize = ctx->avctx->frame_size;
2108			}
2109			/* The official encoder seems to always encode a filter state subblock
2110			* even if there are no filters. TODO check if it is possible to skip
2111			* the filter state subblock for no filters.
2112			*/
2113		✗	s->b[0].decoding_params.blocksize = 8;
2114		✗	s->b[1].decoding_params.blocksize -= 8;
2115
2116		✗	input_to_sample_buffer (ctx, s);
2117		✗	determine_output_shift (ctx, s);
2118		✗	generate_2_noise_channels(ctx, s);
2119		✗	lossless_matrix_coeffs (ctx, s);
2120		✗	rematrix_channels (ctx, s);
2121		✗	determine_quant_step_size(ctx, s);
2122		✗	determine_filters (ctx, s);
2123		✗	apply_filters (ctx, s);
2124
2125		✗	copy_restart_frame_params(ctx, s);
2126
2127		✗	determine_bits(ctx, s);
2128
2129		✗	set_best_codebook(ctx, s);
2130		✗	}
2131
2132		✗	static void process_major_frame(MLPEncodeContext *ctx, MLPSubstream *s)
2133			{
2134		✗	ctx->number_of_frames = ctx->major_number_of_frames;
2135
2136		✗	s->cur_restart_header = &s->restart_header;
2137
2138		✗	generate_2_noise_channels(ctx, s);
2139		✗	rematrix_channels (ctx, s);
2140
2141		✗	apply_filters(ctx, s);
2142		✗	}
2143
2144			/****************************************************************************/
2145
2146		✗	static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
2147			const AVFrame *frame, int *got_packet)
2148			{
2149		✗	MLPEncodeContext *ctx = avctx->priv_data;
2150		✗	int bytes_written = 0;
2151		✗	int channels = avctx->ch_layout.nb_channels;
2152			int restart_frame, ret;
2153			const uint8_t *data;
2154
2155		✗	if (!frame && !ctx->last_frames)
2156		✗	ctx->last_frames = (ctx->afq.remaining_samples + avctx->frame_size - 1) / avctx->frame_size;
2157
2158		✗	if (!frame && !ctx->last_frames--)
2159		✗	return 0;
2160
2161		✗	if ((ret = ff_alloc_packet(avctx, avpkt, 87500 * channels)) < 0)
2162		✗	return ret;
2163
2164		✗	if (frame) {
2165			/* add current frame to queue */
2166		✗	if ((ret = ff_af_queue_add(&ctx->afq, frame)) < 0)
2167		✗	return ret;
2168			}
2169
2170		✗	data = frame ? frame->data[0] : NULL;
2171
2172		✗	ctx->frame_index = avctx->frame_num % ctx->cur_restart_interval;
2173
2174		✗	if (avctx->frame_num < ctx->cur_restart_interval) {
2175		✗	if (data)
2176		✗	goto input_and_return;
2177			}
2178
2179		✗	restart_frame = !ctx->frame_index;
2180
2181		✗	if (restart_frame) {
2182		✗	avpkt->flags |= AV_PKT_FLAG_KEY;
2183		✗	for (int n = 0; n < ctx->num_substreams; n++)
2184		✗	set_major_params(ctx, &ctx->s[n]);
2185
2186		✗	if (ctx->min_restart_interval != ctx->cur_restart_interval)
2187		✗	process_major_frame(ctx, &ctx->s[0]);
2188			}
2189
2190		✗	bytes_written = write_access_unit(ctx, avpkt->data, avpkt->size, restart_frame);
2191
2192		✗	ctx->output_timing += avctx->frame_size;
2193		✗	ctx->input_timing += avctx->frame_size;
2194
2195		✗	input_and_return:
2196
2197		✗	if (frame) {
2198		✗	ctx->shorten_by = avctx->frame_size - frame->nb_samples;
2199		✗	ctx->next_major_frame_size += avctx->frame_size;
2200		✗	ctx->next_major_number_of_frames++;
2201			}
2202		✗	if (data)
2203		✗	for (int n = 0; n < ctx->num_substreams; n++)
2204		✗	input_data(ctx, &ctx->s[n], frame->extended_data, frame->nb_samples);
2205
2206		✗	restart_frame = (ctx->frame_index + 1) % ctx->min_restart_interval;
2207
2208		✗	if (!restart_frame) {
2209		✗	for (unsigned int seq_index = 0; seq_index < ctx->restart_intervals; seq_index++) {
2210			unsigned int number_of_samples;
2211
2212		✗	ctx->number_of_frames = ctx->next_major_number_of_frames;
2213		✗	ctx->number_of_subblocks = ctx->next_major_number_of_frames + 1;
2214
2215		✗	number_of_samples = avctx->frame_size * ctx->number_of_frames;
2216
2217		✗	for (int n = 0; n < ctx->num_substreams; n++) {
2218		✗	MLPSubstream *s = &ctx->s[n];
2219
2220		✗	for (int i = 0; i < s->b[seq_index].seq_size; i++) {
2221		✗	clear_channel_params(s->b[i].channel_params, channels);
2222		✗	default_decoding_params(ctx, &s->b[i].decoding_params);
2223			}
2224			}
2225
2226		✗	if (number_of_samples > 0) {
2227		✗	for (int n = 0; n < ctx->num_substreams; n++)
2228		✗	analyze_sample_buffer(ctx, &ctx->s[n]);
2229			}
2230			}
2231
2232		✗	if (ctx->frame_index == (ctx->cur_restart_interval - 1)) {
2233		✗	ctx->major_frame_size = ctx->next_major_frame_size;
2234		✗	ctx->next_major_frame_size = 0;
2235		✗	ctx->major_number_of_frames = ctx->next_major_number_of_frames;
2236		✗	ctx->next_major_number_of_frames = 0;
2237			}
2238			}
2239
2240		✗	if (!frame && ctx->last_frames < ctx->cur_restart_interval - 1)
2241		✗	avctx->frame_num++;
2242
2243		✗	if (bytes_written > 0) {
2244		✗	ret = ff_af_queue_remove(&ctx->afq, avctx->frame_size, avpkt);
2245		✗	if (ret < 0)
2246		✗	return ret;
2247
2248		✗	av_shrink_packet(avpkt, bytes_written);
2249
2250		✗	*got_packet = 1;
2251			} else {
2252		✗	*got_packet = 0;
2253			}
2254
2255		✗	return 0;
2256			}
2257
2258		✗	static av_cold int mlp_encode_close(AVCodecContext *avctx)
2259			{
2260		✗	MLPEncodeContext *ctx = avctx->priv_data;
2261
2262		✗	ff_lpc_end(&ctx->lpc_ctx);
2263		✗	ff_af_queue_close(&ctx->afq);
2264
2265		✗	return 0;
2266			}
2267
2268			#define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
2269			#define OFFSET(x) offsetof(MLPEncodeContext, x)
2270			static const AVOption mlp_options[] = {
2271			{ "max_interval", "Max number of frames between each new header", OFFSET(max_restart_interval), AV_OPT_TYPE_INT, {.i64 = 16 }, MIN_HEADER_INTERVAL, MAX_HEADER_INTERVAL, FLAGS },
2272			{ "lpc_coeff_precision", "LPC coefficient precision", OFFSET(lpc_coeff_precision), AV_OPT_TYPE_INT, {.i64 = 15 }, 0, 15, FLAGS },
2273			{ "lpc_type", "LPC algorithm", OFFSET(lpc_type), AV_OPT_TYPE_INT, {.i64 = FF_LPC_TYPE_LEVINSON }, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_CHOLESKY, FLAGS, .unit = "lpc_type" },
2274			{ "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, 0, 0, FLAGS, .unit = "lpc_type" },
2275			{ "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, 0, 0, FLAGS, .unit = "lpc_type" },
2276			{ "lpc_passes", "Number of passes to use for Cholesky factorization during LPC analysis", OFFSET(lpc_passes), AV_OPT_TYPE_INT, {.i64 = 2 }, 1, INT_MAX, FLAGS },
2277			{ "codebook_search", "Max number of codebook searches", OFFSET(max_codebook_search), AV_OPT_TYPE_INT, {.i64 = 3 }, 1, 100, FLAGS },
2278			{ "prediction_order", "Search method for selecting prediction order", OFFSET(prediction_order), AV_OPT_TYPE_INT, {.i64 = ORDER_METHOD_EST }, ORDER_METHOD_EST, ORDER_METHOD_SEARCH, FLAGS, .unit = "predm" },
2279			{ "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST }, 0, 0, FLAGS, .unit = "predm" },
2280			{ "search", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, 0, 0, FLAGS, .unit = "predm" },
2281			{ "rematrix_precision", "Rematrix coefficient precision", OFFSET(rematrix_precision), AV_OPT_TYPE_INT, {.i64 = 1 }, 0, 14, FLAGS },
2282			{ NULL },
2283			};
2284
2285			static const AVClass mlp_class = {
2286			.class_name = "mlpenc",
2287			.item_name = av_default_item_name,
2288			.option = mlp_options,
2289			.version = LIBAVUTIL_VERSION_INT,
2290			};
2291
2292			#if CONFIG_MLP_ENCODER
2293			const FFCodec ff_mlp_encoder = {
2294			.p.name ="mlp",
2295			CODEC_LONG_NAME("MLP (Meridian Lossless Packing)"),
2296			.p.type = AVMEDIA_TYPE_AUDIO,
2297			.p.id = AV_CODEC_ID_MLP,
2298			.p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2299			AV_CODEC_CAP_EXPERIMENTAL,
2300			.priv_data_size = sizeof(MLPEncodeContext),
2301			.init = mlp_encode_init,
2302			FF_CODEC_ENCODE_CB(mlp_encode_frame),
2303			.close = mlp_encode_close,
2304			.p.priv_class = &mlp_class,
2305			CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
2306			CODEC_SAMPLERATES(44100, 48000, 88200, 96000, 176400, 192000),
2307			CODEC_CH_LAYOUTS_ARRAY(ff_mlp_ch_layouts),
2308			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2309			};
2310			#endif
2311			#if CONFIG_TRUEHD_ENCODER
2312			const FFCodec ff_truehd_encoder = {
2313			.p.name ="truehd",
2314			CODEC_LONG_NAME("TrueHD"),
2315			.p.type = AVMEDIA_TYPE_AUDIO,
2316			.p.id = AV_CODEC_ID_TRUEHD,
2317			.p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2318			AV_CODEC_CAP_SMALL_LAST_FRAME |
2319			AV_CODEC_CAP_EXPERIMENTAL,
2320			.priv_data_size = sizeof(MLPEncodeContext),
2321			.init = mlp_encode_init,
2322			FF_CODEC_ENCODE_CB(mlp_encode_frame),
2323			.close = mlp_encode_close,
2324			.p.priv_class = &mlp_class,
2325			CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P),
2326			CODEC_SAMPLERATES(44100, 48000, 88200, 96000, 176400, 192000),
2327			CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO,
2328			AV_CHANNEL_LAYOUT_2POINT1, AV_CHANNEL_LAYOUT_SURROUND,
2329			AV_CHANNEL_LAYOUT_3POINT1, AV_CHANNEL_LAYOUT_4POINT0,
2330			AV_CHANNEL_LAYOUT_4POINT1, AV_CHANNEL_LAYOUT_5POINT0,
2331			AV_CHANNEL_LAYOUT_5POINT1),
2332			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2333			};
2334			#endif
2335