├── .github └── FUNDING.yml ├── .gitignore ├── CMakeLists.txt ├── LICENSE ├── README.md ├── dr_mp3.h ├── dr_wav.h ├── main.c └── timing.h /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | 3 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2] 4 | patreon: # Replace with a single Patreon username 5 | open_collective: # Replace with a single Open Collective username 6 | ko_fi: # Replace with a single Ko-fi username 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry 9 | liberapay: # Replace with a single Liberapay username 10 | issuehunt: # Replace with a single IssueHunt username 11 | otechie: # Replace with a single Otechie username 12 | custom: https://www.paypal.com/paypalme/cpuimage/ 13 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | .idea/ 3 | 4 | cmake-build-debug/ 5 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8) 2 | project(resampler LANGUAGES C) 3 | set(CMAKE_POSITION_INDEPENDENT_CODE ON) 4 | SET(CMAKE_BUILD_TYPE "Release") 5 | 6 | include_directories(include) 7 | add_executable(resampler main.c) 8 | 9 | target_link_libraries(resampler -lm) -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2019 Zhihan Gao 2 | 3 | MIT License 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # resampler 2 | A Simple and Efficient Audio Resampler Implementation in C. 3 | 4 | Example 5 | ======= 6 | 7 | ```C 8 | 9 | uint64_t Resample_f32(const float *input, float *output, int inSampleRate, int outSampleRate, uint64_t inputSize, 10 | uint32_t channels) { 11 | if (input == NULL) 12 | return 0; 13 | 14 | uint64_t outputSize = (uint64_t) (inputSize * (double) outSampleRate / (double) inSampleRate); 15 | outputSize -= outputSize % channels; 16 | 17 | if (output == NULL) 18 | return outputSize; 19 | 20 | double stepDist = ((double) inSampleRate / (double) outSampleRate); 21 | const uint64_t fixedFraction = (1LL << 32); 22 | const double normFixed = (1.0 / (1LL << 32)); 23 | uint64_t step = ((uint64_t) (stepDist * fixedFraction + 0.5)); 24 | uint64_t curOffset = 0; 25 | 26 | for (uint32_t i = 0; i < outputSize - channels; i += channels) { 27 | uint64_t currentPos = curOffset >> 32; 28 | uint64_t nextPos = currentPos + 1; 29 | for (uint32_t c = 0; c < channels; c++) { 30 | float current = input[currentPos * channels + c]; 31 | float next = input[nextPos * channels + c]; 32 | double frac = (curOffset & (fixedFraction - 1)) * normFixed; 33 | *output++ = (float) (current + (next - current) * frac); 34 | } 35 | curOffset += step; 36 | uint64_t frameSkip = (curOffset >> 32); 37 | curOffset &= (fixedFraction - 1); 38 | input += frameSkip * channels; 39 | } 40 | uint64_t lastPos = (curOffset >> 32); 41 | for (uint32_t c = 0; c < channels; c++) { 42 | *output++ = input[lastPos * channels + c]; 43 | } 44 | return outputSize; 45 | } 46 | 47 | uint64_t Resample_s16(const int16_t *input, int16_t *output, int inSampleRate, int outSampleRate, uint64_t inputSize, 48 | uint32_t channels) { 49 | if (input == NULL) 50 | return 0; 51 | 52 | uint64_t outputSize = (uint64_t) (inputSize * (double) outSampleRate / (double) inSampleRate); 53 | outputSize -= outputSize % channels; 54 | 55 | if (output == NULL) 56 | return outputSize; 57 | 58 | double stepDist = ((double) inSampleRate / (double) outSampleRate); 59 | const uint64_t fixedFraction = (1LL << 32); 60 | const double normFixed = (1.0 / (1LL << 32)); 61 | uint64_t step = ((uint64_t) (stepDist * fixedFraction + 0.5)); 62 | uint64_t curOffset = 0; 63 | 64 | for (uint32_t i = 0; i < outputSize - channels; i += channels) { 65 | uint64_t currentPos = curOffset >> 32; 66 | uint64_t nextPos = currentPos + 1; 67 | for (uint32_t c = 0; c < channels; c++) { 68 | int16_t current = input[currentPos * channels + c]; 69 | int16_t next = input[nextPos * channels + c]; 70 | double frac = (curOffset & (fixedFraction - 1)) * normFixed; 71 | *output++ = (int16_t) (current + (next - current) * frac); 72 | } 73 | curOffset += step; 74 | uint64_t frameSkip = (curOffset >> 32); 75 | curOffset &= (fixedFraction - 1); 76 | input += frameSkip * channels; 77 | } 78 | uint64_t lastPos = (curOffset >> 32); 79 | for (uint32_t c = 0; c < channels; c++) { 80 | *output++ = input[lastPos * channels + c]; 81 | } 82 | return outputSize; 83 | } 84 | ``` 85 | 86 | 87 | 88 | 89 | # Donating 90 | 91 | If you found this project useful, consider buying me a coffee 92 | 93 | Buy Me A Coffee 94 | -------------------------------------------------------------------------------- /dr_mp3.h: -------------------------------------------------------------------------------- 1 | // MP3 audio decoder. Public domain. See "unlicense" statement at the end of this file. 2 | // dr_mp3 - v0.4.1 - 2018-12-30 3 | // 4 | // David Reid - mackron@gmail.com 5 | // 6 | // Based off minimp3 (https://github.com/lieff/minimp3) which is where the real work was done. See the bottom of this file for 7 | // differences between minimp3 and dr_mp3. 8 | 9 | // USAGE 10 | // ===== 11 | // dr_mp3 is a single-file library. To use it, do something like the following in one .c file. 12 | // #define DR_MP3_IMPLEMENTATION 13 | // #include "dr_mp3.h" 14 | // 15 | // You can then #include this file in other parts of the program as you would with any other header file. To decode audio data, 16 | // do something like the following: 17 | // 18 | // drmp3 mp3; 19 | // if (!drmp3_init_file(&mp3, "MySong.mp3", NULL)) { 20 | // // Failed to open file 21 | // } 22 | // 23 | // ... 24 | // 25 | // drmp3_uint64 framesRead = drmp3_read_pcm_frames_f32(pMP3, framesToRead, pFrames); 26 | // 27 | // The drmp3 object is transparent so you can get access to the channel count and sample rate like so: 28 | // 29 | // drmp3_uint32 channels = mp3.channels; 30 | // drmp3_uint32 sampleRate = mp3.sampleRate; 31 | // 32 | // The third parameter of drmp3_init_file() in the example above allows you to control the output channel count and sample rate. It 33 | // is a pointer to a drmp3_config object. Setting any of the variables of this object to 0 will cause dr_mp3 to use defaults. 34 | // 35 | // The example above initializes a decoder from a file, but you can also initialize it from a block of memory and read and seek 36 | // callbacks with drmp3_init_memory() and drmp3_init() respectively. 37 | // 38 | // You do not need to do any annoying memory management when reading PCM frames - this is all managed internally. You can request 39 | // any number of PCM frames in each call to drmp3_read_pcm_frames_f32() and it will return as many PCM frames as it can, up to the 40 | // requested amount. 41 | // 42 | // You can also decode an entire file in one go with drmp3_open_and_read_f32(), drmp3_open_memory_and_read_f32() and 43 | // drmp3_open_file_and_read_f32(). 44 | // 45 | // 46 | // OPTIONS 47 | // ======= 48 | // #define these options before including this file. 49 | // 50 | // #define DR_MP3_NO_STDIO 51 | // Disable drmp3_init_file(), etc. 52 | // 53 | // #define DR_MP3_NO_SIMD 54 | // Disable SIMD optimizations. 55 | 56 | #ifndef dr_mp3_h 57 | #define dr_mp3_h 58 | 59 | #ifdef __cplusplus 60 | extern "C" { 61 | #endif 62 | 63 | #include 64 | 65 | #if defined(_MSC_VER) && _MSC_VER < 1600 66 | typedef signed char drmp3_int8; 67 | typedef unsigned char drmp3_uint8; 68 | typedef signed short drmp3_int16; 69 | typedef unsigned short drmp3_uint16; 70 | typedef signed int drmp3_int32; 71 | typedef unsigned int drmp3_uint32; 72 | typedef signed __int64 drmp3_int64; 73 | typedef unsigned __int64 drmp3_uint64; 74 | #else 75 | 76 | #include 77 | 78 | typedef int8_t drmp3_int8; 79 | typedef uint8_t drmp3_uint8; 80 | typedef int16_t drmp3_int16; 81 | typedef uint16_t drmp3_uint16; 82 | typedef int32_t drmp3_int32; 83 | typedef uint32_t drmp3_uint32; 84 | typedef int64_t drmp3_int64; 85 | typedef uint64_t drmp3_uint64; 86 | #endif 87 | typedef drmp3_uint8 drmp3_bool8; 88 | typedef drmp3_uint32 drmp3_bool32; 89 | #define DRMP3_TRUE 1 90 | #define DRMP3_FALSE 0 91 | 92 | #define DRMP3_MAX_PCM_FRAMES_PER_MP3_FRAME 1152 93 | #define DRMP3_MAX_SAMPLES_PER_FRAME (DRMP3_MAX_PCM_FRAMES_PER_MP3_FRAME*2) 94 | 95 | 96 | // Low Level Push API 97 | // ================== 98 | typedef struct { 99 | int frame_bytes, channels, hz, layer, bitrate_kbps; 100 | } drmp3dec_frame_info; 101 | 102 | typedef struct { 103 | float mdct_overlap[2][9 * 32], qmf_state[15 * 2 * 32]; 104 | int reserv, free_format_bytes; 105 | unsigned char header[4], reserv_buf[511]; 106 | } drmp3dec; 107 | 108 | // Initializes a low level decoder. 109 | void drmp3dec_init(drmp3dec *dec); 110 | 111 | // Reads a frame from a low level decoder. 112 | int drmp3dec_decode_frame(drmp3dec *dec, const unsigned char *mp3, int mp3_bytes, void *pcm, drmp3dec_frame_info *info); 113 | 114 | // Helper for converting between f32 and s16. 115 | void drmp3dec_f32_to_s16(const float *in, drmp3_int16 *out, int num_samples); 116 | 117 | 118 | 119 | 120 | // Main API (Pull API) 121 | // =================== 122 | 123 | typedef struct drmp3_src drmp3_src; 124 | 125 | typedef drmp3_uint64 (*drmp3_src_read_proc)(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut, 126 | void *pUserData); // Returns the number of frames that were read. 127 | 128 | typedef enum { 129 | drmp3_src_algorithm_none, 130 | drmp3_src_algorithm_linear 131 | } drmp3_src_algorithm; 132 | 133 | #define DRMP3_SRC_CACHE_SIZE_IN_FRAMES 512 134 | typedef struct { 135 | drmp3_src *pSRC; 136 | float pCachedFrames[2 * DRMP3_SRC_CACHE_SIZE_IN_FRAMES]; 137 | drmp3_uint32 cachedFrameCount; 138 | drmp3_uint32 iNextFrame; 139 | } drmp3_src_cache; 140 | 141 | typedef struct { 142 | drmp3_uint32 sampleRateIn; 143 | drmp3_uint32 sampleRateOut; 144 | drmp3_uint32 channels; 145 | drmp3_src_algorithm algorithm; 146 | drmp3_uint32 cacheSizeInFrames; // The number of frames to read from the client at a time. 147 | } drmp3_src_config; 148 | 149 | struct drmp3_src { 150 | drmp3_src_config config; 151 | drmp3_src_read_proc onRead; 152 | void *pUserData; 153 | float bin[256]; 154 | drmp3_src_cache cache; // <-- For simplifying and optimizing client -> memory reading. 155 | union { 156 | struct { 157 | double alpha; 158 | drmp3_bool32 isPrevFramesLoaded : 1; 159 | drmp3_bool32 isNextFramesLoaded : 1; 160 | } linear; 161 | } algo; 162 | }; 163 | 164 | typedef enum { 165 | drmp3_seek_origin_start, 166 | drmp3_seek_origin_current 167 | } drmp3_seek_origin; 168 | 169 | typedef struct { 170 | drmp3_uint64 seekPosInBytes; // Points to the first byte of an MP3 frame. 171 | drmp3_uint64 pcmFrameIndex; // The index of the PCM frame this seek point targets. 172 | drmp3_uint16 mp3FramesToDiscard; // The number of whole MP3 frames to be discarded before pcmFramesToDiscard. 173 | drmp3_uint16 pcmFramesToDiscard; // The number of leading samples to read and discard. These are discarded after mp3FramesToDiscard. 174 | } drmp3_seek_point; 175 | 176 | // Callback for when data is read. Return value is the number of bytes actually read. 177 | // 178 | // pUserData [in] The user data that was passed to drmp3_init(), drmp3_open() and family. 179 | // pBufferOut [out] The output buffer. 180 | // bytesToRead [in] The number of bytes to read. 181 | // 182 | // Returns the number of bytes actually read. 183 | // 184 | // A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until 185 | // either the entire bytesToRead is filled or you have reached the end of the stream. 186 | typedef size_t (*drmp3_read_proc)(void *pUserData, void *pBufferOut, size_t bytesToRead); 187 | 188 | // Callback for when data needs to be seeked. 189 | // 190 | // pUserData [in] The user data that was passed to drmp3_init(), drmp3_open() and family. 191 | // offset [in] The number of bytes to move, relative to the origin. Will never be negative. 192 | // origin [in] The origin of the seek - the current position or the start of the stream. 193 | // 194 | // Returns whether or not the seek was successful. 195 | // 196 | // Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which 197 | // will be either drmp3_seek_origin_start or drmp3_seek_origin_current. 198 | typedef drmp3_bool32 (*drmp3_seek_proc)(void *pUserData, int offset, drmp3_seek_origin origin); 199 | 200 | typedef struct { 201 | drmp3_uint32 outputChannels; 202 | drmp3_uint32 outputSampleRate; 203 | } drmp3_config; 204 | 205 | typedef struct { 206 | drmp3dec decoder; 207 | drmp3dec_frame_info frameInfo; 208 | drmp3_uint32 channels; 209 | drmp3_uint32 sampleRate; 210 | drmp3_read_proc onRead; 211 | drmp3_seek_proc onSeek; 212 | void *pUserData; 213 | drmp3_uint32 mp3FrameChannels; // The number of channels in the currently loaded MP3 frame. Internal use only. 214 | drmp3_uint32 mp3FrameSampleRate; // The sample rate of the currently loaded MP3 frame. Internal use only. 215 | drmp3_uint32 pcmFramesConsumedInMP3Frame; 216 | drmp3_uint32 pcmFramesRemainingInMP3Frame; 217 | drmp3_uint8 pcmFrames[sizeof(float) * 218 | DRMP3_MAX_SAMPLES_PER_FRAME]; // <-- Multipled by sizeof(float) to ensure there's enough room for DR_MP3_FLOAT_OUTPUT. 219 | drmp3_uint64 currentPCMFrame; // The current PCM frame, globally, based on the output sample rate. Mainly used for seeking. 220 | drmp3_uint64 streamCursor; // The current byte the decoder is sitting on in the raw stream. 221 | drmp3_src src; 222 | drmp3_seek_point *pSeekPoints; // NULL by default. Set with drmp3_bind_seek_table(). Memory is owned by the client. dr_mp3 will never attempt to free this pointer. 223 | drmp3_uint32 seekPointCount; // The number of items in pSeekPoints. When set to 0 assumes to no seek table. Defaults to zero. 224 | size_t dataSize; 225 | size_t dataCapacity; 226 | drmp3_uint8 *pData; 227 | drmp3_bool32 atEnd : 1; 228 | struct { 229 | const drmp3_uint8 *pData; 230 | size_t dataSize; 231 | size_t currentReadPos; 232 | } memory; // Only used for decoders that were opened against a block of memory. 233 | } drmp3; 234 | 235 | // Initializes an MP3 decoder. 236 | // 237 | // onRead [in] The function to call when data needs to be read from the client. 238 | // onSeek [in] The function to call when the read position of the client data needs to move. 239 | // pUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek. 240 | // 241 | // Returns true if successful; false otherwise. 242 | // 243 | // Close the loader with drmp3_uninit(). 244 | // 245 | // See also: drmp3_init_file(), drmp3_init_memory(), drmp3_uninit() 246 | drmp3_bool32 247 | drmp3_init(drmp3 *pMP3, drmp3_read_proc onRead, drmp3_seek_proc onSeek, void *pUserData, const drmp3_config *pConfig); 248 | 249 | // Initializes an MP3 decoder from a block of memory. 250 | // 251 | // This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for 252 | // the lifetime of the drmp3 object. 253 | // 254 | // The buffer should contain the contents of the entire MP3 file. 255 | drmp3_bool32 drmp3_init_memory(drmp3 *pMP3, const void *pData, size_t dataSize, const drmp3_config *pConfig); 256 | 257 | #ifndef DR_MP3_NO_STDIO 258 | 259 | // Initializes an MP3 decoder from a file. 260 | // 261 | // This holds the internal FILE object until drmp3_uninit() is called. Keep this in mind if you're caching drmp3 262 | // objects because the operating system may restrict the number of file handles an application can have open at 263 | // any given time. 264 | drmp3_bool32 drmp3_init_file(drmp3 *pMP3, const char *filePath, const drmp3_config *pConfig); 265 | 266 | #endif 267 | 268 | // Uninitializes an MP3 decoder. 269 | void drmp3_uninit(drmp3 *pMP3); 270 | 271 | // Reads PCM frames as interleaved 32-bit IEEE floating point PCM. 272 | // 273 | // Note that framesToRead specifies the number of PCM frames to read, _not_ the number of MP3 frames. 274 | drmp3_uint64 drmp3_read_pcm_frames_f32(drmp3 *pMP3, drmp3_uint64 framesToRead, float *pBufferOut); 275 | 276 | // Seeks to a specific frame. 277 | // 278 | // Note that this is _not_ an MP3 frame, but rather a PCM frame. 279 | drmp3_bool32 drmp3_seek_to_pcm_frame(drmp3 *pMP3, drmp3_uint64 frameIndex); 280 | 281 | // Calculates the total number of PCM frames in the MP3 stream. Cannot be used for infinite streams such as internet 282 | // radio. Runs in linear time. Returns 0 on error. 283 | drmp3_uint64 drmp3_get_pcm_frame_count(drmp3 *pMP3); 284 | 285 | // Calculates the total number of MP3 frames in the MP3 stream. Cannot be used for infinite streams such as internet 286 | // radio. Runs in linear time. Returns 0 on error. 287 | drmp3_uint64 drmp3_get_mp3_frame_count(drmp3 *pMP3); 288 | 289 | // Calculates the seekpoints based on PCM frames. This is slow. 290 | // 291 | // pSeekpoint count is a pointer to a uint32 containing the seekpoint count. On input it contains the desired count. 292 | // On output it contains the actual count. The reason for this design is that the client may request too many 293 | // seekpoints, in which case dr_mp3 will return a corrected count. 294 | // 295 | // Note that seektable seeking is not quite sample exact when the MP3 stream contains inconsistent sample rates. 296 | drmp3_bool32 drmp3_calculate_seek_points(drmp3 *pMP3, drmp3_uint32 *pSeekPointCount, drmp3_seek_point *pSeekPoints); 297 | 298 | // Binds a seek table to the decoder. 299 | // 300 | // This does _not_ make a copy of pSeekPoints - it only references it. It is up to the application to ensure this 301 | // remains valid while it is bound to the decoder. 302 | // 303 | // Use drmp3_calculate_seek_points() to calculate the seek points. 304 | drmp3_bool32 drmp3_bind_seek_table(drmp3 *pMP3, drmp3_uint32 seekPointCount, drmp3_seek_point *pSeekPoints); 305 | 306 | 307 | // Opens an decodes an entire MP3 stream as a single operation. 308 | // 309 | // pConfig is both an input and output. On input it contains what you want. On output it contains what you got. 310 | // 311 | // Free the returned pointer with drmp3_free(). 312 | float *drmp3_open_and_read_f32(drmp3_read_proc onRead, drmp3_seek_proc onSeek, void *pUserData, drmp3_config *pConfig, 313 | drmp3_uint64 *pTotalFrameCount); 314 | 315 | float *drmp3_open_memory_and_read_f32(const void *pData, size_t dataSize, drmp3_config *pConfig, 316 | drmp3_uint64 *pTotalFrameCount); 317 | 318 | #ifndef DR_MP3_NO_STDIO 319 | 320 | float *drmp3_open_file_and_read_f32(const char *filePath, drmp3_config *pConfig, drmp3_uint64 *pTotalFrameCount); 321 | 322 | #endif 323 | 324 | // Frees any memory that was allocated by a public drmp3 API. 325 | void drmp3_free(void *p); 326 | 327 | #ifdef __cplusplus 328 | } 329 | #endif 330 | #endif // dr_mp3_h 331 | 332 | 333 | ///////////////////////////////////////////////////// 334 | // 335 | // IMPLEMENTATION 336 | // 337 | ///////////////////////////////////////////////////// 338 | #ifdef DR_MP3_IMPLEMENTATION 339 | 340 | #include 341 | #include 342 | #include 343 | #include // For INT_MAX 344 | 345 | // Disable SIMD when compiling with TCC for now. 346 | #if defined(__TINYC__) 347 | #define DR_MP3_NO_SIMD 348 | #endif 349 | 350 | #define DRMP3_OFFSET_PTR(p, offset) ((void*)((drmp3_uint8*)(p) + (offset))) 351 | 352 | #define DRMP3_MAX_FREE_FORMAT_FRAME_SIZE 2304 /* more than ISO spec's */ 353 | #ifndef DRMP3_MAX_FRAME_SYNC_MATCHES 354 | #define DRMP3_MAX_FRAME_SYNC_MATCHES 10 355 | #endif 356 | 357 | #define DRMP3_MAX_L3_FRAME_PAYLOAD_BYTES DRMP3_MAX_FREE_FORMAT_FRAME_SIZE /* MUST be >= 320000/8/32000*1152 = 1440 */ 358 | 359 | #define DRMP3_MAX_BITRESERVOIR_BYTES 511 360 | #define DRMP3_SHORT_BLOCK_TYPE 2 361 | #define DRMP3_STOP_BLOCK_TYPE 3 362 | #define DRMP3_MODE_MONO 3 363 | #define DRMP3_MODE_JOINT_STEREO 1 364 | #define DRMP3_HDR_SIZE 4 365 | #define DRMP3_HDR_IS_MONO(h) (((h[3]) & 0xC0) == 0xC0) 366 | #define DRMP3_HDR_IS_MS_STEREO(h) (((h[3]) & 0xE0) == 0x60) 367 | #define DRMP3_HDR_IS_FREE_FORMAT(h) (((h[2]) & 0xF0) == 0) 368 | #define DRMP3_HDR_IS_CRC(h) (!((h[1]) & 1)) 369 | #define DRMP3_HDR_TEST_PADDING(h) ((h[2]) & 0x2) 370 | #define DRMP3_HDR_TEST_MPEG1(h) ((h[1]) & 0x8) 371 | #define DRMP3_HDR_TEST_NOT_MPEG25(h) ((h[1]) & 0x10) 372 | #define DRMP3_HDR_TEST_I_STEREO(h) ((h[3]) & 0x10) 373 | #define DRMP3_HDR_TEST_MS_STEREO(h) ((h[3]) & 0x20) 374 | #define DRMP3_HDR_GET_STEREO_MODE(h) (((h[3]) >> 6) & 3) 375 | #define DRMP3_HDR_GET_STEREO_MODE_EXT(h) (((h[3]) >> 4) & 3) 376 | #define DRMP3_HDR_GET_LAYER(h) (((h[1]) >> 1) & 3) 377 | #define DRMP3_HDR_GET_BITRATE(h) ((h[2]) >> 4) 378 | #define DRMP3_HDR_GET_SAMPLE_RATE(h) (((h[2]) >> 2) & 3) 379 | #define DRMP3_HDR_GET_MY_SAMPLE_RATE(h) (DRMP3_HDR_GET_SAMPLE_RATE(h) + (((h[1] >> 3) & 1) + ((h[1] >> 4) & 1))*3) 380 | #define DRMP3_HDR_IS_FRAME_576(h) ((h[1] & 14) == 2) 381 | #define DRMP3_HDR_IS_LAYER_1(h) ((h[1] & 6) == 6) 382 | 383 | #define DRMP3_BITS_DEQUANTIZER_OUT -1 384 | #define DRMP3_MAX_SCF (255 + DRMP3_BITS_DEQUANTIZER_OUT*4 - 210) 385 | #define DRMP3_MAX_SCFI ((DRMP3_MAX_SCF + 3) & ~3) 386 | 387 | #define DRMP3_MIN(a, b) ((a) > (b) ? (b) : (a)) 388 | #define DRMP3_MAX(a, b) ((a) < (b) ? (b) : (a)) 389 | 390 | #if !defined(DR_MP3_NO_SIMD) 391 | 392 | #if !defined(DR_MP3_ONLY_SIMD) && (defined(_M_X64) || defined(_M_ARM64) || defined(__x86_64__) || defined(__aarch64__)) 393 | /* x64 always have SSE2, arm64 always have neon, no need for generic code */ 394 | #define DR_MP3_ONLY_SIMD 395 | #endif 396 | 397 | #if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))) || ((defined(__i386__) || defined(__x86_64__)) && defined(__SSE2__)) 398 | #if defined(_MSC_VER) 399 | #include 400 | #endif 401 | 402 | #include 403 | 404 | #define DRMP3_HAVE_SSE 1 405 | #define DRMP3_HAVE_SIMD 1 406 | #define DRMP3_VSTORE _mm_storeu_ps 407 | #define DRMP3_VLD _mm_loadu_ps 408 | #define DRMP3_VSET _mm_set1_ps 409 | #define DRMP3_VADD _mm_add_ps 410 | #define DRMP3_VSUB _mm_sub_ps 411 | #define DRMP3_VMUL _mm_mul_ps 412 | #define DRMP3_VMAC(a, x, y) _mm_add_ps(a, _mm_mul_ps(x, y)) 413 | #define DRMP3_VMSB(a, x, y) _mm_sub_ps(a, _mm_mul_ps(x, y)) 414 | #define DRMP3_VMUL_S(x, s) _mm_mul_ps(x, _mm_set1_ps(s)) 415 | #define DRMP3_VREV(x) _mm_shuffle_ps(x, x, _MM_SHUFFLE(0, 1, 2, 3)) 416 | typedef __m128 drmp3_f4; 417 | #if defined(_MSC_VER) || defined(DR_MP3_ONLY_SIMD) 418 | #define drmp3_cpuid __cpuid 419 | #else 420 | static __inline__ __attribute__((always_inline)) void drmp3_cpuid(int CPUInfo[], const int InfoType) 421 | { 422 | #if defined(__PIC__) 423 | __asm__ __volatile__( 424 | #if defined(__x86_64__) 425 | "push %%rbx\n" 426 | "cpuid\n" 427 | "xchgl %%ebx, %1\n" 428 | "pop %%rbx\n" 429 | #else 430 | "xchgl %%ebx, %1\n" 431 | "cpuid\n" 432 | "xchgl %%ebx, %1\n" 433 | #endif 434 | : "=a" (CPUInfo[0]), "=r" (CPUInfo[1]), "=c" (CPUInfo[2]), "=d" (CPUInfo[3]) 435 | : "a" (InfoType)); 436 | #else 437 | __asm__ __volatile__( 438 | "cpuid" 439 | : "=a" (CPUInfo[0]), "=b" (CPUInfo[1]), "=c" (CPUInfo[2]), "=d" (CPUInfo[3]) 440 | : "a" (InfoType)); 441 | #endif 442 | } 443 | #endif 444 | 445 | static int drmp3_have_simd() { 446 | #ifdef DR_MP3_ONLY_SIMD 447 | return 1; 448 | #else 449 | static int g_have_simd; 450 | int CPUInfo[4]; 451 | #ifdef MINIMP3_TEST 452 | static int g_counter; 453 | if (g_counter++ > 100) 454 | return 0; 455 | #endif 456 | if (g_have_simd) 457 | goto end; 458 | drmp3_cpuid(CPUInfo, 0); 459 | if (CPUInfo[0] > 0) 460 | { 461 | drmp3_cpuid(CPUInfo, 1); 462 | g_have_simd = (CPUInfo[3] & (1 << 26)) + 1; /* SSE2 */ 463 | return g_have_simd - 1; 464 | } 465 | 466 | end: 467 | return g_have_simd - 1; 468 | #endif 469 | } 470 | 471 | #elif defined(__ARM_NEON) || defined(__aarch64__) 472 | #include 473 | #define DRMP3_HAVE_SIMD 1 474 | #define DRMP3_VSTORE vst1q_f32 475 | #define DRMP3_VLD vld1q_f32 476 | #define DRMP3_VSET vmovq_n_f32 477 | #define DRMP3_VADD vaddq_f32 478 | #define DRMP3_VSUB vsubq_f32 479 | #define DRMP3_VMUL vmulq_f32 480 | #define DRMP3_VMAC(a, x, y) vmlaq_f32(a, x, y) 481 | #define DRMP3_VMSB(a, x, y) vmlsq_f32(a, x, y) 482 | #define DRMP3_VMUL_S(x, s) vmulq_f32(x, vmovq_n_f32(s)) 483 | #define DRMP3_VREV(x) vcombine_f32(vget_high_f32(vrev64q_f32(x)), vget_low_f32(vrev64q_f32(x))) 484 | typedef float32x4_t drmp3_f4; 485 | static int drmp3_have_simd() 486 | { /* TODO: detect neon for !DR_MP3_ONLY_SIMD */ 487 | return 1; 488 | } 489 | #else 490 | #define DRMP3_HAVE_SIMD 0 491 | #ifdef DR_MP3_ONLY_SIMD 492 | #error DR_MP3_ONLY_SIMD used, but SSE/NEON not enabled 493 | #endif 494 | #endif 495 | 496 | #else 497 | 498 | #define DRMP3_HAVE_SIMD 0 499 | 500 | #endif 501 | 502 | typedef struct { 503 | const drmp3_uint8 *buf; 504 | int pos, limit; 505 | } drmp3_bs; 506 | 507 | typedef struct { 508 | float scf[3 * 64]; 509 | drmp3_uint8 total_bands, stereo_bands, bitalloc[64], scfcod[64]; 510 | } drmp3_L12_scale_info; 511 | 512 | typedef struct { 513 | drmp3_uint8 tab_offset, code_tab_width, band_count; 514 | } drmp3_L12_subband_alloc; 515 | 516 | typedef struct { 517 | const drmp3_uint8 *sfbtab; 518 | drmp3_uint16 part_23_length, big_values, scalefac_compress; 519 | drmp3_uint8 global_gain, block_type, mixed_block_flag, n_long_sfb, n_short_sfb; 520 | drmp3_uint8 table_select[3], region_count[3], subblock_gain[3]; 521 | drmp3_uint8 preflag, scalefac_scale, count1_table, scfsi; 522 | } drmp3_L3_gr_info; 523 | 524 | typedef struct { 525 | drmp3_bs bs; 526 | drmp3_uint8 maindata[DRMP3_MAX_BITRESERVOIR_BYTES + DRMP3_MAX_L3_FRAME_PAYLOAD_BYTES]; 527 | drmp3_L3_gr_info gr_info[4]; 528 | float grbuf[2][576], scf[40], syn[18 + 15][2 * 32]; 529 | drmp3_uint8 ist_pos[2][39]; 530 | } drmp3dec_scratch; 531 | 532 | static void drmp3_bs_init(drmp3_bs *bs, const drmp3_uint8 *data, int bytes) { 533 | bs->buf = data; 534 | bs->pos = 0; 535 | bs->limit = bytes * 8; 536 | } 537 | 538 | static drmp3_uint32 drmp3_bs_get_bits(drmp3_bs *bs, int n) { 539 | drmp3_uint32 next, cache = 0, s = bs->pos & 7; 540 | int shl = n + s; 541 | const drmp3_uint8 *p = bs->buf + (bs->pos >> 3); 542 | if ((bs->pos += n) > bs->limit) 543 | return 0; 544 | next = *p++ & (255 >> s); 545 | while ((shl -= 8) > 0) { 546 | cache |= next << shl; 547 | next = *p++; 548 | } 549 | return cache | (next >> -shl); 550 | } 551 | 552 | static int drmp3_hdr_valid(const drmp3_uint8 *h) { 553 | return h[0] == 0xff && 554 | ((h[1] & 0xF0) == 0xf0 || (h[1] & 0xFE) == 0xe2) && 555 | (DRMP3_HDR_GET_LAYER(h) != 0) && 556 | (DRMP3_HDR_GET_BITRATE(h) != 15) && 557 | (DRMP3_HDR_GET_SAMPLE_RATE(h) != 3); 558 | } 559 | 560 | static int drmp3_hdr_compare(const drmp3_uint8 *h1, const drmp3_uint8 *h2) { 561 | return drmp3_hdr_valid(h2) && 562 | ((h1[1] ^ h2[1]) & 0xFE) == 0 && 563 | ((h1[2] ^ h2[2]) & 0x0C) == 0 && 564 | !(DRMP3_HDR_IS_FREE_FORMAT(h1) ^ DRMP3_HDR_IS_FREE_FORMAT(h2)); 565 | } 566 | 567 | static unsigned drmp3_hdr_bitrate_kbps(const drmp3_uint8 *h) { 568 | static const drmp3_uint8 halfrate[2][3][15] = { 569 | {{0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80}, {0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80}, {0, 16, 24, 28, 32, 40, 48, 56, 64, 72, 80, 88, 96, 112, 128}}, 570 | {{0, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160}, {0, 16, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192}, {0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224}}, 571 | }; 572 | return 2 * halfrate[!!DRMP3_HDR_TEST_MPEG1(h)][DRMP3_HDR_GET_LAYER(h) - 1][DRMP3_HDR_GET_BITRATE(h)]; 573 | } 574 | 575 | static unsigned drmp3_hdr_sample_rate_hz(const drmp3_uint8 *h) { 576 | static const unsigned g_hz[3] = {44100, 48000, 32000}; 577 | return g_hz[DRMP3_HDR_GET_SAMPLE_RATE(h)] >> (int) !DRMP3_HDR_TEST_MPEG1(h) >> (int) !DRMP3_HDR_TEST_NOT_MPEG25(h); 578 | } 579 | 580 | static unsigned drmp3_hdr_frame_samples(const drmp3_uint8 *h) { 581 | return DRMP3_HDR_IS_LAYER_1(h) ? 384 : (1152 >> (int) DRMP3_HDR_IS_FRAME_576(h)); 582 | } 583 | 584 | static int drmp3_hdr_frame_bytes(const drmp3_uint8 *h, int free_format_size) { 585 | int frame_bytes = drmp3_hdr_frame_samples(h) * drmp3_hdr_bitrate_kbps(h) * 125 / drmp3_hdr_sample_rate_hz(h); 586 | if (DRMP3_HDR_IS_LAYER_1(h)) { 587 | frame_bytes &= ~3; /* slot align */ 588 | } 589 | return frame_bytes ? frame_bytes : free_format_size; 590 | } 591 | 592 | static int drmp3_hdr_padding(const drmp3_uint8 *h) { 593 | return DRMP3_HDR_TEST_PADDING(h) ? (DRMP3_HDR_IS_LAYER_1(h) ? 4 : 1) : 0; 594 | } 595 | 596 | #ifndef DR_MP3_ONLY_MP3 597 | 598 | static const drmp3_L12_subband_alloc *drmp3_L12_subband_alloc_table(const drmp3_uint8 *hdr, drmp3_L12_scale_info *sci) { 599 | const drmp3_L12_subband_alloc *alloc; 600 | int mode = DRMP3_HDR_GET_STEREO_MODE(hdr); 601 | int nbands, stereo_bands = (mode == DRMP3_MODE_MONO) ? 0 : (mode == DRMP3_MODE_JOINT_STEREO) ? 602 | (DRMP3_HDR_GET_STEREO_MODE_EXT(hdr) << 2) + 4 : 32; 603 | 604 | if (DRMP3_HDR_IS_LAYER_1(hdr)) { 605 | static const drmp3_L12_subband_alloc g_alloc_L1[] = {{76, 4, 32}}; 606 | alloc = g_alloc_L1; 607 | nbands = 32; 608 | } else if (!DRMP3_HDR_TEST_MPEG1(hdr)) { 609 | static const drmp3_L12_subband_alloc g_alloc_L2M2[] = {{60, 4, 4}, 610 | {44, 3, 7}, 611 | {44, 2, 19}}; 612 | alloc = g_alloc_L2M2; 613 | nbands = 30; 614 | } else { 615 | static const drmp3_L12_subband_alloc g_alloc_L2M1[] = {{0, 4, 3}, 616 | {16, 4, 8}, 617 | {32, 3, 12}, 618 | {40, 2, 7}}; 619 | int sample_rate_idx = DRMP3_HDR_GET_SAMPLE_RATE(hdr); 620 | unsigned kbps = drmp3_hdr_bitrate_kbps(hdr) >> (int) (mode != DRMP3_MODE_MONO); 621 | if (!kbps) /* free-format */ 622 | { 623 | kbps = 192; 624 | } 625 | 626 | alloc = g_alloc_L2M1; 627 | nbands = 27; 628 | if (kbps < 56) { 629 | static const drmp3_L12_subband_alloc g_alloc_L2M1_lowrate[] = {{44, 4, 2}, 630 | {44, 3, 10}}; 631 | alloc = g_alloc_L2M1_lowrate; 632 | nbands = sample_rate_idx == 2 ? 12 : 8; 633 | } else if (kbps >= 96 && sample_rate_idx != 1) { 634 | nbands = 30; 635 | } 636 | } 637 | 638 | sci->total_bands = (drmp3_uint8) nbands; 639 | sci->stereo_bands = (drmp3_uint8) DRMP3_MIN(stereo_bands, nbands); 640 | 641 | return alloc; 642 | } 643 | 644 | static void drmp3_L12_read_scalefactors(drmp3_bs *bs, drmp3_uint8 *pba, drmp3_uint8 *scfcod, int bands, float *scf) { 645 | static const float g_deq_L12[18 * 3] = { 646 | #define DRMP3_DQ(x) 9.53674316e-07f/x, 7.56931807e-07f/x, 6.00777173e-07f/x 647 | DRMP3_DQ(3), DRMP3_DQ(7), DRMP3_DQ(15), DRMP3_DQ(31), DRMP3_DQ(63), DRMP3_DQ(127), DRMP3_DQ(255), 648 | DRMP3_DQ(511), DRMP3_DQ(1023), DRMP3_DQ(2047), DRMP3_DQ(4095), DRMP3_DQ(8191), DRMP3_DQ(16383), 649 | DRMP3_DQ(32767), DRMP3_DQ(65535), DRMP3_DQ(3), DRMP3_DQ(5), DRMP3_DQ(9) 650 | }; 651 | int i, m; 652 | for (i = 0; i < bands; i++) { 653 | float s = 0; 654 | int ba = *pba++; 655 | int mask = ba ? 4 + ((19 >> scfcod[i]) & 3) : 0; 656 | for (m = 4; m; m >>= 1) { 657 | if (mask & m) { 658 | int b = drmp3_bs_get_bits(bs, 6); 659 | s = g_deq_L12[ba * 3 - 6 + b % 3] * (1 << 21 >> b / 3); 660 | } 661 | *scf++ = s; 662 | } 663 | } 664 | } 665 | 666 | static void drmp3_L12_read_scale_info(const drmp3_uint8 *hdr, drmp3_bs *bs, drmp3_L12_scale_info *sci) { 667 | static const drmp3_uint8 g_bitalloc_code_tab[] = { 668 | 0, 17, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 669 | 0, 17, 18, 3, 19, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16, 670 | 0, 17, 18, 3, 19, 4, 5, 16, 671 | 0, 17, 18, 16, 672 | 0, 17, 18, 19, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 673 | 0, 17, 18, 3, 19, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 674 | 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 675 | }; 676 | const drmp3_L12_subband_alloc *subband_alloc = drmp3_L12_subband_alloc_table(hdr, sci); 677 | 678 | int i, k = 0, ba_bits = 0; 679 | const drmp3_uint8 *ba_code_tab = g_bitalloc_code_tab; 680 | 681 | for (i = 0; i < sci->total_bands; i++) { 682 | drmp3_uint8 ba; 683 | if (i == k) { 684 | k += subband_alloc->band_count; 685 | ba_bits = subband_alloc->code_tab_width; 686 | ba_code_tab = g_bitalloc_code_tab + subband_alloc->tab_offset; 687 | subband_alloc++; 688 | } 689 | ba = ba_code_tab[drmp3_bs_get_bits(bs, ba_bits)]; 690 | sci->bitalloc[2 * i] = ba; 691 | if (i < sci->stereo_bands) { 692 | ba = ba_code_tab[drmp3_bs_get_bits(bs, ba_bits)]; 693 | } 694 | sci->bitalloc[2 * i + 1] = sci->stereo_bands ? ba : 0; 695 | } 696 | 697 | for (i = 0; i < 2 * sci->total_bands; i++) { 698 | sci->scfcod[i] = (drmp3_uint8) (sci->bitalloc[i] ? DRMP3_HDR_IS_LAYER_1(hdr) ? 2 : drmp3_bs_get_bits(bs, 2) 699 | : 6); 700 | } 701 | 702 | drmp3_L12_read_scalefactors(bs, sci->bitalloc, sci->scfcod, sci->total_bands * 2, sci->scf); 703 | 704 | for (i = sci->stereo_bands; i < sci->total_bands; i++) { 705 | sci->bitalloc[2 * i + 1] = 0; 706 | } 707 | } 708 | 709 | static int drmp3_L12_dequantize_granule(float *grbuf, drmp3_bs *bs, drmp3_L12_scale_info *sci, int group_size) { 710 | int i, j, k, choff = 576; 711 | for (j = 0; j < 4; j++) { 712 | float *dst = grbuf + group_size * j; 713 | for (i = 0; i < 2 * sci->total_bands; i++) { 714 | int ba = sci->bitalloc[i]; 715 | if (ba != 0) { 716 | if (ba < 17) { 717 | int half = (1 << (ba - 1)) - 1; 718 | for (k = 0; k < group_size; k++) { 719 | dst[k] = (float) ((int) drmp3_bs_get_bits(bs, ba) - half); 720 | } 721 | } else { 722 | unsigned mod = (2 << (ba - 17)) + 1; /* 3, 5, 9 */ 723 | unsigned code = drmp3_bs_get_bits(bs, mod + 2 - (mod >> 3)); /* 5, 7, 10 */ 724 | for (k = 0; k < group_size; k++, code /= mod) { 725 | dst[k] = (float) ((int) (code % mod - mod / 2)); 726 | } 727 | } 728 | } 729 | dst += choff; 730 | choff = 18 - choff; 731 | } 732 | } 733 | return group_size * 4; 734 | } 735 | 736 | static void drmp3_L12_apply_scf_384(drmp3_L12_scale_info *sci, const float *scf, float *dst) { 737 | int i, k; 738 | memcpy(dst + 576 + sci->stereo_bands * 18, dst + sci->stereo_bands * 18, 739 | (sci->total_bands - sci->stereo_bands) * 18 * sizeof(float)); 740 | for (i = 0; i < sci->total_bands; i++, dst += 18, scf += 6) { 741 | for (k = 0; k < 12; k++) { 742 | dst[k + 0] *= scf[0]; 743 | dst[k + 576] *= scf[3]; 744 | } 745 | } 746 | } 747 | 748 | #endif 749 | 750 | static int drmp3_L3_read_side_info(drmp3_bs *bs, drmp3_L3_gr_info *gr, const drmp3_uint8 *hdr) { 751 | static const drmp3_uint8 g_scf_long[8][23] = { 752 | {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0}, 753 | {12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2, 0}, 754 | {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0}, 755 | {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36, 0}, 756 | {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0}, 757 | {4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158, 0}, 758 | {4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192, 0}, 759 | {4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26, 0} 760 | }; 761 | static const drmp3_uint8 g_scf_short[8][40] = { 762 | {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0}, 763 | {8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26, 0}, 764 | {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18, 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18, 0}, 765 | {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12, 0}, 766 | {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0}, 767 | {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56, 0}, 768 | {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14, 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66, 0}, 769 | {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12, 0} 770 | }; 771 | static const drmp3_uint8 g_scf_mixed[8][40] = { 772 | {6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0}, 773 | {12, 12, 12, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26, 0}, 774 | {6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18, 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18, 0}, 775 | {6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12, 0}, 776 | {6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0}, 777 | {4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56, 0}, 778 | {4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 4, 6, 6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14, 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66, 0}, 779 | {4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 4, 6, 6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12, 0} 780 | }; 781 | 782 | unsigned tables, scfsi = 0; 783 | int main_data_begin, part_23_sum = 0; 784 | int sr_idx = DRMP3_HDR_GET_MY_SAMPLE_RATE(hdr); 785 | sr_idx -= (sr_idx != 0); 786 | int gr_count = DRMP3_HDR_IS_MONO(hdr) ? 1 : 2; 787 | 788 | if (DRMP3_HDR_TEST_MPEG1(hdr)) { 789 | gr_count *= 2; 790 | main_data_begin = drmp3_bs_get_bits(bs, 9); 791 | scfsi = drmp3_bs_get_bits(bs, 7 + gr_count); 792 | } else { 793 | main_data_begin = drmp3_bs_get_bits(bs, 8 + gr_count) >> gr_count; 794 | } 795 | 796 | do { 797 | if (DRMP3_HDR_IS_MONO(hdr)) { 798 | scfsi <<= 4; 799 | } 800 | gr->part_23_length = (drmp3_uint16) drmp3_bs_get_bits(bs, 12); 801 | part_23_sum += gr->part_23_length; 802 | gr->big_values = (drmp3_uint16) drmp3_bs_get_bits(bs, 9); 803 | if (gr->big_values > 288) { 804 | return -1; 805 | } 806 | gr->global_gain = (drmp3_uint8) drmp3_bs_get_bits(bs, 8); 807 | gr->scalefac_compress = (drmp3_uint16) drmp3_bs_get_bits(bs, DRMP3_HDR_TEST_MPEG1(hdr) ? 4 : 9); 808 | gr->sfbtab = g_scf_long[sr_idx]; 809 | gr->n_long_sfb = 22; 810 | gr->n_short_sfb = 0; 811 | if (drmp3_bs_get_bits(bs, 1)) { 812 | gr->block_type = (drmp3_uint8) drmp3_bs_get_bits(bs, 2); 813 | if (!gr->block_type) { 814 | return -1; 815 | } 816 | gr->mixed_block_flag = (drmp3_uint8) drmp3_bs_get_bits(bs, 1); 817 | gr->region_count[0] = 7; 818 | gr->region_count[1] = 255; 819 | if (gr->block_type == DRMP3_SHORT_BLOCK_TYPE) { 820 | scfsi &= 0x0F0F; 821 | if (!gr->mixed_block_flag) { 822 | gr->region_count[0] = 8; 823 | gr->sfbtab = g_scf_short[sr_idx]; 824 | gr->n_long_sfb = 0; 825 | gr->n_short_sfb = 39; 826 | } else { 827 | gr->sfbtab = g_scf_mixed[sr_idx]; 828 | gr->n_long_sfb = DRMP3_HDR_TEST_MPEG1(hdr) ? 8 : 6; 829 | gr->n_short_sfb = 30; 830 | } 831 | } 832 | tables = drmp3_bs_get_bits(bs, 10); 833 | tables <<= 5; 834 | gr->subblock_gain[0] = (drmp3_uint8) drmp3_bs_get_bits(bs, 3); 835 | gr->subblock_gain[1] = (drmp3_uint8) drmp3_bs_get_bits(bs, 3); 836 | gr->subblock_gain[2] = (drmp3_uint8) drmp3_bs_get_bits(bs, 3); 837 | } else { 838 | gr->block_type = 0; 839 | gr->mixed_block_flag = 0; 840 | tables = drmp3_bs_get_bits(bs, 15); 841 | gr->region_count[0] = (drmp3_uint8) drmp3_bs_get_bits(bs, 4); 842 | gr->region_count[1] = (drmp3_uint8) drmp3_bs_get_bits(bs, 3); 843 | gr->region_count[2] = 255; 844 | } 845 | gr->table_select[0] = (drmp3_uint8) (tables >> 10); 846 | gr->table_select[1] = (drmp3_uint8) ((tables >> 5) & 31); 847 | gr->table_select[2] = (drmp3_uint8) ((tables) & 31); 848 | gr->preflag = (drmp3_uint8) (DRMP3_HDR_TEST_MPEG1(hdr) ? drmp3_bs_get_bits(bs, 1) : (gr->scalefac_compress >= 849 | 500)); 850 | gr->scalefac_scale = (drmp3_uint8) drmp3_bs_get_bits(bs, 1); 851 | gr->count1_table = (drmp3_uint8) drmp3_bs_get_bits(bs, 1); 852 | gr->scfsi = (drmp3_uint8) ((scfsi >> 12) & 15); 853 | scfsi <<= 4; 854 | gr++; 855 | } while (--gr_count); 856 | 857 | if (part_23_sum + bs->pos > bs->limit + main_data_begin * 8) { 858 | return -1; 859 | } 860 | 861 | return main_data_begin; 862 | } 863 | 864 | static void drmp3_L3_read_scalefactors(drmp3_uint8 *scf, drmp3_uint8 *ist_pos, const drmp3_uint8 *scf_size, 865 | const drmp3_uint8 *scf_count, drmp3_bs *bitbuf, int scfsi) { 866 | int i, k; 867 | for (i = 0; i < 4 && scf_count[i]; i++, scfsi *= 2) { 868 | int cnt = scf_count[i]; 869 | if (scfsi & 8) { 870 | memcpy(scf, ist_pos, cnt); 871 | } else { 872 | int bits = scf_size[i]; 873 | if (!bits) { 874 | memset(scf, 0, cnt); 875 | memset(ist_pos, 0, cnt); 876 | } else { 877 | int max_scf = (scfsi < 0) ? (1 << bits) - 1 : -1; 878 | for (k = 0; k < cnt; k++) { 879 | int s = drmp3_bs_get_bits(bitbuf, bits); 880 | ist_pos[k] = (drmp3_uint8) (s == max_scf ? -1 : s); 881 | scf[k] = (drmp3_uint8) s; 882 | } 883 | } 884 | } 885 | ist_pos += cnt; 886 | scf += cnt; 887 | } 888 | scf[0] = scf[1] = scf[2] = 0; 889 | } 890 | 891 | static float drmp3_L3_ldexp_q2(float y, int exp_q2) { 892 | static const float g_expfrac[4] = {9.31322575e-10f, 7.83145814e-10f, 6.58544508e-10f, 5.53767716e-10f}; 893 | int e; 894 | do { 895 | e = DRMP3_MIN(30 * 4, exp_q2); 896 | y *= g_expfrac[e & 3] * (1 << 30 >> (e >> 2)); 897 | } while ((exp_q2 -= e) > 0); 898 | return y; 899 | } 900 | 901 | static void 902 | drmp3_L3_decode_scalefactors(const drmp3_uint8 *hdr, drmp3_uint8 *ist_pos, drmp3_bs *bs, const drmp3_L3_gr_info *gr, 903 | float *scf, int ch) { 904 | static const drmp3_uint8 g_scf_partitions[3][28] = { 905 | {6, 5, 5, 5, 6, 5, 5, 5, 6, 5, 7, 3, 11, 10, 0, 0, 7, 7, 7, 0, 6, 6, 6, 3, 8, 8, 5, 0}, 906 | {8, 9, 6, 12, 6, 9, 9, 9, 6, 9, 12, 6, 15, 18, 0, 0, 6, 15, 12, 0, 6, 12, 9, 6, 6, 18, 9, 0}, 907 | {9, 9, 6, 12, 9, 9, 9, 9, 9, 9, 12, 6, 18, 18, 0, 0, 12, 12, 12, 0, 12, 9, 9, 6, 15, 12, 9, 0} 908 | }; 909 | const drmp3_uint8 *scf_partition = g_scf_partitions[!!gr->n_short_sfb + !gr->n_long_sfb]; 910 | drmp3_uint8 scf_size[4], iscf[40]; 911 | int i, scf_shift = gr->scalefac_scale + 1, gain_exp, scfsi = gr->scfsi; 912 | float gain; 913 | 914 | if (DRMP3_HDR_TEST_MPEG1(hdr)) { 915 | static const drmp3_uint8 g_scfc_decode[16] = {0, 1, 2, 3, 12, 5, 6, 7, 9, 10, 11, 13, 14, 15, 18, 19}; 916 | int part = g_scfc_decode[gr->scalefac_compress]; 917 | scf_size[1] = scf_size[0] = (drmp3_uint8) (part >> 2); 918 | scf_size[3] = scf_size[2] = (drmp3_uint8) (part & 3); 919 | } else { 920 | static const drmp3_uint8 g_mod[ 921 | 6 * 4] = {5, 5, 4, 4, 5, 5, 4, 1, 4, 3, 1, 1, 5, 6, 6, 1, 4, 4, 4, 1, 4, 3, 1, 1}; 922 | int k, modprod, sfc, ist = DRMP3_HDR_TEST_I_STEREO(hdr) && ch; 923 | sfc = gr->scalefac_compress >> ist; 924 | for (k = ist * 3 * 4; sfc >= 0; sfc -= modprod, k += 4) { 925 | for (modprod = 1, i = 3; i >= 0; i--) { 926 | scf_size[i] = (drmp3_uint8) (sfc / modprod % g_mod[k + i]); 927 | modprod *= g_mod[k + i]; 928 | } 929 | } 930 | scf_partition += k; 931 | scfsi = -16; 932 | } 933 | drmp3_L3_read_scalefactors(iscf, ist_pos, scf_size, scf_partition, bs, scfsi); 934 | 935 | if (gr->n_short_sfb) { 936 | int sh = 3 - scf_shift; 937 | for (i = 0; i < gr->n_short_sfb; i += 3) { 938 | iscf[gr->n_long_sfb + i + 0] += gr->subblock_gain[0] << sh; 939 | iscf[gr->n_long_sfb + i + 1] += gr->subblock_gain[1] << sh; 940 | iscf[gr->n_long_sfb + i + 2] += gr->subblock_gain[2] << sh; 941 | } 942 | } else if (gr->preflag) { 943 | static const drmp3_uint8 g_preamp[10] = {1, 1, 1, 1, 2, 2, 3, 3, 3, 2}; 944 | for (i = 0; i < 10; i++) { 945 | iscf[11 + i] += g_preamp[i]; 946 | } 947 | } 948 | 949 | gain_exp = gr->global_gain + DRMP3_BITS_DEQUANTIZER_OUT * 4 - 210 - (DRMP3_HDR_IS_MS_STEREO(hdr) ? 2 : 0); 950 | gain = drmp3_L3_ldexp_q2(1 << (DRMP3_MAX_SCFI / 4), DRMP3_MAX_SCFI - gain_exp); 951 | for (i = 0; i < (int) (gr->n_long_sfb + gr->n_short_sfb); i++) { 952 | scf[i] = drmp3_L3_ldexp_q2(gain, iscf[i] << scf_shift); 953 | } 954 | } 955 | 956 | static const float g_drmp3_pow43[129 + 16] = { 957 | 0, -1, -2.519842f, -4.326749f, -6.349604f, -8.549880f, -10.902724f, -13.390518f, -16.000000f, -18.720754f, 958 | -21.544347f, -24.463781f, -27.473142f, -30.567351f, -33.741992f, -36.993181f, 959 | 0, 1, 2.519842f, 4.326749f, 6.349604f, 8.549880f, 10.902724f, 13.390518f, 16.000000f, 18.720754f, 21.544347f, 960 | 24.463781f, 27.473142f, 30.567351f, 33.741992f, 36.993181f, 40.317474f, 43.711787f, 47.173345f, 50.699631f, 961 | 54.288352f, 57.937408f, 61.644865f, 65.408941f, 69.227979f, 73.100443f, 77.024898f, 81.000000f, 85.024491f, 962 | 89.097188f, 93.216975f, 97.382800f, 101.593667f, 105.848633f, 110.146801f, 114.487321f, 118.869381f, 963 | 123.292209f, 127.755065f, 132.257246f, 136.798076f, 141.376907f, 145.993119f, 150.646117f, 155.335327f, 964 | 160.060199f, 164.820202f, 169.614826f, 174.443577f, 179.305980f, 184.201575f, 189.129918f, 194.090580f, 965 | 199.083145f, 204.107210f, 209.162385f, 214.248292f, 219.364564f, 224.510845f, 229.686789f, 234.892058f, 966 | 240.126328f, 245.389280f, 250.680604f, 256.000000f, 261.347174f, 266.721841f, 272.123723f, 277.552547f, 967 | 283.008049f, 288.489971f, 293.998060f, 299.532071f, 305.091761f, 310.676898f, 316.287249f, 321.922592f, 968 | 327.582707f, 333.267377f, 338.976394f, 344.709550f, 350.466646f, 356.247482f, 362.051866f, 367.879608f, 969 | 373.730522f, 379.604427f, 385.501143f, 391.420496f, 397.362314f, 403.326427f, 409.312672f, 415.320884f, 970 | 421.350905f, 427.402579f, 433.475750f, 439.570269f, 445.685987f, 451.822757f, 457.980436f, 464.158883f, 971 | 470.357960f, 476.577530f, 482.817459f, 489.077615f, 495.357868f, 501.658090f, 507.978156f, 514.317941f, 972 | 520.677324f, 527.056184f, 533.454404f, 539.871867f, 546.308458f, 552.764065f, 559.238575f, 565.731879f, 973 | 572.243870f, 578.774440f, 585.323483f, 591.890898f, 598.476581f, 605.080431f, 611.702349f, 618.342238f, 974 | 625.000000f, 631.675540f, 638.368763f, 645.079578f 975 | }; 976 | 977 | static float drmp3_L3_pow_43(int x) { 978 | float frac; 979 | int sign, mult = 256; 980 | 981 | if (x < 129) { 982 | return g_drmp3_pow43[16 + x]; 983 | } 984 | 985 | if (x < 1024) { 986 | mult = 16; 987 | x <<= 3; 988 | } 989 | 990 | sign = 2 * x & 64; 991 | frac = (float) ((x & 63) - sign) / ((x & ~63) + sign); 992 | return g_drmp3_pow43[16 + ((x + sign) >> 6)] * (1.f + frac * ((4.f / 3) + frac * (2.f / 9))) * mult; 993 | } 994 | 995 | static void 996 | drmp3_L3_huffman(float *dst, drmp3_bs *bs, const drmp3_L3_gr_info *gr_info, const float *scf, int layer3gr_limit) { 997 | static const drmp3_int16 tabs[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 998 | 0, 0, 0, 0, 0, 999 | 785, 785, 785, 785, 784, 784, 784, 784, 513, 513, 513, 513, 513, 513, 513, 513, 1000 | 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 1001 | -255, 1313, 1298, 1282, 785, 785, 785, 785, 784, 784, 784, 784, 769, 769, 769, 1002 | 769, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 1003 | 256, 290, 288, 1004 | -255, 1313, 1298, 1282, 769, 769, 769, 769, 529, 529, 529, 529, 529, 529, 529, 1005 | 529, 528, 528, 528, 528, 528, 528, 528, 528, 512, 512, 512, 512, 512, 512, 512, 1006 | 512, 290, 288, 1007 | -253, -318, -351, -367, 785, 785, 785, 785, 784, 784, 784, 784, 769, 769, 769, 1008 | 769, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 1009 | 256, 819, 818, 547, 547, 275, 275, 275, 275, 561, 560, 515, 546, 289, 274, 288, 1010 | 258, 1011 | -254, -287, 1329, 1299, 1314, 1312, 1057, 1057, 1042, 1042, 1026, 1026, 784, 784, 1012 | 784, 784, 529, 529, 529, 529, 529, 529, 529, 529, 769, 769, 769, 769, 768, 768, 1013 | 768, 768, 563, 560, 306, 306, 291, 259, 1014 | -252, -413, -477, -542, 1298, -575, 1041, 1041, 784, 784, 784, 784, 769, 769, 1015 | 769, 769, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 1016 | 256, 256, -383, -399, 1107, 1092, 1106, 1061, 849, 849, 789, 789, 1104, 1091, 1017 | 773, 773, 1076, 1075, 341, 340, 325, 309, 834, 804, 577, 577, 532, 532, 516, 516, 1018 | 832, 818, 803, 816, 561, 561, 531, 531, 515, 546, 289, 289, 288, 258, 1019 | -252, -429, -493, -559, 1057, 1057, 1042, 1042, 529, 529, 529, 529, 529, 529, 1020 | 529, 529, 784, 784, 784, 784, 769, 769, 769, 769, 512, 512, 512, 512, 512, 512, 1021 | 512, 512, -382, 1077, -415, 1106, 1061, 1104, 849, 849, 789, 789, 1091, 1076, 1022 | 1029, 1075, 834, 834, 597, 581, 340, 340, 339, 324, 804, 833, 532, 532, 832, 772, 1023 | 818, 803, 817, 787, 816, 771, 290, 290, 290, 290, 288, 258, 1024 | -253, -349, -414, -447, -463, 1329, 1299, -479, 1314, 1312, 1057, 1057, 1042, 1025 | 1042, 1026, 1026, 785, 785, 785, 785, 784, 784, 784, 784, 769, 769, 769, 769, 1026 | 768, 768, 768, 768, -319, 851, 821, -335, 836, 850, 805, 849, 341, 340, 325, 336, 1027 | 533, 533, 579, 579, 564, 564, 773, 832, 578, 548, 563, 516, 321, 276, 306, 291, 1028 | 304, 259, 1029 | -251, -572, -733, -830, -863, -879, 1041, 1041, 784, 784, 784, 784, 769, 769, 1030 | 769, 769, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 1031 | 256, 256, -511, -527, -543, 1396, 1351, 1381, 1366, 1395, 1335, 1380, -559, 1334, 1032 | 1138, 1138, 1063, 1063, 1350, 1392, 1031, 1031, 1062, 1062, 1364, 1363, 1120, 1033 | 1120, 1333, 1348, 881, 881, 881, 881, 375, 374, 359, 373, 343, 358, 341, 325, 1034 | 791, 791, 1123, 1122, -703, 1105, 1045, -719, 865, 865, 790, 790, 774, 774, 1104, 1035 | 1029, 338, 293, 323, 308, -799, -815, 833, 788, 772, 818, 803, 816, 322, 292, 1036 | 307, 320, 561, 531, 515, 546, 289, 274, 288, 258, 1037 | -251, -525, -605, -685, -765, -831, -846, 1298, 1057, 1057, 1312, 1282, 785, 785, 1038 | 785, 785, 784, 784, 784, 784, 769, 769, 769, 769, 512, 512, 512, 512, 512, 512, 1039 | 512, 512, 1399, 1398, 1383, 1367, 1382, 1396, 1351, -511, 1381, 1366, 1139, 1139, 1040 | 1079, 1079, 1124, 1124, 1364, 1349, 1363, 1333, 882, 882, 882, 882, 807, 807, 1041 | 807, 807, 1094, 1094, 1136, 1136, 373, 341, 535, 535, 881, 775, 867, 822, 774, 1042 | -591, 324, 338, -671, 849, 550, 550, 866, 864, 609, 609, 293, 336, 534, 534, 789, 1043 | 835, 773, -751, 834, 804, 308, 307, 833, 788, 832, 772, 562, 562, 547, 547, 305, 1044 | 275, 560, 515, 290, 290, 1045 | -252, -397, -477, -557, -622, -653, -719, -735, -750, 1329, 1299, 1314, 1057, 1046 | 1057, 1042, 1042, 1312, 1282, 1024, 1024, 785, 785, 785, 785, 784, 784, 784, 784, 1047 | 769, 769, 769, 769, -383, 1127, 1141, 1111, 1126, 1140, 1095, 1110, 869, 869, 1048 | 883, 883, 1079, 1109, 882, 882, 375, 374, 807, 868, 838, 881, 791, -463, 867, 1049 | 822, 368, 263, 852, 837, 836, -543, 610, 610, 550, 550, 352, 336, 534, 534, 865, 1050 | 774, 851, 821, 850, 805, 593, 533, 579, 564, 773, 832, 578, 578, 548, 548, 577, 1051 | 577, 307, 276, 306, 291, 516, 560, 259, 259, 1052 | -250, -2107, -2507, -2764, -2909, -2974, -3007, -3023, 1041, 1041, 1040, 1040, 1053 | 769, 769, 769, 769, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 1054 | 256, 256, 256, 256, -767, -1052, -1213, -1277, -1358, -1405, -1469, -1535, -1550, 1055 | -1582, -1614, -1647, -1662, -1694, -1726, -1759, -1774, -1807, -1822, -1854, 1056 | -1886, 1565, -1919, -1935, -1951, -1967, 1731, 1730, 1580, 1717, -1983, 1729, 1057 | 1564, -1999, 1548, -2015, -2031, 1715, 1595, -2047, 1714, -2063, 1610, -2079, 1058 | 1609, -2095, 1323, 1323, 1457, 1457, 1307, 1307, 1712, 1547, 1641, 1700, 1699, 1059 | 1594, 1685, 1625, 1442, 1442, 1322, 1322, -780, -973, -910, 1279, 1278, 1277, 1060 | 1262, 1276, 1261, 1275, 1215, 1260, 1229, -959, 974, 974, 989, 989, -943, 735, 1061 | 478, 478, 495, 463, 506, 414, -1039, 1003, 958, 1017, 927, 942, 987, 957, 431, 1062 | 476, 1272, 1167, 1228, -1183, 1256, -1199, 895, 895, 941, 941, 1242, 1227, 1212, 1063 | 1135, 1014, 1014, 490, 489, 503, 487, 910, 1013, 985, 925, 863, 894, 970, 955, 1064 | 1012, 847, -1343, 831, 755, 755, 984, 909, 428, 366, 754, 559, -1391, 752, 486, 1065 | 457, 924, 997, 698, 698, 983, 893, 740, 740, 908, 877, 739, 739, 667, 667, 953, 1066 | 938, 497, 287, 271, 271, 683, 606, 590, 712, 726, 574, 302, 302, 738, 736, 481, 1067 | 286, 526, 725, 605, 711, 636, 724, 696, 651, 589, 681, 666, 710, 364, 467, 573, 1068 | 695, 466, 466, 301, 465, 379, 379, 709, 604, 665, 679, 316, 316, 634, 633, 436, 1069 | 436, 464, 269, 424, 394, 452, 332, 438, 363, 347, 408, 393, 448, 331, 422, 362, 1070 | 407, 392, 421, 346, 406, 391, 376, 375, 359, 1441, 1306, -2367, 1290, -2383, 1071 | 1337, -2399, -2415, 1426, 1321, -2431, 1411, 1336, -2447, -2463, -2479, 1169, 1072 | 1169, 1049, 1049, 1424, 1289, 1412, 1352, 1319, -2495, 1154, 1154, 1064, 1064, 1073 | 1153, 1153, 416, 390, 360, 404, 403, 389, 344, 374, 373, 343, 358, 372, 327, 357, 1074 | 342, 311, 356, 326, 1395, 1394, 1137, 1137, 1047, 1047, 1365, 1392, 1287, 1379, 1075 | 1334, 1364, 1349, 1378, 1318, 1363, 792, 792, 792, 792, 1152, 1152, 1032, 1032, 1076 | 1121, 1121, 1046, 1046, 1120, 1120, 1030, 1030, -2895, 1106, 1061, 1104, 849, 1077 | 849, 789, 789, 1091, 1076, 1029, 1090, 1060, 1075, 833, 833, 309, 324, 532, 532, 1078 | 832, 772, 818, 803, 561, 561, 531, 560, 515, 546, 289, 274, 288, 258, 1079 | -250, -1179, -1579, -1836, -1996, -2124, -2253, -2333, -2413, -2477, -2542, 1080 | -2574, -2607, -2622, -2655, 1314, 1313, 1298, 1312, 1282, 785, 785, 785, 785, 1081 | 1040, 1040, 1025, 1025, 768, 768, 768, 768, -766, -798, -830, -862, -895, -911, 1082 | -927, -943, -959, -975, -991, -1007, -1023, -1039, -1055, -1070, 1724, 1647, 1083 | -1103, -1119, 1631, 1767, 1662, 1738, 1708, 1723, -1135, 1780, 1615, 1779, 1599, 1084 | 1677, 1646, 1778, 1583, -1151, 1777, 1567, 1737, 1692, 1765, 1722, 1707, 1630, 1085 | 1751, 1661, 1764, 1614, 1736, 1676, 1763, 1750, 1645, 1598, 1721, 1691, 1762, 1086 | 1706, 1582, 1761, 1566, -1167, 1749, 1629, 767, 766, 751, 765, 494, 494, 735, 1087 | 764, 719, 749, 734, 763, 447, 447, 748, 718, 477, 506, 431, 491, 446, 476, 461, 1088 | 505, 415, 430, 475, 445, 504, 399, 460, 489, 414, 503, 383, 474, 429, 459, 502, 1089 | 502, 746, 752, 488, 398, 501, 473, 413, 472, 486, 271, 480, 270, -1439, -1455, 1090 | 1357, -1471, -1487, -1503, 1341, 1325, -1519, 1489, 1463, 1403, 1309, -1535, 1091 | 1372, 1448, 1418, 1476, 1356, 1462, 1387, -1551, 1475, 1340, 1447, 1402, 1386, 1092 | -1567, 1068, 1068, 1474, 1461, 455, 380, 468, 440, 395, 425, 410, 454, 364, 467, 1093 | 466, 464, 453, 269, 409, 448, 268, 432, 1371, 1473, 1432, 1417, 1308, 1460, 1355, 1094 | 1446, 1459, 1431, 1083, 1083, 1401, 1416, 1458, 1445, 1067, 1067, 1370, 1457, 1095 | 1051, 1051, 1291, 1430, 1385, 1444, 1354, 1415, 1400, 1443, 1082, 1082, 1173, 1096 | 1113, 1186, 1066, 1185, 1050, -1967, 1158, 1128, 1172, 1097, 1171, 1081, -1983, 1097 | 1157, 1112, 416, 266, 375, 400, 1170, 1142, 1127, 1065, 793, 793, 1169, 1033, 1098 | 1156, 1096, 1141, 1111, 1155, 1080, 1126, 1140, 898, 898, 808, 808, 897, 897, 1099 | 792, 792, 1095, 1152, 1032, 1125, 1110, 1139, 1079, 1124, 882, 807, 838, 881, 1100 | 853, 791, -2319, 867, 368, 263, 822, 852, 837, 866, 806, 865, -2399, 851, 352, 1101 | 262, 534, 534, 821, 836, 594, 594, 549, 549, 593, 593, 533, 533, 848, 773, 579, 1102 | 579, 564, 578, 548, 563, 276, 276, 577, 576, 306, 291, 516, 560, 305, 305, 275, 1103 | 259, 1104 | -251, -892, -2058, -2620, -2828, -2957, -3023, -3039, 1041, 1041, 1040, 1040, 1105 | 769, 769, 769, 769, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 1106 | 256, 256, 256, 256, -511, -527, -543, -559, 1530, -575, -591, 1528, 1527, 1407, 1107 | 1526, 1391, 1023, 1023, 1023, 1023, 1525, 1375, 1268, 1268, 1103, 1103, 1087, 1108 | 1087, 1039, 1039, 1523, -604, 815, 815, 815, 815, 510, 495, 509, 479, 508, 463, 1109 | 507, 447, 431, 505, 415, 399, -734, -782, 1262, -815, 1259, 1244, -831, 1258, 1110 | 1228, -847, -863, 1196, -879, 1253, 987, 987, 748, -767, 493, 493, 462, 477, 414, 1111 | 414, 686, 669, 478, 446, 461, 445, 474, 429, 487, 458, 412, 471, 1266, 1264, 1112 | 1009, 1009, 799, 799, -1019, -1276, -1452, -1581, -1677, -1757, -1821, -1886, 1113 | -1933, -1997, 1257, 1257, 1483, 1468, 1512, 1422, 1497, 1406, 1467, 1496, 1421, 1114 | 1510, 1134, 1134, 1225, 1225, 1466, 1451, 1374, 1405, 1252, 1252, 1358, 1480, 1115 | 1164, 1164, 1251, 1251, 1238, 1238, 1389, 1465, -1407, 1054, 1101, -1423, 1207, 1116 | -1439, 830, 830, 1248, 1038, 1237, 1117, 1223, 1148, 1236, 1208, 411, 426, 395, 1117 | 410, 379, 269, 1193, 1222, 1132, 1235, 1221, 1116, 976, 976, 1192, 1162, 1177, 1118 | 1220, 1131, 1191, 963, 963, -1647, 961, 780, -1663, 558, 558, 994, 993, 437, 408, 1119 | 393, 407, 829, 978, 813, 797, 947, -1743, 721, 721, 377, 392, 844, 950, 828, 890, 1120 | 706, 706, 812, 859, 796, 960, 948, 843, 934, 874, 571, 571, -1919, 690, 555, 689, 1121 | 421, 346, 539, 539, 944, 779, 918, 873, 932, 842, 903, 888, 570, 570, 931, 917, 1122 | 674, 674, -2575, 1562, -2591, 1609, -2607, 1654, 1322, 1322, 1441, 1441, 1696, 1123 | 1546, 1683, 1593, 1669, 1624, 1426, 1426, 1321, 1321, 1639, 1680, 1425, 1425, 1124 | 1305, 1305, 1545, 1668, 1608, 1623, 1667, 1592, 1638, 1666, 1320, 1320, 1652, 1125 | 1607, 1409, 1409, 1304, 1304, 1288, 1288, 1664, 1637, 1395, 1395, 1335, 1335, 1126 | 1622, 1636, 1394, 1394, 1319, 1319, 1606, 1621, 1392, 1392, 1137, 1137, 1137, 1127 | 1137, 345, 390, 360, 375, 404, 373, 1047, -2751, -2767, -2783, 1062, 1121, 1046, 1128 | -2799, 1077, -2815, 1106, 1061, 789, 789, 1105, 1104, 263, 355, 310, 340, 325, 1129 | 354, 352, 262, 339, 324, 1091, 1076, 1029, 1090, 1060, 1075, 833, 833, 788, 788, 1130 | 1088, 1028, 818, 818, 803, 803, 561, 561, 531, 531, 816, 771, 546, 546, 289, 274, 1131 | 288, 258, 1132 | -253, -317, -381, -446, -478, -509, 1279, 1279, -811, -1179, -1451, -1756, -1900, 1133 | -2028, -2189, -2253, -2333, -2414, -2445, -2511, -2526, 1313, 1298, -2559, 1041, 1134 | 1041, 1040, 1040, 1025, 1025, 1024, 1024, 1022, 1007, 1021, 991, 1020, 975, 1019, 1135 | 959, 687, 687, 1018, 1017, 671, 671, 655, 655, 1016, 1015, 639, 639, 758, 758, 1136 | 623, 623, 757, 607, 756, 591, 755, 575, 754, 559, 543, 543, 1009, 783, -575, 1137 | -621, -685, -749, 496, -590, 750, 749, 734, 748, 974, 989, 1003, 958, 988, 973, 1138 | 1002, 942, 987, 957, 972, 1001, 926, 986, 941, 971, 956, 1000, 910, 985, 925, 1139 | 999, 894, 970, -1071, -1087, -1102, 1390, -1135, 1436, 1509, 1451, 1374, -1151, 1140 | 1405, 1358, 1480, 1420, -1167, 1507, 1494, 1389, 1342, 1465, 1435, 1450, 1326, 1141 | 1505, 1310, 1493, 1373, 1479, 1404, 1492, 1464, 1419, 428, 443, 472, 397, 736, 1142 | 526, 464, 464, 486, 457, 442, 471, 484, 482, 1357, 1449, 1434, 1478, 1388, 1491, 1143 | 1341, 1490, 1325, 1489, 1463, 1403, 1309, 1477, 1372, 1448, 1418, 1433, 1476, 1144 | 1356, 1462, 1387, -1439, 1475, 1340, 1447, 1402, 1474, 1324, 1461, 1371, 1473, 1145 | 269, 448, 1432, 1417, 1308, 1460, -1711, 1459, -1727, 1441, 1099, 1099, 1446, 1146 | 1386, 1431, 1401, -1743, 1289, 1083, 1083, 1160, 1160, 1458, 1445, 1067, 1067, 1147 | 1370, 1457, 1307, 1430, 1129, 1129, 1098, 1098, 268, 432, 267, 416, 266, 400, 1148 | -1887, 1144, 1187, 1082, 1173, 1113, 1186, 1066, 1050, 1158, 1128, 1143, 1172, 1149 | 1097, 1171, 1081, 420, 391, 1157, 1112, 1170, 1142, 1127, 1065, 1169, 1049, 1156, 1150 | 1096, 1141, 1111, 1155, 1080, 1126, 1154, 1064, 1153, 1140, 1095, 1048, -2159, 1151 | 1125, 1110, 1137, -2175, 823, 823, 1139, 1138, 807, 807, 384, 264, 368, 263, 868, 1152 | 838, 853, 791, 867, 822, 852, 837, 866, 806, 865, 790, -2319, 851, 821, 836, 352, 1153 | 262, 850, 805, 849, -2399, 533, 533, 835, 820, 336, 261, 578, 548, 563, 577, 532, 1154 | 532, 832, 772, 562, 562, 547, 547, 305, 275, 560, 515, 290, 290, 288, 258}; 1155 | static const drmp3_uint8 tab32[] = {130, 162, 193, 209, 44, 28, 76, 140, 9, 9, 9, 9, 9, 9, 9, 9, 190, 254, 222, 238, 1156 | 126, 94, 157, 157, 109, 61, 173, 205}; 1157 | static const drmp3_uint8 tab33[] = {252, 236, 220, 204, 188, 172, 156, 140, 124, 108, 92, 76, 60, 44, 28, 12}; 1158 | static const drmp3_int16 tabindex[ 1159 | 2 * 16] = {0, 32, 64, 98, 0, 132, 180, 218, 292, 364, 426, 538, 648, 746, 0, 1126, 1460, 1460, 1460, 1460, 1160 | 1460, 1460, 1460, 1460, 1842, 1842, 1842, 1842, 1842, 1842, 1842, 1842}; 1161 | static const drmp3_uint8 g_linbits[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 8, 10, 13, 4, 1162 | 5, 6, 7, 8, 9, 11, 13}; 1163 | 1164 | #define DRMP3_PEEK_BITS(n) (bs_cache >> (32 - n)) 1165 | #define DRMP3_FLUSH_BITS(n) { bs_cache <<= (n); bs_sh += (n); } 1166 | #define DRMP3_CHECK_BITS while (bs_sh >= 0) { bs_cache |= (drmp3_uint32)*bs_next_ptr++ << bs_sh; bs_sh -= 8; } 1167 | #define DRMP3_BSPOS ((bs_next_ptr - bs->buf)*8 - 24 + bs_sh) 1168 | 1169 | float one = 0.0f; 1170 | int ireg = 0, big_val_cnt = gr_info->big_values; 1171 | const drmp3_uint8 *sfb = gr_info->sfbtab; 1172 | const drmp3_uint8 *bs_next_ptr = bs->buf + bs->pos / 8; 1173 | drmp3_uint32 bs_cache = (((bs_next_ptr[0] * 256u + bs_next_ptr[1]) * 256u + bs_next_ptr[2]) * 256u + bs_next_ptr[3]) 1174 | << (bs->pos & 7); 1175 | int pairs_to_decode, np, bs_sh = (bs->pos & 7) - 8; 1176 | bs_next_ptr += 4; 1177 | 1178 | while (big_val_cnt > 0) { 1179 | int tab_num = gr_info->table_select[ireg]; 1180 | int sfb_cnt = gr_info->region_count[ireg++]; 1181 | const drmp3_int16 *codebook = tabs + tabindex[tab_num]; 1182 | int linbits = g_linbits[tab_num]; 1183 | do { 1184 | np = *sfb++ / 2; 1185 | pairs_to_decode = DRMP3_MIN(big_val_cnt, np); 1186 | one = *scf++; 1187 | do { 1188 | int j, w = 5; 1189 | int leaf = codebook[DRMP3_PEEK_BITS(w)]; 1190 | while (leaf < 0) { 1191 | DRMP3_FLUSH_BITS(w); 1192 | w = leaf & 7; 1193 | leaf = codebook[DRMP3_PEEK_BITS(w) - (leaf >> 3)]; 1194 | } 1195 | DRMP3_FLUSH_BITS(leaf >> 8); 1196 | 1197 | for (j = 0; j < 2; j++, dst++, leaf >>= 4) { 1198 | int lsb = leaf & 0x0F; 1199 | if (lsb == 15 && linbits) { 1200 | lsb += DRMP3_PEEK_BITS(linbits); 1201 | DRMP3_FLUSH_BITS(linbits); 1202 | DRMP3_CHECK_BITS; 1203 | *dst = one * drmp3_L3_pow_43(lsb) * ((int32_t) bs_cache < 0 ? -1 : 1); 1204 | } else { 1205 | *dst = g_drmp3_pow43[16 + lsb - 16 * (bs_cache >> 31)] * one; 1206 | } 1207 | DRMP3_FLUSH_BITS(lsb ? 1 : 0); 1208 | } 1209 | DRMP3_CHECK_BITS; 1210 | } while (--pairs_to_decode); 1211 | } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0); 1212 | } 1213 | 1214 | for (np = 1 - big_val_cnt;; dst += 4) { 1215 | const drmp3_uint8 *codebook_count1 = (gr_info->count1_table) ? tab33 : tab32; 1216 | int leaf = codebook_count1[DRMP3_PEEK_BITS(4)]; 1217 | if (!(leaf & 8)) { 1218 | leaf = codebook_count1[(leaf >> 3) + (bs_cache << 4 >> (32 - (leaf & 3)))]; 1219 | } 1220 | DRMP3_FLUSH_BITS(leaf & 7); 1221 | if (DRMP3_BSPOS > layer3gr_limit) { 1222 | break; 1223 | } 1224 | #define DRMP3_RELOAD_SCALEFACTOR if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; } 1225 | #define DRMP3_DEQ_COUNT1(s) if (leaf & (128 >> s)) { dst[s] = ((drmp3_int32)bs_cache < 0) ? -one : one; DRMP3_FLUSH_BITS(1) } 1226 | DRMP3_RELOAD_SCALEFACTOR; 1227 | DRMP3_DEQ_COUNT1(0); 1228 | DRMP3_DEQ_COUNT1(1); 1229 | DRMP3_RELOAD_SCALEFACTOR; 1230 | DRMP3_DEQ_COUNT1(2); 1231 | DRMP3_DEQ_COUNT1(3); 1232 | DRMP3_CHECK_BITS; 1233 | } 1234 | 1235 | bs->pos = layer3gr_limit; 1236 | } 1237 | 1238 | static void drmp3_L3_midside_stereo(float *left, int n) { 1239 | int i = 0; 1240 | float *right = left + 576; 1241 | #if DRMP3_HAVE_SIMD 1242 | if (drmp3_have_simd()) 1243 | for (; i < n - 3; i += 4) { 1244 | drmp3_f4 vl = DRMP3_VLD(left + i); 1245 | drmp3_f4 vr = DRMP3_VLD(right + i); 1246 | DRMP3_VSTORE(left + i, DRMP3_VADD(vl, vr)); 1247 | DRMP3_VSTORE(right + i, DRMP3_VSUB(vl, vr)); 1248 | } 1249 | #endif 1250 | for (; i < n; i++) { 1251 | float a = left[i]; 1252 | float b = right[i]; 1253 | left[i] = a + b; 1254 | right[i] = a - b; 1255 | } 1256 | } 1257 | 1258 | static void drmp3_L3_intensity_stereo_band(float *left, int n, float kl, float kr) { 1259 | int i; 1260 | for (i = 0; i < n; i++) { 1261 | left[i + 576] = left[i] * kr; 1262 | left[i] = left[i] * kl; 1263 | } 1264 | } 1265 | 1266 | static void drmp3_L3_stereo_top_band(const float *right, const drmp3_uint8 *sfb, int nbands, int max_band[3]) { 1267 | int i, k; 1268 | 1269 | max_band[0] = max_band[1] = max_band[2] = -1; 1270 | 1271 | for (i = 0; i < nbands; i++) { 1272 | for (k = 0; k < sfb[i]; k += 2) { 1273 | if (right[k] != 0 || right[k + 1] != 0) { 1274 | max_band[i % 3] = i; 1275 | break; 1276 | } 1277 | } 1278 | right += sfb[i]; 1279 | } 1280 | } 1281 | 1282 | static void 1283 | drmp3_L3_stereo_process(float *left, const drmp3_uint8 *ist_pos, const drmp3_uint8 *sfb, const drmp3_uint8 *hdr, 1284 | int max_band[3], int mpeg2_sh) { 1285 | static const float g_pan[ 1286 | 7 * 2] = {0, 1, 0.21132487f, 0.78867513f, 0.36602540f, 0.63397460f, 0.5f, 0.5f, 0.63397460f, 0.36602540f, 1287 | 0.78867513f, 0.21132487f, 1, 0}; 1288 | unsigned i, max_pos = DRMP3_HDR_TEST_MPEG1(hdr) ? 7 : 64; 1289 | 1290 | for (i = 0; sfb[i]; i++) { 1291 | unsigned ipos = ist_pos[i]; 1292 | if ((int) i > max_band[i % 3] && ipos < max_pos) { 1293 | float kl, kr, s = DRMP3_HDR_TEST_MS_STEREO(hdr) ? 1.41421356f : 1; 1294 | if (DRMP3_HDR_TEST_MPEG1(hdr)) { 1295 | kl = g_pan[2 * ipos]; 1296 | kr = g_pan[2 * ipos + 1]; 1297 | } else { 1298 | kl = 1; 1299 | kr = drmp3_L3_ldexp_q2(1, (ipos + 1) >> 1 << mpeg2_sh); 1300 | if (ipos & 1) { 1301 | kl = kr; 1302 | kr = 1; 1303 | } 1304 | } 1305 | drmp3_L3_intensity_stereo_band(left, sfb[i], kl * s, kr * s); 1306 | } else if (DRMP3_HDR_TEST_MS_STEREO(hdr)) { 1307 | drmp3_L3_midside_stereo(left, sfb[i]); 1308 | } 1309 | left += sfb[i]; 1310 | } 1311 | } 1312 | 1313 | static void 1314 | drmp3_L3_intensity_stereo(float *left, drmp3_uint8 *ist_pos, const drmp3_L3_gr_info *gr, const drmp3_uint8 *hdr) { 1315 | int max_band[3], n_sfb = gr->n_long_sfb + gr->n_short_sfb; 1316 | int i, max_blocks = gr->n_short_sfb ? 3 : 1; 1317 | 1318 | drmp3_L3_stereo_top_band(left + 576, gr->sfbtab, n_sfb, max_band); 1319 | if (gr->n_long_sfb) { 1320 | max_band[0] = max_band[1] = max_band[2] = DRMP3_MAX(DRMP3_MAX(max_band[0], max_band[1]), max_band[2]); 1321 | } 1322 | for (i = 0; i < max_blocks; i++) { 1323 | int default_pos = DRMP3_HDR_TEST_MPEG1(hdr) ? 3 : 0; 1324 | int itop = n_sfb - max_blocks + i; 1325 | int prev = itop - max_blocks; 1326 | ist_pos[itop] = (drmp3_uint8) (max_band[i] >= prev ? default_pos : ist_pos[prev]); 1327 | } 1328 | drmp3_L3_stereo_process(left, ist_pos, gr->sfbtab, hdr, max_band, gr[1].scalefac_compress & 1); 1329 | } 1330 | 1331 | static void drmp3_L3_reorder(float *grbuf, float *scratch, const drmp3_uint8 *sfb) { 1332 | int i, len; 1333 | float *src = grbuf, *dst = scratch; 1334 | 1335 | for (; 0 != (len = *sfb); sfb += 3, src += 2 * len) { 1336 | for (i = 0; i < len; i++, src++) { 1337 | *dst++ = src[0 * len]; 1338 | *dst++ = src[1 * len]; 1339 | *dst++ = src[2 * len]; 1340 | } 1341 | } 1342 | memcpy(grbuf, scratch, (dst - scratch) * sizeof(float)); 1343 | } 1344 | 1345 | static void drmp3_L3_antialias(float *grbuf, int nbands) { 1346 | static const float g_aa[2][8] = { 1347 | {0.85749293f, 0.88174200f, 0.94962865f, 0.98331459f, 0.99551782f, 0.99916056f, 0.99989920f, 0.99999316f}, 1348 | {0.51449576f, 0.47173197f, 0.31337745f, 0.18191320f, 0.09457419f, 0.04096558f, 0.01419856f, 0.00369997f} 1349 | }; 1350 | 1351 | for (; nbands > 0; nbands--, grbuf += 18) { 1352 | int i = 0; 1353 | #if DRMP3_HAVE_SIMD 1354 | if (drmp3_have_simd()) 1355 | for (; i < 8; i += 4) { 1356 | drmp3_f4 vu = DRMP3_VLD(grbuf + 18 + i); 1357 | drmp3_f4 vd = DRMP3_VLD(grbuf + 14 - i); 1358 | drmp3_f4 vc0 = DRMP3_VLD(g_aa[0] + i); 1359 | drmp3_f4 vc1 = DRMP3_VLD(g_aa[1] + i); 1360 | vd = DRMP3_VREV(vd); 1361 | DRMP3_VSTORE(grbuf + 18 + i, DRMP3_VSUB(DRMP3_VMUL(vu, vc0), DRMP3_VMUL(vd, vc1))); 1362 | vd = DRMP3_VADD(DRMP3_VMUL(vu, vc1), DRMP3_VMUL(vd, vc0)); 1363 | DRMP3_VSTORE(grbuf + 14 - i, DRMP3_VREV(vd)); 1364 | } 1365 | #endif 1366 | #ifndef DR_MP3_ONLY_SIMD 1367 | for(; i < 8; i++) 1368 | { 1369 | float u = grbuf[18 + i]; 1370 | float d = grbuf[17 - i]; 1371 | grbuf[18 + i] = u*g_aa[0][i] - d*g_aa[1][i]; 1372 | grbuf[17 - i] = u*g_aa[1][i] + d*g_aa[0][i]; 1373 | } 1374 | #endif 1375 | } 1376 | } 1377 | 1378 | static void drmp3_L3_dct3_9(float *y) { 1379 | float s0, s1, s2, s3, s4, s5, s6, s7, s8, t0, t2, t4; 1380 | 1381 | s0 = y[0]; 1382 | s2 = y[2]; 1383 | s4 = y[4]; 1384 | s6 = y[6]; 1385 | s8 = y[8]; 1386 | t0 = s0 + s6 * 0.5f; 1387 | s0 -= s6; 1388 | t4 = (s4 + s2) * 0.93969262f; 1389 | t2 = (s8 + s2) * 0.76604444f; 1390 | s6 = (s4 - s8) * 0.17364818f; 1391 | s4 += s8 - s2; 1392 | 1393 | s2 = s0 - s4 * 0.5f; 1394 | y[4] = s4 + s0; 1395 | s8 = t0 - t2 + s6; 1396 | s0 = t0 - t4 + t2; 1397 | s4 = t0 + t4 - s6; 1398 | 1399 | s1 = y[1]; 1400 | s3 = y[3]; 1401 | s5 = y[5]; 1402 | s7 = y[7]; 1403 | 1404 | s3 *= 0.86602540f; 1405 | t0 = (s5 + s1) * 0.98480775f; 1406 | t4 = (s5 - s7) * 0.34202014f; 1407 | t2 = (s1 + s7) * 0.64278761f; 1408 | s1 = (s1 - s5 - s7) * 0.86602540f; 1409 | 1410 | s5 = t0 - s3 - t2; 1411 | s7 = t4 - s3 - t0; 1412 | s3 = t4 + s3 - t2; 1413 | 1414 | y[0] = s4 - s7; 1415 | y[1] = s2 + s1; 1416 | y[2] = s0 - s3; 1417 | y[3] = s8 + s5; 1418 | y[5] = s8 - s5; 1419 | y[6] = s0 + s3; 1420 | y[7] = s2 - s1; 1421 | y[8] = s4 + s7; 1422 | } 1423 | 1424 | static void drmp3_L3_imdct36(float *grbuf, float *overlap, const float *window, int nbands) { 1425 | int i, j; 1426 | static const float g_twid9[18] = { 1427 | 0.73727734f, 0.79335334f, 0.84339145f, 0.88701083f, 0.92387953f, 0.95371695f, 0.97629601f, 0.99144486f, 1428 | 0.99904822f, 0.67559021f, 0.60876143f, 0.53729961f, 0.46174861f, 0.38268343f, 0.30070580f, 0.21643961f, 1429 | 0.13052619f, 0.04361938f 1430 | }; 1431 | 1432 | for (j = 0; j < nbands; j++, grbuf += 18, overlap += 9) { 1433 | float co[9], si[9]; 1434 | co[0] = -grbuf[0]; 1435 | si[0] = grbuf[17]; 1436 | for (i = 0; i < 4; i++) { 1437 | si[8 - 2 * i] = grbuf[4 * i + 1] - grbuf[4 * i + 2]; 1438 | co[1 + 2 * i] = grbuf[4 * i + 1] + grbuf[4 * i + 2]; 1439 | si[7 - 2 * i] = grbuf[4 * i + 4] - grbuf[4 * i + 3]; 1440 | co[2 + 2 * i] = -(grbuf[4 * i + 3] + grbuf[4 * i + 4]); 1441 | } 1442 | drmp3_L3_dct3_9(co); 1443 | drmp3_L3_dct3_9(si); 1444 | 1445 | si[1] = -si[1]; 1446 | si[3] = -si[3]; 1447 | si[5] = -si[5]; 1448 | si[7] = -si[7]; 1449 | 1450 | i = 0; 1451 | 1452 | #if DRMP3_HAVE_SIMD 1453 | if (drmp3_have_simd()) 1454 | for (; i < 8; i += 4) { 1455 | drmp3_f4 vovl = DRMP3_VLD(overlap + i); 1456 | drmp3_f4 vc = DRMP3_VLD(co + i); 1457 | drmp3_f4 vs = DRMP3_VLD(si + i); 1458 | drmp3_f4 vr0 = DRMP3_VLD(g_twid9 + i); 1459 | drmp3_f4 vr1 = DRMP3_VLD(g_twid9 + 9 + i); 1460 | drmp3_f4 vw0 = DRMP3_VLD(window + i); 1461 | drmp3_f4 vw1 = DRMP3_VLD(window + 9 + i); 1462 | drmp3_f4 vsum = DRMP3_VADD(DRMP3_VMUL(vc, vr1), DRMP3_VMUL(vs, vr0)); 1463 | DRMP3_VSTORE(overlap + i, DRMP3_VSUB(DRMP3_VMUL(vc, vr0), DRMP3_VMUL(vs, vr1))); 1464 | DRMP3_VSTORE(grbuf + i, DRMP3_VSUB(DRMP3_VMUL(vovl, vw0), DRMP3_VMUL(vsum, vw1))); 1465 | vsum = DRMP3_VADD(DRMP3_VMUL(vovl, vw1), DRMP3_VMUL(vsum, vw0)); 1466 | DRMP3_VSTORE(grbuf + 14 - i, DRMP3_VREV(vsum)); 1467 | } 1468 | #endif 1469 | for (; i < 9; i++) { 1470 | float ovl = overlap[i]; 1471 | float sum = co[i] * g_twid9[9 + i] + si[i] * g_twid9[0 + i]; 1472 | overlap[i] = co[i] * g_twid9[0 + i] - si[i] * g_twid9[9 + i]; 1473 | grbuf[i] = ovl * window[0 + i] - sum * window[9 + i]; 1474 | grbuf[17 - i] = ovl * window[9 + i] + sum * window[0 + i]; 1475 | } 1476 | } 1477 | } 1478 | 1479 | static void drmp3_L3_idct3(float x0, float x1, float x2, float *dst) { 1480 | float m1 = x1 * 0.86602540f; 1481 | float a1 = x0 - x2 * 0.5f; 1482 | dst[1] = x0 + x2; 1483 | dst[0] = a1 + m1; 1484 | dst[2] = a1 - m1; 1485 | } 1486 | 1487 | static void drmp3_L3_imdct12(float *x, float *dst, float *overlap) { 1488 | static const float g_twid3[6] = {0.79335334f, 0.92387953f, 0.99144486f, 0.60876143f, 0.38268343f, 0.13052619f}; 1489 | float co[3], si[3]; 1490 | int i; 1491 | 1492 | drmp3_L3_idct3(-x[0], x[6] + x[3], x[12] + x[9], co); 1493 | drmp3_L3_idct3(x[15], x[12] - x[9], x[6] - x[3], si); 1494 | si[1] = -si[1]; 1495 | 1496 | for (i = 0; i < 3; i++) { 1497 | float ovl = overlap[i]; 1498 | float sum = co[i] * g_twid3[3 + i] + si[i] * g_twid3[0 + i]; 1499 | overlap[i] = co[i] * g_twid3[0 + i] - si[i] * g_twid3[3 + i]; 1500 | dst[i] = ovl * g_twid3[2 - i] - sum * g_twid3[5 - i]; 1501 | dst[5 - i] = ovl * g_twid3[5 - i] + sum * g_twid3[2 - i]; 1502 | } 1503 | } 1504 | 1505 | static void drmp3_L3_imdct_short(float *grbuf, float *overlap, int nbands) { 1506 | for (; nbands > 0; nbands--, overlap += 9, grbuf += 18) { 1507 | float tmp[18]; 1508 | memcpy(tmp, grbuf, sizeof(tmp)); 1509 | memcpy(grbuf, overlap, 6 * sizeof(float)); 1510 | drmp3_L3_imdct12(tmp, grbuf + 6, overlap + 6); 1511 | drmp3_L3_imdct12(tmp + 1, grbuf + 12, overlap + 6); 1512 | drmp3_L3_imdct12(tmp + 2, overlap, overlap + 6); 1513 | } 1514 | } 1515 | 1516 | static void drmp3_L3_change_sign(float *grbuf) { 1517 | int b, i; 1518 | for (b = 0, grbuf += 18; b < 32; b += 2, grbuf += 36) 1519 | for (i = 1; i < 18; i += 2) 1520 | grbuf[i] = -grbuf[i]; 1521 | } 1522 | 1523 | static void drmp3_L3_imdct_gr(float *grbuf, float *overlap, unsigned block_type, unsigned n_long_bands) { 1524 | static const float g_mdct_window[2][18] = { 1525 | {0.99904822f, 0.99144486f, 0.97629601f, 0.95371695f, 0.92387953f, 0.88701083f, 0.84339145f, 0.79335334f, 0.73727734f, 0.04361938f, 0.13052619f, 0.21643961f, 0.30070580f, 0.38268343f, 0.46174861f, 0.53729961f, 0.60876143f, 0.67559021f}, 1526 | {1, 1, 1, 1, 1, 1, 0.99144486f, 0.92387953f, 0.79335334f, 0, 0, 0, 0, 0, 0, 0.13052619f, 0.38268343f, 0.60876143f} 1527 | }; 1528 | if (n_long_bands) { 1529 | drmp3_L3_imdct36(grbuf, overlap, g_mdct_window[0], n_long_bands); 1530 | grbuf += 18 * n_long_bands; 1531 | overlap += 9 * n_long_bands; 1532 | } 1533 | if (block_type == DRMP3_SHORT_BLOCK_TYPE) 1534 | drmp3_L3_imdct_short(grbuf, overlap, 32 - n_long_bands); 1535 | else 1536 | drmp3_L3_imdct36(grbuf, overlap, g_mdct_window[block_type == DRMP3_STOP_BLOCK_TYPE], 32 - n_long_bands); 1537 | } 1538 | 1539 | static void drmp3_L3_save_reservoir(drmp3dec *h, drmp3dec_scratch *s) { 1540 | int pos = (s->bs.pos + 7) / 8u; 1541 | int remains = s->bs.limit / 8u - pos; 1542 | if (remains > DRMP3_MAX_BITRESERVOIR_BYTES) { 1543 | pos += remains - DRMP3_MAX_BITRESERVOIR_BYTES; 1544 | remains = DRMP3_MAX_BITRESERVOIR_BYTES; 1545 | } 1546 | if (remains > 0) { 1547 | memmove(h->reserv_buf, s->maindata + pos, remains); 1548 | } 1549 | h->reserv = remains; 1550 | } 1551 | 1552 | static int drmp3_L3_restore_reservoir(drmp3dec *h, drmp3_bs *bs, drmp3dec_scratch *s, int main_data_begin) { 1553 | int frame_bytes = (bs->limit - bs->pos) / 8; 1554 | int bytes_have = DRMP3_MIN(h->reserv, main_data_begin); 1555 | memcpy(s->maindata, h->reserv_buf + DRMP3_MAX(0, h->reserv - main_data_begin), 1556 | DRMP3_MIN(h->reserv, main_data_begin)); 1557 | memcpy(s->maindata + bytes_have, bs->buf + bs->pos / 8, frame_bytes); 1558 | drmp3_bs_init(&s->bs, s->maindata, bytes_have + frame_bytes); 1559 | return h->reserv >= main_data_begin; 1560 | } 1561 | 1562 | static void drmp3_L3_decode(drmp3dec *h, drmp3dec_scratch *s, drmp3_L3_gr_info *gr_info, int nch) { 1563 | int ch; 1564 | 1565 | for (ch = 0; ch < nch; ch++) { 1566 | int layer3gr_limit = s->bs.pos + gr_info[ch].part_23_length; 1567 | drmp3_L3_decode_scalefactors(h->header, s->ist_pos[ch], &s->bs, gr_info + ch, s->scf, ch); 1568 | drmp3_L3_huffman(s->grbuf[ch], &s->bs, gr_info + ch, s->scf, layer3gr_limit); 1569 | } 1570 | 1571 | if (DRMP3_HDR_TEST_I_STEREO(h->header)) { 1572 | drmp3_L3_intensity_stereo(s->grbuf[0], s->ist_pos[1], gr_info, h->header); 1573 | } else if (DRMP3_HDR_IS_MS_STEREO(h->header)) { 1574 | drmp3_L3_midside_stereo(s->grbuf[0], 576); 1575 | } 1576 | 1577 | for (ch = 0; ch < nch; ch++, gr_info++) { 1578 | int aa_bands = 31; 1579 | int n_long_bands = (gr_info->mixed_block_flag ? 2 : 0) << (int) (DRMP3_HDR_GET_MY_SAMPLE_RATE(h->header) == 2); 1580 | 1581 | if (gr_info->n_short_sfb) { 1582 | aa_bands = n_long_bands - 1; 1583 | drmp3_L3_reorder(s->grbuf[ch] + n_long_bands * 18, s->syn[0], gr_info->sfbtab + gr_info->n_long_sfb); 1584 | } 1585 | 1586 | drmp3_L3_antialias(s->grbuf[ch], aa_bands); 1587 | drmp3_L3_imdct_gr(s->grbuf[ch], h->mdct_overlap[ch], gr_info->block_type, n_long_bands); 1588 | drmp3_L3_change_sign(s->grbuf[ch]); 1589 | } 1590 | } 1591 | 1592 | static void drmp3d_DCT_II(float *grbuf, int n) { 1593 | static const float g_sec[24] = { 1594 | 10.19000816f, 0.50060302f, 0.50241929f, 3.40760851f, 0.50547093f, 0.52249861f, 2.05778098f, 0.51544732f, 1595 | 0.56694406f, 1.48416460f, 0.53104258f, 0.64682180f, 1.16943991f, 0.55310392f, 0.78815460f, 0.97256821f, 1596 | 0.58293498f, 1.06067765f, 0.83934963f, 0.62250412f, 1.72244716f, 0.74453628f, 0.67480832f, 5.10114861f 1597 | }; 1598 | int i, k = 0; 1599 | #if DRMP3_HAVE_SIMD 1600 | if (drmp3_have_simd()) 1601 | for (; k < n; k += 4) { 1602 | drmp3_f4 t[4][8], *x; 1603 | float *y = grbuf + k; 1604 | 1605 | for (x = t[0], i = 0; i < 8; i++, x++) { 1606 | drmp3_f4 x0 = DRMP3_VLD(&y[i * 18]); 1607 | drmp3_f4 x1 = DRMP3_VLD(&y[(15 - i) * 18]); 1608 | drmp3_f4 x2 = DRMP3_VLD(&y[(16 + i) * 18]); 1609 | drmp3_f4 x3 = DRMP3_VLD(&y[(31 - i) * 18]); 1610 | drmp3_f4 t0 = DRMP3_VADD(x0, x3); 1611 | drmp3_f4 t1 = DRMP3_VADD(x1, x2); 1612 | drmp3_f4 t2 = DRMP3_VMUL_S(DRMP3_VSUB(x1, x2), g_sec[3 * i + 0]); 1613 | drmp3_f4 t3 = DRMP3_VMUL_S(DRMP3_VSUB(x0, x3), g_sec[3 * i + 1]); 1614 | x[0] = DRMP3_VADD(t0, t1); 1615 | x[8] = DRMP3_VMUL_S(DRMP3_VSUB(t0, t1), g_sec[3 * i + 2]); 1616 | x[16] = DRMP3_VADD(t3, t2); 1617 | x[24] = DRMP3_VMUL_S(DRMP3_VSUB(t3, t2), g_sec[3 * i + 2]); 1618 | } 1619 | for (x = t[0], i = 0; i < 4; i++, x += 8) { 1620 | drmp3_f4 x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt; 1621 | xt = DRMP3_VSUB(x0, x7); 1622 | x0 = DRMP3_VADD(x0, x7); 1623 | x7 = DRMP3_VSUB(x1, x6); 1624 | x1 = DRMP3_VADD(x1, x6); 1625 | x6 = DRMP3_VSUB(x2, x5); 1626 | x2 = DRMP3_VADD(x2, x5); 1627 | x5 = DRMP3_VSUB(x3, x4); 1628 | x3 = DRMP3_VADD(x3, x4); 1629 | x4 = DRMP3_VSUB(x0, x3); 1630 | x0 = DRMP3_VADD(x0, x3); 1631 | x3 = DRMP3_VSUB(x1, x2); 1632 | x1 = DRMP3_VADD(x1, x2); 1633 | x[0] = DRMP3_VADD(x0, x1); 1634 | x[4] = DRMP3_VMUL_S(DRMP3_VSUB(x0, x1), 0.70710677f); 1635 | x5 = DRMP3_VADD(x5, x6); 1636 | x6 = DRMP3_VMUL_S(DRMP3_VADD(x6, x7), 0.70710677f); 1637 | x7 = DRMP3_VADD(x7, xt); 1638 | x3 = DRMP3_VMUL_S(DRMP3_VADD(x3, x4), 0.70710677f); 1639 | x5 = DRMP3_VSUB(x5, DRMP3_VMUL_S(x7, 0.198912367f)); /* rotate by PI/8 */ 1640 | x7 = DRMP3_VADD(x7, DRMP3_VMUL_S(x5, 0.382683432f)); 1641 | x5 = DRMP3_VSUB(x5, DRMP3_VMUL_S(x7, 0.198912367f)); 1642 | x0 = DRMP3_VSUB(xt, x6); 1643 | xt = DRMP3_VADD(xt, x6); 1644 | x[1] = DRMP3_VMUL_S(DRMP3_VADD(xt, x7), 0.50979561f); 1645 | x[2] = DRMP3_VMUL_S(DRMP3_VADD(x4, x3), 0.54119611f); 1646 | x[3] = DRMP3_VMUL_S(DRMP3_VSUB(x0, x5), 0.60134488f); 1647 | x[5] = DRMP3_VMUL_S(DRMP3_VADD(x0, x5), 0.89997619f); 1648 | x[6] = DRMP3_VMUL_S(DRMP3_VSUB(x4, x3), 1.30656302f); 1649 | x[7] = DRMP3_VMUL_S(DRMP3_VSUB(xt, x7), 2.56291556f); 1650 | } 1651 | 1652 | if (k > n - 3) { 1653 | #if DRMP3_HAVE_SSE 1654 | #define DRMP3_VSAVE2(i, v) _mm_storel_pi((__m64 *)(void*)&y[i*18], v) 1655 | #else 1656 | #define DRMP3_VSAVE2(i, v) vst1_f32((float32_t *)&y[i*18], vget_low_f32(v)) 1657 | #endif 1658 | for (i = 0; i < 7; i++, y += 4 * 18) { 1659 | drmp3_f4 s = DRMP3_VADD(t[3][i], t[3][i + 1]); 1660 | DRMP3_VSAVE2(0, t[0][i]); 1661 | DRMP3_VSAVE2(1, DRMP3_VADD(t[2][i], s)); 1662 | DRMP3_VSAVE2(2, DRMP3_VADD(t[1][i], t[1][i + 1])); 1663 | DRMP3_VSAVE2(3, DRMP3_VADD(t[2][1 + i], s)); 1664 | } 1665 | DRMP3_VSAVE2(0, t[0][7]); 1666 | DRMP3_VSAVE2(1, DRMP3_VADD(t[2][7], t[3][7])); 1667 | DRMP3_VSAVE2(2, t[1][7]); 1668 | DRMP3_VSAVE2(3, t[3][7]); 1669 | } else { 1670 | #define DRMP3_VSAVE4(i, v) DRMP3_VSTORE(&y[i*18], v) 1671 | for (i = 0; i < 7; i++, y += 4 * 18) { 1672 | drmp3_f4 s = DRMP3_VADD(t[3][i], t[3][i + 1]); 1673 | DRMP3_VSAVE4(0, t[0][i]); 1674 | DRMP3_VSAVE4(1, DRMP3_VADD(t[2][i], s)); 1675 | DRMP3_VSAVE4(2, DRMP3_VADD(t[1][i], t[1][i + 1])); 1676 | DRMP3_VSAVE4(3, DRMP3_VADD(t[2][1 + i], s)); 1677 | } 1678 | DRMP3_VSAVE4(0, t[0][7]); 1679 | DRMP3_VSAVE4(1, DRMP3_VADD(t[2][7], t[3][7])); 1680 | DRMP3_VSAVE4(2, t[1][7]); 1681 | DRMP3_VSAVE4(3, t[3][7]); 1682 | } 1683 | } 1684 | else 1685 | #endif 1686 | #ifdef DR_MP3_ONLY_SIMD 1687 | {} 1688 | #else 1689 | for (; k < n; k++) 1690 | { 1691 | float t[4][8], *x, *y = grbuf + k; 1692 | 1693 | for (x = t[0], i = 0; i < 8; i++, x++) 1694 | { 1695 | float x0 = y[i*18]; 1696 | float x1 = y[(15 - i)*18]; 1697 | float x2 = y[(16 + i)*18]; 1698 | float x3 = y[(31 - i)*18]; 1699 | float t0 = x0 + x3; 1700 | float t1 = x1 + x2; 1701 | float t2 = (x1 - x2)*g_sec[3*i + 0]; 1702 | float t3 = (x0 - x3)*g_sec[3*i + 1]; 1703 | x[0] = t0 + t1; 1704 | x[8] = (t0 - t1)*g_sec[3*i + 2]; 1705 | x[16] = t3 + t2; 1706 | x[24] = (t3 - t2)*g_sec[3*i + 2]; 1707 | } 1708 | for (x = t[0], i = 0; i < 4; i++, x += 8) 1709 | { 1710 | float x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt; 1711 | xt = x0 - x7; x0 += x7; 1712 | x7 = x1 - x6; x1 += x6; 1713 | x6 = x2 - x5; x2 += x5; 1714 | x5 = x3 - x4; x3 += x4; 1715 | x4 = x0 - x3; x0 += x3; 1716 | x3 = x1 - x2; x1 += x2; 1717 | x[0] = x0 + x1; 1718 | x[4] = (x0 - x1)*0.70710677f; 1719 | x5 = x5 + x6; 1720 | x6 = (x6 + x7)*0.70710677f; 1721 | x7 = x7 + xt; 1722 | x3 = (x3 + x4)*0.70710677f; 1723 | x5 -= x7*0.198912367f; /* rotate by PI/8 */ 1724 | x7 += x5*0.382683432f; 1725 | x5 -= x7*0.198912367f; 1726 | x0 = xt - x6; xt += x6; 1727 | x[1] = (xt + x7)*0.50979561f; 1728 | x[2] = (x4 + x3)*0.54119611f; 1729 | x[3] = (x0 - x5)*0.60134488f; 1730 | x[5] = (x0 + x5)*0.89997619f; 1731 | x[6] = (x4 - x3)*1.30656302f; 1732 | x[7] = (xt - x7)*2.56291556f; 1733 | 1734 | } 1735 | for (i = 0; i < 7; i++, y += 4*18) 1736 | { 1737 | y[0*18] = t[0][i]; 1738 | y[1*18] = t[2][i] + t[3][i] + t[3][i + 1]; 1739 | y[2*18] = t[1][i] + t[1][i + 1]; 1740 | y[3*18] = t[2][i + 1] + t[3][i] + t[3][i + 1]; 1741 | } 1742 | y[0*18] = t[0][7]; 1743 | y[1*18] = t[2][7] + t[3][7]; 1744 | y[2*18] = t[1][7]; 1745 | y[3*18] = t[3][7]; 1746 | } 1747 | #endif 1748 | } 1749 | 1750 | #ifndef DR_MP3_FLOAT_OUTPUT 1751 | typedef drmp3_int16 drmp3d_sample_t; 1752 | 1753 | static drmp3_int16 drmp3d_scale_pcm(float sample) { 1754 | if (sample >= 32766.5) return (drmp3_int16) 32767; 1755 | if (sample <= -32767.5) return (drmp3_int16) -32768; 1756 | drmp3_int16 s = (drmp3_int16) (sample + .5f); 1757 | s -= (s < 0); /* away from zero, to be compliant */ 1758 | return (drmp3_int16) s; 1759 | } 1760 | 1761 | #else 1762 | typedef float drmp3d_sample_t; 1763 | 1764 | static float drmp3d_scale_pcm(float sample) 1765 | { 1766 | return sample*(1.f/32768.f); 1767 | } 1768 | #endif 1769 | 1770 | static void drmp3d_synth_pair(drmp3d_sample_t *pcm, int nch, const float *z) { 1771 | float a; 1772 | a = (z[14 * 64] - z[0]) * 29; 1773 | a += (z[1 * 64] + z[13 * 64]) * 213; 1774 | a += (z[12 * 64] - z[2 * 64]) * 459; 1775 | a += (z[3 * 64] + z[11 * 64]) * 2037; 1776 | a += (z[10 * 64] - z[4 * 64]) * 5153; 1777 | a += (z[5 * 64] + z[9 * 64]) * 6574; 1778 | a += (z[8 * 64] - z[6 * 64]) * 37489; 1779 | a += z[7 * 64] * 75038; 1780 | pcm[0] = drmp3d_scale_pcm(a); 1781 | 1782 | z += 2; 1783 | a = z[14 * 64] * 104; 1784 | a += z[12 * 64] * 1567; 1785 | a += z[10 * 64] * 9727; 1786 | a += z[8 * 64] * 64019; 1787 | a += z[6 * 64] * -9975; 1788 | a += z[4 * 64] * -45; 1789 | a += z[2 * 64] * 146; 1790 | a += z[0 * 64] * -5; 1791 | pcm[16 * nch] = drmp3d_scale_pcm(a); 1792 | } 1793 | 1794 | static void drmp3d_synth(float *xl, drmp3d_sample_t *dstl, int nch, float *lins) { 1795 | int i; 1796 | float *xr = xl + 576 * (nch - 1); 1797 | drmp3d_sample_t *dstr = dstl + (nch - 1); 1798 | 1799 | static const float g_win[] = { 1800 | -1, 26, -31, 208, 218, 401, -519, 2063, 2000, 4788, -5517, 7134, 5959, 35640, -39336, 74992, 1801 | -1, 24, -35, 202, 222, 347, -581, 2080, 1952, 4425, -5879, 7640, 5288, 33791, -41176, 74856, 1802 | -1, 21, -38, 196, 225, 294, -645, 2087, 1893, 4063, -6237, 8092, 4561, 31947, -43006, 74630, 1803 | -1, 19, -41, 190, 227, 244, -711, 2085, 1822, 3705, -6589, 8492, 3776, 30112, -44821, 74313, 1804 | -1, 17, -45, 183, 228, 197, -779, 2075, 1739, 3351, -6935, 8840, 2935, 28289, -46617, 73908, 1805 | -1, 16, -49, 176, 228, 153, -848, 2057, 1644, 3004, -7271, 9139, 2037, 26482, -48390, 73415, 1806 | -2, 14, -53, 169, 227, 111, -919, 2032, 1535, 2663, -7597, 9389, 1082, 24694, -50137, 72835, 1807 | -2, 13, -58, 161, 224, 72, -991, 2001, 1414, 2330, -7910, 9592, 70, 22929, -51853, 72169, 1808 | -2, 11, -63, 154, 221, 36, -1064, 1962, 1280, 2006, -8209, 9750, -998, 21189, -53534, 71420, 1809 | -2, 10, -68, 147, 215, 2, -1137, 1919, 1131, 1692, -8491, 9863, -2122, 19478, -55178, 70590, 1810 | -3, 9, -73, 139, 208, -29, -1210, 1870, 970, 1388, -8755, 9935, -3300, 17799, -56778, 69679, 1811 | -3, 8, -79, 132, 200, -57, -1283, 1817, 794, 1095, -8998, 9966, -4533, 16155, -58333, 68692, 1812 | -4, 7, -85, 125, 189, -83, -1356, 1759, 605, 814, -9219, 9959, -5818, 14548, -59838, 67629, 1813 | -4, 7, -91, 117, 177, -106, -1428, 1698, 402, 545, -9416, 9916, -7154, 12980, -61289, 66494, 1814 | -5, 6, -97, 111, 163, -127, -1498, 1634, 185, 288, -9585, 9838, -8540, 11455, -62684, 65290 1815 | }; 1816 | float *zlin = lins + 15 * 64; 1817 | const float *w = g_win; 1818 | 1819 | zlin[4 * 15] = xl[18 * 16]; 1820 | zlin[4 * 15 + 1] = xr[18 * 16]; 1821 | zlin[4 * 15 + 2] = xl[0]; 1822 | zlin[4 * 15 + 3] = xr[0]; 1823 | 1824 | zlin[4 * 31] = xl[1 + 18 * 16]; 1825 | zlin[4 * 31 + 1] = xr[1 + 18 * 16]; 1826 | zlin[4 * 31 + 2] = xl[1]; 1827 | zlin[4 * 31 + 3] = xr[1]; 1828 | 1829 | drmp3d_synth_pair(dstr, nch, lins + 4 * 15 + 1); 1830 | drmp3d_synth_pair(dstr + 32 * nch, nch, lins + 4 * 15 + 64 + 1); 1831 | drmp3d_synth_pair(dstl, nch, lins + 4 * 15); 1832 | drmp3d_synth_pair(dstl + 32 * nch, nch, lins + 4 * 15 + 64); 1833 | 1834 | #if DRMP3_HAVE_SIMD 1835 | if (drmp3_have_simd()) 1836 | for (i = 14; i >= 0; i--) { 1837 | #define DRMP3_VLOAD(k) drmp3_f4 w0 = DRMP3_VSET(*w++); drmp3_f4 w1 = DRMP3_VSET(*w++); drmp3_f4 vz = DRMP3_VLD(&zlin[4*i - 64*k]); drmp3_f4 vy = DRMP3_VLD(&zlin[4*i - 64*(15 - k)]); 1838 | #define DRMP3_V0(k) { DRMP3_VLOAD(k) b = DRMP3_VADD(DRMP3_VMUL(vz, w1), DRMP3_VMUL(vy, w0)) ; a = DRMP3_VSUB(DRMP3_VMUL(vz, w0), DRMP3_VMUL(vy, w1)); } 1839 | #define DRMP3_V1(k) { DRMP3_VLOAD(k) b = DRMP3_VADD(b, DRMP3_VADD(DRMP3_VMUL(vz, w1), DRMP3_VMUL(vy, w0))); a = DRMP3_VADD(a, DRMP3_VSUB(DRMP3_VMUL(vz, w0), DRMP3_VMUL(vy, w1))); } 1840 | #define DRMP3_V2(k) { DRMP3_VLOAD(k) b = DRMP3_VADD(b, DRMP3_VADD(DRMP3_VMUL(vz, w1), DRMP3_VMUL(vy, w0))); a = DRMP3_VADD(a, DRMP3_VSUB(DRMP3_VMUL(vy, w1), DRMP3_VMUL(vz, w0))); } 1841 | drmp3_f4 a, b; 1842 | zlin[4 * i] = xl[18 * (31 - i)]; 1843 | zlin[4 * i + 1] = xr[18 * (31 - i)]; 1844 | zlin[4 * i + 2] = xl[1 + 18 * (31 - i)]; 1845 | zlin[4 * i + 3] = xr[1 + 18 * (31 - i)]; 1846 | zlin[4 * i + 64] = xl[1 + 18 * (1 + i)]; 1847 | zlin[4 * i + 64 + 1] = xr[1 + 18 * (1 + i)]; 1848 | zlin[4 * i - 64 + 2] = xl[18 * (1 + i)]; 1849 | zlin[4 * i - 64 + 3] = xr[18 * (1 + i)]; 1850 | 1851 | DRMP3_V0(0) 1852 | DRMP3_V2(1) 1853 | DRMP3_V1(2) 1854 | DRMP3_V2(3) 1855 | DRMP3_V1(4) 1856 | DRMP3_V2(5) 1857 | DRMP3_V1(6) 1858 | DRMP3_V2(7) 1859 | 1860 | { 1861 | #ifndef DR_MP3_FLOAT_OUTPUT 1862 | #if DRMP3_HAVE_SSE 1863 | static const drmp3_f4 g_max = {32767.0f, 32767.0f, 32767.0f, 32767.0f}; 1864 | static const drmp3_f4 g_min = {-32768.0f, -32768.0f, -32768.0f, -32768.0f}; 1865 | __m128i pcm8 = _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)), 1866 | _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min))); 1867 | dstr[(15 - i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 1); 1868 | dstr[(17 + i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 5); 1869 | dstl[(15 - i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 0); 1870 | dstl[(17 + i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 4); 1871 | dstr[(47 - i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 3); 1872 | dstr[(49 + i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 7); 1873 | dstl[(47 - i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 2); 1874 | dstl[(49 + i) * nch] = (drmp3_int16) _mm_extract_epi16(pcm8, 6); 1875 | #else 1876 | int16x4_t pcma, pcmb; 1877 | a = DRMP3_VADD(a, DRMP3_VSET(0.5f)); 1878 | b = DRMP3_VADD(b, DRMP3_VSET(0.5f)); 1879 | pcma = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, DRMP3_VSET(0))))); 1880 | pcmb = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, DRMP3_VSET(0))))); 1881 | vst1_lane_s16(dstr + (15 - i)*nch, pcma, 1); 1882 | vst1_lane_s16(dstr + (17 + i)*nch, pcmb, 1); 1883 | vst1_lane_s16(dstl + (15 - i)*nch, pcma, 0); 1884 | vst1_lane_s16(dstl + (17 + i)*nch, pcmb, 0); 1885 | vst1_lane_s16(dstr + (47 - i)*nch, pcma, 3); 1886 | vst1_lane_s16(dstr + (49 + i)*nch, pcmb, 3); 1887 | vst1_lane_s16(dstl + (47 - i)*nch, pcma, 2); 1888 | vst1_lane_s16(dstl + (49 + i)*nch, pcmb, 2); 1889 | #endif 1890 | #else 1891 | static const drmp3_f4 g_scale = { 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f }; 1892 | a = DRMP3_VMUL(a, g_scale); 1893 | b = DRMP3_VMUL(b, g_scale); 1894 | #if DRMP3_HAVE_SSE 1895 | _mm_store_ss(dstr + (15 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1))); 1896 | _mm_store_ss(dstr + (17 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1))); 1897 | _mm_store_ss(dstl + (15 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(0, 0, 0, 0))); 1898 | _mm_store_ss(dstl + (17 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 0, 0, 0))); 1899 | _mm_store_ss(dstr + (47 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 3, 3, 3))); 1900 | _mm_store_ss(dstr + (49 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 3, 3, 3))); 1901 | _mm_store_ss(dstl + (47 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(2, 2, 2, 2))); 1902 | _mm_store_ss(dstl + (49 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(2, 2, 2, 2))); 1903 | #else 1904 | vst1q_lane_f32(dstr + (15 - i)*nch, a, 1); 1905 | vst1q_lane_f32(dstr + (17 + i)*nch, b, 1); 1906 | vst1q_lane_f32(dstl + (15 - i)*nch, a, 0); 1907 | vst1q_lane_f32(dstl + (17 + i)*nch, b, 0); 1908 | vst1q_lane_f32(dstr + (47 - i)*nch, a, 3); 1909 | vst1q_lane_f32(dstr + (49 + i)*nch, b, 3); 1910 | vst1q_lane_f32(dstl + (47 - i)*nch, a, 2); 1911 | vst1q_lane_f32(dstl + (49 + i)*nch, b, 2); 1912 | #endif 1913 | #endif /* DR_MP3_FLOAT_OUTPUT */ 1914 | } 1915 | } 1916 | else 1917 | #endif 1918 | #ifdef DR_MP3_ONLY_SIMD 1919 | {} 1920 | #else 1921 | for (i = 14; i >= 0; i--) 1922 | { 1923 | #define DRMP3_LOAD(k) float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - k*64]; float *vy = &zlin[4*i - (15 - k)*64]; 1924 | #define DRMP3_S0(k) { int j; DRMP3_LOAD(k); for (j = 0; j < 4; j++) b[j] = vz[j]*w1 + vy[j]*w0, a[j] = vz[j]*w0 - vy[j]*w1; } 1925 | #define DRMP3_S1(k) { int j; DRMP3_LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vz[j]*w0 - vy[j]*w1; } 1926 | #define DRMP3_S2(k) { int j; DRMP3_LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; } 1927 | float a[4], b[4]; 1928 | 1929 | zlin[4*i] = xl[18*(31 - i)]; 1930 | zlin[4*i + 1] = xr[18*(31 - i)]; 1931 | zlin[4*i + 2] = xl[1 + 18*(31 - i)]; 1932 | zlin[4*i + 3] = xr[1 + 18*(31 - i)]; 1933 | zlin[4*(i + 16)] = xl[1 + 18*(1 + i)]; 1934 | zlin[4*(i + 16) + 1] = xr[1 + 18*(1 + i)]; 1935 | zlin[4*(i - 16) + 2] = xl[18*(1 + i)]; 1936 | zlin[4*(i - 16) + 3] = xr[18*(1 + i)]; 1937 | 1938 | DRMP3_S0(0) DRMP3_S2(1) DRMP3_S1(2) DRMP3_S2(3) DRMP3_S1(4) DRMP3_S2(5) DRMP3_S1(6) DRMP3_S2(7) 1939 | 1940 | dstr[(15 - i)*nch] = drmp3d_scale_pcm(a[1]); 1941 | dstr[(17 + i)*nch] = drmp3d_scale_pcm(b[1]); 1942 | dstl[(15 - i)*nch] = drmp3d_scale_pcm(a[0]); 1943 | dstl[(17 + i)*nch] = drmp3d_scale_pcm(b[0]); 1944 | dstr[(47 - i)*nch] = drmp3d_scale_pcm(a[3]); 1945 | dstr[(49 + i)*nch] = drmp3d_scale_pcm(b[3]); 1946 | dstl[(47 - i)*nch] = drmp3d_scale_pcm(a[2]); 1947 | dstl[(49 + i)*nch] = drmp3d_scale_pcm(b[2]); 1948 | } 1949 | #endif 1950 | } 1951 | 1952 | static void 1953 | drmp3d_synth_granule(float *qmf_state, float *grbuf, int nbands, int nch, drmp3d_sample_t *pcm, float *lins) { 1954 | int i; 1955 | for (i = 0; i < nch; i++) { 1956 | drmp3d_DCT_II(grbuf + 576 * i, nbands); 1957 | } 1958 | 1959 | memcpy(lins, qmf_state, sizeof(float) * 15 * 64); 1960 | 1961 | for (i = 0; i < nbands; i += 2) { 1962 | drmp3d_synth(grbuf + i, pcm + 32 * nch * i, nch, lins + i * 64); 1963 | } 1964 | #ifndef DR_MP3_NONSTANDARD_BUT_LOGICAL 1965 | if (nch == 1) { 1966 | for (i = 0; i < 15 * 64; i += 2) { 1967 | qmf_state[i] = lins[nbands * 64 + i]; 1968 | } 1969 | } else 1970 | #endif 1971 | { 1972 | memcpy(qmf_state, lins + nbands * 64, sizeof(float) * 15 * 64); 1973 | } 1974 | } 1975 | 1976 | static int drmp3d_match_frame(const drmp3_uint8 *hdr, int mp3_bytes, int frame_bytes) { 1977 | int i, nmatch; 1978 | for (i = 0, nmatch = 0; nmatch < DRMP3_MAX_FRAME_SYNC_MATCHES; nmatch++) { 1979 | i += drmp3_hdr_frame_bytes(hdr + i, frame_bytes) + drmp3_hdr_padding(hdr + i); 1980 | if (i + DRMP3_HDR_SIZE > mp3_bytes) 1981 | return nmatch > 0; 1982 | if (!drmp3_hdr_compare(hdr, hdr + i)) 1983 | return 0; 1984 | } 1985 | return 1; 1986 | } 1987 | 1988 | static int drmp3d_find_frame(const drmp3_uint8 *mp3, int mp3_bytes, int *free_format_bytes, int *ptr_frame_bytes) { 1989 | int i, k; 1990 | for (i = 0; i < mp3_bytes - DRMP3_HDR_SIZE; i++, mp3++) { 1991 | if (drmp3_hdr_valid(mp3)) { 1992 | int frame_bytes = drmp3_hdr_frame_bytes(mp3, *free_format_bytes); 1993 | int frame_and_padding = frame_bytes + drmp3_hdr_padding(mp3); 1994 | 1995 | for (k = DRMP3_HDR_SIZE; 1996 | !frame_bytes && k < DRMP3_MAX_FREE_FORMAT_FRAME_SIZE && i + 2 * k < mp3_bytes - DRMP3_HDR_SIZE; k++) { 1997 | if (drmp3_hdr_compare(mp3, mp3 + k)) { 1998 | int fb = k - drmp3_hdr_padding(mp3); 1999 | int nextfb = fb + drmp3_hdr_padding(mp3 + k); 2000 | if (i + k + nextfb + DRMP3_HDR_SIZE > mp3_bytes || !drmp3_hdr_compare(mp3, mp3 + k + nextfb)) 2001 | continue; 2002 | frame_and_padding = k; 2003 | frame_bytes = fb; 2004 | *free_format_bytes = fb; 2005 | } 2006 | } 2007 | 2008 | if ((frame_bytes && i + frame_and_padding <= mp3_bytes && 2009 | drmp3d_match_frame(mp3, mp3_bytes - i, frame_bytes)) || 2010 | (!i && frame_and_padding == mp3_bytes)) { 2011 | *ptr_frame_bytes = frame_and_padding; 2012 | return i; 2013 | } 2014 | *free_format_bytes = 0; 2015 | } 2016 | } 2017 | *ptr_frame_bytes = 0; 2018 | return i; 2019 | } 2020 | 2021 | void drmp3dec_init(drmp3dec *dec) { 2022 | dec->header[0] = 0; 2023 | } 2024 | 2025 | int 2026 | drmp3dec_decode_frame(drmp3dec *dec, const unsigned char *mp3, int mp3_bytes, void *pcm, drmp3dec_frame_info *info) { 2027 | int i = 0, igr, frame_size = 0, success = 1; 2028 | const drmp3_uint8 *hdr; 2029 | drmp3_bs bs_frame[1]; 2030 | drmp3dec_scratch scratch; 2031 | 2032 | if (mp3_bytes > 4 && dec->header[0] == 0xff && drmp3_hdr_compare(dec->header, mp3)) { 2033 | frame_size = drmp3_hdr_frame_bytes(mp3, dec->free_format_bytes) + drmp3_hdr_padding(mp3); 2034 | if (frame_size != mp3_bytes && 2035 | (frame_size + DRMP3_HDR_SIZE > mp3_bytes || !drmp3_hdr_compare(mp3, mp3 + frame_size))) { 2036 | frame_size = 0; 2037 | } 2038 | } 2039 | if (!frame_size) { 2040 | memset(dec, 0, sizeof(drmp3dec)); 2041 | i = drmp3d_find_frame(mp3, mp3_bytes, &dec->free_format_bytes, &frame_size); 2042 | if (!frame_size || i + frame_size > mp3_bytes) { 2043 | info->frame_bytes = i; 2044 | return 0; 2045 | } 2046 | } 2047 | 2048 | hdr = mp3 + i; 2049 | memcpy(dec->header, hdr, DRMP3_HDR_SIZE); 2050 | info->frame_bytes = i + frame_size; 2051 | info->channels = DRMP3_HDR_IS_MONO(hdr) ? 1 : 2; 2052 | info->hz = drmp3_hdr_sample_rate_hz(hdr); 2053 | info->layer = 4 - DRMP3_HDR_GET_LAYER(hdr); 2054 | info->bitrate_kbps = drmp3_hdr_bitrate_kbps(hdr); 2055 | 2056 | drmp3_bs_init(bs_frame, hdr + DRMP3_HDR_SIZE, frame_size - DRMP3_HDR_SIZE); 2057 | if (DRMP3_HDR_IS_CRC(hdr)) { 2058 | drmp3_bs_get_bits(bs_frame, 16); 2059 | } 2060 | 2061 | if (info->layer == 3) { 2062 | int main_data_begin = drmp3_L3_read_side_info(bs_frame, scratch.gr_info, hdr); 2063 | if (main_data_begin < 0 || bs_frame->pos > bs_frame->limit) { 2064 | drmp3dec_init(dec); 2065 | return 0; 2066 | } 2067 | success = drmp3_L3_restore_reservoir(dec, bs_frame, &scratch, main_data_begin); 2068 | if (success && pcm != NULL) { 2069 | for (igr = 0; igr < (DRMP3_HDR_TEST_MPEG1(hdr) ? 2 : 1); igr++, pcm = DRMP3_OFFSET_PTR(pcm, 2070 | sizeof(drmp3d_sample_t) * 2071 | 576 * 2072 | info->channels)) { 2073 | memset(scratch.grbuf[0], 0, 576 * 2 * sizeof(float)); 2074 | drmp3_L3_decode(dec, &scratch, scratch.gr_info + igr * info->channels, info->channels); 2075 | drmp3d_synth_granule(dec->qmf_state, scratch.grbuf[0], 18, info->channels, (drmp3d_sample_t *) pcm, 2076 | scratch.syn[0]); 2077 | } 2078 | } 2079 | drmp3_L3_save_reservoir(dec, &scratch); 2080 | } else { 2081 | #ifdef DR_MP3_ONLY_MP3 2082 | return 0; 2083 | #else 2084 | if (pcm == NULL) { 2085 | return drmp3_hdr_frame_samples(hdr); 2086 | } 2087 | 2088 | drmp3_L12_scale_info sci[1]; 2089 | drmp3_L12_read_scale_info(hdr, bs_frame, sci); 2090 | 2091 | memset(scratch.grbuf[0], 0, 576 * 2 * sizeof(float)); 2092 | for (i = 0, igr = 0; igr < 3; igr++) { 2093 | if (12 == (i += drmp3_L12_dequantize_granule(scratch.grbuf[0] + i, bs_frame, sci, info->layer | 1))) { 2094 | i = 0; 2095 | drmp3_L12_apply_scf_384(sci, sci->scf + igr, scratch.grbuf[0]); 2096 | drmp3d_synth_granule(dec->qmf_state, scratch.grbuf[0], 12, info->channels, (drmp3d_sample_t *) pcm, 2097 | scratch.syn[0]); 2098 | memset(scratch.grbuf[0], 0, 576 * 2 * sizeof(float)); 2099 | pcm = DRMP3_OFFSET_PTR(pcm, sizeof(drmp3d_sample_t) * 384 * info->channels); 2100 | } 2101 | if (bs_frame->pos > bs_frame->limit) { 2102 | drmp3dec_init(dec); 2103 | return 0; 2104 | } 2105 | } 2106 | #endif 2107 | } 2108 | 2109 | return success * drmp3_hdr_frame_samples(dec->header); 2110 | } 2111 | 2112 | void drmp3dec_f32_to_s16(const float *in, drmp3_int16 *out, int num_samples) { 2113 | if (num_samples > 0) { 2114 | int i = 0; 2115 | #if DRMP3_HAVE_SIMD 2116 | int aligned_count = num_samples & ~7; 2117 | for (; i < aligned_count; i += 8) { 2118 | static const drmp3_f4 g_scale = {32768.0f, 32768.0f, 32768.0f, 32768.0f}; 2119 | drmp3_f4 a = DRMP3_VMUL(DRMP3_VLD(&in[i]), g_scale); 2120 | drmp3_f4 b = DRMP3_VMUL(DRMP3_VLD(&in[i + 4]), g_scale); 2121 | #if DRMP3_HAVE_SSE 2122 | static const drmp3_f4 g_max = {32767.0f, 32767.0f, 32767.0f, 32767.0f}; 2123 | static const drmp3_f4 g_min = {-32768.0f, -32768.0f, -32768.0f, -32768.0f}; 2124 | __m128i pcm8 = _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)), 2125 | _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min))); 2126 | out[i] = (drmp3_int16) _mm_extract_epi16(pcm8, 0); 2127 | out[i + 1] = (drmp3_int16) _mm_extract_epi16(pcm8, 1); 2128 | out[i + 2] = (drmp3_int16) _mm_extract_epi16(pcm8, 2); 2129 | out[i + 3] = (drmp3_int16) _mm_extract_epi16(pcm8, 3); 2130 | out[i + 4] = (drmp3_int16) _mm_extract_epi16(pcm8, 4); 2131 | out[i + 5] = (drmp3_int16) _mm_extract_epi16(pcm8, 5); 2132 | out[i + 6] = (drmp3_int16) _mm_extract_epi16(pcm8, 6); 2133 | out[i + 7] = (drmp3_int16) _mm_extract_epi16(pcm8, 7); 2134 | #else 2135 | int16x4_t pcma, pcmb; 2136 | a = DRMP3_VADD(a, DRMP3_VSET(0.5f)); 2137 | b = DRMP3_VADD(b, DRMP3_VSET(0.5f)); 2138 | pcma = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, DRMP3_VSET(0))))); 2139 | pcmb = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, DRMP3_VSET(0))))); 2140 | vst1_lane_s16(out+i , pcma, 0); 2141 | vst1_lane_s16(out+i+1, pcma, 1); 2142 | vst1_lane_s16(out+i+2, pcma, 2); 2143 | vst1_lane_s16(out+i+3, pcma, 3); 2144 | vst1_lane_s16(out+i+4, pcmb, 0); 2145 | vst1_lane_s16(out+i+5, pcmb, 1); 2146 | vst1_lane_s16(out+i+6, pcmb, 2); 2147 | vst1_lane_s16(out+i+7, pcmb, 3); 2148 | #endif 2149 | } 2150 | #endif 2151 | for (; i < num_samples; i++) { 2152 | float sample = in[i] * 32768.0f; 2153 | if (sample >= 32766.5) 2154 | out[i] = (drmp3_int16) 32767; 2155 | else if (sample <= -32767.5) 2156 | out[i] = (drmp3_int16) -32768; 2157 | else { 2158 | short s = (drmp3_int16) (sample + .5f); 2159 | s -= (s < 0); /* away from zero, to be compliant */ 2160 | out[i] = s; 2161 | } 2162 | } 2163 | } 2164 | } 2165 | 2166 | 2167 | 2168 | /////////////////////////////////////////////////////////////////////////////// 2169 | // 2170 | // Main Public API 2171 | // 2172 | /////////////////////////////////////////////////////////////////////////////// 2173 | 2174 | #if defined(SIZE_MAX) 2175 | #define DRMP3_SIZE_MAX SIZE_MAX 2176 | #else 2177 | #if defined(_WIN64) || defined(_LP64) || defined(__LP64__) 2178 | #define DRMP3_SIZE_MAX ((drmp3_uint64)0xFFFFFFFFFFFFFFFF) 2179 | #else 2180 | #define DRMP3_SIZE_MAX 0xFFFFFFFF 2181 | #endif 2182 | #endif 2183 | 2184 | // Options. 2185 | #ifndef DR_MP3_DEFAULT_CHANNELS 2186 | #define DR_MP3_DEFAULT_CHANNELS 2 2187 | #endif 2188 | #ifndef DR_MP3_DEFAULT_SAMPLE_RATE 2189 | #define DR_MP3_DEFAULT_SAMPLE_RATE 44100 2190 | #endif 2191 | #ifndef DRMP3_SEEK_LEADING_MP3_FRAMES 2192 | #define DRMP3_SEEK_LEADING_MP3_FRAMES 2 2193 | #endif 2194 | 2195 | 2196 | // Standard library stuff. 2197 | #ifndef DRMP3_ASSERT 2198 | 2199 | #include 2200 | 2201 | #define DRMP3_ASSERT(expression) assert(expression) 2202 | #endif 2203 | #ifndef DRMP3_COPY_MEMORY 2204 | #define DRMP3_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz)) 2205 | #endif 2206 | #ifndef DRMP3_ZERO_MEMORY 2207 | #define DRMP3_ZERO_MEMORY(p, sz) memset((p), 0, (sz)) 2208 | #endif 2209 | #define DRMP3_ZERO_OBJECT(p) DRMP3_ZERO_MEMORY((p), sizeof(*(p))) 2210 | #ifndef DRMP3_MALLOC 2211 | #define DRMP3_MALLOC(sz) malloc((sz)) 2212 | #endif 2213 | #ifndef DRMP3_REALLOC 2214 | #define DRMP3_REALLOC(p, sz) realloc((p), (sz)) 2215 | #endif 2216 | #ifndef DRMP3_FREE 2217 | #define DRMP3_FREE(p) free((p)) 2218 | #endif 2219 | 2220 | #define drmp3_assert DRMP3_ASSERT 2221 | #define drmp3_copy_memory DRMP3_COPY_MEMORY 2222 | #define drmp3_zero_memory DRMP3_ZERO_MEMORY 2223 | #define drmp3_zero_object DRMP3_ZERO_OBJECT 2224 | #define drmp3_malloc DRMP3_MALLOC 2225 | #define drmp3_realloc DRMP3_REALLOC 2226 | 2227 | #define drmp3_countof(x) (sizeof(x) / sizeof(x[0])) 2228 | #define drmp3_max(x, y) (((x) > (y)) ? (x) : (y)) 2229 | #define drmp3_min(x, y) (((x) < (y)) ? (x) : (y)) 2230 | 2231 | #define DRMP3_DATA_CHUNK_SIZE 16384 // The size in bytes of each chunk of data to read from the MP3 stream. minimp3 recommends 16K. 2232 | 2233 | static inline float drmp3_mix_f32(float x, float y, float a) { 2234 | return x * (1 - a) + y * a; 2235 | } 2236 | 2237 | static void drmp3_blend_f32(float *pOut, float *pInA, float *pInB, float factor, drmp3_uint32 channels) { 2238 | for (drmp3_uint32 i = 0; i < channels; ++i) { 2239 | pOut[i] = drmp3_mix_f32(pInA[i], pInB[i], factor); 2240 | } 2241 | } 2242 | 2243 | void drmp3_src_cache_init(drmp3_src *pSRC, drmp3_src_cache *pCache) { 2244 | drmp3_assert(pSRC != NULL); 2245 | drmp3_assert(pCache != NULL); 2246 | 2247 | pCache->pSRC = pSRC; 2248 | pCache->cachedFrameCount = 0; 2249 | pCache->iNextFrame = 0; 2250 | } 2251 | 2252 | drmp3_uint64 drmp3_src_cache_read_frames(drmp3_src_cache *pCache, drmp3_uint64 frameCount, float *pFramesOut) { 2253 | drmp3_assert(pCache != NULL); 2254 | drmp3_assert(pCache->pSRC != NULL); 2255 | drmp3_assert(pCache->pSRC->onRead != NULL); 2256 | drmp3_assert(frameCount > 0); 2257 | drmp3_assert(pFramesOut != NULL); 2258 | 2259 | drmp3_uint32 channels = pCache->pSRC->config.channels; 2260 | 2261 | drmp3_uint64 totalFramesRead = 0; 2262 | while (frameCount > 0) { 2263 | // If there's anything in memory go ahead and copy that over first. 2264 | drmp3_uint64 framesRemainingInMemory = pCache->cachedFrameCount - pCache->iNextFrame; 2265 | drmp3_uint64 framesToReadFromMemory = frameCount; 2266 | if (framesToReadFromMemory > framesRemainingInMemory) { 2267 | framesToReadFromMemory = framesRemainingInMemory; 2268 | } 2269 | 2270 | drmp3_copy_memory(pFramesOut, pCache->pCachedFrames + pCache->iNextFrame * channels, 2271 | (drmp3_uint32) (framesToReadFromMemory * channels * sizeof(float))); 2272 | pCache->iNextFrame += (drmp3_uint32) framesToReadFromMemory; 2273 | 2274 | totalFramesRead += framesToReadFromMemory; 2275 | frameCount -= framesToReadFromMemory; 2276 | if (frameCount == 0) { 2277 | break; 2278 | } 2279 | 2280 | 2281 | // At this point there are still more frames to read from the client, so we'll need to reload the cache with fresh data. 2282 | drmp3_assert(frameCount > 0); 2283 | pFramesOut += framesToReadFromMemory * channels; 2284 | 2285 | pCache->iNextFrame = 0; 2286 | pCache->cachedFrameCount = 0; 2287 | 2288 | drmp3_uint32 framesToReadFromClient = drmp3_countof(pCache->pCachedFrames) / pCache->pSRC->config.channels; 2289 | if (framesToReadFromClient > pCache->pSRC->config.cacheSizeInFrames) { 2290 | framesToReadFromClient = pCache->pSRC->config.cacheSizeInFrames; 2291 | } 2292 | 2293 | pCache->cachedFrameCount = (drmp3_uint32) pCache->pSRC->onRead(pCache->pSRC, framesToReadFromClient, 2294 | pCache->pCachedFrames, pCache->pSRC->pUserData); 2295 | 2296 | 2297 | // Get out of this loop if nothing was able to be retrieved. 2298 | if (pCache->cachedFrameCount == 0) { 2299 | break; 2300 | } 2301 | } 2302 | 2303 | return totalFramesRead; 2304 | } 2305 | 2306 | 2307 | drmp3_uint64 2308 | drmp3_src_read_frames_passthrough(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut, drmp3_bool32 flush); 2309 | 2310 | drmp3_uint64 2311 | drmp3_src_read_frames_linear(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut, drmp3_bool32 flush); 2312 | 2313 | drmp3_bool32 2314 | drmp3_src_init(const drmp3_src_config *pConfig, drmp3_src_read_proc onRead, void *pUserData, drmp3_src *pSRC) { 2315 | if (pSRC == NULL) return DRMP3_FALSE; 2316 | drmp3_zero_object(pSRC); 2317 | 2318 | if (pConfig == NULL || onRead == NULL) return DRMP3_FALSE; 2319 | if (pConfig->channels == 0 || pConfig->channels > 2) return DRMP3_FALSE; 2320 | 2321 | pSRC->config = *pConfig; 2322 | pSRC->onRead = onRead; 2323 | pSRC->pUserData = pUserData; 2324 | 2325 | if (pSRC->config.cacheSizeInFrames > DRMP3_SRC_CACHE_SIZE_IN_FRAMES || pSRC->config.cacheSizeInFrames == 0) { 2326 | pSRC->config.cacheSizeInFrames = DRMP3_SRC_CACHE_SIZE_IN_FRAMES; 2327 | } 2328 | 2329 | drmp3_src_cache_init(pSRC, &pSRC->cache); 2330 | return DRMP3_TRUE; 2331 | } 2332 | 2333 | drmp3_bool32 drmp3_src_set_input_sample_rate(drmp3_src *pSRC, drmp3_uint32 sampleRateIn) { 2334 | if (pSRC == NULL) return DRMP3_FALSE; 2335 | 2336 | // Must have a sample rate of > 0. 2337 | if (sampleRateIn == 0) { 2338 | return DRMP3_FALSE; 2339 | } 2340 | 2341 | pSRC->config.sampleRateIn = sampleRateIn; 2342 | return DRMP3_TRUE; 2343 | } 2344 | 2345 | drmp3_bool32 drmp3_src_set_output_sample_rate(drmp3_src *pSRC, drmp3_uint32 sampleRateOut) { 2346 | if (pSRC == NULL) return DRMP3_FALSE; 2347 | 2348 | // Must have a sample rate of > 0. 2349 | if (sampleRateOut == 0) { 2350 | return DRMP3_FALSE; 2351 | } 2352 | 2353 | pSRC->config.sampleRateOut = sampleRateOut; 2354 | return DRMP3_TRUE; 2355 | } 2356 | 2357 | drmp3_uint64 drmp3_src_read_frames_ex(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut, drmp3_bool32 flush) { 2358 | if (pSRC == NULL || frameCount == 0 || pFramesOut == NULL) return 0; 2359 | 2360 | drmp3_src_algorithm algorithm = pSRC->config.algorithm; 2361 | 2362 | // Always use passthrough if the sample rates are the same. 2363 | if (pSRC->config.sampleRateIn == pSRC->config.sampleRateOut) { 2364 | algorithm = drmp3_src_algorithm_none; 2365 | } 2366 | 2367 | // Could just use a function pointer instead of a switch for this... 2368 | switch (algorithm) { 2369 | case drmp3_src_algorithm_none: 2370 | return drmp3_src_read_frames_passthrough(pSRC, frameCount, pFramesOut, flush); 2371 | case drmp3_src_algorithm_linear: 2372 | return drmp3_src_read_frames_linear(pSRC, frameCount, pFramesOut, flush); 2373 | default: 2374 | return 0; 2375 | } 2376 | } 2377 | 2378 | drmp3_uint64 drmp3_src_read_frames(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut) { 2379 | return drmp3_src_read_frames_ex(pSRC, frameCount, pFramesOut, DRMP3_FALSE); 2380 | } 2381 | 2382 | drmp3_uint64 2383 | drmp3_src_read_frames_passthrough(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut, drmp3_bool32 flush) { 2384 | drmp3_assert(pSRC != NULL); 2385 | drmp3_assert(frameCount > 0); 2386 | drmp3_assert(pFramesOut != NULL); 2387 | 2388 | (void) flush; // Passthrough need not care about flushing. 2389 | return pSRC->onRead(pSRC, frameCount, pFramesOut, pSRC->pUserData); 2390 | } 2391 | 2392 | drmp3_uint64 2393 | drmp3_src_read_frames_linear(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut, drmp3_bool32 flush) { 2394 | drmp3_assert(pSRC != NULL); 2395 | drmp3_assert(frameCount > 0); 2396 | drmp3_assert(pFramesOut != NULL); 2397 | 2398 | // For linear SRC, the bin is only 2 frames: 1 prior, 1 future. 2399 | 2400 | // Load the bin if necessary. 2401 | if (!pSRC->algo.linear.isPrevFramesLoaded) { 2402 | drmp3_uint64 framesRead = drmp3_src_cache_read_frames(&pSRC->cache, 1, pSRC->bin); 2403 | if (framesRead == 0) { 2404 | return 0; 2405 | } 2406 | pSRC->algo.linear.isPrevFramesLoaded = DRMP3_TRUE; 2407 | } 2408 | if (!pSRC->algo.linear.isNextFramesLoaded) { 2409 | drmp3_uint64 framesRead = drmp3_src_cache_read_frames(&pSRC->cache, 1, pSRC->bin + pSRC->config.channels); 2410 | if (framesRead == 0) { 2411 | return 0; 2412 | } 2413 | pSRC->algo.linear.isNextFramesLoaded = DRMP3_TRUE; 2414 | } 2415 | 2416 | double factor = (double) pSRC->config.sampleRateIn / pSRC->config.sampleRateOut; 2417 | 2418 | drmp3_uint64 totalFramesRead = 0; 2419 | while (frameCount > 0) { 2420 | // The bin is where the previous and next frames are located. 2421 | float *pPrevFrame = pSRC->bin; 2422 | float *pNextFrame = pSRC->bin + pSRC->config.channels; 2423 | 2424 | drmp3_blend_f32((float *) pFramesOut, pPrevFrame, pNextFrame, (float) pSRC->algo.linear.alpha, 2425 | pSRC->config.channels); 2426 | 2427 | pSRC->algo.linear.alpha += factor; 2428 | 2429 | // The new alpha value is how we determine whether or not we need to read fresh frames. 2430 | drmp3_uint32 framesToReadFromClient = (drmp3_uint32) pSRC->algo.linear.alpha; 2431 | pSRC->algo.linear.alpha = pSRC->algo.linear.alpha - framesToReadFromClient; 2432 | 2433 | for (drmp3_uint32 i = 0; i < framesToReadFromClient; ++i) { 2434 | for (drmp3_uint32 j = 0; j < pSRC->config.channels; ++j) { 2435 | pPrevFrame[j] = pNextFrame[j]; 2436 | } 2437 | 2438 | drmp3_uint64 framesRead = drmp3_src_cache_read_frames(&pSRC->cache, 1, pNextFrame); 2439 | if (framesRead == 0) { 2440 | for (drmp3_uint32 j = 0; j < pSRC->config.channels; ++j) { 2441 | pNextFrame[j] = 0; 2442 | } 2443 | 2444 | if (pSRC->algo.linear.isNextFramesLoaded) { 2445 | pSRC->algo.linear.isNextFramesLoaded = DRMP3_FALSE; 2446 | } else { 2447 | if (flush) { 2448 | pSRC->algo.linear.isPrevFramesLoaded = DRMP3_FALSE; 2449 | } 2450 | } 2451 | 2452 | break; 2453 | } 2454 | } 2455 | 2456 | pFramesOut = (drmp3_uint8 *) pFramesOut + (1 * pSRC->config.channels * sizeof(float)); 2457 | frameCount -= 1; 2458 | totalFramesRead += 1; 2459 | 2460 | // If there's no frames available we need to get out of this loop. 2461 | if (!pSRC->algo.linear.isNextFramesLoaded && (!flush || !pSRC->algo.linear.isPrevFramesLoaded)) { 2462 | break; 2463 | } 2464 | } 2465 | 2466 | return totalFramesRead; 2467 | } 2468 | 2469 | 2470 | static size_t drmp3__on_read(drmp3 *pMP3, void *pBufferOut, size_t bytesToRead) { 2471 | size_t bytesRead = pMP3->onRead(pMP3->pUserData, pBufferOut, bytesToRead); 2472 | pMP3->streamCursor += bytesRead; 2473 | return bytesRead; 2474 | } 2475 | 2476 | static drmp3_bool32 drmp3__on_seek(drmp3 *pMP3, int offset, drmp3_seek_origin origin) { 2477 | drmp3_assert(offset >= 0); 2478 | 2479 | if (!pMP3->onSeek(pMP3->pUserData, offset, origin)) { 2480 | return DRMP3_FALSE; 2481 | } 2482 | 2483 | if (origin == drmp3_seek_origin_start) { 2484 | pMP3->streamCursor = (drmp3_uint64) offset; 2485 | } else { 2486 | pMP3->streamCursor += offset; 2487 | } 2488 | 2489 | return DRMP3_TRUE; 2490 | } 2491 | 2492 | static drmp3_bool32 drmp3__on_seek_64(drmp3 *pMP3, drmp3_uint64 offset, drmp3_seek_origin origin) { 2493 | if (offset <= 0x7FFFFFFF) { 2494 | return drmp3__on_seek(pMP3, (int) offset, origin); 2495 | } 2496 | 2497 | 2498 | // Getting here "offset" is too large for a 32-bit integer. We just keep seeking forward until we hit the offset. 2499 | if (!drmp3__on_seek(pMP3, 0x7FFFFFFF, drmp3_seek_origin_start)) { 2500 | return DRMP3_FALSE; 2501 | } 2502 | 2503 | offset -= 0x7FFFFFFF; 2504 | while (offset > 0) { 2505 | if (offset <= 0x7FFFFFFF) { 2506 | if (!drmp3__on_seek(pMP3, (int) offset, drmp3_seek_origin_current)) { 2507 | return DRMP3_FALSE; 2508 | } 2509 | offset = 0; 2510 | } else { 2511 | if (!drmp3__on_seek(pMP3, 0x7FFFFFFF, drmp3_seek_origin_current)) { 2512 | return DRMP3_FALSE; 2513 | } 2514 | offset -= 0x7FFFFFFF; 2515 | } 2516 | } 2517 | 2518 | return DRMP3_TRUE; 2519 | } 2520 | 2521 | 2522 | static drmp3_uint32 drmp3_decode_next_frame_ex(drmp3 *pMP3, drmp3d_sample_t *pPCMFrames, drmp3_bool32 discard) { 2523 | drmp3_assert(pMP3 != NULL); 2524 | drmp3_assert(pMP3->onRead != NULL); 2525 | 2526 | if (pMP3->atEnd) { 2527 | return 0; 2528 | } 2529 | 2530 | drmp3_uint32 pcmFramesRead = 0; 2531 | do { 2532 | // minimp3 recommends doing data submission in 16K chunks. If we don't have at least 16K bytes available, get more. 2533 | if (pMP3->dataSize < DRMP3_DATA_CHUNK_SIZE) { 2534 | if (pMP3->dataCapacity < DRMP3_DATA_CHUNK_SIZE) { 2535 | pMP3->dataCapacity = DRMP3_DATA_CHUNK_SIZE; 2536 | drmp3_uint8 *pNewData = (drmp3_uint8 *) drmp3_realloc(pMP3->pData, pMP3->dataCapacity); 2537 | if (pNewData == NULL) { 2538 | return 0; // Out of memory. 2539 | } 2540 | 2541 | pMP3->pData = pNewData; 2542 | } 2543 | 2544 | size_t bytesRead = drmp3__on_read(pMP3, pMP3->pData + pMP3->dataSize, 2545 | (pMP3->dataCapacity - pMP3->dataSize)); 2546 | if (bytesRead == 0) { 2547 | if (pMP3->dataSize == 0) { 2548 | pMP3->atEnd = DRMP3_TRUE; 2549 | return 0; // No data. 2550 | } 2551 | } 2552 | 2553 | pMP3->dataSize += bytesRead; 2554 | } 2555 | 2556 | if (pMP3->dataSize > INT_MAX) { 2557 | pMP3->atEnd = DRMP3_TRUE; 2558 | return 0; // File too big. 2559 | } 2560 | 2561 | drmp3dec_frame_info info; 2562 | pcmFramesRead = drmp3dec_decode_frame(&pMP3->decoder, pMP3->pData, (int) pMP3->dataSize, pPCMFrames, 2563 | &info); // <-- Safe size_t -> int conversion thanks to the check above. 2564 | 2565 | // Consume the data. 2566 | size_t leftoverDataSize = (pMP3->dataSize - (size_t) info.frame_bytes); 2567 | if (info.frame_bytes > 0) { 2568 | memmove(pMP3->pData, pMP3->pData + info.frame_bytes, leftoverDataSize); 2569 | pMP3->dataSize = leftoverDataSize; 2570 | } 2571 | 2572 | // pcmFramesRead will be equal to 0 if decoding failed. If it is zero and info.frame_bytes > 0 then we have successfully 2573 | // decoded the frame. A special case is if we are wanting to discard the frame, in which case we return successfully. 2574 | if (pcmFramesRead > 0 || (info.frame_bytes > 0 && discard)) { 2575 | pcmFramesRead = drmp3_hdr_frame_samples(pMP3->decoder.header); 2576 | pMP3->pcmFramesConsumedInMP3Frame = 0; 2577 | pMP3->pcmFramesRemainingInMP3Frame = pcmFramesRead; 2578 | pMP3->mp3FrameChannels = info.channels; 2579 | pMP3->mp3FrameSampleRate = info.hz; 2580 | drmp3_src_set_input_sample_rate(&pMP3->src, pMP3->mp3FrameSampleRate); 2581 | break; 2582 | } else if (info.frame_bytes == 0) { 2583 | // Need more data. minimp3 recommends doing data submission in 16K chunks. 2584 | if (pMP3->dataCapacity == pMP3->dataSize) { 2585 | // No room. Expand. 2586 | pMP3->dataCapacity += DRMP3_DATA_CHUNK_SIZE; 2587 | drmp3_uint8 *pNewData = (drmp3_uint8 *) drmp3_realloc(pMP3->pData, pMP3->dataCapacity); 2588 | if (pNewData == NULL) { 2589 | return 0; // Out of memory. 2590 | } 2591 | 2592 | pMP3->pData = pNewData; 2593 | } 2594 | 2595 | // Fill in a chunk. 2596 | size_t bytesRead = drmp3__on_read(pMP3, pMP3->pData + pMP3->dataSize, 2597 | (pMP3->dataCapacity - pMP3->dataSize)); 2598 | if (bytesRead == 0) { 2599 | pMP3->atEnd = DRMP3_TRUE; 2600 | return 0; // Error reading more data. 2601 | } 2602 | 2603 | pMP3->dataSize += bytesRead; 2604 | } 2605 | } while (DRMP3_TRUE); 2606 | 2607 | return pcmFramesRead; 2608 | } 2609 | 2610 | static drmp3_uint32 drmp3_decode_next_frame(drmp3 *pMP3) { 2611 | drmp3_assert(pMP3 != NULL); 2612 | return drmp3_decode_next_frame_ex(pMP3, (drmp3d_sample_t *) pMP3->pcmFrames, DRMP3_FALSE); 2613 | } 2614 | 2615 | #if 0 2616 | static drmp3_uint32 drmp3_seek_next_frame(drmp3* pMP3) 2617 | { 2618 | drmp3_assert(pMP3 != NULL); 2619 | 2620 | drmp3_uint32 pcmFrameCount = drmp3_decode_next_frame_ex(pMP3, NULL); 2621 | if (pcmFrameCount == 0) { 2622 | return 0; 2623 | } 2624 | 2625 | // We have essentially just skipped past the frame, so just set the remaining samples to 0. 2626 | pMP3->currentPCMFrame += pcmFrameCount; 2627 | pMP3->pcmFramesConsumedInMP3Frame = pcmFrameCount; 2628 | pMP3->pcmFramesRemainingInMP3Frame = 0; 2629 | 2630 | return pcmFrameCount; 2631 | } 2632 | #endif 2633 | 2634 | static drmp3_uint64 drmp3_read_src(drmp3_src *pSRC, drmp3_uint64 frameCount, void *pFramesOut, void *pUserData) { 2635 | drmp3 *pMP3 = (drmp3 *) pUserData; 2636 | drmp3_assert(pMP3 != NULL); 2637 | drmp3_assert(pMP3->onRead != NULL); 2638 | 2639 | float *pFramesOutF = (float *) pFramesOut; 2640 | drmp3_uint64 totalFramesRead = 0; 2641 | 2642 | while (frameCount > 0) { 2643 | // Read from the in-memory buffer first. 2644 | while (pMP3->pcmFramesRemainingInMP3Frame > 0 && frameCount > 0) { 2645 | drmp3d_sample_t *frames = (drmp3d_sample_t *) pMP3->pcmFrames; 2646 | #ifndef DR_MP3_FLOAT_OUTPUT 2647 | if (pMP3->mp3FrameChannels == 1) { 2648 | if (pMP3->channels == 1) { 2649 | // Mono -> Mono. 2650 | pFramesOutF[0] = frames[pMP3->pcmFramesConsumedInMP3Frame] / 32768.0f; 2651 | } else { 2652 | // Mono -> Stereo. 2653 | pFramesOutF[0] = frames[pMP3->pcmFramesConsumedInMP3Frame] / 32768.0f; 2654 | pFramesOutF[1] = frames[pMP3->pcmFramesConsumedInMP3Frame] / 32768.0f; 2655 | } 2656 | } else { 2657 | if (pMP3->channels == 1) { 2658 | // Stereo -> Mono 2659 | float sample = 0; 2660 | sample += frames[(pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels) + 0] / 32768.0f; 2661 | sample += frames[(pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels) + 1] / 32768.0f; 2662 | pFramesOutF[0] = sample * 0.5f; 2663 | } else { 2664 | // Stereo -> Stereo 2665 | pFramesOutF[0] = 2666 | frames[(pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels) + 0] / 32768.0f; 2667 | pFramesOutF[1] = 2668 | frames[(pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels) + 1] / 32768.0f; 2669 | } 2670 | } 2671 | #else 2672 | if (pMP3->mp3FrameChannels == 1) { 2673 | if (pMP3->channels == 1) { 2674 | // Mono -> Mono. 2675 | pFramesOutF[0] = frames[pMP3->pcmFramesConsumedInMP3Frame]; 2676 | } else { 2677 | // Mono -> Stereo. 2678 | pFramesOutF[0] = frames[pMP3->pcmFramesConsumedInMP3Frame]; 2679 | pFramesOutF[1] = frames[pMP3->pcmFramesConsumedInMP3Frame]; 2680 | } 2681 | } else { 2682 | if (pMP3->channels == 1) { 2683 | // Stereo -> Mono 2684 | float sample = 0; 2685 | sample += frames[(pMP3->pcmFramesConsumedInMP3Frame*pMP3->mp3FrameChannels)+0]; 2686 | sample += frames[(pMP3->pcmFramesConsumedInMP3Frame*pMP3->mp3FrameChannels)+1]; 2687 | pFramesOutF[0] = sample * 0.5f; 2688 | } else { 2689 | // Stereo -> Stereo 2690 | pFramesOutF[0] = frames[(pMP3->pcmFramesConsumedInMP3Frame*pMP3->mp3FrameChannels)+0]; 2691 | pFramesOutF[1] = frames[(pMP3->pcmFramesConsumedInMP3Frame*pMP3->mp3FrameChannels)+1]; 2692 | } 2693 | } 2694 | #endif 2695 | 2696 | pMP3->pcmFramesConsumedInMP3Frame += 1; 2697 | pMP3->pcmFramesRemainingInMP3Frame -= 1; 2698 | totalFramesRead += 1; 2699 | frameCount -= 1; 2700 | pFramesOutF += pSRC->config.channels; 2701 | } 2702 | 2703 | if (frameCount == 0) { 2704 | break; 2705 | } 2706 | 2707 | drmp3_assert(pMP3->pcmFramesRemainingInMP3Frame == 0); 2708 | 2709 | // At this point we have exhausted our in-memory buffer so we need to re-fill. Note that the sample rate may have changed 2710 | // at this point which means we'll also need to update our sample rate conversion pipeline. 2711 | if (drmp3_decode_next_frame(pMP3) == 0) { 2712 | break; 2713 | } 2714 | } 2715 | 2716 | return totalFramesRead; 2717 | } 2718 | 2719 | drmp3_bool32 drmp3_init_internal(drmp3 *pMP3, drmp3_read_proc onRead, drmp3_seek_proc onSeek, void *pUserData, 2720 | const drmp3_config *pConfig) { 2721 | drmp3_assert(pMP3 != NULL); 2722 | drmp3_assert(onRead != NULL); 2723 | 2724 | // This function assumes the output object has already been reset to 0. Do not do that here, otherwise things will break. 2725 | drmp3dec_init(&pMP3->decoder); 2726 | 2727 | // The config can be null in which case we use defaults. 2728 | drmp3_config config; 2729 | if (pConfig != NULL) { 2730 | config = *pConfig; 2731 | } else { 2732 | drmp3_zero_object(&config); 2733 | } 2734 | 2735 | pMP3->channels = config.outputChannels; 2736 | if (pMP3->channels == 0) { 2737 | pMP3->channels = DR_MP3_DEFAULT_CHANNELS; 2738 | } 2739 | 2740 | // Cannot have more than 2 channels. 2741 | if (pMP3->channels > 2) { 2742 | pMP3->channels = 2; 2743 | } 2744 | 2745 | pMP3->sampleRate = config.outputSampleRate; 2746 | if (pMP3->sampleRate == 0) { 2747 | pMP3->sampleRate = DR_MP3_DEFAULT_SAMPLE_RATE; 2748 | } 2749 | 2750 | pMP3->onRead = onRead; 2751 | pMP3->onSeek = onSeek; 2752 | pMP3->pUserData = pUserData; 2753 | 2754 | // We need a sample rate converter for converting the sample rate from the MP3 frames to the requested output sample rate. 2755 | drmp3_src_config srcConfig; 2756 | drmp3_zero_object(&srcConfig); 2757 | srcConfig.sampleRateIn = DR_MP3_DEFAULT_SAMPLE_RATE; 2758 | srcConfig.sampleRateOut = pMP3->sampleRate; 2759 | srcConfig.channels = pMP3->channels; 2760 | srcConfig.algorithm = drmp3_src_algorithm_linear; 2761 | if (!drmp3_src_init(&srcConfig, drmp3_read_src, pMP3, &pMP3->src)) { 2762 | drmp3_uninit(pMP3); 2763 | return DRMP3_FALSE; 2764 | } 2765 | 2766 | // Decode the first frame to confirm that it is indeed a valid MP3 stream. 2767 | if (!drmp3_decode_next_frame(pMP3)) { 2768 | drmp3_uninit(pMP3); 2769 | return DRMP3_FALSE; // Not a valid MP3 stream. 2770 | } 2771 | 2772 | return DRMP3_TRUE; 2773 | } 2774 | 2775 | drmp3_bool32 2776 | drmp3_init(drmp3 *pMP3, drmp3_read_proc onRead, drmp3_seek_proc onSeek, void *pUserData, const drmp3_config *pConfig) { 2777 | if (pMP3 == NULL || onRead == NULL) { 2778 | return DRMP3_FALSE; 2779 | } 2780 | 2781 | drmp3_zero_object(pMP3); 2782 | return drmp3_init_internal(pMP3, onRead, onSeek, pUserData, pConfig); 2783 | } 2784 | 2785 | 2786 | static size_t drmp3__on_read_memory(void *pUserData, void *pBufferOut, size_t bytesToRead) { 2787 | drmp3 *pMP3 = (drmp3 *) pUserData; 2788 | drmp3_assert(pMP3 != NULL); 2789 | drmp3_assert(pMP3->memory.dataSize >= pMP3->memory.currentReadPos); 2790 | 2791 | size_t bytesRemaining = pMP3->memory.dataSize - pMP3->memory.currentReadPos; 2792 | if (bytesToRead > bytesRemaining) { 2793 | bytesToRead = bytesRemaining; 2794 | } 2795 | 2796 | if (bytesToRead > 0) { 2797 | drmp3_copy_memory(pBufferOut, pMP3->memory.pData + pMP3->memory.currentReadPos, bytesToRead); 2798 | pMP3->memory.currentReadPos += bytesToRead; 2799 | } 2800 | 2801 | return bytesToRead; 2802 | } 2803 | 2804 | static drmp3_bool32 drmp3__on_seek_memory(void *pUserData, int byteOffset, drmp3_seek_origin origin) { 2805 | drmp3 *pMP3 = (drmp3 *) pUserData; 2806 | drmp3_assert(pMP3 != NULL); 2807 | 2808 | if (origin == drmp3_seek_origin_current) { 2809 | if (byteOffset > 0) { 2810 | if (pMP3->memory.currentReadPos + byteOffset > pMP3->memory.dataSize) { 2811 | byteOffset = (int) (pMP3->memory.dataSize - 2812 | pMP3->memory.currentReadPos); // Trying to seek too far forward. 2813 | } 2814 | } else { 2815 | if (pMP3->memory.currentReadPos < (size_t) -byteOffset) { 2816 | byteOffset = -(int) pMP3->memory.currentReadPos; // Trying to seek too far backwards. 2817 | } 2818 | } 2819 | 2820 | // This will never underflow thanks to the clamps above. 2821 | pMP3->memory.currentReadPos += byteOffset; 2822 | } else { 2823 | if ((drmp3_uint32) byteOffset <= pMP3->memory.dataSize) { 2824 | pMP3->memory.currentReadPos = byteOffset; 2825 | } else { 2826 | pMP3->memory.currentReadPos = pMP3->memory.dataSize; // Trying to seek too far forward. 2827 | } 2828 | } 2829 | 2830 | return DRMP3_TRUE; 2831 | } 2832 | 2833 | drmp3_bool32 drmp3_init_memory(drmp3 *pMP3, const void *pData, size_t dataSize, const drmp3_config *pConfig) { 2834 | if (pMP3 == NULL) { 2835 | return DRMP3_FALSE; 2836 | } 2837 | 2838 | drmp3_zero_object(pMP3); 2839 | 2840 | if (pData == NULL || dataSize == 0) { 2841 | return DRMP3_FALSE; 2842 | } 2843 | 2844 | pMP3->memory.pData = (const drmp3_uint8 *) pData; 2845 | pMP3->memory.dataSize = dataSize; 2846 | pMP3->memory.currentReadPos = 0; 2847 | 2848 | return drmp3_init_internal(pMP3, drmp3__on_read_memory, drmp3__on_seek_memory, pMP3, pConfig); 2849 | } 2850 | 2851 | 2852 | #ifndef DR_MP3_NO_STDIO 2853 | 2854 | #include 2855 | 2856 | static size_t drmp3__on_read_stdio(void *pUserData, void *pBufferOut, size_t bytesToRead) { 2857 | return fread(pBufferOut, 1, bytesToRead, (FILE *) pUserData); 2858 | } 2859 | 2860 | static drmp3_bool32 drmp3__on_seek_stdio(void *pUserData, int offset, drmp3_seek_origin origin) { 2861 | return fseek((FILE *) pUserData, offset, (origin == drmp3_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0; 2862 | } 2863 | 2864 | drmp3_bool32 drmp3_init_file(drmp3 *pMP3, const char *filePath, const drmp3_config *pConfig) { 2865 | FILE *pFile; 2866 | #if defined(_MSC_VER) && _MSC_VER >= 1400 2867 | if (fopen_s(&pFile, filePath, "rb") != 0) { 2868 | return DRMP3_FALSE; 2869 | } 2870 | #else 2871 | pFile = fopen(filePath, "rb"); 2872 | if (pFile == NULL) { 2873 | return DRMP3_FALSE; 2874 | } 2875 | #endif 2876 | 2877 | return drmp3_init(pMP3, drmp3__on_read_stdio, drmp3__on_seek_stdio, (void *) pFile, pConfig); 2878 | } 2879 | 2880 | #endif 2881 | 2882 | void drmp3_uninit(drmp3 *pMP3) { 2883 | if (pMP3 == NULL) { 2884 | return; 2885 | } 2886 | 2887 | #ifndef DR_MP3_NO_STDIO 2888 | if (pMP3->onRead == drmp3__on_read_stdio) { 2889 | fclose((FILE *) pMP3->pUserData); 2890 | } 2891 | #endif 2892 | 2893 | drmp3_free(pMP3->pData); 2894 | } 2895 | 2896 | drmp3_uint64 drmp3_read_pcm_frames_f32(drmp3 *pMP3, drmp3_uint64 framesToRead, float *pBufferOut) { 2897 | if (pMP3 == NULL || pMP3->onRead == NULL) { 2898 | return 0; 2899 | } 2900 | 2901 | drmp3_uint64 totalFramesRead = 0; 2902 | 2903 | if (pBufferOut == NULL) { 2904 | float temp[4096]; 2905 | while (framesToRead > 0) { 2906 | drmp3_uint64 framesToReadRightNow = sizeof(temp) / sizeof(temp[0]) / pMP3->channels; 2907 | if (framesToReadRightNow > framesToRead) { 2908 | framesToReadRightNow = framesToRead; 2909 | } 2910 | 2911 | drmp3_uint64 framesJustRead = drmp3_read_pcm_frames_f32(pMP3, framesToReadRightNow, temp); 2912 | if (framesJustRead == 0) { 2913 | break; 2914 | } 2915 | 2916 | framesToRead -= framesJustRead; 2917 | totalFramesRead += framesJustRead; 2918 | } 2919 | } else { 2920 | totalFramesRead = drmp3_src_read_frames_ex(&pMP3->src, framesToRead, pBufferOut, DRMP3_TRUE); 2921 | pMP3->currentPCMFrame += totalFramesRead; 2922 | } 2923 | 2924 | return totalFramesRead; 2925 | } 2926 | 2927 | void drmp3_reset(drmp3 *pMP3) { 2928 | drmp3_assert(pMP3 != NULL); 2929 | 2930 | pMP3->pcmFramesConsumedInMP3Frame = 0; 2931 | pMP3->pcmFramesRemainingInMP3Frame = 0; 2932 | pMP3->currentPCMFrame = 0; 2933 | pMP3->dataSize = 0; 2934 | pMP3->atEnd = DRMP3_FALSE; 2935 | pMP3->src.bin[0] = 0; 2936 | pMP3->src.bin[1] = 0; 2937 | pMP3->src.bin[2] = 0; 2938 | pMP3->src.bin[3] = 0; 2939 | pMP3->src.cache.cachedFrameCount = 0; 2940 | pMP3->src.cache.iNextFrame = 0; 2941 | pMP3->src.algo.linear.alpha = 0; 2942 | pMP3->src.algo.linear.isNextFramesLoaded = 0; 2943 | pMP3->src.algo.linear.isPrevFramesLoaded = 0; 2944 | //drmp3_zero_object(&pMP3->decoder); 2945 | drmp3dec_init(&pMP3->decoder); 2946 | } 2947 | 2948 | drmp3_bool32 drmp3_seek_to_start_of_stream(drmp3 *pMP3) { 2949 | drmp3_assert(pMP3 != NULL); 2950 | drmp3_assert(pMP3->onSeek != NULL); 2951 | 2952 | // Seek to the start of the stream to begin with. 2953 | if (!drmp3__on_seek(pMP3, 0, drmp3_seek_origin_start)) { 2954 | return DRMP3_FALSE; 2955 | } 2956 | 2957 | // Clear any cached data. 2958 | drmp3_reset(pMP3); 2959 | return DRMP3_TRUE; 2960 | } 2961 | 2962 | float drmp3_get_cached_pcm_frame_count_from_src(drmp3 *pMP3) { 2963 | return (pMP3->src.cache.cachedFrameCount - pMP3->src.cache.iNextFrame) + (float) pMP3->src.algo.linear.alpha; 2964 | } 2965 | 2966 | float drmp3_get_pcm_frames_remaining_in_mp3_frame(drmp3 *pMP3) { 2967 | float factor = (float) pMP3->src.config.sampleRateOut / (float) pMP3->src.config.sampleRateIn; 2968 | float frameCountPreSRC = drmp3_get_cached_pcm_frame_count_from_src(pMP3) + pMP3->pcmFramesRemainingInMP3Frame; 2969 | return frameCountPreSRC * factor; 2970 | } 2971 | 2972 | // NOTE ON SEEKING 2973 | // =============== 2974 | // The seeking code below is a complete mess and is broken for cases when the sample rate changes. The problem 2975 | // is with the resampling and the crappy resampler used by dr_mp3. What needs to happen is the following: 2976 | // 2977 | // 1) The resampler needs to be replaced. 2978 | // 2) The resampler has state which needs to be updated whenever an MP3 frame is decoded outside of 2979 | // drmp3_read_pcm_frames_f32(). The resampler needs an API to "flush" some imaginary input so that it's 2980 | // state is updated accordingly. 2981 | 2982 | drmp3_bool32 drmp3_seek_forward_by_pcm_frames__brute_force(drmp3 *pMP3, drmp3_uint64 frameOffset) { 2983 | #if 0 2984 | // MP3 is a bit annoying when it comes to seeking because of the bit reservoir. It basically means that an MP3 frame can possibly 2985 | // depend on some of the data of prior frames. This means it's not as simple as seeking to the first byte of the MP3 frame that 2986 | // contains the sample because that MP3 frame will need the data from the previous MP3 frame (which we just seeked past!). To 2987 | // resolve this we seek past a number of MP3 frames up to a point, and then read-and-discard the remainder. 2988 | drmp3_uint64 maxFramesToReadAndDiscard = (drmp3_uint64)(DRMP3_MAX_PCM_FRAMES_PER_MP3_FRAME * 3 * ((float)pMP3->src.config.sampleRateOut / (float)pMP3->src.config.sampleRateIn)); 2989 | 2990 | // Now get rid of leading whole frames. 2991 | while (frameOffset > maxFramesToReadAndDiscard) { 2992 | float pcmFramesRemainingInCurrentMP3FrameF = drmp3_get_pcm_frames_remaining_in_mp3_frame(pMP3); 2993 | drmp3_uint32 pcmFramesRemainingInCurrentMP3Frame = (drmp3_uint32)pcmFramesRemainingInCurrentMP3FrameF; 2994 | if (frameOffset > pcmFramesRemainingInCurrentMP3Frame) { 2995 | frameOffset -= pcmFramesRemainingInCurrentMP3Frame; 2996 | pMP3->currentPCMFrame += pcmFramesRemainingInCurrentMP3Frame; 2997 | pMP3->pcmFramesConsumedInMP3Frame += pMP3->pcmFramesRemainingInMP3Frame; 2998 | pMP3->pcmFramesRemainingInMP3Frame = 0; 2999 | } else { 3000 | break; 3001 | } 3002 | 3003 | drmp3_uint32 pcmFrameCount = drmp3_decode_next_frame_ex(pMP3, pMP3->pcmFrames, DRMP3_FALSE); 3004 | if (pcmFrameCount == 0) { 3005 | break; 3006 | } 3007 | } 3008 | 3009 | // The last step is to read-and-discard any remaining PCM frames to make it sample-exact. 3010 | drmp3_uint64 framesRead = drmp3_read_pcm_frames_f32(pMP3, frameOffset, NULL); 3011 | if (framesRead != frameOffset) { 3012 | return DRMP3_FALSE; 3013 | } 3014 | #else 3015 | // Just using a dumb read-and-discard for now pending updates to the resampler. 3016 | drmp3_uint64 framesRead = drmp3_read_pcm_frames_f32(pMP3, frameOffset, NULL); 3017 | if (framesRead != frameOffset) { 3018 | return DRMP3_FALSE; 3019 | } 3020 | #endif 3021 | 3022 | return DRMP3_TRUE; 3023 | } 3024 | 3025 | drmp3_bool32 drmp3_seek_to_pcm_frame__brute_force(drmp3 *pMP3, drmp3_uint64 frameIndex) { 3026 | drmp3_assert(pMP3 != NULL); 3027 | 3028 | if (frameIndex == pMP3->currentPCMFrame) { 3029 | return DRMP3_TRUE; 3030 | } 3031 | 3032 | // If we're moving foward we just read from where we're at. Otherwise we need to move back to the start of 3033 | // the stream and read from the beginning. 3034 | //drmp3_uint64 framesToReadAndDiscard; 3035 | if (frameIndex < pMP3->currentPCMFrame) { 3036 | // Moving backward. Move to the start of the stream and then move forward. 3037 | if (!drmp3_seek_to_start_of_stream(pMP3)) { 3038 | return DRMP3_FALSE; 3039 | } 3040 | } 3041 | 3042 | drmp3_assert(frameIndex >= pMP3->currentPCMFrame); 3043 | return drmp3_seek_forward_by_pcm_frames__brute_force(pMP3, (frameIndex - pMP3->currentPCMFrame)); 3044 | } 3045 | 3046 | drmp3_bool32 drmp3_find_closest_seek_point(drmp3 *pMP3, drmp3_uint64 frameIndex, drmp3_uint32 *pSeekPointIndex) { 3047 | drmp3_assert(pSeekPointIndex != NULL); 3048 | 3049 | if (frameIndex < pMP3->pSeekPoints[0].pcmFrameIndex) { 3050 | return DRMP3_FALSE; 3051 | } 3052 | 3053 | // Linear search for simplicity to begin with while I'm getting this thing working. Once it's all working change this to a binary search. 3054 | for (drmp3_uint32 iSeekPoint = 0; iSeekPoint < pMP3->seekPointCount; ++iSeekPoint) { 3055 | if (pMP3->pSeekPoints[iSeekPoint].pcmFrameIndex > frameIndex) { 3056 | break; // Found it. 3057 | } 3058 | 3059 | *pSeekPointIndex = iSeekPoint; 3060 | } 3061 | 3062 | return DRMP3_TRUE; 3063 | } 3064 | 3065 | drmp3_bool32 drmp3_seek_to_pcm_frame__seek_table(drmp3 *pMP3, drmp3_uint64 frameIndex) { 3066 | drmp3_assert(pMP3 != NULL); 3067 | drmp3_assert(pMP3->pSeekPoints != NULL); 3068 | drmp3_assert(pMP3->seekPointCount > 0); 3069 | 3070 | drmp3_seek_point seekPoint; 3071 | 3072 | // If there is no prior seekpoint it means the target PCM frame comes before the first seek point. Just assume a seekpoint at the start of the file in this case. 3073 | drmp3_uint32 priorSeekPointIndex; 3074 | if (drmp3_find_closest_seek_point(pMP3, frameIndex, &priorSeekPointIndex)) { 3075 | seekPoint = pMP3->pSeekPoints[priorSeekPointIndex]; 3076 | } else { 3077 | seekPoint.seekPosInBytes = 0; 3078 | seekPoint.pcmFrameIndex = 0; 3079 | seekPoint.mp3FramesToDiscard = 0; 3080 | seekPoint.pcmFramesToDiscard = 0; 3081 | } 3082 | 3083 | // First thing to do is seek to the first byte of the relevant MP3 frame. 3084 | if (!drmp3__on_seek_64(pMP3, seekPoint.seekPosInBytes, drmp3_seek_origin_start)) { 3085 | return DRMP3_FALSE; // Failed to seek. 3086 | } 3087 | 3088 | // Clear any cached data. 3089 | drmp3_reset(pMP3); 3090 | 3091 | // Whole MP3 frames need to be discarded first. 3092 | for (drmp3_uint16 iMP3Frame = 0; iMP3Frame < seekPoint.mp3FramesToDiscard; ++iMP3Frame) { 3093 | // Pass in non-null for the last frame because we want to ensure the sample rate converter is preloaded correctly. 3094 | drmp3d_sample_t *pPCMFrames = NULL; 3095 | if (iMP3Frame == seekPoint.mp3FramesToDiscard - 1) { 3096 | pPCMFrames = (drmp3d_sample_t *) pMP3->pcmFrames; 3097 | } 3098 | 3099 | // We first need to decode the next frame, and then we need to flush the resampler. 3100 | drmp3_uint32 pcmFramesReadPreSRC = drmp3_decode_next_frame_ex(pMP3, pPCMFrames, DRMP3_TRUE); 3101 | if (pcmFramesReadPreSRC == 0) { 3102 | return DRMP3_FALSE; 3103 | } 3104 | } 3105 | 3106 | // We seeked to an MP3 frame in the raw stream so we need to make sure the current PCM frame is set correctly. 3107 | pMP3->currentPCMFrame = seekPoint.pcmFrameIndex - seekPoint.pcmFramesToDiscard; 3108 | 3109 | // Update resampler. This is wrong. Need to instead update it on a per MP3 frame basis. Also broken for cases when 3110 | // the sample rate is being reduced in my testing. Should work fine when the input and output sample rate is the same 3111 | // or a clean multiple. 3112 | pMP3->src.algo.linear.alpha = 3113 | pMP3->currentPCMFrame * ((double) pMP3->src.config.sampleRateIn / pMP3->src.config.sampleRateOut); 3114 | pMP3->src.algo.linear.alpha = pMP3->src.algo.linear.alpha - (drmp3_uint32) (pMP3->src.algo.linear.alpha); 3115 | if (pMP3->src.algo.linear.alpha > 0) { 3116 | pMP3->src.algo.linear.isPrevFramesLoaded = 1; 3117 | } 3118 | 3119 | // Now at this point we can follow the same process as the brute force technique where we just skip over unnecessary MP3 frames and then 3120 | // read-and-discard at least 2 whole MP3 frames. 3121 | drmp3_uint64 leftoverFrames = frameIndex - pMP3->currentPCMFrame; 3122 | return drmp3_seek_forward_by_pcm_frames__brute_force(pMP3, leftoverFrames); 3123 | } 3124 | 3125 | drmp3_bool32 drmp3_seek_to_pcm_frame(drmp3 *pMP3, drmp3_uint64 frameIndex) { 3126 | if (pMP3 == NULL || pMP3->onSeek == NULL) { 3127 | return DRMP3_FALSE; 3128 | } 3129 | 3130 | if (frameIndex == 0) { 3131 | return drmp3_seek_to_start_of_stream(pMP3); 3132 | } 3133 | 3134 | // Use the seek table if we have one. 3135 | if (pMP3->pSeekPoints != NULL && pMP3->seekPointCount > 0) { 3136 | return drmp3_seek_to_pcm_frame__seek_table(pMP3, frameIndex); 3137 | } else { 3138 | return drmp3_seek_to_pcm_frame__brute_force(pMP3, frameIndex); 3139 | } 3140 | } 3141 | 3142 | drmp3_bool32 3143 | drmp3_get_mp3_and_pcm_frame_count(drmp3 *pMP3, drmp3_uint64 *pMP3FrameCount, drmp3_uint64 *pPCMFrameCount) { 3144 | if (pMP3 == NULL) { 3145 | return DRMP3_FALSE; 3146 | } 3147 | 3148 | // The way this works is we move back to the start of the stream, iterate over each MP3 frame and calculate the frame count based 3149 | // on our output sample rate, the seek back to the PCM frame we were sitting on before calling this function. 3150 | 3151 | // The stream must support seeking for this to work. 3152 | if (pMP3->onSeek == NULL) { 3153 | return DRMP3_FALSE; 3154 | } 3155 | 3156 | // We'll need to seek back to where we were, so grab the PCM frame we're currently sitting on so we can restore later. 3157 | drmp3_uint64 currentPCMFrame = pMP3->currentPCMFrame; 3158 | 3159 | if (!drmp3_seek_to_start_of_stream(pMP3)) { 3160 | return DRMP3_FALSE; 3161 | } 3162 | 3163 | drmp3_uint64 totalPCMFrameCount = 0; 3164 | drmp3_uint64 totalMP3FrameCount = 0; 3165 | 3166 | float totalPCMFrameCountFractionalPart = 0; // <-- With resampling there will be a fractional part to each MP3 frame that we need to accumulate. 3167 | for (;;) { 3168 | drmp3_uint32 pcmFramesInCurrentMP3FrameIn = drmp3_decode_next_frame_ex(pMP3, NULL, DRMP3_FALSE); 3169 | if (pcmFramesInCurrentMP3FrameIn == 0) { 3170 | break; 3171 | } 3172 | 3173 | float srcRatio = (float) pMP3->mp3FrameSampleRate / (float) pMP3->sampleRate; 3174 | drmp3_assert(srcRatio > 0); 3175 | 3176 | float pcmFramesInCurrentMP3FrameOutF = 3177 | totalPCMFrameCountFractionalPart + (pcmFramesInCurrentMP3FrameIn / srcRatio); 3178 | drmp3_uint32 pcmFramesInCurrentMP3FrameOut = (drmp3_uint32) pcmFramesInCurrentMP3FrameOutF; 3179 | totalPCMFrameCountFractionalPart = pcmFramesInCurrentMP3FrameOutF - pcmFramesInCurrentMP3FrameOut; 3180 | totalPCMFrameCount += pcmFramesInCurrentMP3FrameOut; 3181 | totalMP3FrameCount += 1; 3182 | } 3183 | 3184 | // Finally, we need to seek back to where we were. 3185 | if (!drmp3_seek_to_start_of_stream(pMP3)) { 3186 | return DRMP3_FALSE; 3187 | } 3188 | 3189 | if (!drmp3_seek_to_pcm_frame(pMP3, currentPCMFrame)) { 3190 | return DRMP3_FALSE; 3191 | } 3192 | 3193 | if (pMP3FrameCount != NULL) { 3194 | *pMP3FrameCount = totalMP3FrameCount; 3195 | } 3196 | if (pPCMFrameCount != NULL) { 3197 | *pPCMFrameCount = totalPCMFrameCount; 3198 | } 3199 | 3200 | return DRMP3_TRUE; 3201 | } 3202 | 3203 | drmp3_uint64 drmp3_get_pcm_frame_count(drmp3 *pMP3) { 3204 | drmp3_uint64 totalPCMFrameCount; 3205 | if (!drmp3_get_mp3_and_pcm_frame_count(pMP3, NULL, &totalPCMFrameCount)) { 3206 | return 0; 3207 | } 3208 | 3209 | return totalPCMFrameCount; 3210 | } 3211 | 3212 | drmp3_uint64 drmp3_get_mp3_frame_count(drmp3 *pMP3) { 3213 | drmp3_uint64 totalMP3FrameCount; 3214 | if (!drmp3_get_mp3_and_pcm_frame_count(pMP3, &totalMP3FrameCount, NULL)) { 3215 | return 0; 3216 | } 3217 | 3218 | return totalMP3FrameCount; 3219 | } 3220 | 3221 | void drmp3__accumulate_running_pcm_frame_count(drmp3 *pMP3, drmp3_uint32 pcmFrameCountIn, 3222 | drmp3_uint64 *pRunningPCMFrameCount, 3223 | float *pRunningPCMFrameCountFractionalPart) { 3224 | float srcRatio = (float) pMP3->mp3FrameSampleRate / (float) pMP3->sampleRate; 3225 | drmp3_assert(srcRatio > 0); 3226 | 3227 | float pcmFrameCountOutF = *pRunningPCMFrameCountFractionalPart + (pcmFrameCountIn / srcRatio); 3228 | drmp3_uint32 pcmFrameCountOut = (drmp3_uint32) pcmFrameCountOutF; 3229 | *pRunningPCMFrameCountFractionalPart = pcmFrameCountOutF - pcmFrameCountOut; 3230 | *pRunningPCMFrameCount += pcmFrameCountOut; 3231 | } 3232 | 3233 | typedef struct { 3234 | drmp3_uint64 bytePos; 3235 | drmp3_uint64 pcmFrameIndex; // <-- After sample rate conversion. 3236 | } drmp3__seeking_mp3_frame_info; 3237 | 3238 | drmp3_bool32 drmp3_calculate_seek_points(drmp3 *pMP3, drmp3_uint32 *pSeekPointCount, drmp3_seek_point *pSeekPoints) { 3239 | if (pMP3 == NULL || pSeekPointCount == NULL || pSeekPoints == NULL) { 3240 | return DRMP3_FALSE; // Invalid args. 3241 | } 3242 | 3243 | drmp3_uint32 seekPointCount = *pSeekPointCount; 3244 | if (seekPointCount == 0) { 3245 | return DRMP3_FALSE; // The client has requested no seek points. Consider this to be invalid arguments since the client has probably not intended this. 3246 | } 3247 | 3248 | // We'll need to seek back to the current sample after calculating the seekpoints so we need to go ahead and grab the current location at the top. 3249 | drmp3_uint64 currentPCMFrame = pMP3->currentPCMFrame; 3250 | 3251 | // We never do more than the total number of MP3 frames and we limit it to 32-bits. 3252 | drmp3_uint64 totalMP3FrameCount; 3253 | drmp3_uint64 totalPCMFrameCount; 3254 | if (!drmp3_get_mp3_and_pcm_frame_count(pMP3, &totalMP3FrameCount, &totalPCMFrameCount)) { 3255 | return DRMP3_FALSE; 3256 | } 3257 | 3258 | // If there's less than DRMP3_SEEK_LEADING_MP3_FRAMES+1 frames we just report 1 seek point which will be the very start of the stream. 3259 | if (totalMP3FrameCount < DRMP3_SEEK_LEADING_MP3_FRAMES + 1) { 3260 | seekPointCount = 1; 3261 | pSeekPoints[0].seekPosInBytes = 0; 3262 | pSeekPoints[0].pcmFrameIndex = 0; 3263 | pSeekPoints[0].mp3FramesToDiscard = 0; 3264 | pSeekPoints[0].pcmFramesToDiscard = 0; 3265 | } else { 3266 | if (seekPointCount > totalMP3FrameCount - 1) { 3267 | seekPointCount = (drmp3_uint32) totalMP3FrameCount - 1; 3268 | } 3269 | 3270 | drmp3_uint64 pcmFramesBetweenSeekPoints = totalPCMFrameCount / (seekPointCount + 1); 3271 | 3272 | // Here is where we actually calculate the seek points. We need to start by moving the start of the stream. We then enumerate over each 3273 | // MP3 frame. 3274 | if (!drmp3_seek_to_start_of_stream(pMP3)) { 3275 | return DRMP3_FALSE; 3276 | } 3277 | 3278 | // We need to cache the byte positions of the previous MP3 frames. As a new MP3 frame is iterated, we cycle the byte positions in this 3279 | // array. The value in the first item in this array is the byte position that will be reported in the next seek point. 3280 | drmp3__seeking_mp3_frame_info mp3FrameInfo[DRMP3_SEEK_LEADING_MP3_FRAMES + 1]; 3281 | 3282 | drmp3_uint64 runningPCMFrameCount = 0; 3283 | float runningPCMFrameCountFractionalPart = 0; 3284 | 3285 | // We need to initialize the array of MP3 byte positions for the leading MP3 frames. 3286 | for (int iMP3Frame = 0; iMP3Frame < DRMP3_SEEK_LEADING_MP3_FRAMES + 1; ++iMP3Frame) { 3287 | // The byte position of the next frame will be the stream's cursor position, minus whatever is sitting in the buffer. 3288 | drmp3_assert(pMP3->streamCursor >= pMP3->dataSize); 3289 | mp3FrameInfo[iMP3Frame].bytePos = pMP3->streamCursor - pMP3->dataSize; 3290 | mp3FrameInfo[iMP3Frame].pcmFrameIndex = runningPCMFrameCount; 3291 | 3292 | // We need to get information about this frame so we can know how many samples it contained. 3293 | drmp3_uint32 pcmFramesInCurrentMP3FrameIn = drmp3_decode_next_frame_ex(pMP3, NULL, DRMP3_FALSE); 3294 | if (pcmFramesInCurrentMP3FrameIn == 0) { 3295 | return DRMP3_FALSE; // This should never happen. 3296 | } 3297 | 3298 | drmp3__accumulate_running_pcm_frame_count(pMP3, pcmFramesInCurrentMP3FrameIn, &runningPCMFrameCount, 3299 | &runningPCMFrameCountFractionalPart); 3300 | } 3301 | 3302 | // At this point we will have extracted the byte positions of the leading MP3 frames. We can now start iterating over each seek point and 3303 | // calculate them. 3304 | drmp3_uint64 nextTargetPCMFrame = 0; 3305 | for (drmp3_uint32 iSeekPoint = 0; iSeekPoint < seekPointCount; ++iSeekPoint) { 3306 | nextTargetPCMFrame += pcmFramesBetweenSeekPoints; 3307 | 3308 | for (;;) { 3309 | if (nextTargetPCMFrame < runningPCMFrameCount) { 3310 | // The next seek point is in the current MP3 frame. 3311 | pSeekPoints[iSeekPoint].seekPosInBytes = mp3FrameInfo[0].bytePos; 3312 | pSeekPoints[iSeekPoint].pcmFrameIndex = nextTargetPCMFrame; 3313 | pSeekPoints[iSeekPoint].mp3FramesToDiscard = DRMP3_SEEK_LEADING_MP3_FRAMES; 3314 | pSeekPoints[iSeekPoint].pcmFramesToDiscard = (drmp3_uint16) (nextTargetPCMFrame - mp3FrameInfo[ 3315 | DRMP3_SEEK_LEADING_MP3_FRAMES - 1].pcmFrameIndex); 3316 | break; 3317 | } else { 3318 | // The next seek point is not in the current MP3 frame, so continue on to the next one. The first thing to do is cycle the cached 3319 | // MP3 frame info. 3320 | for (size_t i = 0; i < drmp3_countof(mp3FrameInfo) - 1; ++i) { 3321 | mp3FrameInfo[i] = mp3FrameInfo[i + 1]; 3322 | } 3323 | 3324 | // Cache previous MP3 frame info. 3325 | mp3FrameInfo[drmp3_countof(mp3FrameInfo) - 1].bytePos = pMP3->streamCursor - pMP3->dataSize; 3326 | mp3FrameInfo[drmp3_countof(mp3FrameInfo) - 1].pcmFrameIndex = runningPCMFrameCount; 3327 | 3328 | // Go to the next MP3 frame. This shouldn't ever fail, but just in case it does we just set the seek point and break. If it happens, it 3329 | // should only ever do it for the last seek point. 3330 | drmp3_uint32 pcmFramesInCurrentMP3FrameIn = drmp3_decode_next_frame_ex(pMP3, NULL, DRMP3_TRUE); 3331 | if (pcmFramesInCurrentMP3FrameIn == 0) { 3332 | pSeekPoints[iSeekPoint].seekPosInBytes = mp3FrameInfo[0].bytePos; 3333 | pSeekPoints[iSeekPoint].pcmFrameIndex = nextTargetPCMFrame; 3334 | pSeekPoints[iSeekPoint].mp3FramesToDiscard = DRMP3_SEEK_LEADING_MP3_FRAMES; 3335 | pSeekPoints[iSeekPoint].pcmFramesToDiscard = (drmp3_uint16) (nextTargetPCMFrame - mp3FrameInfo[ 3336 | DRMP3_SEEK_LEADING_MP3_FRAMES - 1].pcmFrameIndex); 3337 | break; 3338 | } 3339 | 3340 | drmp3__accumulate_running_pcm_frame_count(pMP3, pcmFramesInCurrentMP3FrameIn, &runningPCMFrameCount, 3341 | &runningPCMFrameCountFractionalPart); 3342 | } 3343 | } 3344 | } 3345 | 3346 | // Finally, we need to seek back to where we were. 3347 | if (!drmp3_seek_to_start_of_stream(pMP3)) { 3348 | return DRMP3_FALSE; 3349 | } 3350 | if (!drmp3_seek_to_pcm_frame(pMP3, currentPCMFrame)) { 3351 | return DRMP3_FALSE; 3352 | } 3353 | } 3354 | 3355 | *pSeekPointCount = seekPointCount; 3356 | return DRMP3_TRUE; 3357 | } 3358 | 3359 | drmp3_bool32 drmp3_bind_seek_table(drmp3 *pMP3, drmp3_uint32 seekPointCount, drmp3_seek_point *pSeekPoints) { 3360 | if (pMP3 == NULL) { 3361 | return DRMP3_FALSE; 3362 | } 3363 | 3364 | if (seekPointCount == 0 || pSeekPoints == NULL) { 3365 | // Unbinding. 3366 | pMP3->seekPointCount = 0; 3367 | pMP3->pSeekPoints = NULL; 3368 | } else { 3369 | // Binding. 3370 | pMP3->seekPointCount = seekPointCount; 3371 | pMP3->pSeekPoints = pSeekPoints; 3372 | } 3373 | 3374 | return DRMP3_TRUE; 3375 | } 3376 | 3377 | 3378 | float *drmp3__full_read_and_close_f32(drmp3 *pMP3, drmp3_config *pConfig, drmp3_uint64 *pTotalFrameCount) { 3379 | drmp3_assert(pMP3 != NULL); 3380 | 3381 | drmp3_uint64 totalFramesRead = 0; 3382 | drmp3_uint64 framesCapacity = 0; 3383 | float *pFrames = NULL; 3384 | 3385 | float temp[4096]; 3386 | for (;;) { 3387 | drmp3_uint64 framesToReadRightNow = drmp3_countof(temp) / pMP3->channels; 3388 | drmp3_uint64 framesJustRead = drmp3_read_pcm_frames_f32(pMP3, framesToReadRightNow, temp); 3389 | if (framesJustRead == 0) { 3390 | break; 3391 | } 3392 | 3393 | // Reallocate the output buffer if there's not enough room. 3394 | if (framesCapacity < totalFramesRead + framesJustRead) { 3395 | framesCapacity *= 2; 3396 | if (framesCapacity < totalFramesRead + framesJustRead) { 3397 | framesCapacity = totalFramesRead + framesJustRead; 3398 | } 3399 | 3400 | drmp3_uint64 newFramesBufferSize = framesCapacity * pMP3->channels * sizeof(float); 3401 | if (newFramesBufferSize > DRMP3_SIZE_MAX) { 3402 | break; 3403 | } 3404 | 3405 | float *pNewFrames = (float *) drmp3_realloc(pFrames, (size_t) newFramesBufferSize); 3406 | if (pNewFrames == NULL) { 3407 | drmp3_free(pFrames); 3408 | break; 3409 | } 3410 | 3411 | pFrames = pNewFrames; 3412 | } 3413 | 3414 | drmp3_copy_memory(pFrames + totalFramesRead * pMP3->channels, temp, 3415 | (size_t) (framesJustRead * pMP3->channels * sizeof(float))); 3416 | totalFramesRead += framesJustRead; 3417 | 3418 | // If the number of frames we asked for is less that what we actually read it means we've reached the end. 3419 | if (framesJustRead != framesToReadRightNow) { 3420 | break; 3421 | } 3422 | } 3423 | 3424 | if (pConfig != NULL) { 3425 | pConfig->outputChannels = pMP3->channels; 3426 | pConfig->outputSampleRate = pMP3->sampleRate; 3427 | } 3428 | 3429 | drmp3_uninit(pMP3); 3430 | 3431 | if (pTotalFrameCount) *pTotalFrameCount = totalFramesRead; 3432 | return pFrames; 3433 | } 3434 | 3435 | float *drmp3_open_and_read_f32(drmp3_read_proc onRead, drmp3_seek_proc onSeek, void *pUserData, drmp3_config *pConfig, 3436 | drmp3_uint64 *pTotalFrameCount) { 3437 | drmp3 mp3; 3438 | if (!drmp3_init(&mp3, onRead, onSeek, pUserData, pConfig)) { 3439 | return NULL; 3440 | } 3441 | 3442 | return drmp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount); 3443 | } 3444 | 3445 | float *drmp3_open_memory_and_read_f32(const void *pData, size_t dataSize, drmp3_config *pConfig, 3446 | drmp3_uint64 *pTotalFrameCount) { 3447 | drmp3 mp3; 3448 | if (!drmp3_init_memory(&mp3, pData, dataSize, pConfig)) { 3449 | return NULL; 3450 | } 3451 | 3452 | return drmp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount); 3453 | } 3454 | 3455 | #ifndef DR_MP3_NO_STDIO 3456 | 3457 | float *drmp3_open_file_and_read_f32(const char *filePath, drmp3_config *pConfig, drmp3_uint64 *pTotalFrameCount) { 3458 | drmp3 mp3; 3459 | if (!drmp3_init_file(&mp3, filePath, pConfig)) { 3460 | return NULL; 3461 | } 3462 | 3463 | return drmp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount); 3464 | } 3465 | 3466 | #endif 3467 | 3468 | void drmp3_free(void *p) { 3469 | DRMP3_FREE(p); 3470 | } 3471 | 3472 | #endif /*DR_MP3_IMPLEMENTATION*/ 3473 | 3474 | 3475 | // DIFFERENCES BETWEEN minimp3 AND dr_mp3 3476 | // ====================================== 3477 | // - First, keep in mind that minimp3 (https://github.com/lieff/minimp3) is where all the real work was done. All of the 3478 | // code relating to the actual decoding remains mostly unmodified, apart from some namespacing changes. 3479 | // - dr_mp3 adds a pulling style API which allows you to deliver raw data via callbacks. So, rather than pushing data 3480 | // to the decoder, the decoder _pulls_ data from your callbacks. 3481 | // - In addition to callbacks, a decoder can be initialized from a block of memory and a file. 3482 | // - The dr_mp3 pull API reads PCM frames rather than whole MP3 frames. 3483 | // - dr_mp3 adds convenience APIs for opening and decoding entire files in one go. 3484 | // - dr_mp3 is fully namespaced, including the implementation section, which is more suitable when compiling projects 3485 | // as a single translation unit (aka unity builds). At the time of writing this, a unity build is not possible when 3486 | // using minimp3 in conjunction with stb_vorbis. dr_mp3 addresses this. 3487 | 3488 | 3489 | // REVISION HISTORY 3490 | // ================ 3491 | // 3492 | // v0.4.1 - 2018-12-30 3493 | // - Fix a warning. 3494 | // 3495 | // v0.4.0 - 2018-12-16 3496 | // - API CHANGE: Rename some APIs: 3497 | // - drmp3_read_f32 -> to drmp3_read_pcm_frames_f32 3498 | // - drmp3_seek_to_frame -> drmp3_seek_to_pcm_frame 3499 | // - drmp3_open_and_decode_f32 -> drmp3_open_and_read_f32 3500 | // - drmp3_open_and_decode_memory_f32 -> drmp3_open_memory_and_read_f32 3501 | // - drmp3_open_and_decode_file_f32 -> drmp3_open_file_and_read_f32 3502 | // - Add drmp3_get_pcm_frame_count(). 3503 | // - Add drmp3_get_mp3_frame_count(). 3504 | // - Improve seeking performance. 3505 | // 3506 | // v0.3.2 - 2018-09-11 3507 | // - Fix a couple of memory leaks. 3508 | // - Bring up to date with minimp3. 3509 | // 3510 | // v0.3.1 - 2018-08-25 3511 | // - Fix C++ build. 3512 | // 3513 | // v0.3.0 - 2018-08-25 3514 | // - Bring up to date with minimp3. This has a minor API change: the "pcm" parameter of drmp3dec_decode_frame() has 3515 | // been changed from short* to void* because it can now output both s16 and f32 samples, depending on whether or 3516 | // not the DR_MP3_FLOAT_OUTPUT option is set. 3517 | // 3518 | // v0.2.11 - 2018-08-08 3519 | // - Fix a bug where the last part of a file is not read. 3520 | // 3521 | // v0.2.10 - 2018-08-07 3522 | // - Improve 64-bit detection. 3523 | // 3524 | // v0.2.9 - 2018-08-05 3525 | // - Fix C++ build on older versions of GCC. 3526 | // - Bring up to date with minimp3. 3527 | // 3528 | // v0.2.8 - 2018-08-02 3529 | // - Fix compilation errors with older versions of GCC. 3530 | // 3531 | // v0.2.7 - 2018-07-13 3532 | // - Bring up to date with minimp3. 3533 | // 3534 | // v0.2.6 - 2018-07-12 3535 | // - Bring up to date with minimp3. 3536 | // 3537 | // v0.2.5 - 2018-06-22 3538 | // - Bring up to date with minimp3. 3539 | // 3540 | // v0.2.4 - 2018-05-12 3541 | // - Bring up to date with minimp3. 3542 | // 3543 | // v0.2.3 - 2018-04-29 3544 | // - Fix TCC build. 3545 | // 3546 | // v0.2.2 - 2018-04-28 3547 | // - Fix bug when opening a decoder from memory. 3548 | // 3549 | // v0.2.1 - 2018-04-27 3550 | // - Efficiency improvements when the decoder reaches the end of the stream. 3551 | // 3552 | // v0.2 - 2018-04-21 3553 | // - Bring up to date with minimp3. 3554 | // - Start using major.minor.revision versioning. 3555 | // 3556 | // v0.1d - 2018-03-30 3557 | // - Bring up to date with minimp3. 3558 | // 3559 | // v0.1c - 2018-03-11 3560 | // - Fix C++ build error. 3561 | // 3562 | // v0.1b - 2018-03-07 3563 | // - Bring up to date with minimp3. 3564 | // 3565 | // v0.1a - 2018-02-28 3566 | // - Fix compilation error on GCC/Clang. 3567 | // - Fix some warnings. 3568 | // 3569 | // v0.1 - 2018-02-xx 3570 | // - Initial versioned release. 3571 | 3572 | 3573 | /* 3574 | This is free and unencumbered software released into the public domain. 3575 | 3576 | Anyone is free to copy, modify, publish, use, compile, sell, or 3577 | distribute this software, either in source code form or as a compiled 3578 | binary, for any purpose, commercial or non-commercial, and by any 3579 | means. 3580 | 3581 | In jurisdictions that recognize copyright laws, the author or authors 3582 | of this software dedicate any and all copyright interest in the 3583 | software to the public domain. We make this dedication for the benefit 3584 | of the public at large and to the detriment of our heirs and 3585 | successors. We intend this dedication to be an overt act of 3586 | relinquishment in perpetuity of all present and future rights to this 3587 | software under copyright law. 3588 | 3589 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 3590 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 3591 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 3592 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 3593 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 3594 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 3595 | OTHER DEALINGS IN THE SOFTWARE. 3596 | 3597 | For more information, please refer to 3598 | */ 3599 | 3600 | /* 3601 | https://github.com/lieff/minimp3 3602 | To the extent possible under law, the author(s) have dedicated all copyright and related and neighboring rights to this software to the public domain worldwide. 3603 | This software is distributed without any warranty. 3604 | See . 3605 | */ -------------------------------------------------------------------------------- /main.c: -------------------------------------------------------------------------------- 1 | #ifdef __cplusplus 2 | extern "C" { 3 | #endif 4 | #define _CRT_SECURE_NO_WARNINGS 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | #define DR_WAV_IMPLEMENTATION 11 | 12 | #include "dr_wav.h" 13 | 14 | #define DR_MP3_IMPLEMENTATION 15 | 16 | 17 | #include "dr_mp3.h" 18 | 19 | #include "timing.h" 20 | 21 | 22 | void wavWrite_f32(char *filename, float *buffer, int sampleRate, uint32_t totalSampleCount, uint32_t channels) { 23 | drwav_data_format format; 24 | format.container = drwav_container_riff; 25 | format.format = DR_WAVE_FORMAT_IEEE_FLOAT; 26 | format.channels = channels; 27 | format.sampleRate = (drwav_uint32) sampleRate; 28 | format.bitsPerSample = 32; 29 | drwav *pWav = drwav_open_file_write(filename, &format); 30 | if (pWav) { 31 | drwav_uint64 samplesWritten = drwav_write(pWav, totalSampleCount, buffer); 32 | drwav_uninit(pWav); 33 | if (samplesWritten != totalSampleCount) { 34 | fprintf(stderr, "write file [%s] error.\n", filename); 35 | exit(1); 36 | } 37 | } 38 | } 39 | 40 | float *wavRead_f32(const char *filename, uint32_t *sampleRate, uint64_t *sampleCount, uint32_t *channels) { 41 | drwav_uint64 totalSampleCount = 0; 42 | float *input = drwav_open_file_and_read_pcm_frames_f32(filename, channels, sampleRate, &totalSampleCount); 43 | if (input == NULL) { 44 | drmp3_config pConfig; 45 | input = drmp3_open_file_and_read_f32(filename, &pConfig, &totalSampleCount); 46 | if (input != NULL) { 47 | *channels = pConfig.outputChannels; 48 | *sampleRate = pConfig.outputSampleRate; 49 | } 50 | } 51 | if (input == NULL) { 52 | fprintf(stderr, "read file [%s] error.\n", filename); 53 | exit(1); 54 | } 55 | *sampleCount = totalSampleCount * (*channels); 56 | return input; 57 | } 58 | 59 | 60 | void splitpath(const char *path, char *drv, char *dir, char *name, char *ext) { 61 | const char *end; 62 | const char *p; 63 | const char *s; 64 | if (path[0] && path[1] == ':') { 65 | if (drv) { 66 | *drv++ = *path++; 67 | *drv++ = *path++; 68 | *drv = '\0'; 69 | } 70 | } else if (drv) 71 | *drv = '\0'; 72 | for (end = path; *end && *end != ':';) 73 | end++; 74 | for (p = end; p > path && *--p != '\\' && *p != '/';) 75 | if (*p == '.') { 76 | end = p; 77 | break; 78 | } 79 | if (ext) 80 | for (s = end; (*ext = *s++);) 81 | ext++; 82 | for (p = end; p > path;) 83 | if (*--p == '\\' || *p == '/') { 84 | p++; 85 | break; 86 | } 87 | if (name) { 88 | for (s = p; s < end;) 89 | *name++ = *s++; 90 | *name = '\0'; 91 | } 92 | if (dir) { 93 | for (s = path; s < p;) 94 | *dir++ = *s++; 95 | *dir = '\0'; 96 | } 97 | } 98 | 99 | 100 | uint64_t Resample_f32(const float *input, float *output, int inSampleRate, int outSampleRate, uint64_t inputSize, 101 | uint32_t channels) { 102 | if (input == NULL) 103 | return 0; 104 | 105 | uint64_t outputSize = (uint64_t) (inputSize * (double) outSampleRate / (double) inSampleRate); 106 | outputSize -= outputSize % channels; 107 | 108 | if (output == NULL) 109 | return outputSize; 110 | 111 | double stepDist = ((double) inSampleRate / (double) outSampleRate); 112 | const uint64_t fixedFraction = (1LL << 32); 113 | const double normFixed = (1.0 / (1LL << 32)); 114 | uint64_t step = ((uint64_t) (stepDist * fixedFraction + 0.5)); 115 | uint64_t curOffset = 0; 116 | 117 | for (uint32_t i = 0; i < outputSize - channels; i += channels) { 118 | uint64_t currentPos = curOffset >> 32; 119 | uint64_t nextPos = currentPos + 1; 120 | for (uint32_t c = 0; c < channels; c++) { 121 | float current = input[currentPos * channels + c]; 122 | float next = input[nextPos * channels + c]; 123 | double frac = (curOffset & (fixedFraction - 1)) * normFixed; 124 | *output++ = (float) (current + (next - current) * frac); 125 | } 126 | curOffset += step; 127 | uint64_t frameSkip = (curOffset >> 32); 128 | curOffset &= (fixedFraction - 1); 129 | input += frameSkip * channels; 130 | } 131 | uint64_t lastPos = (curOffset >> 32); 132 | for (uint32_t c = 0; c < channels; c++) { 133 | *output++ = input[lastPos * channels + c]; 134 | } 135 | return outputSize; 136 | } 137 | 138 | uint64_t Resample_s16(const int16_t *input, int16_t *output, int inSampleRate, int outSampleRate, uint64_t inputSize, 139 | uint32_t channels) { 140 | if (input == NULL) 141 | return 0; 142 | 143 | uint64_t outputSize = (uint64_t) (inputSize * (double) outSampleRate / (double) inSampleRate); 144 | outputSize -= outputSize % channels; 145 | 146 | if (output == NULL) 147 | return outputSize; 148 | 149 | double stepDist = ((double) inSampleRate / (double) outSampleRate); 150 | const uint64_t fixedFraction = (1LL << 32); 151 | const double normFixed = (1.0 / (1LL << 32)); 152 | uint64_t step = ((uint64_t) (stepDist * fixedFraction + 0.5)); 153 | uint64_t curOffset = 0; 154 | 155 | for (uint32_t i = 0; i < outputSize - channels; i += channels) { 156 | uint64_t currentPos = curOffset >> 32; 157 | uint64_t nextPos = currentPos + 1; 158 | for (uint32_t c = 0; c < channels; c++) { 159 | int16_t current = input[currentPos * channels + c]; 160 | int16_t next = input[nextPos * channels + c]; 161 | double frac = (curOffset & (fixedFraction - 1)) * normFixed; 162 | *output++ = (int16_t) (current + (next - current) * frac); 163 | } 164 | curOffset += step; 165 | uint64_t frameSkip = (curOffset >> 32); 166 | curOffset &= (fixedFraction - 1); 167 | input += frameSkip * channels; 168 | } 169 | uint64_t lastPos = (curOffset >> 32); 170 | for (uint32_t c = 0; c < channels; c++) { 171 | *output++ = input[lastPos * channels + c]; 172 | } 173 | return outputSize; 174 | } 175 | 176 | void printUsage() { 177 | printf("usage:\n"); 178 | printf("./Resampler input.wav 48000\n"); 179 | printf("./Resampler input.mp3 16000\n"); 180 | printf("or\n"); 181 | printf("./Resampler input.wav output.wav 8000\n"); 182 | printf("./Resampler input.mp3 output.wav 44100\n"); 183 | printf("press any key to exit.\n"); 184 | getchar(); 185 | } 186 | 187 | void resampler(char *in_file, char *out_file, uint32_t targetSampleRate) { 188 | if (targetSampleRate == 0) { 189 | printUsage(); 190 | return; 191 | } 192 | uint32_t sampleRate = 0; 193 | uint64_t sampleCount = 0; 194 | uint32_t channels = 0; 195 | float *input = wavRead_f32(in_file, &sampleRate, &sampleCount, &channels); 196 | uint64_t targetSampleCount = Resample_f32(input, NULL, sampleRate, targetSampleRate, sampleCount, channels); 197 | if (input) { 198 | float *output = (float *) malloc(targetSampleCount * sizeof(float)); 199 | if (output) { 200 | double startTime = now(); 201 | Resample_f32(input, output, sampleRate, targetSampleRate, sampleCount / channels, channels); 202 | double time_interval = calcElapsed(startTime, now()); 203 | printf("time interval: %f ms\n ", (time_interval * 1000)); 204 | wavWrite_f32(out_file, output, targetSampleRate, (uint32_t) targetSampleCount, channels); 205 | free(output); 206 | } 207 | free(input); 208 | } 209 | } 210 | 211 | 212 | int main(int argc, char *argv[]) { 213 | printf("Audio Processing\n"); 214 | printf("blog:http://cpuimage.cnblogs.com/\n"); 215 | printf("Audio Resampler\n"); 216 | if (argc < 3) { 217 | printUsage(); 218 | return -1; 219 | } 220 | char *in_file = argv[1]; 221 | if (argc > 3) { 222 | char *out_file = argv[2]; 223 | uint32_t targetSampleRate = (uint32_t) atoi(argv[3]); 224 | resampler(in_file, out_file, targetSampleRate); 225 | } else { 226 | uint32_t targetSampleRate = (uint32_t) atoi(argv[2]); 227 | char drive[3]; 228 | char dir[256]; 229 | char fname[256]; 230 | char ext[256]; 231 | char out_file[1024]; 232 | splitpath(in_file, drive, dir, fname, ext); 233 | sprintf(out_file, "%s%s%s_out.wav", drive, dir, fname); 234 | resampler(in_file, out_file, targetSampleRate); 235 | } 236 | 237 | return 0; 238 | } 239 | 240 | #ifdef __cplusplus 241 | } 242 | #endif 243 | -------------------------------------------------------------------------------- /timing.h: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | #if defined(__APPLE__) 5 | # include 6 | #elif defined(_WIN32) 7 | # define WIN32_LEAN_AND_MEAN 8 | 9 | # include 10 | 11 | #else // __linux 12 | 13 | # include 14 | 15 | # ifndef CLOCK_MONOTONIC //_RAW 16 | # define CLOCK_MONOTONIC CLOCK_REALTIME 17 | # endif 18 | #endif 19 | 20 | static 21 | uint64_t nanotimer() { 22 | static int ever = 0; 23 | #if defined(__APPLE__) 24 | static mach_timebase_info_data_t frequency; 25 | if (!ever) { 26 | if (mach_timebase_info(&frequency) != KERN_SUCCESS) { 27 | return 0; 28 | } 29 | ever = 1; 30 | } 31 | return (mach_absolute_time() * frequency.numer / frequency.denom); 32 | #elif defined(_WIN32) 33 | static LARGE_INTEGER frequency; 34 | if (!ever) { 35 | QueryPerformanceFrequency(&frequency); 36 | ever = 1; 37 | } 38 | LARGE_INTEGER t; 39 | QueryPerformanceCounter(&t); 40 | return (t.QuadPart * (uint64_t) 1e9) / frequency.QuadPart; 41 | #else // __linux 42 | struct timespec t; 43 | if (!ever) { 44 | if (clock_gettime(CLOCK_MONOTONIC, &t) != 0) { 45 | return 0; 46 | } 47 | ever = 1; 48 | } 49 | clock_gettime(CLOCK_MONOTONIC, &t); 50 | return (t.tv_sec * (uint64_t) 1e9) + t.tv_nsec; 51 | #endif 52 | } 53 | 54 | 55 | static double now() { 56 | static uint64_t epoch = 0; 57 | if (!epoch) { 58 | epoch = nanotimer(); 59 | } 60 | return (nanotimer() - epoch) / 1e9; 61 | }; 62 | 63 | static double calcElapsed(double start, double end) { 64 | double took = -start; 65 | return took + end; 66 | } --------------------------------------------------------------------------------