#ifdef MINIMP3_TEST

static int malloc_num = 0, fail_malloc_num = -1;

#include <stdio.h>

#include <stdlib.h>

#include <sys/mman.h>

static void *local_malloc(size_t size)

{

/*printf("%d malloc(%d)\n", malloc_num, (int)size);*/

if (fail_malloc_num == malloc_num)

return 0;

malloc_num++;

return malloc(size);

}

#define malloc local_malloc

void *local_realloc(void *ptr, size_t new_size)

{

/*printf("%d realloc(%d)\n", malloc_num, (int)new_size);*/

if (fail_malloc_num == malloc_num)

return 0;

malloc_num++;

return realloc(ptr, new_size);

}

#define realloc local_realloc

void *local_mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)

{

/*printf("%d mmap(%d)\n", malloc_num, (int)length);*/

if (fail_malloc_num == malloc_num)

return MAP_FAILED;

malloc_num++;

return mmap(addr, length, prot, flags, fd, offset);

}

#define mmap local_mmap

#endif

/*#define MINIMP3_ONLY_MP3*/

/*#define MINIMP3_ONLY_SIMD*/

/*#define MINIMP3_NONSTANDARD_BUT_LOGICAL*/

#define MINIMP3_IMPLEMENTATION

#define MINIMP3_ALLOW_MONO_STEREO_TRANSITION

#include "minimp3_ex.h"

#include <stdio.h>

#include <math.h>

#include <string.h>

#include <time.h>

#if defined(_MSC_VER)

#define strcasecmp(str1, str2) _strnicmp(str1, str2, strlen(str2))

#else

#include <strings.h>

#endif

#define MODE_LOAD 0

#define MODE_LOAD_BUF 1

#define MODE_LOAD_CB 2

#define MODE_ITERATE 3

#define MODE_ITERATE_BUF 4

#define MODE_ITERATE_CB 5

#define MODE_STREAM 6

#define MODE_STREAM_BUF 7

#define MODE_STREAM_CB 8

#define MODE_DETECT 9

#define MODE_DETECT_BUF 10

#define MODE_DETECT_CB 11

static int16_t read16le(const void *p)

{

const uint8_t *src = (const uint8_t *)p;

return ((src[0]) << 0) | ((src[1]) << 8);

}

#ifndef MINIMP3_NO_WAV

static char *wav_header(int hz, int ch, int bips, int data_bytes)

{

static char hdr[44] = "RIFFsizeWAVEfmt \x10\0\0\0\1\0ch_hz_abpsbabsdatasize";

unsigned long nAvgBytesPerSec = bips*ch*hz >> 3;

unsigned int nBlockAlign = bips*ch >> 3;

*(int32_t *)(void*)(hdr + 0x04) = 44 + data_bytes - 8; /* File size - 8 */

*(int16_t *)(void*)(hdr + 0x14) = 1; /* Integer PCM format */

*(int16_t *)(void*)(hdr + 0x16) = ch;

*(int32_t *)(void*)(hdr + 0x18) = hz;

*(int32_t *)(void*)(hdr + 0x1C) = nAvgBytesPerSec;

*(int16_t *)(void*)(hdr + 0x20) = nBlockAlign;

*(int16_t *)(void*)(hdr + 0x22) = bips;

*(int32_t *)(void*)(hdr + 0x28) = data_bytes;

return hdr;

}

#endif

static unsigned char *preload(FILE *file, int *data_size)

{

unsigned char *data;

*data_size = 0;

if (!file)

return 0;

if (fseek(file, 0, SEEK_END))

return 0;

*data_size = (int)ftell(file);

if (*data_size < 0)

return 0;

if (fseek(file, 0, SEEK_SET))

return 0;

data = (unsigned char*)malloc(*data_size);

#define FAIL_MEM(data) \

if (!(data)) \

{ \

printf("error: not enough memory\n"); \

exit(1); \

}

FAIL_MEM(data);

if ((int)fread(data, 1, *data_size, file) != *data_size)

exit(1);

return data;

}

static int io_num, fail_io_num = -1;

static int wave_out = 0, mode = 0, position = 0, portion = 0, seek_to_byte = 0;

static size_t read_cb(void *buf, size_t size, void *user_data)

{

/*printf("%d read_cb(%d)\n", io_num, (int)size);*/

if (fail_io_num == io_num++)

return -1;

return fread(buf, 1, size, (FILE*)user_data);

}

static int seek_cb(uint64_t position, void *user_data)

{

/*printf("%d seek_cb(%d)\n", io_num, (int)position);*/

if (fail_io_num == io_num++)

return -1;

return fseek((FILE*)user_data, position, SEEK_SET);

}

typedef struct

{

mp3dec_t *mp3d;

mp3dec_file_info_t *info;

size_t allocated;

} frames_iterate_data;

static int frames_iterate_cb(void *user_data, const uint8_t *frame, int frame_size, int free_format_bytes, size_t buf_size, uint64_t offset, mp3dec_frame_info_t *info)

{

(void)buf_size;

(void)offset;

(void)free_format_bytes;

frames_iterate_data *d = user_data;

d->info->channels = info->channels;

d->info->hz = info->hz;

d->info->layer = info->layer;

/*printf("%d %d %d\n", frame_size, (int)offset, info->channels);*/

if ((d->allocated - d->info->samples*sizeof(mp3d_sample_t)) < MINIMP3_MAX_SAMPLES_PER_FRAME*sizeof(mp3d_sample_t))

{

if (!d->allocated)

d->allocated = 1024*1024;

else

d->allocated *= 2;

mp3d_sample_t *alloc_buf = realloc(d->info->buffer, d->allocated);

if (!alloc_buf)

return MP3D_E_MEMORY;

d->info->buffer = alloc_buf;

}

int samples = mp3dec_decode_frame(d->mp3d, frame, frame_size, d->info->buffer + d->info->samples, info);

if (samples)

{

d->info->samples += samples*info->channels;

}

return 0;

}

static int progress_cb(void *user_data, size_t file_size, uint64_t offset, mp3dec_frame_info_t *info)

{

(void)user_data;

(void)file_size;

(void)offset;

(void)info;

return MP3D_E_USER;

}

static void decode_file(const char *input_file_name, const unsigned char *buf_ref, int ref_size, FILE *file_out)

{

mp3dec_t mp3d;

int i, res = -1, data_bytes, total_samples = 0, maxdiff = 0;

int no_std_vec = strstr(input_file_name, "nonstandard") || strstr(input_file_name, "ILL");

uint8_t *buf = 0;

double MSE = 0.0, psnr;

mp3dec_io_t io;

mp3dec_file_info_t info;

memset(&info, 0, sizeof(info));

io.read = read_cb;

io.seek = seek_cb;

if (MODE_LOAD == mode)

{

res = mp3dec_load(&mp3d, input_file_name, &info, 0, 0);

} else if (MODE_LOAD_BUF == mode)

{

int size = 0;

FILE *file = fopen(input_file_name, "rb");

uint8_t *buf = preload(file, &size);

fclose(file);

res = buf ? mp3dec_load_buf(&mp3d, buf, size, &info, 0, 0) : MP3D_E_IOERROR;

free(buf);

} else if (MODE_LOAD_CB == mode)

{

uint8_t *io_buf = malloc(MINIMP3_IO_SIZE);

FAIL_MEM(io_buf);

FILE *file = fopen(input_file_name, "rb");

io.read_data = io.seek_data = file;

res = file ? mp3dec_load_cb(&mp3d, &io, io_buf, MINIMP3_IO_SIZE, &info, 0, 0) : MP3D_E_IOERROR;

fclose((FILE*)io.read_data);

free(io_buf);

} else if (MODE_ITERATE == mode)

{

frames_iterate_data d = { &mp3d, &info, 0 };

mp3dec_init(&mp3d);

res = mp3dec_iterate(input_file_name, frames_iterate_cb, &d);

} else if (MODE_ITERATE_BUF == mode)

{

int size = 0;

FILE *file = fopen(input_file_name, "rb");

uint8_t *buf = preload(file, &size);

fclose(file);

frames_iterate_data d = { &mp3d, &info, 0 };

mp3dec_init(&mp3d);

res = buf ? mp3dec_iterate_buf(buf, size, frames_iterate_cb, &d) : MP3D_E_IOERROR;

free(buf);

} else if (MODE_ITERATE_CB == mode)

{

uint8_t *io_buf = malloc(MINIMP3_IO_SIZE);

FAIL_MEM(io_buf);

FILE *file = fopen(input_file_name, "rb");

io.read_data = io.seek_data = file;

frames_iterate_data d = { &mp3d, &info, 0 };

mp3dec_init(&mp3d);

res = file ? mp3dec_iterate_cb(&io, io_buf, MINIMP3_IO_SIZE, frames_iterate_cb, &d) : MP3D_E_IOERROR;

fclose((FILE*)io.read_data);

free(io_buf);

} else if (MODE_STREAM == mode || MODE_STREAM_BUF == mode || MODE_STREAM_CB == mode)

{

mp3dec_ex_t dec;

size_t readed;

if (MODE_STREAM == mode)

{

res = mp3dec_ex_open(&dec, input_file_name, (seek_to_byte ? MP3D_SEEK_TO_BYTE : MP3D_SEEK_TO_SAMPLE) | MP3D_ALLOW_MONO_STEREO_TRANSITION);

} else if (MODE_STREAM_BUF == mode)

{

int size = 0;

FILE *file = fopen(input_file_name, "rb");

buf = preload(file, &size);

fclose(file);

res = buf ? mp3dec_ex_open_buf(&dec, buf, size, (seek_to_byte ? MP3D_SEEK_TO_BYTE : MP3D_SEEK_TO_SAMPLE) | MP3D_ALLOW_MONO_STEREO_TRANSITION) : MP3D_E_IOERROR;

} else if (MODE_STREAM_CB == mode)

{

FILE *file = fopen(input_file_name, "rb");

io.read_data = io.seek_data = file;

res = file ? mp3dec_ex_open_cb(&dec, &io, (seek_to_byte ? MP3D_SEEK_TO_BYTE : MP3D_SEEK_TO_SAMPLE) | MP3D_ALLOW_MONO_STEREO_TRANSITION) : MP3D_E_IOERROR;

}

if (res)

{

printf("error: mp3dec_ex_open()=%d failed\n", res);

exit(1);

}

info.samples = dec.samples;

info.buffer = malloc(dec.samples*sizeof(mp3d_sample_t));

FAIL_MEM(info.buffer);

info.hz = dec.info.hz;

info.layer = dec.info.layer;

info.channels = dec.info.channels;

if (position < 0 && -2 != position)

{

#ifdef _WIN32

LARGE_INTEGER t;

QueryPerformanceCounter(&t);

srand(t.QuadPart);

#else

srand(time(0));

#endif

position = info.samples > 500 ? (uint64_t)(info.samples - 500)*rand()/RAND_MAX : 0;

printf("info: seek to %d/%d\n", position, (int)info.samples);

}

if (position)

{

if (-2 == position)

position = 0;

if (!seek_to_byte)

{

info.samples -= MINIMP3_MIN(info.samples, (size_t)position);

int skip_ref = MINIMP3_MIN((size_t)ref_size, position*sizeof(int16_t));

buf_ref += skip_ref;

ref_size -= skip_ref;

}

res = mp3dec_ex_seek(&dec, position);

if (res)

{

printf("error: mp3dec_ex_seek()=%d failed\n", res);

exit(1);

}

}

if (portion < 0)

{

portion = (uint64_t)(info.samples + 150)*rand()/RAND_MAX;

printf("info: read by %d samples\n", portion);

}

if (0 == portion)

portion = info.samples;

int samples = info.samples, samples_readed = 0;

while (samples)

{

int to_read = MINIMP3_MIN(samples, portion);

readed = mp3dec_ex_read(&dec, info.buffer + samples_readed, portion);

samples -= readed;

samples_readed += readed;

if (readed != (size_t)to_read)

{

if (seek_to_byte && readed < (size_t)to_read)

break;

printf("error: mp3dec_ex_read() readed less than expected, last_error=%d\n", dec.last_error);

exit(1);

}

}

readed = mp3dec_ex_read(&dec, info.buffer, 1);

if (readed)

{

printf("error: mp3dec_ex_read() readed more than expected, last_error=%d\n", dec.last_error);

exit(1);

}

if (seek_to_byte)

{

info.samples = samples_readed;

}

mp3dec_ex_close(&dec);

if (MODE_STREAM_BUF == mode && buf)

free(buf);

if (MODE_STREAM_CB == mode)

fclose((FILE*)io.read_data);

} else if (MODE_DETECT == mode || MODE_DETECT_BUF == mode || MODE_DETECT_CB == mode)

{

if (MODE_DETECT == mode)

{

res = mp3dec_detect(input_file_name);

} else if (MODE_DETECT_BUF == mode)

{

int size = 0;

FILE *file = fopen(input_file_name, "rb");

buf = preload(file, &size);

fclose(file);

res = buf ? mp3dec_detect_buf(buf, size) : MP3D_E_IOERROR;

} else if (MODE_DETECT_CB == mode)

{

uint8_t *io_buf = malloc(MINIMP3_BUF_SIZE);

FAIL_MEM(io_buf);

FILE *file = fopen(input_file_name, "rb");

io.read_data = io.seek_data = file;

res = file ? mp3dec_detect_cb(&io, io_buf, MINIMP3_BUF_SIZE) : MP3D_E_IOERROR;

free(io_buf);

}

if (MP3D_E_USER == res)

{

printf("info: not an mp3/mpa file\n");

exit(1);

} else if (res)

{

printf("error: mp3dec_detect*()=%d failed\n", res);

exit(1);

}

printf("info: mp3/mpa file detected\n");

exit(0);

} else

{

printf("error: unknown mode\n");

exit(1);

}

if (res && MP3D_E_DECODE != res)

{

printf("error: read function failed, code=%d\n", res);

exit(1);

}

#ifdef MINIMP3_FLOAT_OUTPUT

int16_t *buffer = malloc(info.samples*sizeof(int16_t));

FAIL_MEM(buffer);

mp3dec_f32_to_s16(info.buffer, buffer, info.samples);

free(info.buffer);

#else

int16_t *buffer = info.buffer;

#endif

#ifndef MINIMP3_NO_WAV

if (wave_out && file_out)

fwrite(wav_header(0, 0, 0, 0), 1, 44, file_out);

#endif

total_samples += info.samples;

if (buf_ref)

{

size_t ref_samples = ref_size/2;

int len_match = ref_samples == info.samples;

int relaxed_len_match = len_match || (ref_samples + 1152) == info.samples || (ref_samples + 2304) == info.samples;

int seek_len_match = (ref_samples <= info.samples) || (ref_samples + 2304) >= info.samples;

if ((((!relaxed_len_match && MODE_STREAM != mode && MODE_STREAM_BUF != mode && MODE_STREAM_CB != mode) || !seek_len_match) && (3 == info.layer || 0 == info.layer) && !no_std_vec) || (no_std_vec && !len_match))

{ /* some standard vectors are for some reason a little shorter */

printf("error: reference and produced number of samples do not match (%d/%d)\n", (int)ref_samples, (int)info.samples);

exit(1);

}

int max_samples = MINIMP3_MIN(ref_samples, info.samples);

for (i = 0; i < max_samples; i++)

{

int MSEtemp = abs((int)buffer[i] - (int)(int16_t)read16le(&buf_ref[i*sizeof(int16_t)]));

if (MSEtemp > maxdiff)

maxdiff = MSEtemp;

MSE += (float)MSEtemp*(float)MSEtemp;

}

}

if (file_out)

fwrite(buffer, info.samples, sizeof(int16_t), file_out);

if (buffer)

free(buffer);

#ifndef LIBFUZZER

MSE /= total_samples ? total_samples : 1;

if (0 == MSE)

psnr = 99.0;

else

psnr = 10.0*log10(((double)0x7fff*0x7fff)/MSE);

printf("rate=%d samples=%d max_diff=%d PSNR=%f\n", info.hz, total_samples, maxdiff, psnr);

if (psnr < 96)

{

printf("error: PSNR compliance failed\n");

exit(1);

}

#endif

#ifndef MINIMP3_NO_WAV

if (wave_out && file_out)

{

data_bytes = ftell(file_out) - 44;

rewind(file_out);

fwrite(wav_header(info.hz, info.channels, 16, data_bytes), 1, 44, file_out);

}

#endif

}

static int self_test(const char *input_file_name)

{

int ret, size = 0;

mp3dec_t mp3d;

mp3dec_ex_t dec;

mp3dec_frame_info_t frame_info;

mp3dec_file_info_t finfo;

mp3dec_io_t io;

FILE *file = fopen(input_file_name, "rb");

uint8_t *buf = preload(file, &size);

fclose(file);

int samples = mp3dec_decode_frame(&mp3d, buf, size, 0, &frame_info);

free(buf);

#define ASSERT(c) if (!(c)) { printf("failed, line=%d\n", __LINE__); exit(1); }

ASSERT(1152 == samples);

ret = mp3dec_detect_buf(0, size);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_detect_buf(buf, (size_t)-1);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_buf(0, buf, size, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_buf(&mp3d, 0, size, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_buf(&mp3d, buf, (size_t)-1, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_buf(&mp3d, buf, size, 0, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

memset(&finfo, 0xff, sizeof(finfo));

ret = mp3dec_load_buf(&mp3d, buf, 0, &finfo, 0, 0);

ASSERT(0 == ret && 0 == finfo.samples);

ret = mp3dec_detect_cb(&io, 0, size);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_detect_cb(&io, buf, (size_t)-1);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_cb(0, &io, buf, size, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_cb(&mp3d, &io, 0, size, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_cb(&mp3d, &io, buf, (size_t)-1, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_cb(&mp3d, &io, buf, size, 0, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load_cb(&mp3d, &io, buf, 0, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_buf(0, size, frames_iterate_cb, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_buf(buf, (size_t)-1, frames_iterate_cb, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_buf(buf, size, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_buf(buf, 0, frames_iterate_cb, 0);

ASSERT(0 == ret);

ret = mp3dec_iterate_cb(0, buf, size, frames_iterate_cb, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_cb(&io, 0, size, frames_iterate_cb, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_cb(&io, buf, (size_t)-1, frames_iterate_cb, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_cb(&io, buf, size, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate_cb(&io, buf, 0, frames_iterate_cb, 0);

ASSERT(MP3D_E_PARAM == ret);

memset(&dec, 0, sizeof(dec));

ret = mp3dec_ex_seek(&dec, 10); /* seek with zero initialized decoder - no-op without fail */

ASSERT(0 == ret);

ret = mp3dec_ex_read(&dec, (mp3d_sample_t*)buf, 10); /* read with zero initialized decoder - reads zero samples */

ASSERT(0 == ret);

mp3dec_ex_close(&dec); /* close zero initialized decoder - should not crash */

ret = mp3dec_ex_open_buf(0, buf, size, MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open_buf(&dec, 0, size, MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open_buf(&dec, buf, (size_t)-1, MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open_buf(&dec, buf, size, MP3D_SEEK_TO_SAMPLE | (MP3D_FLAGS_MASK + 1));

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open_buf(&dec, buf, 0, MP3D_SEEK_TO_SAMPLE);

ASSERT(0 == ret);

ret = mp3dec_ex_read(&dec, (mp3d_sample_t*)buf, 10);

ASSERT(0 == ret);

mp3dec_ex_close(&dec);

{

/* Regression: out-of-range sample seek must not corrupt to_skip and crash in mp3dec_ex_read(). */

static const uint8_t seek_oob_buf[] = {

0xff,0xfd,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0xa5,0xce,0xa7,0x8b,0xff,0xff,0x00,0x00,0x00,0x00,

0x47,0x45,0x58,0x00,0xff,0xfd,0x18,0xd6,0x64,0x41,

0xae,0xce,0xd6,0x97,0x8a,0x4e,0x18,0x8b,0x82,0xff,

0xfd,0x18,0xd6,0x45,0x54,0x18,0x8b,0x82,0x47,0x45,

0x58,0x00,0xff,0xfd,0x18,0xd6,0x64,0x41,0x50,0x45,

0x54,0x41,0x01,0x18,0xd6,0x64,0x41,0x50,0x45,0x54,

0x41,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x23,0xff,

0xfd,0x18,0xd6,0x64,0x41,0x50,0x45,0x54,0x41,0x47,

0x45,0x58,0x00,0xff,0xfd,0x18,0xd6

};

mp3d_sample_t pcm[MINIMP3_MAX_SAMPLES_PER_FRAME];

size_t r, total = 0;

ret = mp3dec_ex_open_buf(&dec, seek_oob_buf, sizeof(seek_oob_buf), MP3D_SEEK_TO_SAMPLE | MP3D_ALLOW_MONO_STEREO_TRANSITION);

ASSERT(0 == ret);

do

{

r = mp3dec_ex_read(&dec, pcm, MINIMP3_MAX_SAMPLES_PER_FRAME);

total += r;

} while (r);

ASSERT(2304 == total);

ret = mp3dec_ex_seek(&dec, 3888454656ULL);

ASSERT(0 == ret);

r = mp3dec_ex_read(&dec, pcm, MINIMP3_MAX_SAMPLES_PER_FRAME);

ASSERT(0 == r);

mp3dec_ex_close(&dec);

}

ret = mp3dec_ex_open_cb(0, &io, MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open_cb(&dec, 0, MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open_cb(&dec, &io, MP3D_SEEK_TO_SAMPLE | (MP3D_FLAGS_MASK + 1));

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_seek(0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_read(0, (mp3d_sample_t*)buf, 10);

ASSERT(0 == ret); /* invalid param case, no decoder structure to report an error */

ret = mp3dec_ex_read(&dec, 0, 10);

ASSERT(0 == ret && MP3D_E_PARAM == dec.last_error); /* invalid param case */

ret = mp3dec_ex_read_frame(0, (mp3d_sample_t**)buf, &frame_info, 10);

ASSERT(0 == ret); /* invalid param case, no decoder structure to report an error */

ret = mp3dec_ex_read_frame(&dec, 0, &frame_info, 10);

ASSERT(0 == ret && MP3D_E_PARAM == dec.last_error); /* invalid param case */

ret = mp3dec_ex_read_frame(&dec, (mp3d_sample_t**)buf, 0, 10);

ASSERT(0 == ret && MP3D_E_PARAM == dec.last_error); /* invalid param case */

ret = mp3dec_load(0, input_file_name, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load(&mp3d, 0, &finfo, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load(&mp3d, input_file_name, 0, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_load(&mp3d, "not_foud", &finfo, 0, 0);

ASSERT(MP3D_E_IOERROR == ret);

memset(&mp3d, 0xff, sizeof(mp3d));

memset(&finfo, 0xff, sizeof(finfo));

ret = mp3dec_load(&mp3d, input_file_name, &finfo, progress_cb, 0);

ASSERT(MP3D_E_USER == ret && 2304 == finfo.samples && 44100 == finfo.hz && 2 == finfo.channels && 3 == finfo.layer);

ASSERT(NULL != finfo.buffer);

free(finfo.buffer);

ret = mp3dec_iterate(0, frames_iterate_cb, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate(input_file_name, 0, 0);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_iterate("not_foud", frames_iterate_cb, 0);

ASSERT(MP3D_E_IOERROR == ret);

ret = mp3dec_ex_open(0, input_file_name, MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open(&dec, 0, MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open(&dec, input_file_name, MP3D_SEEK_TO_SAMPLE | (MP3D_FLAGS_MASK + 1));

ASSERT(MP3D_E_PARAM == ret);

ret = mp3dec_ex_open(&dec, "not_foud", MP3D_SEEK_TO_SAMPLE);

ASSERT(MP3D_E_IOERROR == ret);

file = fopen(input_file_name, "rb");

io.read = read_cb;

io.seek = seek_cb;

io.read_data = io.seek_data = file;

ret = mp3dec_ex_open_cb(&dec, &io, MP3D_SEEK_TO_SAMPLE);

ASSERT(0 == ret);

ASSERT(5 == io_num);

ASSERT(725760 == dec.samples); /* num samples detected */

fail_io_num = 5;

mp3d_sample_t sample;

size_t readed = mp3dec_ex_read(&dec, &sample, 1);

ASSERT(0 == readed);

ASSERT(MP3D_E_IOERROR == dec.last_error);

readed = mp3dec_ex_read(&dec, &sample, 1);

ASSERT(0 == readed);

ASSERT(MP3D_E_IOERROR == dec.last_error); /* stays in error state */

ret = mp3dec_ex_seek(&dec, 0);

ASSERT(0 == ret);

ASSERT(0 == dec.last_error); /* error state reset */

readed = mp3dec_ex_read(&dec, &sample, 1);

ASSERT(1 == readed);

mp3dec_ex_close(&dec);

ret = mp3dec_ex_open_cb(&dec, &io, MP3D_SEEK_TO_SAMPLE | MP3D_DO_NOT_SCAN);

ASSERT(0 == ret);

ASSERT(0 == dec.samples); /* num samples do not detected because of MP3D_DO_NOT_SCAN */

readed = mp3dec_ex_read(&dec, &sample, 1);

ASSERT(1 == readed);

mp3dec_ex_close(&dec);

fclose((FILE*)io.read_data);

printf("passed\n");

return 0;

}

#ifdef LIBFUZZER

int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size)

{

decode_file(Data, Size, 0, 0, 0, 0);

return 0;

}

#else

#if defined(__arm__) || defined(__aarch64__) || defined(__PPC__)

int main2(int argc, char *argv[]);

int main2(int argc, char *argv[])

#else

int main(int argc, char *argv[])

#endif

{

int i, ref_size, do_self_test = 0;

for(i = 1; i < argc; i++)

{

if (argv[i][0] != '-')

break;

switch (argv[i][1])

{

case 'm': i++; if (i < argc) mode = atoi(argv[i]); break;

case 's': i++; if (i < argc) position = atoi(argv[i]); break;

case 'p': i++; if (i < argc) portion = atoi(argv[i]); break;

case 'e': i++; if (i < argc) fail_io_num = atoi(argv[i]); break;

#ifdef MINIMP3_TEST

case 'f': i++; if (i < argc) fail_malloc_num = atoi(argv[i]); break;

#endif

case 'b': seek_to_byte = 1; break;

case 't': do_self_test = 1; break;

default:

printf("error: unrecognized option\n");

return 1;

}

}

char *ref_file_name = (argc > (i + 1)) ? argv[i + 1] : NULL;

char *output_file_name = (argc > (i + 2)) ? argv[i + 2] : NULL;

FILE *file_out = NULL;

if (output_file_name)

{

file_out = fopen(output_file_name, "wb");

#ifndef MINIMP3_NO_WAV

char *ext = strrchr(output_file_name, '.');

if (ext && !strcasecmp(ext + 1, "wav"))

wave_out = 1;

#endif

}

FILE *file_ref = ref_file_name ? fopen(ref_file_name, "rb") : NULL;

unsigned char *buf_ref = preload(file_ref, &ref_size);

if (file_ref)

fclose(file_ref);

#ifdef __AFL_HAVE_MANUAL_CONTROL

__AFL_INIT();

while (__AFL_LOOP(1000)) {

#endif

char *input_file_name = (argc > i) ? argv[i] : NULL;

if (!input_file_name)

{

printf("error: no file names given\n");

return 1;

}

if (do_self_test)

return self_test(input_file_name);

decode_file(input_file_name, buf_ref, ref_size, file_out);

#ifdef __AFL_HAVE_MANUAL_CONTROL

}

#endif

if (buf_ref)

free(buf_ref);

if (file_out)

fclose(file_out);

return 0;

}

#if defined(__arm__) || defined(__aarch64__) || defined(__PPC__)

static const char *g_files[] = {

"vectors/ILL2_center2.bit",

"vectors/ILL2_dual.bit",

"vectors/ILL2_dynx22.bit",

"vectors/ILL2_dynx31.bit",

"vectors/ILL2_dynx32.bit",

"vectors/ILL2_ext_switching.bit",

"vectors/ILL2_layer1.bit",

"vectors/ILL2_layer3.bit",

"vectors/ILL2_mono.bit",

"vectors/ILL2_multilingual.bit",

"vectors/ILL2_overalloc1.bit",

"vectors/ILL2_overalloc2.bit",

"vectors/ILL2_prediction.bit",

"vectors/ILL2_samples.bit",

"vectors/ILL2_scf63.bit",

"vectors/ILL2_tca21.bit",

"vectors/ILL2_tca30.bit",

"vectors/ILL2_tca30_PC.bit",

"vectors/ILL2_tca31_mtx0.bit",

"vectors/ILL2_tca31_mtx2.bit",

"vectors/ILL2_tca31_PC.bit",

"vectors/ILL2_tca32_PC.bit",

"vectors/ILL2_wrongcrc.bit",

"vectors/ILL4_ext_id1.bit",

"vectors/ILL4_sync.bit",

"vectors/ILL4_wrongcrc.bit",

"vectors/ILL4_wrong_length1.bit",

"vectors/ILL4_wrong_length2.bit",

"vectors/l1-fl1.bit",

"vectors/l1-fl2.bit",

"vectors/l1-fl3.bit",

"vectors/l1-fl4.bit",

"vectors/l1-fl5.bit",

"vectors/l1-fl6.bit",

"vectors/l1-fl7.bit",

"vectors/l1-fl8.bit",

"vectors/l2-fl10.bit",

"vectors/l2-fl11.bit",

"vectors/l2-fl12.bit",

"vectors/l2-fl13.bit",

"vectors/l2-fl14.bit",

"vectors/l2-fl15.bit",

"vectors/l2-fl16.bit",

"vectors/l2-nonstandard-fl1_fl2_ff.bit",

"vectors/l2-nonstandard-free_format.bit",

"vectors/l2-nonstandard-test32-size.bit",

"vectors/l2-test32.bit",

"vectors/l3-compl.bit",

"vectors/l3-he_32khz.bit",

"vectors/l3-he_44khz.bit",

"vectors/l3-he_48khz.bit",

"vectors/l3-hecommon.bit",

"vectors/l3-he_free.bit",

"vectors/l3-he_mode.bit",

"vectors/l3-nonstandard-big-iscf.bit",

"vectors/l3-nonstandard-compl-sideinfo-bigvalues.bit",

"vectors/l3-nonstandard-compl-sideinfo-blocktype.bit",

"vectors/l3-nonstandard-compl-sideinfo-size.bit",

"vectors/l3-nonstandard-sideinfo-size.bit",

"vectors/l3-nonstandard-vbrtag-oob-read.bit",

"vectors/l3-si.bit",

"vectors/l3-si_block.bit",

"vectors/l3-si_huff.bit",

"vectors/l3-sin1k0db.bit",

"vectors/l3-test45.bit",

"vectors/l3-test46.bit",

"vectors/M2L3_bitrate_16_all.bit",

"vectors/M2L3_bitrate_22_all.bit",

"vectors/M2L3_bitrate_24_all.bit",

"vectors/M2L3_compl24.bit",

"vectors/M2L3_noise.bit"

};

int main()

{

size_t i;

char buf[256];

char *v[3];

v[2] = buf;

for (i = 0; i < sizeof(g_files)/sizeof(g_files[0]); i++)

{

int ret;

const char *file = g_files[i];

size_t len = strlen(file);

strcpy(buf, file);

buf[len - 3] = 'p';

buf[len - 2] = 'c';

buf[len - 1] = 'm';

v[1] = (char*)file;

printf("%s\n", file);

ret = main2(3, v);

if (ret)

return ret;

}

return 0;

}

#endif

#endif