As well as tables littered everywhere, functions were spread out all across the encoder's files. This moves them to a single place where they can be used by either the encoder's main files or additional encoder files. Additionally, it changes the type of some to 'inline' to enable us to simply put them in a header file and possibly gain some speed due to compiler optimizations.
Unified · Split
| @@ -40,6 +40,7 @@ · 39 unmodified lines | |||
| 40 | #include "aacenc.h" | 40 | #include "aacenc.h" |
| 41 | #include "aactab.h" | 41 | #include "aactab.h" |
| 42 | #include "aacenctab.h" | 42 | #include "aacenctab.h" |
| 43 | #include "aacenc_utils.h" | ||
| 43 | #include "aac_tablegen_decl.h" | 44 | #include "aac_tablegen_decl.h" |
| 44 | 45 | ||
| 45 | /** Frequency in Hz for lower limit of noise substitution **/ | 46 | /** Frequency in Hz for lower limit of noise substitution **/ |
| @@ -57,45 +58,6 @@ · 11 unmodified lines | |||
| 57 | /** Frequency in Hz for lower limit of intensity stereo **/ | 58 | /** Frequency in Hz for lower limit of intensity stereo **/ |
| 58 | #define INT_STEREO_LOW_LIMIT 6100 | 59 | #define INT_STEREO_LOW_LIMIT 6100 |
| 59 | 60 | ||
| 60 | #define ROUND_STANDARD 0.4054f | ||
| 61 | #define ROUND_TO_ZERO 0.1054f | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Quantize one coefficient. | ||
| 65 | * @return absolute value of the quantized coefficient | ||
| 66 | * @see 3GPP TS26.403 5.6.2 "Scalefactor determination" | ||
| 67 | */ | ||
| 68 | static av_always_inline int quant(float coef, const float Q, const float rounding) | ||
| 69 | { | ||
| 70 | float a = coef * Q; | ||
| 71 | return sqrtf(a * sqrtf(a)) + rounding; | ||
| 72 | } | ||
| 73 | |||
| 74 | static void quantize_bands(int *out, const float *in, const float *scaled, | ||
| 75 | int size, float Q34, int is_signed, int maxval, const float rounding) | ||
| 76 | { | ||
| 77 | int i; | ||
| 78 | double qc; | ||
| 79 | for (i = 0; i < size; i++) { | ||
| 80 | qc = scaled[i] * Q34; | ||
| 81 | out[i] = (int)FFMIN(qc + rounding, (double)maxval); | ||
| 82 | if (is_signed && in[i] < 0.0f) { | ||
| 83 | out[i] = -out[i]; | ||
| 84 | } | ||
| 85 | } | ||
| 86 | } | ||
| 87 | |||
| 88 | static void abs_pow34_v(float *out, const float *in, const int size) | ||
| 89 | { | ||
| 90 | #ifndef USE_REALLY_FULL_SEARCH | ||
| 91 | int i; | ||
| 92 | for (i = 0; i < size; i++) { | ||
| 93 | float a = fabsf(in[i]); | ||
| 94 | out[i] = sqrtf(a * sqrtf(a)); | ||
| 95 | } | ||
| 96 | #endif /* USE_REALLY_FULL_SEARCH */ | ||
| 97 | } | ||
| 98 | |||
| 99 | /** | 61 | /** |
| 100 | * Calculate rate distortion cost for quantizing with given codebook | 62 | * Calculate rate distortion cost for quantizing with given codebook |
| 101 | * | 63 | * |
| @@ -310,32 +272,6 @@ static void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb, · 208 unmodified lines | |||
| 310 | INFINITY, NULL, rtz); | 272 | INFINITY, NULL, rtz); |
| 311 | } | 273 | } |
| 312 | 274 | ||
| 313 | static float find_max_val(int group_len, int swb_size, const float *scaled) { | ||
| 314 | float maxval = 0.0f; | ||
| 315 | int w2, i; | ||
| 316 | for (w2 = 0; w2 < group_len; w2++) { | ||
| 317 | for (i = 0; i < swb_size; i++) { | ||
| 318 | maxval = FFMAX(maxval, scaled[w2*128+i]); | ||
| 319 | } | ||
| 320 | } | ||
| 321 | return maxval; | ||
| 322 | } | ||
| 323 | |||
| 324 | static int find_min_book(float maxval, int sf) { | ||
| 325 | float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512]; | ||
| 326 | float Q34 = sqrtf(Q * sqrtf(Q)); | ||
| 327 | int qmaxval, cb; | ||
| 328 | qmaxval = maxval * Q34 + 0.4054f; | ||
| 329 | if (qmaxval == 0) cb = 0; | ||
| 330 | else if (qmaxval == 1) cb = 1; | ||
| 331 | else if (qmaxval == 2) cb = 3; | ||
| 332 | else if (qmaxval <= 4) cb = 5; | ||
| 333 | else if (qmaxval <= 7) cb = 7; | ||
| 334 | else if (qmaxval <= 12) cb = 9; | ||
| 335 | else cb = 11; | ||
| 336 | return cb; | ||
| 337 | } | ||
| 338 | |||
| 339 | /** | 275 | /** |
| 340 | * structure used in optimal codebook search | 276 | * structure used in optimal codebook search |
| 341 | */ | 277 | */ |
| @@ -590,16 +526,6 @@ static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce, · 248 unmodified lines | |||
| 590 | } | 526 | } |
| 591 | } | 527 | } |
| 592 | 528 | ||
| 593 | /** Return the minimum scalefactor where the quantized coef does not clip. */ | ||
| 594 | static av_always_inline uint8_t coef2minsf(float coef) { | ||
| 595 | return av_clip_uint8(log2f(coef)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512); | ||
| 596 | } | ||
| 597 | |||
| 598 | /** Return the maximum scalefactor where the quantized coef is not zero. */ | ||
| 599 | static av_always_inline uint8_t coef2maxsf(float coef) { | ||
| 600 | return av_clip_uint8(log2f(coef)*4 + 6 + SCALE_ONE_POS - SCALE_DIV_512); | ||
| 601 | } | ||
| 602 | |||
| 603 | typedef struct TrellisPath { | 529 | typedef struct TrellisPath { |
| 604 | float cost; | 530 | float cost; |
| 605 | int prev; | 531 | int prev; |
| @@ -43,20 +43,10 @@ · 42 unmodified lines | |||
| 43 | #include "aactab.h" | 43 | #include "aactab.h" |
| 44 | #include "aacenc.h" | 44 | #include "aacenc.h" |
| 45 | #include "aacenctab.h" | 45 | #include "aacenctab.h" |
| 46 | #include "aacenc_utils.h" | ||
| 46 | 47 | ||
| 47 | #include "psymodel.h" | 48 | #include "psymodel.h" |
| 48 | 49 | ||
| 49 | #define ERROR_IF(cond, ...) \ | ||
| 50 | if (cond) { \ | ||
| 51 | av_log(avctx, AV_LOG_ERROR, __VA_ARGS__); \ | ||
| 52 | return AVERROR(EINVAL); \ | ||
| 53 | } | ||
| 54 | |||
| 55 | #define WARN_IF(cond, ...) \ | ||
| 56 | if (cond) { \ | ||
| 57 | av_log(avctx, AV_LOG_WARNING, __VA_ARGS__); \ | ||
| 58 | } | ||
| 59 | |||
| 60 | /** | 50 | /** |
| 61 | * Make AAC audio config object. | 51 | * Make AAC audio config object. |
| 62 | * @see 1.6.2.1 "Syntax - AudioSpecificConfig" | 52 | * @see 1.6.2.1 "Syntax - AudioSpecificConfig" |
| @@ -0,0 +1,143 @@ | |||
| 1 | /* | ||
| 2 | * AAC encoder utilities | ||
| 3 | * Copyright (C) 2015 Rostislav Pehlivanov | ||
| 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 | /** | ||
| 23 | * @file | ||
| 24 | * AAC encoder utilities | ||
| 25 | * @author Rostislav Pehlivanov ( atomnuker gmail com ) | ||
| 26 | */ | ||
| 27 | |||
| 28 | #ifndef AVCODEC_AACENC_UTILS_H | ||
| 29 | #define AVCODEC_AACENC_UTILS_H | ||
| 30 | |||
| 31 | #include "aac.h" | ||
| 32 | #include "aac_tablegen_decl.h" | ||
| 33 | #include "aacenctab.h" | ||
| 34 | |||
| 35 | #define ROUND_STANDARD 0.4054f | ||
| 36 | #define ROUND_TO_ZERO 0.1054f | ||
| 37 | #define C_QUANT 0.4054f | ||
| 38 | |||
| 39 | static inline void abs_pow34_v(float *out, const float *in, const int size) | ||
| 40 | { | ||
| 41 | int i; | ||
| 42 | for (i = 0; i < size; i++) { | ||
| 43 | float a = fabsf(in[i]); | ||
| 44 | out[i] = sqrtf(a * sqrtf(a)); | ||
| 45 | } | ||
| 46 | } | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Quantize one coefficient. | ||
| 50 | * @return absolute value of the quantized coefficient | ||
| 51 | * @see 3GPP TS26.403 5.6.2 "Scalefactor determination" | ||
| 52 | */ | ||
| 53 | static inline int quant(float coef, const float Q, const float rounding) | ||
| 54 | { | ||
| 55 | float a = coef * Q; | ||
| 56 | return sqrtf(a * sqrtf(a)) + rounding; | ||
| 57 | } | ||
| 58 | |||
| 59 | static inline void quantize_bands(int *out, const float *in, const float *scaled, | ||
| 60 | int size, float Q34, int is_signed, int maxval, | ||
| 61 | const float rounding) | ||
| 62 | { | ||
| 63 | int i; | ||
| 64 | double qc; | ||
| 65 | for (i = 0; i < size; i++) { | ||
| 66 | qc = scaled[i] * Q34; | ||
| 67 | out[i] = (int)FFMIN(qc + rounding, (double)maxval); | ||
| 68 | if (is_signed && in[i] < 0.0f) { | ||
| 69 | out[i] = -out[i]; | ||
| 70 | } | ||
| 71 | } | ||
| 72 | } | ||
| 73 | |||
| 74 | static inline float find_max_val(int group_len, int swb_size, const float *scaled) | ||
| 75 | { | ||
| 76 | float maxval = 0.0f; | ||
| 77 | int w2, i; | ||
| 78 | for (w2 = 0; w2 < group_len; w2++) { | ||
| 79 | for (i = 0; i < swb_size; i++) { | ||
| 80 | maxval = FFMAX(maxval, scaled[w2*128+i]); | ||
| 81 | } | ||
| 82 | } | ||
| 83 | return maxval; | ||
| 84 | } | ||
| 85 | |||
| 86 | static inline int find_min_book(float maxval, int sf) | ||
| 87 | { | ||
| 88 | float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512]; | ||
| 89 | float Q34 = sqrtf(Q * sqrtf(Q)); | ||
| 90 | int qmaxval, cb; | ||
| 91 | qmaxval = maxval * Q34 + C_QUANT; | ||
| 92 | if (qmaxval == 0) cb = 0; | ||
| 93 | else if (qmaxval == 1) cb = 1; | ||
| 94 | else if (qmaxval == 2) cb = 3; | ||
| 95 | else if (qmaxval <= 4) cb = 5; | ||
| 96 | else if (qmaxval <= 7) cb = 7; | ||
| 97 | else if (qmaxval <= 12) cb = 9; | ||
| 98 | else cb = 11; | ||
| 99 | return cb; | ||
| 100 | } | ||
| 101 | |||
| 102 | /** Return the minimum scalefactor where the quantized coef does not clip. */ | ||
| 103 | static inline uint8_t coef2minsf(float coef) | ||
| 104 | { | ||
| 105 | return av_clip_uint8(log2f(coef)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512); | ||
| 106 | } | ||
| 107 | |||
| 108 | /** Return the maximum scalefactor where the quantized coef is not zero. */ | ||
| 109 | static inline uint8_t coef2maxsf(float coef) | ||
| 110 | { | ||
| 111 | return av_clip_uint8(log2f(coef)*4 + 6 + SCALE_ONE_POS - SCALE_DIV_512); | ||
| 112 | } | ||
| 113 | |||
| 114 | /* | ||
| 115 | * Returns the closest possible index to an array of float values, given a value. | ||
| 116 | */ | ||
| 117 | static inline int quant_array_idx(const float val, const float *arr, const int num) | ||
| 118 | { | ||
| 119 | int i, index = 0; | ||
| 120 | float quant_min_err = INFINITY; | ||
| 121 | for (i = 0; i < num; i++) { | ||
| 122 | float error = (val - arr[i])*(val - arr[i]); | ||
| 123 | if (error < quant_min_err) { | ||
| 124 | quant_min_err = error; | ||
| 125 | index = i; | ||
| 126 | } | ||
| 127 | } | ||
| 128 | return index; | ||
| 129 | } | ||
| 130 | |||
| 131 | #define ERROR_IF(cond, ...) \ | ||
| 132 | if (cond) { \ | ||
| 133 | av_log(avctx, AV_LOG_ERROR, __VA_ARGS__); \ | ||
| 134 | return AVERROR(EINVAL); \ | ||
| 135 | } | ||
| 136 | |||
| 137 | #define WARN_IF(cond, ...) \ | ||
| 138 | if (cond) { \ | ||
| 139 | av_log(avctx, AV_LOG_WARNING, __VA_ARGS__); \ | ||
| 140 | } | ||
| 141 | |||
| 142 | |||
| 143 | #endif /* AVCODEC_AACENC_UTILS_H */ | ||