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