| @@ -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 |