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_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d. Supported "
525			"sample rates are 44100, 88200, 176400, 48000, "
526			"96000, and 192000.\n", avctx->sample_rate);
527		✗	return AVERROR(EINVAL);
528			}
529		✗	ctx->coded_sample_rate[1] = -1 & 0xf;
530
531		✗	ctx->coded_peak_bitrate = mlp_peak_bitrate(9600000, avctx->sample_rate);
532
533		✗	ctx->substream_info |= SUBSTREAM_INFO_ALWAYS_SET;
534		✗	if (avctx->ch_layout.nb_channels <= 2)
535		✗	ctx->substream_info |= SUBSTREAM_INFO_MAX_2_CHAN;
536
537		✗	switch (avctx->sample_fmt) {
538		✗	case AV_SAMPLE_FMT_S16P:
539		✗	ctx->coded_sample_fmt[0] = BITS_16;
540		✗	ctx->wordlength = 16;
541		✗	avctx->bits_per_raw_sample = 16;
542		✗	break;
543			/* TODO 20 bits: */
544		✗	case AV_SAMPLE_FMT_S32P:
545		✗	ctx->coded_sample_fmt[0] = BITS_24;
546		✗	ctx->wordlength = 24;
547		✗	avctx->bits_per_raw_sample = 24;
548		✗	break;
549		✗	default:
550		✗	av_log(avctx, AV_LOG_ERROR, "Sample format not supported. "
551			"Only 16- and 24-bit samples are supported.\n");
552		✗	return AVERROR(EINVAL);
553			}
554		✗	ctx->coded_sample_fmt[1] = -1 & 0xf;
555
556		✗	ctx->input_timing = -avctx->frame_size;
557
558		✗	ctx->num_channels = avctx->ch_layout.nb_channels + 2; /* +2 noise channels */
559
560		✗	ctx->min_restart_interval = ctx->cur_restart_interval = ctx->max_restart_interval;
561		✗	ctx->restart_intervals = ctx->max_restart_interval / ctx->min_restart_interval;
562
563		✗	ctx->num_substreams = 1;
564
565		✗	channels_present = av_channel_layout_subset(&avctx->ch_layout, ~(uint64_t)0);
566		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
567			static const uint64_t layout_arrangement[] = {
568			AV_CH_LAYOUT_MONO, AV_CH_LAYOUT_STEREO,
569			AV_CH_LAYOUT_2_1, AV_CH_LAYOUT_QUAD,
570			AV_CH_LAYOUT_2POINT1, 0, 0,
571			AV_CH_LAYOUT_SURROUND, AV_CH_LAYOUT_4POINT0,
572			AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_3POINT1,
573			AV_CH_LAYOUT_4POINT1, AV_CH_LAYOUT_5POINT1_BACK,
574			};
575			int i;
576
577		✗	for (i = 0;; i++) {
578		✗	av_assert1(i < FF_ARRAY_ELEMS(layout_arrangement) ||
579			!"Impossible channel layout");
580		✗	if (channels_present == layout_arrangement[i])
581		✗	break;
582			}
583		✗	ctx->channel_arrangement = i;
584		✗	ctx->flags = FLAGS_DVDA;
585		✗	ctx->channel_occupancy = ff_mlp_ch_info[ctx->channel_arrangement].channel_occupancy;
586		✗	ctx->summary_info = ff_mlp_ch_info[ctx->channel_arrangement].summary_info ;
587			} else {
588			/* TrueHD */
589		✗	ctx->num_substreams = 1 + (avctx->ch_layout.nb_channels > 2);
590		✗	switch (channels_present) {
591		✗	case AV_CH_LAYOUT_MONO:
592		✗	ctx->ch2_presentation_mod= 3;
593		✗	ctx->ch6_presentation_mod= 3;
594		✗	ctx->ch8_presentation_mod= 3;
595		✗	ctx->thd_substream_info = 0x14;
596		✗	break;
597		✗	case AV_CH_LAYOUT_STEREO:
598		✗	ctx->ch2_presentation_mod= 1;
599		✗	ctx->ch6_presentation_mod= 1;
600		✗	ctx->ch8_presentation_mod= 1;
601		✗	ctx->thd_substream_info = 0x14;
602		✗	break;
603		✗	case AV_CH_LAYOUT_2POINT1:
604			case AV_CH_LAYOUT_SURROUND:
605			case AV_CH_LAYOUT_3POINT1:
606			case AV_CH_LAYOUT_4POINT0:
607			case AV_CH_LAYOUT_4POINT1:
608			case AV_CH_LAYOUT_5POINT0:
609			case AV_CH_LAYOUT_5POINT1:
610		✗	ctx->ch2_presentation_mod= 0;
611		✗	ctx->ch6_presentation_mod= 0;
612		✗	ctx->ch8_presentation_mod= 0;
613		✗	ctx->thd_substream_info = 0x3C;
614		✗	break;
615		✗	default:
616			av_assert1(!"AVCodec.ch_layouts needs to be updated");
617			}
618		✗	ctx->flags = 0;
619		✗	ctx->channel_occupancy = 0;
620		✗	ctx->summary_info = 0;
621		✗	ctx->channel_arrangement =
622		✗	ctx->channel_arrangement8 = layout_truehd(channels_present);
623			}
624
625		✗	for (unsigned int index = 0; index < ctx->restart_intervals; index++) {
626		✗	for (int n = 0; n < ctx->num_substreams; n++)
627		✗	ctx->s[n].b[index].seq_size = ((index + 1) * ctx->min_restart_interval) + 1;
628			}
629
630
631			/* TODO see if noisegen_seed is really worth it. */
632		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
633		✗	RestartHeader *const rh = &ctx->s[0].restart_header;
634
635		✗	rh->noisegen_seed = 0;
636		✗	rh->min_channel = 0;
637		✗	rh->max_channel = avctx->ch_layout.nb_channels - 1;
638		✗	rh->max_matrix_channel = rh->max_channel;
639			} else {
640		✗	RestartHeader *rh = &ctx->s[0].restart_header;
641
642		✗	rh->noisegen_seed = 0;
643		✗	rh->min_channel = 0;
644		✗	rh->max_channel = FFMIN(avctx->ch_layout.nb_channels, 2) - 1;
645		✗	rh->max_matrix_channel = rh->max_channel;
646
647		✗	if (avctx->ch_layout.nb_channels > 2) {
648		✗	rh = &ctx->s[1].restart_header;
649
650		✗	rh->noisegen_seed = 0;
651		✗	rh->min_channel = 2;
652		✗	rh->max_channel = avctx->ch_layout.nb_channels - 1;
653		✗	rh->max_matrix_channel = rh->max_channel;
654			}
655			}
656
657		✗	if ((ret = ff_lpc_init(&ctx->lpc_ctx, ctx->avctx->frame_size,
658		✗	MLP_MAX_LPC_ORDER, ctx->lpc_type)) < 0)
659		✗	return ret;
660
661		✗	ff_af_queue_init(avctx, &ctx->afq);
662
663		✗	ff_thread_once(&init_static_once, mlp_encode_init_static);
664
665		✗	return 0;
666			}
667
668			/****************************************************************************
669			****************** Functions that write to the bitstream *******************
670			****************************************************************************/
671
672			/** Writes a major sync header to the bitstream. */
673		✗	static void write_major_sync(MLPEncodeContext *ctx, uint8_t *buf, int buf_size)
674			{
675			PutBitContext pb;
676
677		✗	init_put_bits(&pb, buf, buf_size);
678
679		✗	put_bits(&pb, 24, SYNC_MAJOR );
680
681		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
682		✗	put_bits(&pb, 8, SYNC_MLP );
683		✗	put_bits(&pb, 4, ctx->coded_sample_fmt [0]);
684		✗	put_bits(&pb, 4, ctx->coded_sample_fmt [1]);
685		✗	put_bits(&pb, 4, ctx->coded_sample_rate[0]);
686		✗	put_bits(&pb, 4, ctx->coded_sample_rate[1]);
687		✗	put_bits(&pb, 4, 0 ); /* ignored */
688		✗	put_bits(&pb, 4, 0 ); /* multi_channel_type */
689		✗	put_bits(&pb, 3, 0 ); /* ignored */
690		✗	put_bits(&pb, 5, ctx->channel_arrangement );
691		✗	} else if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
692		✗	put_bits(&pb, 8, SYNC_TRUEHD );
693		✗	put_bits(&pb, 4, ctx->coded_sample_rate[0]);
694		✗	put_bits(&pb, 1, ctx->multichannel_type6ch);
695		✗	put_bits(&pb, 1, ctx->multichannel_type8ch);
696		✗	put_bits(&pb, 2, 0 ); /* ignored */
697		✗	put_bits(&pb, 2, ctx->ch2_presentation_mod);
698		✗	put_bits(&pb, 2, ctx->ch6_presentation_mod);
699		✗	put_bits(&pb, 5, ctx->channel_arrangement );
700		✗	put_bits(&pb, 2, ctx->ch8_presentation_mod);
701		✗	put_bits(&pb, 13, ctx->channel_arrangement8);
702			}
703
704		✗	put_bits(&pb, 16, MAJOR_SYNC_INFO_SIGNATURE);
705		✗	put_bits(&pb, 16, ctx->flags );
706		✗	put_bits(&pb, 16, 0 ); /* ignored */
707		✗	put_bits(&pb, 1, 1 ); /* is_vbr */
708		✗	put_bits(&pb, 15, ctx->coded_peak_bitrate );
709		✗	put_bits(&pb, 4, ctx->num_substreams );
710		✗	put_bits(&pb, 2, 0 ); /* ignored */
711		✗	put_bits(&pb, 2, 0 ); /* extended substream info */
712
713			/* channel_meaning */
714		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
715		✗	put_bits(&pb, 8, ctx->substream_info );
716		✗	put_bits(&pb, 5, ctx->fs );
717		✗	put_bits(&pb, 5, ctx->wordlength );
718		✗	put_bits(&pb, 6, ctx->channel_occupancy );
719		✗	put_bits(&pb, 3, 0 ); /* ignored */
720		✗	put_bits(&pb, 10, 0 ); /* speaker_layout */
721		✗	put_bits(&pb, 3, 0 ); /* copy_protection */
722		✗	put_bits(&pb, 16, 0x8080 ); /* ignored */
723		✗	put_bits(&pb, 7, 0 ); /* ignored */
724		✗	put_bits(&pb, 4, 0 ); /* source_format */
725		✗	put_bits(&pb, 5, ctx->summary_info );
726		✗	} else if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
727		✗	put_bits(&pb, 8, ctx->thd_substream_info );
728		✗	put_bits(&pb, 6, 0 ); /* reserved */
729		✗	put_bits(&pb, 1, 0 ); /* 2ch control enabled */
730		✗	put_bits(&pb, 1, 0 ); /* 6ch control enabled */
731		✗	put_bits(&pb, 1, 0 ); /* 8ch control enabled */
732		✗	put_bits(&pb, 1, 0 ); /* reserved */
733		✗	put_bits(&pb, 7, 0 ); /* drc start up gain */
734		✗	put_bits(&pb, 6, 0 ); /* 2ch dialogue norm */
735		✗	put_bits(&pb, 6, 0 ); /* 2ch mix level */
736		✗	put_bits(&pb, 5, 0 ); /* 6ch dialogue norm */
737		✗	put_bits(&pb, 6, 0 ); /* 6ch mix level */
738		✗	put_bits(&pb, 5, 0 ); /* 6ch source format */
739		✗	put_bits(&pb, 5, 0 ); /* 8ch dialogue norm */
740		✗	put_bits(&pb, 6, 0 ); /* 8ch mix level */
741		✗	put_bits(&pb, 6, 0 ); /* 8ch source format */
742		✗	put_bits(&pb, 1, 0 ); /* reserved */
743		✗	put_bits(&pb, 1, 0 ); /* extra channel meaning present */
744			}
745
746		✗	flush_put_bits(&pb);
747
748		✗	AV_WL16(buf+26, ff_mlp_checksum16(buf, 26));
749		✗	}
750
751			/** Writes a restart header to the bitstream. Damaged streams can start being
752			* decoded losslessly again after such a header and the subsequent decoding
753			* params header.
754			*/
755		✗	static void write_restart_header(MLPEncodeContext *ctx, MLPSubstream *s,
756			PutBitContext *pb)
757			{
758		✗	RestartHeader *rh = s->cur_restart_header;
759		✗	uint8_t lossless_check = xor_32_to_8(rh->lossless_check_data);
760		✗	unsigned int start_count = put_bits_count(pb);
761			PutBitContext tmpb;
762			uint8_t checksum;
763
764		✗	put_bits(pb, 14, 0x31ea ); /* TODO 0x31eb */
765		✗	put_bits(pb, 16, ctx->output_timing );
766		✗	put_bits(pb, 4, rh->min_channel );
767		✗	put_bits(pb, 4, rh->max_channel );
768		✗	put_bits(pb, 4, rh->max_matrix_channel);
769		✗	put_bits(pb, 4, rh->noise_shift );
770		✗	put_bits(pb, 23, rh->noisegen_seed );
771		✗	put_bits(pb, 4, rh->max_shift );
772		✗	put_bits(pb, 5, rh->max_huff_lsbs );
773		✗	put_bits(pb, 5, rh->max_output_bits );
774		✗	put_bits(pb, 5, rh->max_output_bits );
775		✗	put_bits(pb, 1, rh->data_check_present);
776		✗	put_bits(pb, 8, lossless_check );
777		✗	put_bits(pb, 16, 0 ); /* ignored */
778
779		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
780		✗	put_bits(pb, 6, ch);
781
782			/* Data must be flushed for the checksum to be correct. */
783		✗	tmpb = *pb;
784		✗	flush_put_bits(&tmpb);
785
786		✗	checksum = ff_mlp_restart_checksum(pb->buf, put_bits_count(pb) - start_count);
787
788		✗	put_bits(pb, 8, checksum);
789		✗	}
790
791			/** Writes matrix params for all primitive matrices to the bitstream. */
792		✗	static void write_matrix_params(MLPEncodeContext *ctx,
793			MLPSubstream *s,
794			DecodingParams *dp,
795			PutBitContext *pb)
796			{
797		✗	RestartHeader *rh = s->cur_restart_header;
798		✗	MatrixParams *mp = &dp->matrix_params;
799		✗	int max_channel = rh->max_matrix_channel;
800
801		✗	put_bits(pb, 4, mp->count);
802
803		✗	if (!ctx->noise_type)
804		✗	max_channel += 2;
805
806		✗	for (unsigned int mat = 0; mat < mp->count; mat++) {
807		✗	put_bits(pb, 4, mp->outch[mat]); /* matrix_out_ch */
808		✗	put_bits(pb, 4, mp->fbits[mat]);
809		✗	put_bits(pb, 1, mp->lsb_bypass[mat]);
810
811		✗	for (int ch = 0; ch <= max_channel; ch++) {
812		✗	int32_t coeff = mp->coeff[mat][ch];
813
814		✗	if (coeff) {
815		✗	put_bits(pb, 1, 1);
816
817		✗	coeff >>= 14 - mp->fbits[mat];
818
819		✗	put_sbits(pb, mp->fbits[mat] + 2, coeff);
820			} else {
821		✗	put_bits(pb, 1, 0);
822			}
823			}
824			}
825		✗	}
826
827			/** Writes filter parameters for one filter to the bitstream. */
828		✗	static void write_filter_params(MLPEncodeContext *ctx,
829			ChannelParams *cp,
830			PutBitContext *pb,
831			int channel, unsigned int filter)
832			{
833		✗	FilterParams *fp = &cp->filter_params[filter];
834
835		✗	put_bits(pb, 4, fp->order);
836
837		✗	if (fp->order > 0) {
838		✗	int32_t *fcoeff = cp->coeff[filter];
839
840		✗	put_bits(pb, 4, fp->shift );
841		✗	put_bits(pb, 5, fp->coeff_bits );
842		✗	put_bits(pb, 3, fp->coeff_shift);
843
844		✗	for (int i = 0; i < fp->order; i++) {
845		✗	put_sbits(pb, fp->coeff_bits, fcoeff[i] >> fp->coeff_shift);
846			}
847
848			/* TODO state data for IIR filter. */
849		✗	put_bits(pb, 1, 0);
850			}
851		✗	}
852
853			/** Writes decoding parameters to the bitstream. These change very often,
854			* usually at almost every frame.
855			*/
856		✗	static void write_decoding_params(MLPEncodeContext *ctx, MLPSubstream *s,
857			PutBitContext *pb, int params_changed,
858			unsigned int subblock_index)
859			{
860		✗	DecodingParams *dp = &s->b[subblock_index].major_decoding_params;
861		✗	RestartHeader *rh = s->cur_restart_header;
862
863		✗	if (dp->param_presence_flags != PARAMS_DEFAULT &&
864		✗	params_changed & PARAM_PRESENCE_FLAGS) {
865		✗	put_bits(pb, 1, 1);
866		✗	put_bits(pb, 8, dp->param_presence_flags);
867			} else {
868		✗	put_bits(pb, 1, 0);
869			}
870
871		✗	if (dp->param_presence_flags & PARAM_BLOCKSIZE) {
872		✗	if (params_changed & PARAM_BLOCKSIZE) {
873		✗	put_bits(pb, 1, 1);
874		✗	put_bits(pb, 9, dp->blocksize);
875			} else {
876		✗	put_bits(pb, 1, 0);
877			}
878			}
879
880		✗	if (dp->param_presence_flags & PARAM_MATRIX) {
881		✗	if (params_changed & PARAM_MATRIX) {
882		✗	put_bits(pb, 1, 1);
883		✗	write_matrix_params(ctx, s, dp, pb);
884			} else {
885		✗	put_bits(pb, 1, 0);
886			}
887			}
888
889		✗	if (dp->param_presence_flags & PARAM_OUTSHIFT) {
890		✗	if (params_changed & PARAM_OUTSHIFT) {
891		✗	put_bits(pb, 1, 1);
892		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
893		✗	put_sbits(pb, 4, dp->output_shift[ch]);
894			} else {
895		✗	put_bits(pb, 1, 0);
896			}
897			}
898
899		✗	if (dp->param_presence_flags & PARAM_QUANTSTEP) {
900		✗	if (params_changed & PARAM_QUANTSTEP) {
901		✗	put_bits(pb, 1, 1);
902		✗	for (int ch = 0; ch <= rh->max_channel; ch++)
903		✗	put_bits(pb, 4, dp->quant_step_size[ch]);
904			} else {
905		✗	put_bits(pb, 1, 0);
906			}
907			}
908
909		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
910		✗	ChannelParams *cp = &s->b[subblock_index].major_channel_params[ch];
911
912		✗	if (dp->param_presence_flags & 0xF) {
913		✗	put_bits(pb, 1, 1);
914
915		✗	if (dp->param_presence_flags & PARAM_FIR) {
916		✗	if (params_changed & PARAM_FIR) {
917		✗	put_bits(pb, 1, 1);
918		✗	write_filter_params(ctx, cp, pb, ch, FIR);
919			} else {
920		✗	put_bits(pb, 1, 0);
921			}
922			}
923
924		✗	if (dp->param_presence_flags & PARAM_IIR) {
925		✗	if (params_changed & PARAM_IIR) {
926		✗	put_bits(pb, 1, 1);
927		✗	write_filter_params(ctx, cp, pb, ch, IIR);
928			} else {
929		✗	put_bits(pb, 1, 0);
930			}
931			}
932
933		✗	if (dp->param_presence_flags & PARAM_HUFFOFFSET) {
934		✗	if (params_changed & PARAM_HUFFOFFSET) {
935		✗	put_bits (pb, 1, 1);
936		✗	put_sbits(pb, 15, cp->huff_offset);
937			} else {
938		✗	put_bits(pb, 1, 0);
939			}
940			}
941		✗	if (cp->codebook > 0 && cp->huff_lsbs > 24) {
942		✗	av_log(ctx->avctx, AV_LOG_ERROR, "Invalid Huff LSBs %d\n", cp->huff_lsbs);
943			}
944
945		✗	put_bits(pb, 2, cp->codebook );
946		✗	put_bits(pb, 5, cp->huff_lsbs);
947			} else {
948		✗	put_bits(pb, 1, 0);
949			}
950			}
951		✗	}
952
953			/** Writes the residuals to the bitstream. That is, the VLC codes from the
954			* codebooks (if any is used), and then the residual.
955			*/
956		✗	static void write_block_data(MLPEncodeContext *ctx, MLPSubstream *s,
957			PutBitContext *pb, unsigned int subblock_index)
958			{
959		✗	RestartHeader *rh = s->cur_restart_header;
960		✗	DecodingParams *dp = &s->b[subblock_index].major_decoding_params;
961		✗	MatrixParams *mp = &dp->matrix_params;
962			int32_t sign_huff_offset[MAX_CHANNELS];
963			int codebook_index [MAX_CHANNELS];
964			int lsb_bits [MAX_CHANNELS];
965
966		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
967		✗	ChannelParams *cp = &s->b[subblock_index].major_channel_params[ch];
968			int sign_shift;
969
970		✗	lsb_bits [ch] = cp->huff_lsbs - dp->quant_step_size[ch];
971		✗	codebook_index [ch] = cp->codebook - 1;
972		✗	sign_huff_offset[ch] = cp->huff_offset;
973
974		✗	sign_shift = lsb_bits[ch] + (cp->codebook ? 2 - cp->codebook : -1);
975
976		✗	if (cp->codebook > 0)
977		✗	sign_huff_offset[ch] -= 7 << lsb_bits[ch];
978
979			/* Unsign if needed. */
980		✗	if (sign_shift >= 0)
981		✗	sign_huff_offset[ch] -= 1 << sign_shift;
982			}
983
984		✗	for (unsigned int i = 0; i < dp->blocksize; i++) {
985		✗	for (unsigned int mat = 0; mat < mp->count; mat++) {
986		✗	if (mp->lsb_bypass[mat]) {
987		✗	const int8_t *bypassed_lsbs = mp->bypassed_lsbs[mat];
988
989		✗	put_bits(pb, 1, bypassed_lsbs[i]);
990			}
991			}
992
993		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
994		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
995		✗	int32_t sample = sample_buffer[i] >> dp->quant_step_size[ch];
996		✗	sample -= sign_huff_offset[ch];
997
998		✗	if (codebook_index[ch] >= 0) {
999		✗	int vlc = sample >> lsb_bits[ch];
1000		✗	put_bits(pb, ff_mlp_huffman_tables[codebook_index[ch]][vlc][1],
1001		✗	ff_mlp_huffman_tables[codebook_index[ch]][vlc][0]);
1002		✗	sample &= ((1 << lsb_bits[ch]) - 1);
1003			}
1004
1005		✗	put_bits(pb, lsb_bits[ch], sample);
1006			}
1007			}
1008		✗	}
1009
1010			/** Writes the substream data to the bitstream. */
1011		✗	static uint8_t *write_substr(MLPEncodeContext *ctx,
1012			MLPSubstream *s,
1013			uint8_t *buf, int buf_size,
1014			int restart_frame,
1015			uint16_t *substream_data_len)
1016			{
1017		✗	int32_t *lossless_check_data = &s->b[ctx->frame_index].lossless_check_data;
1018		✗	unsigned int cur_subblock_index = s->major_cur_subblock_index;
1019		✗	unsigned int num_subblocks = s->major_filter_state_subblock;
1020		✗	RestartHeader *rh = &s->restart_header;
1021		✗	int substr_restart_frame = restart_frame;
1022			uint8_t parity, checksum;
1023			PutBitContext pb;
1024			int params_changed;
1025
1026		✗	s->cur_restart_header = rh;
1027
1028		✗	init_put_bits(&pb, buf, buf_size);
1029
1030		✗	for (unsigned int subblock = 0; subblock <= num_subblocks; subblock++) {
1031		✗	unsigned int subblock_index = cur_subblock_index++;
1032
1033		✗	params_changed = s->b[subblock_index].major_params_changed;
1034
1035		✗	if (substr_restart_frame || params_changed) {
1036		✗	put_bits(&pb, 1, 1);
1037
1038		✗	if (substr_restart_frame) {
1039		✗	put_bits(&pb, 1, 1);
1040
1041		✗	write_restart_header(ctx, s, &pb);
1042		✗	rh->lossless_check_data = 0;
1043			} else {
1044		✗	put_bits(&pb, 1, 0);
1045			}
1046
1047		✗	write_decoding_params(ctx, s, &pb, params_changed,
1048			subblock_index);
1049			} else {
1050		✗	put_bits(&pb, 1, 0);
1051			}
1052
1053		✗	write_block_data(ctx, s, &pb, subblock_index);
1054
1055		✗	put_bits(&pb, 1, !substr_restart_frame);
1056
1057		✗	substr_restart_frame = 0;
1058			}
1059
1060		✗	put_bits(&pb, (-put_bits_count(&pb)) & 15, 0);
1061
1062		✗	rh->lossless_check_data ^= lossless_check_data[0];
1063
1064		✗	if (ctx->last_frames == 0 && ctx->shorten_by) {
1065		✗	if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
1066		✗	put_bits(&pb, 16, END_OF_STREAM & 0xFFFF);
1067		✗	put_bits(&pb, 16, (ctx->shorten_by & 0x1FFF) | 0xE000);
1068			} else {
1069		✗	put_bits32(&pb, END_OF_STREAM);
1070			}
1071			}
1072
1073			/* Data must be flushed for the checksum and parity to be correct;
1074			* notice that we already are word-aligned here. */
1075		✗	flush_put_bits(&pb);
1076
1077		✗	parity = ff_mlp_calculate_parity(buf, put_bytes_output(&pb)) ^ 0xa9;
1078		✗	checksum = ff_mlp_checksum8 (buf, put_bytes_output(&pb));
1079
1080		✗	put_bits(&pb, 8, parity );
1081		✗	put_bits(&pb, 8, checksum);
1082
1083		✗	flush_put_bits(&pb);
1084
1085		✗	substream_data_len[0] = put_bytes_output(&pb);
1086
1087		✗	buf += substream_data_len[0];
1088
1089		✗	s->major_cur_subblock_index += s->major_filter_state_subblock + 1;
1090		✗	s->major_filter_state_subblock = 0;
1091
1092		✗	return buf;
1093			}
1094
1095			/** Writes the access unit and substream headers to the bitstream. */
1096		✗	static void write_frame_headers(MLPEncodeContext *ctx, uint8_t *frame_header,
1097			uint8_t *substream_headers, unsigned int length,
1098			int restart_frame,
1099			uint16_t substream_data_len[MAX_SUBSTREAMS])
1100			{
1101		✗	uint16_t access_unit_header = 0;
1102		✗	uint16_t substream_data_end = 0;
1103		✗	uint16_t parity_nibble = 0;
1104
1105		✗	parity_nibble = ctx->input_timing;
1106		✗	parity_nibble ^= length;
1107
1108		✗	for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
1109		✗	uint16_t substr_hdr = 0;
1110
1111		✗	substream_data_end += substream_data_len[substr];
1112
1113		✗	substr_hdr |= (0 << 15); /* extraword */
1114		✗	substr_hdr |= (!restart_frame << 14); /* !restart_frame */
1115		✗	substr_hdr |= (1 << 13); /* checkdata */
1116		✗	substr_hdr |= (0 << 12); /* ??? */
1117		✗	substr_hdr |= (substream_data_end / 2) & 0x0FFF;
1118
1119		✗	AV_WB16(substream_headers, substr_hdr);
1120
1121		✗	parity_nibble ^= *substream_headers++;
1122		✗	parity_nibble ^= *substream_headers++;
1123			}
1124
1125		✗	parity_nibble ^= parity_nibble >> 8;
1126		✗	parity_nibble ^= parity_nibble >> 4;
1127		✗	parity_nibble &= 0xF;
1128
1129		✗	access_unit_header |= (parity_nibble ^ 0xF) << 12;
1130		✗	access_unit_header |= length & 0xFFF;
1131
1132		✗	AV_WB16(frame_header , access_unit_header);
1133		✗	AV_WB16(frame_header+2, ctx->input_timing );
1134		✗	}
1135
1136			/** Writes an entire access unit to the bitstream. */
1137		✗	static int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf,
1138			int buf_size, int restart_frame)
1139			{
1140			uint16_t substream_data_len[MAX_SUBSTREAMS];
1141		✗	uint8_t *buf1, *buf0 = buf;
1142			int total_length;
1143
1144			/* Frame header will be written at the end. */
1145		✗	buf += 4;
1146		✗	buf_size -= 4;
1147
1148		✗	if (restart_frame) {
1149		✗	write_major_sync(ctx, buf, buf_size);
1150		✗	buf += 28;
1151		✗	buf_size -= 28;
1152			}
1153
1154		✗	buf1 = buf;
1155
1156			/* Substream headers will be written at the end. */
1157		✗	for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
1158		✗	buf += 2;
1159		✗	buf_size -= 2;
1160			}
1161
1162		✗	for (int substr = 0; substr < ctx->num_substreams; substr++) {
1163		✗	MLPSubstream *s = &ctx->s[substr];
1164		✗	uint8_t *buf0 = buf;
1165
1166		✗	buf = write_substr(ctx, s, buf, buf_size, restart_frame, &substream_data_len[substr]);
1167		✗	buf_size -= buf - buf0;
1168			}
1169
1170		✗	total_length = buf - buf0;
1171
1172		✗	write_frame_headers(ctx, buf0, buf1, total_length / 2, restart_frame, substream_data_len);
1173
1174		✗	return total_length;
1175			}
1176
1177			/****************************************************************************
1178			****************** Functions that input data to context ********************
1179			****************************************************************************/
1180
1181			/** Inputs data from the samples passed by lavc into the context, shifts them
1182			* appropriately depending on the bit-depth, and calculates the
1183			* lossless_check_data that will be written to the restart header.
1184			*/
1185		✗	static void input_data_internal(MLPEncodeContext *ctx, MLPSubstream *s,
1186			uint8_t **const samples,
1187			int nb_samples, int is24)
1188			{
1189		✗	int32_t *lossless_check_data = &s->b[ctx->frame_index].lossless_check_data;
1190		✗	RestartHeader *rh = &s->restart_header;
1191		✗	int32_t temp_lossless_check_data = 0;
1192		✗	uint32_t bits = 0;
1193
1194		✗	for (int i = 0; i < nb_samples; i++) {
1195		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1196		✗	const int32_t *samples_32 = (const int32_t *)samples[ch];
1197		✗	const int16_t *samples_16 = (const int16_t *)samples[ch];
1198		✗	int32_t *sample_buffer = s->b[ctx->frame_index].inout_buffer[ch];
1199			int32_t sample;
1200
1201		✗	sample = is24 ? samples_32[i] >> 8 : samples_16[i] * 256;
1202
1203		✗	bits = FFMAX(number_sbits(sample), bits);
1204
1205		✗	temp_lossless_check_data ^= (sample & 0x00ffffff) << ch;
1206		✗	sample_buffer[i] = sample;
1207			}
1208			}
1209
1210		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1211		✗	for (int i = nb_samples; i < ctx->avctx->frame_size; i++) {
1212		✗	int32_t *sample_buffer = s->b[ctx->frame_index].inout_buffer[ch];
1213
1214		✗	sample_buffer[i] = 0;
1215			}
1216			}
1217
1218		✗	s->b[ctx->frame_index].max_output_bits = bits;
1219
1220		✗	lossless_check_data[0] = temp_lossless_check_data;
1221		✗	}
1222
1223			/** Wrapper function for inputting data in two different bit-depths. */
1224		✗	static void input_data(MLPEncodeContext *ctx, MLPSubstream *s, uint8_t **const samples, int nb_samples)
1225			{
1226		✗	input_data_internal(ctx, s, samples, nb_samples, ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S32P);
1227		✗	}
1228
1229		✗	static void input_to_sample_buffer(MLPEncodeContext *ctx, MLPSubstream *s)
1230			{
1231		✗	RestartHeader *rh = &s->restart_header;
1232
1233		✗	for (unsigned int index = 0; index < ctx->number_of_frames; index++) {
1234		✗	unsigned int cur_index = (ctx->frame_index + index + 1) % ctx->cur_restart_interval;
1235		✗	DecodingParams *dp = &s->b[index+1].decoding_params;
1236
1237		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1238		✗	const int32_t *input_buffer = s->b[cur_index].inout_buffer[ch];
1239		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1240		✗	int off = 0;
1241
1242		✗	if (dp->blocksize < ctx->avctx->frame_size) {
1243		✗	DecodingParams *dp = &s->b[index].decoding_params;
1244		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1245		✗	for (unsigned int i = 0; i < dp->blocksize; i++)
1246		✗	sample_buffer[i] = input_buffer[i];
1247		✗	off = dp->blocksize;
1248			}
1249
1250		✗	for (unsigned int i = 0; i < dp->blocksize; i++)
1251		✗	sample_buffer[i] = input_buffer[i + off];
1252			}
1253			}
1254		✗	}
1255
1256			/****************************************************************************
1257			********* Functions that analyze the data and set the parameters ***********
1258			****************************************************************************/
1259
1260			/** Counts the number of trailing zeroes in a value */
1261		✗	static int number_trailing_zeroes(int32_t sample, unsigned int max, unsigned int def)
1262			{
1263		✗	return sample ? FFMIN(max, ff_ctz(sample)) : def;
1264			}
1265
1266		✗	static void determine_output_shift(MLPEncodeContext *ctx, MLPSubstream *s)
1267			{
1268		✗	RestartHeader *rh = s->cur_restart_header;
1269		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1270			int32_t sample_mask[MAX_CHANNELS];
1271
1272		✗	memset(sample_mask, 0, sizeof(sample_mask));
1273
1274		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1275		✗	DecodingParams *dp = &s->b[j].decoding_params;
1276
1277		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++) {
1278		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1279
1280		✗	for (int i = 0; i < dp->blocksize; i++)
1281		✗	sample_mask[ch] |= sample_buffer[i];
1282			}
1283			}
1284
1285		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
1286		✗	dp1->output_shift[ch] = number_trailing_zeroes(sample_mask[ch], 7, 0);
1287
1288		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1289		✗	DecodingParams *dp = &s->b[j].decoding_params;
1290
1291		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++) {
1292		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1293		✗	const int shift = dp1->output_shift[ch];
1294
1295		✗	for (int i = 0; i < dp->blocksize; i++)
1296		✗	sample_buffer[i] >>= shift;
1297			}
1298			}
1299		✗	}
1300
1301			/** Determines how many bits are zero at the end of all samples so they can be
1302			* shifted out.
1303			*/
1304		✗	static void determine_quant_step_size(MLPEncodeContext *ctx, MLPSubstream *s)
1305			{
1306		✗	RestartHeader *rh = s->cur_restart_header;
1307		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1308			int32_t sample_mask[MAX_CHANNELS];
1309
1310		✗	memset(sample_mask, 0, sizeof(sample_mask));
1311
1312		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1313		✗	DecodingParams *dp = &s->b[j].decoding_params;
1314
1315		✗	for (int ch = 0; ch <= rh->max_channel; ch++) {
1316		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1317
1318		✗	for (int i = 0; i < dp->blocksize; i++)
1319		✗	sample_mask[ch] |= sample_buffer[i];
1320			}
1321			}
1322
1323		✗	for (int ch = 0; ch <= rh->max_channel; ch++)
1324		✗	dp1->quant_step_size[ch] = number_trailing_zeroes(sample_mask[ch], 15, 0);
1325		✗	}
1326
1327			/** Determines the smallest number of bits needed to encode the filter
1328			* coefficients, and if it's possible to right-shift their values without
1329			* losing any precision.
1330			*/
1331		✗	static void code_filter_coeffs(MLPEncodeContext *ctx, FilterParams *fp, const int32_t *fcoeff)
1332			{
1333		✗	uint32_t coeff_mask = 0;
1334		✗	int bits = 0, shift;
1335
1336		✗	for (int order = 0; order < fp->order; order++) {
1337		✗	int32_t coeff = fcoeff[order];
1338
1339		✗	bits = FFMAX(number_sbits(coeff), bits);
1340
1341		✗	coeff_mask |= coeff;
1342			}
1343
1344		✗	shift = FFMIN(7, coeff_mask ? ff_ctz(coeff_mask) : 0);
1345
1346		✗	fp->coeff_bits = FFMAX(1, bits - shift);
1347		✗	fp->coeff_shift = FFMIN(shift, 16 - fp->coeff_bits);
1348		✗	}
1349
1350			/** Determines the best filter parameters for the given data and writes the
1351			* necessary information to the context.
1352			*/
1353		✗	static void set_filter(MLPEncodeContext *ctx, MLPSubstream *s,
1354			int channel, int retry_filter)
1355			{
1356		✗	ChannelParams *cp = &s->b[1].channel_params[channel];
1357		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1358		✗	FilterParams *fp = &cp->filter_params[FIR];
1359
1360		✗	if (retry_filter)
1361		✗	dp1->max_order[channel]--;
1362
1363		✗	if (dp1->max_order[channel] == 0) {
1364		✗	fp->order = 0;
1365			} else {
1366		✗	int32_t *lpc_samples = ctx->lpc_sample_buffer;
1367		✗	int32_t *fcoeff = cp->coeff[FIR];
1368			int shift[MAX_LPC_ORDER];
1369			int order;
1370
1371		✗	for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) {
1372		✗	DecodingParams *dp = &s->b[j].decoding_params;
1373		✗	int32_t *sample_buffer = dp->sample_buffer[channel];
1374
1375		✗	for (unsigned int i = 0; i < dp->blocksize; i++)
1376		✗	lpc_samples[i] = sample_buffer[i];
1377		✗	lpc_samples += dp->blocksize;
1378			}
1379
1380		✗	order = ff_lpc_calc_coefs(&ctx->lpc_ctx, ctx->lpc_sample_buffer,
1381		✗	lpc_samples - ctx->lpc_sample_buffer,
1382		✗	MLP_MIN_LPC_ORDER, dp1->max_order[channel],
1383			ctx->lpc_coeff_precision,
1384		✗	s->coefs[channel], shift, ctx->lpc_type, ctx->lpc_passes,
1385			ctx->prediction_order, MLP_MIN_LPC_SHIFT,
1386			MLP_MAX_LPC_SHIFT, 0);
1387
1388		✗	fp->order = order;
1389		✗	fp->shift = order ? shift[order-1] : 0;
1390
1391		✗	for (unsigned int i = 0; i < order; i++)
1392		✗	fcoeff[i] = s->coefs[channel][order-1][i];
1393
1394		✗	code_filter_coeffs(ctx, fp, fcoeff);
1395			}
1396		✗	}
1397
1398			/** Tries to determine a good prediction filter, and applies it to the samples
1399			* buffer if the filter is good enough. Sets the filter data to be cleared if
1400			* no good filter was found.
1401			*/
1402		✗	static void determine_filters(MLPEncodeContext *ctx, MLPSubstream *s)
1403			{
1404		✗	RestartHeader *rh = s->cur_restart_header;
1405
1406		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++)
1407		✗	set_filter(ctx, s, ch, 0);
1408		✗	}
1409
1410		✗	static int estimate_coeff(MLPEncodeContext *ctx, MLPSubstream *s,
1411			MatrixParams *mp,
1412			int ch0, int ch1)
1413			{
1414		✗	int32_t maxl = INT32_MIN, maxr = INT32_MIN, minl = INT32_MAX, minr = INT32_MAX;
1415		✗	int64_t summ = 0, sums = 0, suml = 0, sumr = 0, enl = 0, enr = 0;
1416		✗	const int shift = 14 - ctx->rematrix_precision;
1417			int32_t cf0, cf1, e[4], d[4], ml, mr;
1418		✗	int i, count = 0;
1419
1420		✗	for (int j = 0; j <= ctx->cur_restart_interval; j++) {
1421		✗	DecodingParams *dp = &s->b[j].decoding_params;
1422			const int32_t *ch[2];
1423
1424		✗	ch[0] = dp->sample_buffer[ch0];
1425		✗	ch[1] = dp->sample_buffer[ch1];
1426
1427		✗	for (int i = 0; i < dp->blocksize; i++) {
1428		✗	int32_t lm = ch[0][i], rm = ch[1][i];
1429
1430		✗	enl += FFABS(lm);
1431		✗	enr += FFABS(rm);
1432
1433		✗	summ += FFABS(lm + rm);
1434		✗	sums += FFABS(lm - rm);
1435
1436		✗	suml += lm;
1437		✗	sumr += rm;
1438
1439		✗	maxl = FFMAX(maxl, lm);
1440		✗	maxr = FFMAX(maxr, rm);
1441
1442		✗	minl = FFMIN(minl, lm);
1443		✗	minr = FFMIN(minr, rm);
1444			}
1445			}
1446
1447		✗	summ -= FFABS(suml + sumr);
1448		✗	sums -= FFABS(suml - sumr);
1449
1450		✗	ml = maxl - minl;
1451		✗	mr = maxr - minr;
1452
1453		✗	if (!summ && !sums)
1454		✗	return 0;
1455
1456		✗	if (!ml || !mr)
1457		✗	return 0;
1458
1459		✗	if ((FFABS(ml) + FFABS(mr)) >= (1 << 24))
1460		✗	return 0;
1461
1462		✗	cf0 = (FFMIN(FFABS(mr), FFABS(ml)) * (1LL << 14)) / FFMAX(FFABS(ml), FFABS(mr));
1463		✗	cf0 = (cf0 >> shift) << shift;
1464		✗	cf1 = -cf0;
1465
1466		✗	if (sums > summ)
1467		✗	FFSWAP(int32_t, cf0, cf1);
1468
1469		✗	count = 1;
1470		✗	i = enl < enr;
1471		✗	mp->outch[0] = ch0 + i;
1472
1473		✗	d[!i] = cf0;
1474		✗	d[ i] = 1 << 14;
1475		✗	e[!i] = cf1;
1476		✗	e[ i] = 1 << 14;
1477
1478		✗	mp->coeff[0][ch0] = av_clip_intp2(d[0], 15);
1479		✗	mp->coeff[0][ch1] = av_clip_intp2(d[1], 15);
1480
1481		✗	mp->forco[0][ch0] = av_clip_intp2(e[0], 15);
1482		✗	mp->forco[0][ch1] = av_clip_intp2(e[1], 15);
1483
1484		✗	return count;
1485			}
1486
1487			/** Determines how many fractional bits are needed to encode matrix
1488			* coefficients. Also shifts the coefficients to fit within 2.14 bits.
1489			*/
1490		✗	static void code_matrix_coeffs(MLPEncodeContext *ctx, MLPSubstream *s,
1491			DecodingParams *dp,
1492			unsigned int mat)
1493			{
1494		✗	RestartHeader *rh = s->cur_restart_header;
1495		✗	MatrixParams *mp = &dp->matrix_params;
1496		✗	int32_t coeff_mask = 0;
1497
1498		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++)
1499		✗	coeff_mask |= mp->coeff[mat][ch];
1500
1501		✗	mp->fbits[mat] = 14 - number_trailing_zeroes(coeff_mask, 14, 14);
1502		✗	}
1503
1504			/** Determines best coefficients to use for the lossless matrix. */
1505		✗	static void lossless_matrix_coeffs(MLPEncodeContext *ctx, MLPSubstream *s)
1506			{
1507		✗	RestartHeader *rh = s->cur_restart_header;
1508		✗	DecodingParams *dp = &s->b[1].decoding_params;
1509		✗	MatrixParams *mp = &dp->matrix_params;
1510
1511		✗	mp->count = 0;
1512		✗	if (ctx->num_channels - 2 != 2)
1513		✗	return;
1514
1515		✗	mp->count = estimate_coeff(ctx, s, mp,
1516		✗	rh->min_channel, rh->max_channel);
1517
1518		✗	for (int mat = 0; mat < mp->count; mat++)
1519		✗	code_matrix_coeffs(ctx, s, dp, mat);
1520			}
1521
1522			/** Min and max values that can be encoded with each codebook. The values for
1523			* the third codebook take into account the fact that the sign shift for this
1524			* codebook is outside the coded value, so it has one more bit of precision.
1525			* It should actually be -7 -> 7, shifted down by 0.5.
1526			*/
1527			static const int8_t codebook_extremes[3][2] = {
1528			{-9, 8}, {-8, 7}, {-15, 14},
1529			};
1530
1531			/** Determines the amount of bits needed to encode the samples using no
1532			* codebooks and a specified offset.
1533			*/
1534		✗	static void no_codebook_bits_offset(MLPEncodeContext *ctx,
1535			DecodingParams *dp,
1536			int channel, int32_t offset,
1537			int32_t min, int32_t max,
1538			BestOffset *bo)
1539			{
1540		✗	int32_t unsign = 0;
1541			int lsb_bits;
1542
1543		✗	min -= offset;
1544		✗	max -= offset;
1545
1546		✗	lsb_bits = FFMAX(number_sbits(min), number_sbits(max)) - 1;
1547
1548		✗	lsb_bits += !!lsb_bits;
1549
1550		✗	if (lsb_bits > 0)
1551		✗	unsign = 1U << (lsb_bits - 1);
1552
1553		✗	bo->offset = offset;
1554		✗	bo->lsb_bits = lsb_bits;
1555		✗	bo->bitcount = lsb_bits * dp->blocksize;
1556		✗	bo->min = offset - unsign + 1;
1557		✗	bo->max = offset + unsign;
1558		✗	}
1559
1560			/** Determines the least amount of bits needed to encode the samples using no
1561			* codebooks.
1562			*/
1563		✗	static void no_codebook_bits(MLPEncodeContext *ctx,
1564			DecodingParams *dp,
1565			int channel,
1566			int32_t min, int32_t max,
1567			BestOffset *bo)
1568			{
1569		✗	int32_t offset, unsign = 0;
1570			uint8_t lsb_bits;
1571
1572			/* Set offset inside huffoffset's boundaries by adjusting extremes
1573			* so that more bits are used, thus shifting the offset. */
1574		✗	if (min < HUFF_OFFSET_MIN)
1575		✗	max = FFMAX(max, 2 * HUFF_OFFSET_MIN - min + 1);
1576		✗	if (max > HUFF_OFFSET_MAX)
1577		✗	min = FFMIN(min, 2 * HUFF_OFFSET_MAX - max - 1);
1578
1579		✗	lsb_bits = FFMAX(number_sbits(min), number_sbits(max));
1580
1581		✗	if (lsb_bits > 0)
1582		✗	unsign = 1 << (lsb_bits - 1);
1583
1584			/* If all samples are the same (lsb_bits == 0), offset must be
1585			* adjusted because of sign_shift. */
1586		✗	offset = min + (max - min) / 2 + !!lsb_bits;
1587
1588		✗	bo->offset = offset;
1589		✗	bo->lsb_bits = lsb_bits;
1590		✗	bo->bitcount = lsb_bits * dp->blocksize;
1591		✗	bo->min = max - unsign + 1;
1592		✗	bo->max = min + unsign;
1593		✗	bo->min = FFMAX(bo->min, HUFF_OFFSET_MIN);
1594		✗	bo->max = FFMIN(bo->max, HUFF_OFFSET_MAX);
1595		✗	}
1596
1597			/** Determines the least amount of bits needed to encode the samples using a
1598			* given codebook and a given offset.
1599			*/
1600		✗	static inline void codebook_bits_offset(MLPEncodeContext *ctx,
1601			DecodingParams *dp,
1602			int channel, int codebook,
1603			int32_t sample_min, int32_t sample_max,
1604			int32_t offset, BestOffset *bo)
1605			{
1606		✗	int32_t codebook_min = codebook_extremes[codebook][0];
1607		✗	int32_t codebook_max = codebook_extremes[codebook][1];
1608		✗	int32_t *sample_buffer = dp->sample_buffer[channel];
1609		✗	int codebook_offset = 7 + (2 - codebook);
1610		✗	int32_t unsign_offset = offset;
1611		✗	uint32_t bitcount = 0;
1612		✗	int lsb_bits = 0;
1613		✗	int offset_min = INT_MAX, offset_max = INT_MAX;
1614			int unsign, mask;
1615
1616		✗	sample_min -= offset;
1617		✗	sample_max -= offset;
1618
1619		✗	while (sample_min < codebook_min || sample_max > codebook_max) {
1620		✗	lsb_bits++;
1621		✗	sample_min >>= 1;
1622		✗	sample_max >>= 1;
1623			}
1624
1625		✗	unsign = 1 << lsb_bits;
1626		✗	mask = unsign - 1;
1627
1628		✗	if (codebook == 2) {
1629		✗	unsign_offset -= unsign;
1630		✗	lsb_bits++;
1631			}
1632
1633		✗	for (int i = 0; i < dp->blocksize; i++) {
1634		✗	int32_t sample = sample_buffer[i] >> dp->quant_step_size[channel];
1635			int temp_min, temp_max;
1636
1637		✗	sample -= unsign_offset;
1638
1639		✗	temp_min = sample & mask;
1640		✗	if (temp_min < offset_min)
1641		✗	offset_min = temp_min;
1642
1643		✗	temp_max = unsign - temp_min - 1;
1644		✗	if (temp_max < offset_max)
1645		✗	offset_max = temp_max;
1646
1647		✗	sample >>= lsb_bits;
1648
1649		✗	bitcount += ff_mlp_huffman_tables[codebook][sample + codebook_offset][1];
1650			}
1651
1652		✗	bo->offset = offset;
1653		✗	bo->lsb_bits = lsb_bits;
1654		✗	bo->bitcount = lsb_bits * dp->blocksize + bitcount;
1655		✗	bo->min = FFMAX(offset - offset_min, HUFF_OFFSET_MIN);
1656		✗	bo->max = FFMIN(offset + offset_max, HUFF_OFFSET_MAX);
1657		✗	}
1658
1659			/** Determines the least amount of bits needed to encode the samples using a
1660			* given codebook. Searches for the best offset to minimize the bits.
1661			*/
1662		✗	static inline void codebook_bits(MLPEncodeContext *ctx,
1663			DecodingParams *dp,
1664			int channel, int codebook,
1665			int offset, int32_t min, int32_t max,
1666			BestOffset *bo, int direction)
1667			{
1668		✗	uint32_t previous_count = UINT32_MAX;
1669			int offset_min, offset_max;
1670		✗	int is_greater = 0;
1671
1672		✗	offset_min = FFMAX(min, HUFF_OFFSET_MIN);
1673		✗	offset_max = FFMIN(max, HUFF_OFFSET_MAX);
1674
1675		✗	while (offset <= offset_max && offset >= offset_min) {
1676			BestOffset temp_bo;
1677
1678		✗	codebook_bits_offset(ctx, dp, channel, codebook,
1679			min, max, offset,
1680			&temp_bo);
1681
1682		✗	if (temp_bo.bitcount < previous_count) {
1683		✗	if (temp_bo.bitcount < bo->bitcount)
1684		✗	*bo = temp_bo;
1685
1686		✗	is_greater = 0;
1687		✗	} else if (++is_greater >= ctx->max_codebook_search)
1688		✗	break;
1689
1690		✗	previous_count = temp_bo.bitcount;
1691
1692		✗	if (direction) {
1693		✗	offset = temp_bo.max + 1;
1694			} else {
1695		✗	offset = temp_bo.min - 1;
1696			}
1697			}
1698		✗	}
1699
1700			/** Determines the least amount of bits needed to encode the samples using
1701			* any or no codebook.
1702			*/
1703		✗	static void determine_bits(MLPEncodeContext *ctx, MLPSubstream *s)
1704			{
1705		✗	RestartHeader *rh = s->cur_restart_header;
1706		✗	for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
1707		✗	DecodingParams *dp = &s->b[index].decoding_params;
1708
1709		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
1710		✗	ChannelParams *cp = &s->b[index].channel_params[ch];
1711		✗	int32_t *sample_buffer = dp->sample_buffer[ch];
1712		✗	int32_t min = INT32_MAX, max = INT32_MIN;
1713		✗	int no_filters_used = !cp->filter_params[FIR].order;
1714		✗	int average = 0;
1715		✗	int offset = 0;
1716
1717			/* Determine extremes and average. */
1718		✗	for (int i = 0; i < dp->blocksize; i++) {
1719		✗	int32_t sample = sample_buffer[i] >> dp->quant_step_size[ch];
1720		✗	if (sample < min)
1721		✗	min = sample;
1722		✗	if (sample > max)
1723		✗	max = sample;
1724		✗	average += sample;
1725			}
1726		✗	average /= dp->blocksize;
1727
1728			/* If filtering is used, we always set the offset to zero, otherwise
1729			* we search for the offset that minimizes the bitcount. */
1730		✗	if (no_filters_used) {
1731		✗	no_codebook_bits(ctx, dp, ch, min, max, &s->b[index].best_offset[ch][0]);
1732		✗	offset = av_clip(average, HUFF_OFFSET_MIN, HUFF_OFFSET_MAX);
1733			} else {
1734		✗	no_codebook_bits_offset(ctx, dp, ch, offset, min, max, &s->b[index].best_offset[ch][0]);
1735			}
1736
1737		✗	for (int i = 1; i < NUM_CODEBOOKS; i++) {
1738		✗	BestOffset temp_bo = { 0, UINT32_MAX, 0, 0, 0, };
1739			int32_t offset_max;
1740
1741		✗	codebook_bits_offset(ctx, dp, ch, i - 1,
1742			min, max, offset,
1743			&temp_bo);
1744
1745		✗	if (no_filters_used) {
1746		✗	offset_max = temp_bo.max;
1747
1748		✗	codebook_bits(ctx, dp, ch, i - 1, temp_bo.min - 1,
1749			min, max, &temp_bo, 0);
1750		✗	codebook_bits(ctx, dp, ch, i - 1, offset_max + 1,
1751			min, max, &temp_bo, 1);
1752			}
1753
1754		✗	s->b[index].best_offset[ch][i] = temp_bo;
1755			}
1756			}
1757			}
1758		✗	}
1759
1760			/****************************************************************************
1761			*************** Functions that process the data in some way ****************
1762			****************************************************************************/
1763
1764			#define SAMPLE_MAX(bitdepth) ((1 << (bitdepth - 1)) - 1)
1765			#define SAMPLE_MIN(bitdepth) (~SAMPLE_MAX(bitdepth))
1766
1767			#define MSB_MASK(bits) (-(int)(1u << (bits)))
1768
1769			/** Applies the filter to the current samples, and saves the residual back
1770			* into the samples buffer. If the filter is too bad and overflows the
1771			* maximum amount of bits allowed (24), the samples buffer is left as is and
1772			* the function returns -1.
1773			*/
1774		✗	static int apply_filter(MLPEncodeContext *ctx, MLPSubstream *s, int channel)
1775			{
1776		✗	DecodingParams *dp = &s->b[1].decoding_params;
1777		✗	ChannelParams *cp = &s->b[1].channel_params[channel];
1778		✗	FilterParams *fp[NUM_FILTERS] = { &cp->filter_params[FIR],
1779		✗	&cp->filter_params[IIR], };
1780		✗	const uint8_t codebook = cp->codebook;
1781		✗	int32_t mask = MSB_MASK(dp->quant_step_size[channel]);
1782		✗	int32_t *sample_buffer = s->b[0].decoding_params.sample_buffer[channel];
1783		✗	unsigned int filter_shift = fp[FIR]->shift;
1784		✗	int32_t *filter_state[NUM_FILTERS] = { ctx->filter_state[FIR],
1785		✗	ctx->filter_state[IIR], };
1786		✗	int i, j = 1, k = 0;
1787
1788		✗	for (i = 0; i < 8; i++) {
1789		✗	filter_state[FIR][i] = sample_buffer[i];
1790		✗	filter_state[IIR][i] = sample_buffer[i];
1791			}
1792
1793		✗	while (1) {
1794		✗	int32_t *sample_buffer = s->b[j].decoding_params.sample_buffer[channel];
1795		✗	unsigned int blocksize = s->b[j].decoding_params.blocksize;
1796			int32_t sample, residual;
1797		✗	int64_t accum = 0;
1798
1799		✗	if (!blocksize)
1800		✗	break;
1801
1802		✗	for (int filter = 0; filter < NUM_FILTERS; filter++) {
1803		✗	int32_t *fcoeff = cp->coeff[filter];
1804		✗	for (unsigned int order = 0; order < fp[filter]->order; order++)
1805		✗	accum += (int64_t)filter_state[filter][i - 1 - order] *
1806		✗	fcoeff[order];
1807			}
1808
1809		✗	sample = sample_buffer[k];
1810		✗	accum >>= filter_shift;
1811		✗	residual = sample - (accum & mask);
1812
1813		✗	if ((codebook > 0) &&
1814		✗	(residual < SAMPLE_MIN(24) ||
1815			residual > SAMPLE_MAX(24)))
1816		✗	return -1;
1817
1818		✗	filter_state[FIR][i] = sample;
1819		✗	filter_state[IIR][i] = residual;
1820
1821		✗	i++;
1822		✗	k++;
1823		✗	if (k >= blocksize) {
1824		✗	k = 0;
1825		✗	j++;
1826		✗	if (j > ctx->cur_restart_interval)
1827		✗	break;
1828			}
1829			}
1830
1831		✗	for (int l = 0, j = 0; j <= ctx->cur_restart_interval; j++) {
1832		✗	int32_t *sample_buffer = s->b[j].decoding_params.sample_buffer[channel];
1833		✗	unsigned int blocksize = s->b[j].decoding_params.blocksize;
1834
1835		✗	for (int i = 0; i < blocksize; i++, l++)
1836		✗	sample_buffer[i] = filter_state[IIR][l];
1837			}
1838
1839		✗	return 0;
1840			}
1841
1842		✗	static void apply_filters(MLPEncodeContext *ctx, MLPSubstream *s)
1843			{
1844		✗	RestartHeader *rh = s->cur_restart_header;
1845
1846		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
1847		✗	while (apply_filter(ctx, s, ch) < 0) {
1848			/* Filter is horribly wrong. Retry. */
1849		✗	set_filter(ctx, s, ch, 1);
1850			}
1851			}
1852		✗	}
1853
1854			/** Generates two noise channels worth of data. */
1855		✗	static void generate_2_noise_channels(MLPEncodeContext *ctx, MLPSubstream *s)
1856			{
1857		✗	RestartHeader *rh = s->cur_restart_header;
1858		✗	uint32_t seed = rh->noisegen_seed;
1859
1860		✗	for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) {
1861		✗	DecodingParams *dp = &s->b[j].decoding_params;
1862		✗	int32_t *sample_buffer2 = dp->sample_buffer[ctx->num_channels-2];
1863		✗	int32_t *sample_buffer1 = dp->sample_buffer[ctx->num_channels-1];
1864
1865		✗	for (unsigned int i = 0; i < dp->blocksize; i++) {
1866		✗	uint16_t seed_shr7 = seed >> 7;
1867		✗	sample_buffer2[i] = ((int8_t)(seed >> 15)) * (1 << rh->noise_shift);
1868		✗	sample_buffer1[i] = ((int8_t) seed_shr7) * (1 << rh->noise_shift);
1869
1870		✗	seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1871			}
1872			}
1873
1874		✗	rh->noisegen_seed = seed & ((1 << 24)-1);
1875		✗	}
1876
1877			/** Rematrixes all channels using chosen coefficients. */
1878		✗	static void rematrix_channels(MLPEncodeContext *ctx, MLPSubstream *s)
1879			{
1880		✗	RestartHeader *rh = s->cur_restart_header;
1881		✗	DecodingParams *dp1 = &s->b[1].decoding_params;
1882		✗	MatrixParams *mp1 = &dp1->matrix_params;
1883		✗	const int maxchan = rh->max_matrix_channel;
1884			int32_t orig_samples[MAX_NCHANNELS];
1885			int32_t rematrix_samples[MAX_NCHANNELS];
1886		✗	uint8_t lsb_bypass[MAX_MATRICES] = { 0 };
1887
1888		✗	for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) {
1889		✗	DecodingParams *dp = &s->b[j].decoding_params;
1890		✗	MatrixParams *mp = &dp->matrix_params;
1891
1892		✗	for (unsigned int i = 0; i < dp->blocksize; i++) {
1893		✗	for (int ch = 0; ch <= maxchan; ch++)
1894		✗	orig_samples[ch] = rematrix_samples[ch] = dp->sample_buffer[ch][i];
1895
1896		✗	for (int mat = 0; mat < mp1->count; mat++) {
1897		✗	unsigned int outch = mp1->outch[mat];
1898		✗	int64_t accum = 0;
1899
1900		✗	for (int ch = 0; ch <= maxchan; ch++) {
1901		✗	int32_t sample = rematrix_samples[ch];
1902
1903		✗	accum += (int64_t)sample * mp1->forco[mat][ch];
1904			}
1905
1906		✗	rematrix_samples[outch] = accum >> 14;
1907			}
1908
1909		✗	for (int ch = 0; ch <= maxchan; ch++)
1910		✗	dp->sample_buffer[ch][i] = rematrix_samples[ch];
1911
1912		✗	for (unsigned int mat = 0; mat < mp1->count; mat++) {
1913		✗	int8_t *bypassed_lsbs = mp->bypassed_lsbs[mat];
1914		✗	unsigned int outch = mp1->outch[mat];
1915		✗	int64_t accum = 0;
1916			int8_t bit;
1917
1918		✗	for (int ch = 0; ch <= maxchan; ch++) {
1919		✗	int32_t sample = rematrix_samples[ch];
1920
1921		✗	accum += (int64_t)sample * mp1->coeff[mat][ch];
1922			}
1923
1924		✗	rematrix_samples[outch] = accum >> 14;
1925		✗	bit = rematrix_samples[outch] != orig_samples[outch];
1926
1927		✗	bypassed_lsbs[i] = bit;
1928		✗	lsb_bypass[mat] |= bit;
1929			}
1930			}
1931			}
1932
1933		✗	for (unsigned int mat = 0; mat < mp1->count; mat++)
1934		✗	mp1->lsb_bypass[mat] = lsb_bypass[mat];
1935		✗	}
1936
1937			/****************************************************************************
1938			**** Functions that deal with determining the best parameters and output ***
1939			****************************************************************************/
1940
1941			typedef struct PathCounter {
1942			char path[MAX_HEADER_INTERVAL + 2];
1943			int cur_idx;
1944			uint32_t bitcount;
1945			} PathCounter;
1946
1947			#define CODEBOOK_CHANGE_BITS 21
1948
1949		✗	static void clear_path_counter(PathCounter *path_counter)
1950			{
1951		✗	memset(path_counter, 0, (NUM_CODEBOOKS + 1) * sizeof(*path_counter));
1952		✗	}
1953
1954		✗	static int compare_best_offset(const BestOffset *prev, const BestOffset *cur)
1955			{
1956		✗	return prev->lsb_bits != cur->lsb_bits;
1957			}
1958
1959		✗	static uint32_t best_codebook_path_cost(MLPEncodeContext *ctx, MLPSubstream *s,
1960			int channel,
1961			PathCounter *src, int cur_codebook)
1962			{
1963		✗	int idx = src->cur_idx;
1964		✗	const BestOffset *cur_bo = s->b[idx].best_offset[channel],
1965		✗	*prev_bo = idx ? s->b[idx - 1].best_offset[channel] :
1966			restart_best_offset;
1967		✗	uint32_t bitcount = src->bitcount;
1968		✗	int prev_codebook = src->path[idx];
1969
1970		✗	bitcount += cur_bo[cur_codebook].bitcount;
1971
1972		✗	if (prev_codebook != cur_codebook ||
1973		✗	compare_best_offset(&prev_bo[prev_codebook], &cur_bo[cur_codebook]))
1974		✗	bitcount += CODEBOOK_CHANGE_BITS;
1975
1976		✗	return bitcount;
1977			}
1978
1979		✗	static void set_best_codebook(MLPEncodeContext *ctx, MLPSubstream *s)
1980			{
1981		✗	RestartHeader *rh = s->cur_restart_header;
1982
1983		✗	for (int channel = rh->min_channel; channel <= rh->max_channel; channel++) {
1984		✗	const BestOffset *prev_bo = restart_best_offset;
1985			BestOffset *cur_bo;
1986			PathCounter path_counter[NUM_CODEBOOKS + 1];
1987			unsigned int best_codebook;
1988			char *best_path;
1989
1990		✗	clear_path_counter(path_counter);
1991
1992		✗	for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
1993		✗	uint32_t best_bitcount = UINT32_MAX;
1994
1995		✗	cur_bo = s->b[index].best_offset[channel];
1996
1997		✗	for (unsigned int codebook = 0; codebook < NUM_CODEBOOKS; codebook++) {
1998		✗	uint32_t prev_best_bitcount = UINT32_MAX;
1999
2000		✗	for (unsigned int last_best = 0; last_best < 2; last_best++) {
2001		✗	PathCounter *dst_path = &path_counter[codebook];
2002			PathCounter *src_path;
2003			uint32_t temp_bitcount;
2004
2005			/* First test last path with same headers,
2006			* then with last best. */
2007		✗	if (last_best) {
2008		✗	src_path = &path_counter[NUM_CODEBOOKS];
2009			} else {
2010		✗	if (compare_best_offset(&prev_bo[codebook], &cur_bo[codebook]))
2011		✗	continue;
2012			else
2013		✗	src_path = &path_counter[codebook];
2014			}
2015
2016		✗	temp_bitcount = best_codebook_path_cost(ctx, s, channel, src_path, codebook);
2017
2018		✗	if (temp_bitcount < best_bitcount) {
2019		✗	best_bitcount = temp_bitcount;
2020		✗	best_codebook = codebook;
2021			}
2022
2023		✗	if (temp_bitcount < prev_best_bitcount) {
2024		✗	prev_best_bitcount = temp_bitcount;
2025		✗	if (src_path != dst_path)
2026		✗	memcpy(dst_path, src_path, sizeof(PathCounter));
2027		✗	if (dst_path->cur_idx < FF_ARRAY_ELEMS(dst_path->path) - 1)
2028		✗	dst_path->path[++dst_path->cur_idx] = codebook;
2029		✗	dst_path->bitcount = temp_bitcount;
2030			}
2031			}
2032			}
2033
2034		✗	prev_bo = cur_bo;
2035
2036		✗	memcpy(&path_counter[NUM_CODEBOOKS], &path_counter[best_codebook], sizeof(PathCounter));
2037			}
2038
2039		✗	best_path = path_counter[NUM_CODEBOOKS].path + 1;
2040
2041			/* Update context. */
2042		✗	for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
2043		✗	ChannelParams *cp = &s->b[index].channel_params[channel];
2044		✗	DecodingParams *dp = &s->b[index].decoding_params;
2045
2046		✗	best_codebook = *best_path++;
2047		✗	cur_bo = &s->b[index].best_offset[channel][best_codebook];
2048
2049		✗	cp->huff_offset = cur_bo->offset;
2050		✗	cp->huff_lsbs = cur_bo->lsb_bits + dp->quant_step_size[channel];
2051		✗	cp->codebook = best_codebook;
2052			}
2053			}
2054		✗	}
2055
2056			/** Analyzes all collected bitcounts and selects the best parameters for each
2057			* individual access unit.
2058			* TODO This is just a stub!
2059			*/
2060		✗	static void set_major_params(MLPEncodeContext *ctx, MLPSubstream *s)
2061			{
2062		✗	RestartHeader *rh = s->cur_restart_header;
2063		✗	uint8_t max_huff_lsbs = 0, max_output_bits = 0;
2064		✗	int8_t max_shift = 0;
2065
2066		✗	for (int index = 0; index < s->b[ctx->restart_intervals-1].seq_size; index++) {
2067		✗	memcpy(&s->b[index].major_decoding_params,
2068		✗	&s->b[index].decoding_params, sizeof(DecodingParams));
2069		✗	for (int ch = 0; ch <= rh->max_matrix_channel; ch++) {
2070		✗	int8_t shift = s->b[index].decoding_params.output_shift[ch];
2071
2072		✗	max_shift = FFMAX(max_shift, shift);
2073			}
2074		✗	for (int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
2075		✗	uint8_t huff_lsbs = s->b[index].channel_params[ch].huff_lsbs;
2076
2077		✗	max_huff_lsbs = FFMAX(max_huff_lsbs, huff_lsbs);
2078
2079		✗	memcpy(&s->b[index].major_channel_params[ch],
2080		✗	&s->b[index].channel_params[ch],
2081			sizeof(ChannelParams));
2082			}
2083			}
2084
2085		✗	rh->max_huff_lsbs = max_huff_lsbs;
2086		✗	rh->max_shift = max_shift;
2087
2088		✗	for (int index = 0; index < ctx->number_of_frames; index++)
2089		✗	if (max_output_bits < s->b[index].max_output_bits)
2090		✗	max_output_bits = s->b[index].max_output_bits;
2091		✗	rh->max_output_bits = max_output_bits;
2092
2093		✗	s->cur_restart_header = &s->restart_header;
2094
2095		✗	for (int index = 0; index <= ctx->cur_restart_interval; index++)
2096		✗	s->b[index].major_params_changed = compare_decoding_params(ctx, s, index);
2097
2098		✗	s->major_filter_state_subblock = 1;
2099		✗	s->major_cur_subblock_index = 0;
2100		✗	}
2101
2102		✗	static void analyze_sample_buffer(MLPEncodeContext *ctx, MLPSubstream *s)
2103			{
2104		✗	s->cur_restart_header = &s->restart_header;
2105
2106			/* Copy frame_size from frames 0...max to decoding_params 1...max + 1
2107			* decoding_params[0] is for the filter state subblock.
2108			*/
2109		✗	for (unsigned int index = 0; index < ctx->number_of_frames; index++) {
2110		✗	DecodingParams *dp = &s->b[index+1].decoding_params;
2111		✗	dp->blocksize = ctx->avctx->frame_size;
2112			}
2113			/* The official encoder seems to always encode a filter state subblock
2114			* even if there are no filters. TODO check if it is possible to skip
2115			* the filter state subblock for no filters.
2116			*/
2117		✗	s->b[0].decoding_params.blocksize = 8;
2118		✗	s->b[1].decoding_params.blocksize -= 8;
2119
2120		✗	input_to_sample_buffer (ctx, s);
2121		✗	determine_output_shift (ctx, s);
2122		✗	generate_2_noise_channels(ctx, s);
2123		✗	lossless_matrix_coeffs (ctx, s);
2124		✗	rematrix_channels (ctx, s);
2125		✗	determine_quant_step_size(ctx, s);
2126		✗	determine_filters (ctx, s);
2127		✗	apply_filters (ctx, s);
2128
2129		✗	copy_restart_frame_params(ctx, s);
2130
2131		✗	determine_bits(ctx, s);
2132
2133		✗	set_best_codebook(ctx, s);
2134		✗	}
2135
2136		✗	static void process_major_frame(MLPEncodeContext *ctx, MLPSubstream *s)
2137			{
2138		✗	ctx->number_of_frames = ctx->major_number_of_frames;
2139
2140		✗	s->cur_restart_header = &s->restart_header;
2141
2142		✗	generate_2_noise_channels(ctx, s);
2143		✗	rematrix_channels (ctx, s);
2144
2145		✗	apply_filters(ctx, s);
2146		✗	}
2147
2148			/****************************************************************************/
2149
2150		✗	static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
2151			const AVFrame *frame, int *got_packet)
2152			{
2153		✗	MLPEncodeContext *ctx = avctx->priv_data;
2154		✗	int bytes_written = 0;
2155		✗	int channels = avctx->ch_layout.nb_channels;
2156			int restart_frame, ret;
2157			const uint8_t *data;
2158
2159		✗	if (!frame && !ctx->last_frames)
2160		✗	ctx->last_frames = (ctx->afq.remaining_samples + avctx->frame_size - 1) / avctx->frame_size;
2161
2162		✗	if (!frame && !ctx->last_frames--)
2163		✗	return 0;
2164
2165		✗	if ((ret = ff_alloc_packet(avctx, avpkt, 87500 * channels)) < 0)
2166		✗	return ret;
2167
2168		✗	if (frame) {
2169			/* add current frame to queue */
2170		✗	if ((ret = ff_af_queue_add(&ctx->afq, frame)) < 0)
2171		✗	return ret;
2172			}
2173
2174		✗	data = frame ? frame->data[0] : NULL;
2175
2176		✗	ctx->frame_index = avctx->frame_num % ctx->cur_restart_interval;
2177
2178		✗	if (avctx->frame_num < ctx->cur_restart_interval) {
2179		✗	if (data)
2180		✗	goto input_and_return;
2181			}
2182
2183		✗	restart_frame = !ctx->frame_index;
2184
2185		✗	if (restart_frame) {
2186		✗	avpkt->flags |= AV_PKT_FLAG_KEY;
2187		✗	for (int n = 0; n < ctx->num_substreams; n++)
2188		✗	set_major_params(ctx, &ctx->s[n]);
2189
2190		✗	if (ctx->min_restart_interval != ctx->cur_restart_interval)
2191		✗	process_major_frame(ctx, &ctx->s[0]);
2192			}
2193
2194		✗	bytes_written = write_access_unit(ctx, avpkt->data, avpkt->size, restart_frame);
2195
2196		✗	ctx->output_timing += avctx->frame_size;
2197		✗	ctx->input_timing += avctx->frame_size;
2198
2199		✗	input_and_return:
2200
2201		✗	if (frame) {
2202		✗	ctx->shorten_by = avctx->frame_size - frame->nb_samples;
2203		✗	ctx->next_major_frame_size += avctx->frame_size;
2204		✗	ctx->next_major_number_of_frames++;
2205			}
2206		✗	if (data)
2207		✗	for (int n = 0; n < ctx->num_substreams; n++)
2208		✗	input_data(ctx, &ctx->s[n], frame->extended_data, frame->nb_samples);
2209
2210		✗	restart_frame = (ctx->frame_index + 1) % ctx->min_restart_interval;
2211
2212		✗	if (!restart_frame) {
2213		✗	for (unsigned int seq_index = 0; seq_index < ctx->restart_intervals; seq_index++) {
2214			unsigned int number_of_samples;
2215
2216		✗	ctx->number_of_frames = ctx->next_major_number_of_frames;
2217		✗	ctx->number_of_subblocks = ctx->next_major_number_of_frames + 1;
2218
2219		✗	number_of_samples = avctx->frame_size * ctx->number_of_frames;
2220
2221		✗	for (int n = 0; n < ctx->num_substreams; n++) {
2222		✗	MLPSubstream *s = &ctx->s[n];
2223
2224		✗	for (int i = 0; i < s->b[seq_index].seq_size; i++) {
2225		✗	clear_channel_params(s->b[i].channel_params, channels);
2226		✗	default_decoding_params(ctx, &s->b[i].decoding_params);
2227			}
2228			}
2229
2230		✗	if (number_of_samples > 0) {
2231		✗	for (int n = 0; n < ctx->num_substreams; n++)
2232		✗	analyze_sample_buffer(ctx, &ctx->s[n]);
2233			}
2234			}
2235
2236		✗	if (ctx->frame_index == (ctx->cur_restart_interval - 1)) {
2237		✗	ctx->major_frame_size = ctx->next_major_frame_size;
2238		✗	ctx->next_major_frame_size = 0;
2239		✗	ctx->major_number_of_frames = ctx->next_major_number_of_frames;
2240		✗	ctx->next_major_number_of_frames = 0;
2241			}
2242			}
2243
2244		✗	if (!frame && ctx->last_frames < ctx->cur_restart_interval - 1)
2245		✗	avctx->frame_num++;
2246
2247		✗	if (bytes_written > 0) {
2248		✗	ff_af_queue_remove(&ctx->afq,
2249		✗	FFMIN(avctx->frame_size, ctx->afq.remaining_samples),
2250			&avpkt->pts,
2251			&avpkt->duration);
2252
2253		✗	av_shrink_packet(avpkt, bytes_written);
2254
2255		✗	*got_packet = 1;
2256			} else {
2257		✗	*got_packet = 0;
2258			}
2259
2260		✗	return 0;
2261			}
2262
2263		✗	static av_cold int mlp_encode_close(AVCodecContext *avctx)
2264			{
2265		✗	MLPEncodeContext *ctx = avctx->priv_data;
2266
2267		✗	ff_lpc_end(&ctx->lpc_ctx);
2268		✗	ff_af_queue_close(&ctx->afq);
2269
2270		✗	return 0;
2271			}
2272
2273			#define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
2274			#define OFFSET(x) offsetof(MLPEncodeContext, x)
2275			static const AVOption mlp_options[] = {
2276			{ "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 },
2277			{ "lpc_coeff_precision", "LPC coefficient precision", OFFSET(lpc_coeff_precision), AV_OPT_TYPE_INT, {.i64 = 15 }, 0, 15, FLAGS },
2278			{ "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" },
2279			{ "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, 0, 0, FLAGS, .unit = "lpc_type" },
2280			{ "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, 0, 0, FLAGS, .unit = "lpc_type" },
2281			{ "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 },
2282			{ "codebook_search", "Max number of codebook searches", OFFSET(max_codebook_search), AV_OPT_TYPE_INT, {.i64 = 3 }, 1, 100, FLAGS },
2283			{ "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" },
2284			{ "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST }, 0, 0, FLAGS, .unit = "predm" },
2285			{ "search", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, 0, 0, FLAGS, .unit = "predm" },
2286			{ "rematrix_precision", "Rematrix coefficient precision", OFFSET(rematrix_precision), AV_OPT_TYPE_INT, {.i64 = 1 }, 0, 14, FLAGS },
2287			{ NULL },
2288			};
2289
2290			static const AVClass mlp_class = {
2291			.class_name = "mlpenc",
2292			.item_name = av_default_item_name,
2293			.option = mlp_options,
2294			.version = LIBAVUTIL_VERSION_INT,
2295			};
2296
2297			#if CONFIG_MLP_ENCODER
2298			const FFCodec ff_mlp_encoder = {
2299			.p.name ="mlp",
2300			CODEC_LONG_NAME("MLP (Meridian Lossless Packing)"),
2301			.p.type = AVMEDIA_TYPE_AUDIO,
2302			.p.id = AV_CODEC_ID_MLP,
2303			.p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2304			AV_CODEC_CAP_EXPERIMENTAL,
2305			.priv_data_size = sizeof(MLPEncodeContext),
2306			.init = mlp_encode_init,
2307			FF_CODEC_ENCODE_CB(mlp_encode_frame),
2308			.close = mlp_encode_close,
2309			.p.priv_class = &mlp_class,
2310			.p.sample_fmts = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE},
2311			.p.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
2312			.p.ch_layouts = ff_mlp_ch_layouts,
2313			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2314			};
2315			#endif
2316			#if CONFIG_TRUEHD_ENCODER
2317			const FFCodec ff_truehd_encoder = {
2318			.p.name ="truehd",
2319			CODEC_LONG_NAME("TrueHD"),
2320			.p.type = AVMEDIA_TYPE_AUDIO,
2321			.p.id = AV_CODEC_ID_TRUEHD,
2322			.p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2323			AV_CODEC_CAP_SMALL_LAST_FRAME |
2324			AV_CODEC_CAP_EXPERIMENTAL,
2325			.priv_data_size = sizeof(MLPEncodeContext),
2326			.init = mlp_encode_init,
2327			FF_CODEC_ENCODE_CB(mlp_encode_frame),
2328			.close = mlp_encode_close,
2329			.p.priv_class = &mlp_class,
2330			.p.sample_fmts = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE},
2331			.p.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
2332			.p.ch_layouts = (const AVChannelLayout[]) {
2333			AV_CHANNEL_LAYOUT_MONO,
2334			AV_CHANNEL_LAYOUT_STEREO,
2335			AV_CHANNEL_LAYOUT_2POINT1,
2336			AV_CHANNEL_LAYOUT_SURROUND,
2337			AV_CHANNEL_LAYOUT_3POINT1,
2338			AV_CHANNEL_LAYOUT_4POINT0,
2339			AV_CHANNEL_LAYOUT_4POINT1,
2340			AV_CHANNEL_LAYOUT_5POINT0,
2341			AV_CHANNEL_LAYOUT_5POINT1,
2342			{ 0 }
2343			},
2344			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2345			};
2346			#endif
2347