cannam@154: /* Copyright (c) 2011-2013 Xiph.Org Foundation
cannam@154:    Written by Gregory Maxwell */
cannam@154: /*
cannam@154:    Redistribution and use in source and binary forms, with or without
cannam@154:    modification, are permitted provided that the following conditions
cannam@154:    are met:
cannam@154: 
cannam@154:    - Redistributions of source code must retain the above copyright
cannam@154:    notice, this list of conditions and the following disclaimer.
cannam@154: 
cannam@154:    - Redistributions in binary form must reproduce the above copyright
cannam@154:    notice, this list of conditions and the following disclaimer in the
cannam@154:    documentation and/or other materials provided with the distribution.
cannam@154: 
cannam@154:    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
cannam@154:    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
cannam@154:    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
cannam@154:    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
cannam@154:    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
cannam@154:    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
cannam@154:    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
cannam@154:    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
cannam@154:    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
cannam@154:    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
cannam@154:    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
cannam@154: */
cannam@154: 
cannam@154: #ifdef HAVE_CONFIG_H
cannam@154: #include "config.h"
cannam@154: #endif
cannam@154: 
cannam@154: #include <stdio.h>
cannam@154: #include <stdlib.h>
cannam@154: #include <limits.h>
cannam@154: #include <stdint.h>
cannam@154: #include <math.h>
cannam@154: #include <string.h>
cannam@154: #include <time.h>
cannam@154: #if (!defined WIN32 && !defined _WIN32) || defined(__MINGW32__)
cannam@154: #include <unistd.h>
cannam@154: #else
cannam@154: #include <process.h>
cannam@154: #define getpid _getpid
cannam@154: #endif
cannam@154: #include "opus_multistream.h"
cannam@154: #include "opus.h"
cannam@154: #include "../src/opus_private.h"
cannam@154: #include "test_opus_common.h"
cannam@154: 
cannam@154: #define MAX_PACKET (1500)
cannam@154: #define SAMPLES (48000*30)
cannam@154: #define SSAMPLES (SAMPLES/3)
cannam@154: #define MAX_FRAME_SAMP (5760)
cannam@154: #define PI (3.141592653589793238462643f)
cannam@154: #define RAND_SAMPLE(a) (a[fast_rand() % sizeof(a)/sizeof(a[0])])
cannam@154: 
cannam@154: void generate_music(short *buf, opus_int32 len)
cannam@154: {
cannam@154:    opus_int32 a1,b1,a2,b2;
cannam@154:    opus_int32 c1,c2,d1,d2;
cannam@154:    opus_int32 i,j;
cannam@154:    a1=b1=a2=b2=0;
cannam@154:    c1=c2=d1=d2=0;
cannam@154:    j=0;
cannam@154:    /*60ms silence*/
cannam@154:    for(i=0;i<2880;i++)buf[i*2]=buf[i*2+1]=0;
cannam@154:    for(i=2880;i<len;i++)
cannam@154:    {
cannam@154:      opus_uint32 r;
cannam@154:      opus_int32 v1,v2;
cannam@154:      v1=v2=(((j*((j>>12)^((j>>10|j>>12)&26&j>>7)))&128)+128)<<15;
cannam@154:      r=fast_rand();v1+=r&65535;v1-=r>>16;
cannam@154:      r=fast_rand();v2+=r&65535;v2-=r>>16;
cannam@154:      b1=v1-a1+((b1*61+32)>>6);a1=v1;
cannam@154:      b2=v2-a2+((b2*61+32)>>6);a2=v2;
cannam@154:      c1=(30*(c1+b1+d1)+32)>>6;d1=b1;
cannam@154:      c2=(30*(c2+b2+d2)+32)>>6;d2=b2;
cannam@154:      v1=(c1+128)>>8;
cannam@154:      v2=(c2+128)>>8;
cannam@154:      buf[i*2]=v1>32767?32767:(v1<-32768?-32768:v1);
cannam@154:      buf[i*2+1]=v2>32767?32767:(v2<-32768?-32768:v2);
cannam@154:      if(i%6==0)j++;
cannam@154:    }
cannam@154: }
cannam@154: 
cannam@154: #if 0
cannam@154: static int save_ctr = 0;
cannam@154: static void int_to_char(opus_uint32 i, unsigned char ch[4])
cannam@154: {
cannam@154:     ch[0] = i>>24;
cannam@154:     ch[1] = (i>>16)&0xFF;
cannam@154:     ch[2] = (i>>8)&0xFF;
cannam@154:     ch[3] = i&0xFF;
cannam@154: }
cannam@154: 
cannam@154: static OPUS_INLINE void save_packet(unsigned char* p, int len, opus_uint32 rng)
cannam@154: {
cannam@154:    FILE *fout;
cannam@154:    unsigned char int_field[4];
cannam@154:    char name[256];
cannam@154:    snprintf(name,255,"test_opus_encode.%llu.%d.bit",(unsigned long long)iseed,save_ctr);
cannam@154:    fprintf(stdout,"writing %d byte packet to %s\n",len,name);
cannam@154:    fout=fopen(name, "wb+");
cannam@154:    if(fout==NULL)test_failed();
cannam@154:    int_to_char(len, int_field);
cannam@154:    fwrite(int_field, 1, 4, fout);
cannam@154:    int_to_char(rng, int_field);
cannam@154:    fwrite(int_field, 1, 4, fout);
cannam@154:    fwrite(p, 1, len, fout);
cannam@154:    fclose(fout);
cannam@154:    save_ctr++;
cannam@154: }
cannam@154: #endif
cannam@154: 
cannam@154: int get_frame_size_enum(int frame_size, int sampling_rate)
cannam@154: {
cannam@154:    int frame_size_enum;
cannam@154: 
cannam@154:    if(frame_size==sampling_rate/400)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_2_5_MS;
cannam@154:    else if(frame_size==sampling_rate/200)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_5_MS;
cannam@154:    else if(frame_size==sampling_rate/100)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_10_MS;
cannam@154:    else if(frame_size==sampling_rate/50)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_20_MS;
cannam@154:    else if(frame_size==sampling_rate/25)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_40_MS;
cannam@154:    else if(frame_size==3*sampling_rate/50)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_60_MS;
cannam@154:    else if(frame_size==4*sampling_rate/50)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_80_MS;
cannam@154:    else if(frame_size==5*sampling_rate/50)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_100_MS;
cannam@154:    else if(frame_size==6*sampling_rate/50)
cannam@154:       frame_size_enum = OPUS_FRAMESIZE_120_MS;
cannam@154:    else
cannam@154:       test_failed();
cannam@154: 
cannam@154:    return frame_size_enum;
cannam@154: }
cannam@154: 
cannam@154: void test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *dec, const char* debug_info)
cannam@154: {
cannam@154:    int samp_count = 0;
cannam@154:    opus_int16 *inbuf;
cannam@154:    unsigned char packet[MAX_PACKET+257];
cannam@154:    int len;
cannam@154:    opus_int16 *outbuf;
cannam@154:    int out_samples;
cannam@154: 
cannam@154:    /* Generate input data */
cannam@154:    inbuf = (opus_int16*)malloc(sizeof(*inbuf)*SSAMPLES);
cannam@154:    generate_music(inbuf, SSAMPLES/2);
cannam@154: 
cannam@154:    /* Allocate memory for output data */
cannam@154:    outbuf = (opus_int16*)malloc(sizeof(*outbuf)*MAX_FRAME_SAMP*3);
cannam@154: 
cannam@154:    /* Encode data, then decode for sanity check */
cannam@154:    do {
cannam@154:       len = opus_encode(enc, &inbuf[samp_count*channels], frame_size, packet, MAX_PACKET);
cannam@154:       if(len<0 || len>MAX_PACKET) {
cannam@154:          fprintf(stderr,"%s\n",debug_info);
cannam@154:          fprintf(stderr,"opus_encode() returned %d\n",len);
cannam@154:          test_failed();
cannam@154:       }
cannam@154: 
cannam@154:       out_samples = opus_decode(dec, packet, len, outbuf, MAX_FRAME_SAMP, 0);
cannam@154:       if(out_samples!=frame_size) {
cannam@154:          fprintf(stderr,"%s\n",debug_info);
cannam@154:          fprintf(stderr,"opus_decode() returned %d\n",out_samples);
cannam@154:          test_failed();
cannam@154:       }
cannam@154: 
cannam@154:       samp_count += frame_size;
cannam@154:    } while (samp_count < ((SSAMPLES/2)-MAX_FRAME_SAMP));
cannam@154: 
cannam@154:    /* Clean up */
cannam@154:    free(inbuf);
cannam@154:    free(outbuf);
cannam@154: }
cannam@154: 
cannam@154: void fuzz_encoder_settings(const int num_encoders, const int num_setting_changes)
cannam@154: {
cannam@154:    OpusEncoder *enc;
cannam@154:    OpusDecoder *dec;
cannam@154:    int i,j,err;
cannam@154: 
cannam@154:    /* Parameters to fuzz. Some values are duplicated to increase their probability of being tested. */
cannam@154:    int sampling_rates[5] = {8000, 12000, 16000, 24000, 48000};
cannam@154:    int channels[2] = {1, 2};
cannam@154:    int applications[3] = {OPUS_APPLICATION_AUDIO, OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY};
cannam@154:    int bitrates[11] = {6000, 12000, 16000, 24000, 32000, 48000, 64000, 96000, 510000, OPUS_AUTO, OPUS_BITRATE_MAX};
cannam@154:    int force_channels[4] = {OPUS_AUTO, OPUS_AUTO, 1, 2};
cannam@154:    int use_vbr[3] = {0, 1, 1};
cannam@154:    int vbr_constraints[3] = {0, 1, 1};
cannam@154:    int complexities[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
cannam@154:    int max_bandwidths[6] = {OPUS_BANDWIDTH_NARROWBAND, OPUS_BANDWIDTH_MEDIUMBAND,
cannam@154:                             OPUS_BANDWIDTH_WIDEBAND, OPUS_BANDWIDTH_SUPERWIDEBAND,
cannam@154:                             OPUS_BANDWIDTH_FULLBAND, OPUS_BANDWIDTH_FULLBAND};
cannam@154:    int signals[4] = {OPUS_AUTO, OPUS_AUTO, OPUS_SIGNAL_VOICE, OPUS_SIGNAL_MUSIC};
cannam@154:    int inband_fecs[3] = {0, 0, 1};
cannam@154:    int packet_loss_perc[4] = {0, 1, 2, 5};
cannam@154:    int lsb_depths[2] = {8, 24};
cannam@154:    int prediction_disabled[3] = {0, 0, 1};
cannam@154:    int use_dtx[2] = {0, 1};
cannam@154:    int frame_sizes_ms_x2[9] = {5, 10, 20, 40, 80, 120, 160, 200, 240};  /* x2 to avoid 2.5 ms */
cannam@154:    char debug_info[512];
cannam@154: 
cannam@154:    for (i=0; i<num_encoders; i++) {
cannam@154:       int sampling_rate = RAND_SAMPLE(sampling_rates);
cannam@154:       int num_channels = RAND_SAMPLE(channels);
cannam@154:       int application = RAND_SAMPLE(applications);
cannam@154: 
cannam@154:       dec = opus_decoder_create(sampling_rate, num_channels, &err);
cannam@154:       if(err!=OPUS_OK || dec==NULL)test_failed();
cannam@154: 
cannam@154:       enc = opus_encoder_create(sampling_rate, num_channels, application, &err);
cannam@154:       if(err!=OPUS_OK || enc==NULL)test_failed();
cannam@154: 
cannam@154:       for (j=0; j<num_setting_changes; j++) {
cannam@154:          int bitrate = RAND_SAMPLE(bitrates);
cannam@154:          int force_channel = RAND_SAMPLE(force_channels);
cannam@154:          int vbr = RAND_SAMPLE(use_vbr);
cannam@154:          int vbr_constraint = RAND_SAMPLE(vbr_constraints);
cannam@154:          int complexity = RAND_SAMPLE(complexities);
cannam@154:          int max_bw = RAND_SAMPLE(max_bandwidths);
cannam@154:          int sig = RAND_SAMPLE(signals);
cannam@154:          int inband_fec = RAND_SAMPLE(inband_fecs);
cannam@154:          int pkt_loss = RAND_SAMPLE(packet_loss_perc);
cannam@154:          int lsb_depth = RAND_SAMPLE(lsb_depths);
cannam@154:          int pred_disabled = RAND_SAMPLE(prediction_disabled);
cannam@154:          int dtx = RAND_SAMPLE(use_dtx);
cannam@154:          int frame_size_ms_x2 = RAND_SAMPLE(frame_sizes_ms_x2);
cannam@154:          int frame_size = frame_size_ms_x2*sampling_rate/2000;
cannam@154:          int frame_size_enum = get_frame_size_enum(frame_size, sampling_rate);
cannam@154:          force_channel = IMIN(force_channel, num_channels);
cannam@154: 
cannam@154:          sprintf(debug_info,
cannam@154:                  "fuzz_encoder_settings: %d kHz, %d ch, application: %d, "
cannam@154:                  "%d bps, force ch: %d, vbr: %d, vbr constraint: %d, complexity: %d, "
cannam@154:                  "max bw: %d, signal: %d, inband fec: %d, pkt loss: %d%%, lsb depth: %d, "
cannam@154:                  "pred disabled: %d, dtx: %d, (%d/2) ms\n",
cannam@154:                  sampling_rate/1000, num_channels, application, bitrate,
cannam@154:                  force_channel, vbr, vbr_constraint, complexity, max_bw, sig, inband_fec,
cannam@154:                  pkt_loss, lsb_depth, pred_disabled, dtx, frame_size_ms_x2);
cannam@154: 
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(force_channel)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_VBR(vbr)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(vbr_constraint)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_MAX_BANDWIDTH(max_bw)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_SIGNAL(sig)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(inband_fec)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(pkt_loss)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(lsb_depth)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_PREDICTION_DISABLED(pred_disabled)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_DTX(dtx)) != OPUS_OK) test_failed();
cannam@154:          if(opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(frame_size_enum)) != OPUS_OK) test_failed();
cannam@154: 
cannam@154:          test_encode(enc, num_channels, frame_size, dec, debug_info);
cannam@154:       }
cannam@154: 
cannam@154:       opus_encoder_destroy(enc);
cannam@154:       opus_decoder_destroy(dec);
cannam@154:    }
cannam@154: }
cannam@154: 
cannam@154: int run_test1(int no_fuzz)
cannam@154: {
cannam@154:    static const int fsizes[6]={960*3,960*2,120,240,480,960};
cannam@154:    static const char *mstrings[3] = {"    LP","Hybrid","  MDCT"};
cannam@154:    unsigned char mapping[256] = {0,1,255};
cannam@154:    unsigned char db62[36];
cannam@154:    opus_int32 i,j;
cannam@154:    int rc,err;
cannam@154:    OpusEncoder *enc;
cannam@154:    OpusMSEncoder *MSenc;
cannam@154:    OpusDecoder *dec;
cannam@154:    OpusMSDecoder *MSdec;
cannam@154:    OpusMSDecoder *MSdec_err;
cannam@154:    OpusDecoder *dec_err[10];
cannam@154:    short *inbuf;
cannam@154:    short *outbuf;
cannam@154:    short *out2buf;
cannam@154:    opus_int32 bitrate_bps;
cannam@154:    unsigned char packet[MAX_PACKET+257];
cannam@154:    opus_uint32 enc_final_range;
cannam@154:    opus_uint32 dec_final_range;
cannam@154:    int fswitch;
cannam@154:    int fsize;
cannam@154:    int count;
cannam@154: 
cannam@154:   /*FIXME: encoder api tests, fs!=48k, mono, VBR*/
cannam@154: 
cannam@154:    fprintf(stdout,"  Encode+Decode tests.\n");
cannam@154: 
cannam@154:    enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err);
cannam@154:    if(err != OPUS_OK || enc==NULL)test_failed();
cannam@154: 
cannam@154:    for(i=0;i<2;i++)
cannam@154:    {
cannam@154:       int *ret_err;
cannam@154:       ret_err = i?0:&err;
cannam@154:       MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_UNIMPLEMENTED, ret_err);
cannam@154:       if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
cannam@154: 
cannam@154:       MSenc = opus_multistream_encoder_create(8000, 0, 1, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
cannam@154:       if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
cannam@154: 
cannam@154:       MSenc = opus_multistream_encoder_create(44100, 2, 2, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
cannam@154:       if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
cannam@154: 
cannam@154:       MSenc = opus_multistream_encoder_create(8000, 2, 2, 3, mapping, OPUS_APPLICATION_VOIP, ret_err);
cannam@154:       if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
cannam@154: 
cannam@154:       MSenc = opus_multistream_encoder_create(8000, 2, -1, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
cannam@154:       if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
cannam@154: 
cannam@154:       MSenc = opus_multistream_encoder_create(8000, 256, 2, 0, mapping, OPUS_APPLICATION_VOIP, ret_err);
cannam@154:       if((ret_err && *ret_err != OPUS_BAD_ARG) || MSenc!=NULL)test_failed();
cannam@154:    }
cannam@154: 
cannam@154:    MSenc = opus_multistream_encoder_create(8000, 2, 2, 0, mapping, OPUS_APPLICATION_AUDIO, &err);
cannam@154:    if(err != OPUS_OK || MSenc==NULL)test_failed();
cannam@154: 
cannam@154:    /*Some multistream encoder API tests*/
cannam@154:    if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_BITRATE(&i))!=OPUS_OK)test_failed();
cannam@154:    if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_LSB_DEPTH(&i))!=OPUS_OK)test_failed();
cannam@154:    if(i<16)test_failed();
cannam@154: 
cannam@154:    {
cannam@154:       OpusEncoder *tmp_enc;
cannam@154:       if(opus_multistream_encoder_ctl(MSenc,  OPUS_MULTISTREAM_GET_ENCODER_STATE(1,&tmp_enc))!=OPUS_OK)test_failed();
cannam@154:       if(opus_encoder_ctl(tmp_enc, OPUS_GET_LSB_DEPTH(&j))!=OPUS_OK)test_failed();
cannam@154:       if(i!=j)test_failed();
cannam@154:       if(opus_multistream_encoder_ctl(MSenc,  OPUS_MULTISTREAM_GET_ENCODER_STATE(2,&tmp_enc))!=OPUS_BAD_ARG)test_failed();
cannam@154:    }
cannam@154: 
cannam@154:    dec = opus_decoder_create(48000, 2, &err);
cannam@154:    if(err != OPUS_OK || dec==NULL)test_failed();
cannam@154: 
cannam@154:    MSdec = opus_multistream_decoder_create(48000, 2, 2, 0, mapping, &err);
cannam@154:    if(err != OPUS_OK || MSdec==NULL)test_failed();
cannam@154: 
cannam@154:    MSdec_err = opus_multistream_decoder_create(48000, 3, 2, 0, mapping, &err);
cannam@154:    if(err != OPUS_OK || MSdec_err==NULL)test_failed();
cannam@154: 
cannam@154:    dec_err[0]=(OpusDecoder *)malloc(opus_decoder_get_size(2));
cannam@154:    memcpy(dec_err[0],dec,opus_decoder_get_size(2));
cannam@154:    dec_err[1] = opus_decoder_create(48000, 1, &err);
cannam@154:    dec_err[2] = opus_decoder_create(24000, 2, &err);
cannam@154:    dec_err[3] = opus_decoder_create(24000, 1, &err);
cannam@154:    dec_err[4] = opus_decoder_create(16000, 2, &err);
cannam@154:    dec_err[5] = opus_decoder_create(16000, 1, &err);
cannam@154:    dec_err[6] = opus_decoder_create(12000, 2, &err);
cannam@154:    dec_err[7] = opus_decoder_create(12000, 1, &err);
cannam@154:    dec_err[8] = opus_decoder_create(8000, 2, &err);
cannam@154:    dec_err[9] = opus_decoder_create(8000, 1, &err);
cannam@154:    for(i=0;i<10;i++)if(dec_err[i]==NULL)test_failed();
cannam@154: 
cannam@154:    {
cannam@154:       OpusEncoder *enccpy;
cannam@154:       /*The opus state structures contain no pointers and can be freely copied*/
cannam@154:       enccpy=(OpusEncoder *)malloc(opus_encoder_get_size(2));
cannam@154:       memcpy(enccpy,enc,opus_encoder_get_size(2));
cannam@154:       memset(enc,255,opus_encoder_get_size(2));
cannam@154:       opus_encoder_destroy(enc);
cannam@154:       enc=enccpy;
cannam@154:    }
cannam@154: 
cannam@154:    inbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
cannam@154:    outbuf=(short *)malloc(sizeof(short)*SAMPLES*2);
cannam@154:    out2buf=(short *)malloc(sizeof(short)*MAX_FRAME_SAMP*3);
cannam@154:    if(inbuf==NULL || outbuf==NULL || out2buf==NULL)test_failed();
cannam@154: 
cannam@154:    generate_music(inbuf,SAMPLES);
cannam@154: 
cannam@154: /*   FILE *foo;
cannam@154:    foo = fopen("foo.sw", "wb+");
cannam@154:    fwrite(inbuf, 1, SAMPLES*2*2, foo);
cannam@154:    fclose(foo);*/
cannam@154: 
cannam@154:    if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_AUTO))!=OPUS_OK)test_failed();
cannam@154:    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(-2))!=OPUS_BAD_ARG)test_failed();
cannam@154:    if(opus_encode(enc, inbuf, 500, packet, MAX_PACKET)!=OPUS_BAD_ARG)test_failed();
cannam@154: 
cannam@154:    for(rc=0;rc<3;rc++)
cannam@154:    {
cannam@154:       if(opus_encoder_ctl(enc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
cannam@154:       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
cannam@154:       if(opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
cannam@154:       if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
cannam@154:       for(j=0;j<13;j++)
cannam@154:       {
cannam@154:          int rate;
cannam@154:          int modes[13]={0,0,0,1,1,1,1,2,2,2,2,2,2};
cannam@154:          int rates[13]={6000,12000,48000,16000,32000,48000,64000,512000,13000,24000,48000,64000,96000};
cannam@154:          int frame[13]={960*2,960,480,960,960,960,480,960*3,960*3,960,480,240,120};
cannam@154:          rate=rates[j]+fast_rand()%rates[j];
cannam@154:          count=i=0;
cannam@154:          do {
cannam@154:             int bw,len,out_samples,frame_size;
cannam@154:             frame_size=frame[j];
cannam@154:             if((fast_rand()&255)==0)
cannam@154:             {
cannam@154:                if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:                if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:                if((fast_rand()&1)!=0)
cannam@154:                {
cannam@154:                   if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:                }
cannam@154:             }
cannam@154:             if((fast_rand()&127)==0)
cannam@154:             {
cannam@154:                if(opus_decoder_ctl(dec_err[fast_rand()&1], OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:             }
cannam@154:             if(fast_rand()%10==0){
cannam@154:                int complex=fast_rand()%11;
cannam@154:                if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complex))!=OPUS_OK)test_failed();
cannam@154:             }
cannam@154:             if(fast_rand()%50==0)opus_decoder_ctl(dec, OPUS_RESET_STATE);
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS((rates[j]>=64000?2:1)))!=OPUS_OK)test_failed();
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
cannam@154:             bw=modes[j]==0?OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%3):
cannam@154:                modes[j]==1?OPUS_BANDWIDTH_SUPERWIDEBAND+(fast_rand()&1):
cannam@154:                            OPUS_BANDWIDTH_NARROWBAND+(fast_rand()%5);
cannam@154:             if(modes[j]==2&&bw==OPUS_BANDWIDTH_MEDIUMBAND)bw+=3;
cannam@154:             if(opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bw))!=OPUS_OK)test_failed();
cannam@154:             len = opus_encode(enc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
cannam@154:             if(len<0 || len>MAX_PACKET)test_failed();
cannam@154:             if(opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
cannam@154:             if((fast_rand()&3)==0)
cannam@154:             {
cannam@154:                if(opus_packet_pad(packet,len,len+1)!=OPUS_OK)test_failed();
cannam@154:                len++;
cannam@154:             }
cannam@154:             if((fast_rand()&7)==0)
cannam@154:             {
cannam@154:                if(opus_packet_pad(packet,len,len+256)!=OPUS_OK)test_failed();
cannam@154:                len+=256;
cannam@154:             }
cannam@154:             if((fast_rand()&3)==0)
cannam@154:             {
cannam@154:                len=opus_packet_unpad(packet,len);
cannam@154:                if(len<1)test_failed();
cannam@154:             }
cannam@154:             out_samples = opus_decode(dec, packet, len, &outbuf[i<<1], MAX_FRAME_SAMP, 0);
cannam@154:             if(out_samples!=frame_size)test_failed();
cannam@154:             if(opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
cannam@154:             if(enc_final_range!=dec_final_range)test_failed();
cannam@154:             /*LBRR decode*/
cannam@154:             out_samples = opus_decode(dec_err[0], packet, len, out2buf, frame_size, (fast_rand()&3)!=0);
cannam@154:             if(out_samples!=frame_size)test_failed();
cannam@154:             out_samples = opus_decode(dec_err[1], packet, (fast_rand()&3)==0?0:len, out2buf, MAX_FRAME_SAMP, (fast_rand()&7)!=0);
cannam@154:             if(out_samples<120)test_failed();
cannam@154:             i+=frame_size;
cannam@154:             count++;
cannam@154:          }while(i<(SSAMPLES-MAX_FRAME_SAMP));
cannam@154:          fprintf(stdout,"    Mode %s FB encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
cannam@154:       }
cannam@154:    }
cannam@154: 
cannam@154:    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(OPUS_AUTO))!=OPUS_OK)test_failed();
cannam@154:    if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(OPUS_AUTO))!=OPUS_OK)test_failed();
cannam@154:    if(opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(0))!=OPUS_OK)test_failed();
cannam@154:    if(opus_encoder_ctl(enc, OPUS_SET_DTX(0))!=OPUS_OK)test_failed();
cannam@154: 
cannam@154:    for(rc=0;rc<3;rc++)
cannam@154:    {
cannam@154:       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR(rc<2))!=OPUS_OK)test_failed();
cannam@154:       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
cannam@154:       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_VBR_CONSTRAINT(rc==1))!=OPUS_OK)test_failed();
cannam@154:       if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0))!=OPUS_OK)test_failed();
cannam@154:       for(j=0;j<16;j++)
cannam@154:       {
cannam@154:          int rate;
cannam@154:          int modes[16]={0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2};
cannam@154:          int rates[16]={4000,12000,32000,8000,16000,32000,48000,88000,4000,12000,32000,8000,16000,32000,48000,88000};
cannam@154:          int frame[16]={160*1,160,80,160,160,80,40,20,160*1,160,80,160,160,80,40,20};
cannam@154:          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_INBAND_FEC(rc==0&&j==1))!=OPUS_OK)test_failed();
cannam@154:          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_FORCE_MODE(MODE_SILK_ONLY+modes[j]))!=OPUS_OK)test_failed();
cannam@154:          rate=rates[j]+fast_rand()%rates[j];
cannam@154:          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_DTX(fast_rand()&1))!=OPUS_OK)test_failed();
cannam@154:          if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_BITRATE(rate))!=OPUS_OK)test_failed();
cannam@154:          count=i=0;
cannam@154:          do {
cannam@154:             int len,out_samples,frame_size,loss;
cannam@154:             opus_int32 pred;
cannam@154:             if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_PREDICTION_DISABLED(&pred))!=OPUS_OK)test_failed();
cannam@154:             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PREDICTION_DISABLED((int)(fast_rand()&15)<(pred?11:4)))!=OPUS_OK)test_failed();
cannam@154:             frame_size=frame[j];
cannam@154:             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_COMPLEXITY((count>>2)%11))!=OPUS_OK)test_failed();
cannam@154:             if(opus_multistream_encoder_ctl(MSenc, OPUS_SET_PACKET_LOSS_PERC((fast_rand()&15)&(fast_rand()%15)))!=OPUS_OK)test_failed();
cannam@154:             if((fast_rand()&255)==0)
cannam@154:             {
cannam@154:                if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:                if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:                if((fast_rand()&3)!=0)
cannam@154:                {
cannam@154:                   if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:                }
cannam@154:             }
cannam@154:             if((fast_rand()&255)==0)
cannam@154:             {
cannam@154:                if(opus_multistream_decoder_ctl(MSdec_err, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:             }
cannam@154:             len = opus_multistream_encode(MSenc, &inbuf[i<<1], frame_size, packet, MAX_PACKET);
cannam@154:             if(len<0 || len>MAX_PACKET)test_failed();
cannam@154:             if(opus_multistream_encoder_ctl(MSenc, OPUS_GET_FINAL_RANGE(&enc_final_range))!=OPUS_OK)test_failed();
cannam@154:             if((fast_rand()&3)==0)
cannam@154:             {
cannam@154:                if(opus_multistream_packet_pad(packet,len,len+1,2)!=OPUS_OK)test_failed();
cannam@154:                len++;
cannam@154:             }
cannam@154:             if((fast_rand()&7)==0)
cannam@154:             {
cannam@154:                if(opus_multistream_packet_pad(packet,len,len+256,2)!=OPUS_OK)test_failed();
cannam@154:                len+=256;
cannam@154:             }
cannam@154:             if((fast_rand()&3)==0)
cannam@154:             {
cannam@154:                len=opus_multistream_packet_unpad(packet,len,2);
cannam@154:                if(len<1)test_failed();
cannam@154:             }
cannam@154:             out_samples = opus_multistream_decode(MSdec, packet, len, out2buf, MAX_FRAME_SAMP, 0);
cannam@154:             if(out_samples!=frame_size*6)test_failed();
cannam@154:             if(opus_multistream_decoder_ctl(MSdec, OPUS_GET_FINAL_RANGE(&dec_final_range))!=OPUS_OK)test_failed();
cannam@154:             if(enc_final_range!=dec_final_range)test_failed();
cannam@154:             /*LBRR decode*/
cannam@154:             loss=(fast_rand()&63)==0;
cannam@154:             out_samples = opus_multistream_decode(MSdec_err, packet, loss?0:len, out2buf, frame_size*6, (fast_rand()&3)!=0);
cannam@154:             if(out_samples!=(frame_size*6))test_failed();
cannam@154:             i+=frame_size;
cannam@154:             count++;
cannam@154:          }while(i<(SSAMPLES/12-MAX_FRAME_SAMP));
cannam@154:          fprintf(stdout,"    Mode %s NB dual-mono MS encode %s, %6d bps OK.\n",mstrings[modes[j]],rc==0?" VBR":rc==1?"CVBR":" CBR",rate);
cannam@154:       }
cannam@154:    }
cannam@154: 
cannam@154:    bitrate_bps=512000;
cannam@154:    fsize=fast_rand()%31;
cannam@154:    fswitch=100;
cannam@154: 
cannam@154:    debruijn2(6,db62);
cannam@154:    count=i=0;
cannam@154:    do {
cannam@154:       unsigned char toc;
cannam@154:       const unsigned char *frames[48];
cannam@154:       short size[48];
cannam@154:       int payload_offset;
cannam@154:       opus_uint32 dec_final_range2;
cannam@154:       int jj,dec2;
cannam@154:       int len,out_samples;
cannam@154:       int frame_size=fsizes[db62[fsize]];
cannam@154:       opus_int32 offset=i%(SAMPLES-MAX_FRAME_SAMP);
cannam@154: 
cannam@154:       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
cannam@154: 
cannam@154:       len = opus_encode(enc, &inbuf[offset<<1], frame_size, packet, MAX_PACKET);
cannam@154:       if(len<0 || len>MAX_PACKET)test_failed();
cannam@154:       count++;
cannam@154: 
cannam@154:       opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range));
cannam@154: 
cannam@154:       out_samples = opus_decode(dec, packet, len, &outbuf[offset<<1], MAX_FRAME_SAMP, 0);
cannam@154:       if(out_samples!=frame_size)test_failed();
cannam@154: 
cannam@154:       opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
cannam@154: 
cannam@154:       /* compare final range encoder rng values of encoder and decoder */
cannam@154:       if(dec_final_range!=enc_final_range)test_failed();
cannam@154: 
cannam@154:       /* We fuzz the packet, but take care not to only corrupt the payload
cannam@154:          Corrupted headers are tested elsewhere and we need to actually run
cannam@154:          the decoders in order to compare them. */
cannam@154:       if(opus_packet_parse(packet,len,&toc,frames,size,&payload_offset)<=0)test_failed();
cannam@154:       if((fast_rand()&1023)==0)len=0;
cannam@154:       for(j=(opus_int32)(frames[0]-packet);j<len;j++)for(jj=0;jj<8;jj++)packet[j]^=((!no_fuzz)&&((fast_rand()&1023)==0))<<jj;
cannam@154:       out_samples = opus_decode(dec_err[0], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
cannam@154:       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed();
cannam@154:       if((len>0&&out_samples!=frame_size))test_failed(); /*FIXME use lastframe*/
cannam@154: 
cannam@154:       opus_decoder_ctl(dec_err[0], OPUS_GET_FINAL_RANGE(&dec_final_range));
cannam@154: 
cannam@154:       /*randomly select one of the decoders to compare with*/
cannam@154:       dec2=fast_rand()%9+1;
cannam@154:       out_samples = opus_decode(dec_err[dec2], len>0?packet:NULL, len, out2buf, MAX_FRAME_SAMP, 0);
cannam@154:       if(out_samples<0||out_samples>MAX_FRAME_SAMP)test_failed(); /*FIXME, use factor, lastframe for loss*/
cannam@154: 
cannam@154:       opus_decoder_ctl(dec_err[dec2], OPUS_GET_FINAL_RANGE(&dec_final_range2));
cannam@154:       if(len>0&&dec_final_range!=dec_final_range2)test_failed();
cannam@154: 
cannam@154:       fswitch--;
cannam@154:       if(fswitch<1)
cannam@154:       {
cannam@154:         int new_size;
cannam@154:         fsize=(fsize+1)%36;
cannam@154:         new_size=fsizes[db62[fsize]];
cannam@154:         if(new_size==960||new_size==480)fswitch=2880/new_size*(fast_rand()%19+1);
cannam@154:         else fswitch=(fast_rand()%(2880/new_size))+1;
cannam@154:       }
cannam@154:       bitrate_bps=((fast_rand()%508000+4000)+bitrate_bps)>>1;
cannam@154:       i+=frame_size;
cannam@154:    }while(i<SAMPLES*4);
cannam@154:    fprintf(stdout,"    All framesize pairs switching encode, %d frames OK.\n",count);
cannam@154: 
cannam@154:    if(opus_encoder_ctl(enc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:    opus_encoder_destroy(enc);
cannam@154:    if(opus_multistream_encoder_ctl(MSenc, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:    opus_multistream_encoder_destroy(MSenc);
cannam@154:    if(opus_decoder_ctl(dec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:    opus_decoder_destroy(dec);
cannam@154:    if(opus_multistream_decoder_ctl(MSdec, OPUS_RESET_STATE)!=OPUS_OK)test_failed();
cannam@154:    opus_multistream_decoder_destroy(MSdec);
cannam@154:    opus_multistream_decoder_destroy(MSdec_err);
cannam@154:    for(i=0;i<10;i++)opus_decoder_destroy(dec_err[i]);
cannam@154:    free(inbuf);
cannam@154:    free(outbuf);
cannam@154:    free(out2buf);
cannam@154:    return 0;
cannam@154: }
cannam@154: 
cannam@154: void print_usage(char* _argv[])
cannam@154: {
cannam@154:    fprintf(stderr,"Usage: %s [<seed>] [-fuzz <num_encoders> <num_settings_per_encoder>]\n",_argv[0]);
cannam@154: }
cannam@154: 
cannam@154: int main(int _argc, char **_argv)
cannam@154: {
cannam@154:    int args=1;
cannam@154:    char * strtol_str=NULL;
cannam@154:    const char * oversion;
cannam@154:    const char * env_seed;
cannam@154:    int env_used;
cannam@154:    int num_encoders_to_fuzz=5;
cannam@154:    int num_setting_changes=40;
cannam@154: 
cannam@154:    env_used=0;
cannam@154:    env_seed=getenv("SEED");
cannam@154:    if(_argc>1)
cannam@154:       iseed=strtol(_argv[1], &strtol_str, 10);  /* the first input argument might be the seed */
cannam@154:    if(strtol_str!=NULL && strtol_str[0]=='\0')   /* iseed is a valid number */
cannam@154:       args++;
cannam@154:    else if(env_seed) {
cannam@154:       iseed=atoi(env_seed);
cannam@154:       env_used=1;
cannam@154:    }
cannam@154:    else iseed=(opus_uint32)time(NULL)^(((opus_uint32)getpid()&65535)<<16);
cannam@154:    Rw=Rz=iseed;
cannam@154: 
cannam@154:    while(args<_argc)
cannam@154:    {
cannam@154:       if(strcmp(_argv[args], "-fuzz")==0 && _argc==(args+3)) {
cannam@154:          num_encoders_to_fuzz=strtol(_argv[args+1], &strtol_str, 10);
cannam@154:          if(strtol_str[0]!='\0' || num_encoders_to_fuzz<=0) {
cannam@154:             print_usage(_argv);
cannam@154:             return EXIT_FAILURE;
cannam@154:          }
cannam@154:          num_setting_changes=strtol(_argv[args+2], &strtol_str, 10);
cannam@154:          if(strtol_str[0]!='\0' || num_setting_changes<=0) {
cannam@154:             print_usage(_argv);
cannam@154:             return EXIT_FAILURE;
cannam@154:          }
cannam@154:          args+=3;
cannam@154:       }
cannam@154:       else {
cannam@154:         print_usage(_argv);
cannam@154:         return EXIT_FAILURE;
cannam@154:       }
cannam@154:    }
cannam@154: 
cannam@154:    oversion=opus_get_version_string();
cannam@154:    if(!oversion)test_failed();
cannam@154:    fprintf(stderr,"Testing %s encoder. Random seed: %u (%.4X)\n", oversion, iseed, fast_rand() % 65535);
cannam@154:    if(env_used)fprintf(stderr,"  Random seed set from the environment (SEED=%s).\n", env_seed);
cannam@154: 
cannam@154:    regression_test();
cannam@154: 
cannam@154:    /*Setting TEST_OPUS_NOFUZZ tells the tool not to send garbage data
cannam@154:      into the decoders. This is helpful because garbage data
cannam@154:      may cause the decoders to clip, which angers CLANG IOC.*/
cannam@154:    run_test1(getenv("TEST_OPUS_NOFUZZ")!=NULL);
cannam@154: 
cannam@154:    /* Fuzz encoder settings online */
cannam@154:    if(getenv("TEST_OPUS_NOFUZZ")==NULL) {
cannam@154:       fprintf(stderr,"Running fuzz_encoder_settings with %d encoder(s) and %d setting change(s) each.\n",
cannam@154:               num_encoders_to_fuzz, num_setting_changes);
cannam@154:       fuzz_encoder_settings(num_encoders_to_fuzz, num_setting_changes);
cannam@154:    }
cannam@154: 
cannam@154:    fprintf(stderr,"Tests completed successfully.\n");
cannam@154: 
cannam@154:    return 0;
cannam@154: }