path: root/test/test_opus.cc

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            test_init.cc
 *
 *  Mon Sep  2 14:02:16 CEST 2013
 *  Copyright 2013 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of lrtp.
 *
 * lrtp is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * lrtp is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with lrtp; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <lrtp.h>

#include <stdio.h>

#include <string>
#include <vector>

#include <math.h>
#include <opus/opus.h>
#include <limits.h>
#include <ao/ao.h>

#define KEY "123456789012345678901234567890123456789012345678901234567890"
#define SSRC 1234567890

#define FS 48000

#define F1 440
#define AF1 0.3

#define F2 500
#define AF2 0.7

void dump(const char *title, const char *buf, size_t size)
{
  printf("%12s: ", title);
  for(int i = 0; i < size; i++) {
    if(i % 8 == 0) printf(" ");
    printf("%02x ", (unsigned char)*buf++);
  }
  printf("\n");
}

class Audio {
public:
  Audio() {
    ao_initialize();

    device = NULL;
    ao_sample_format format;
    
    int default_driver = ao_default_driver_id();
    if(default_driver == -1) {
      printf("Error could not default driver.\n");
      return;
    }   
    printf("Default driver: %d\n", default_driver);

    format.bits = 16;
    format.channels = 2;
    format.rate = FS;
    format.byte_format = AO_FMT_LITTLE;
				
    device = ao_open_live(default_driver, &format, NULL);
    if(device == NULL) {
      printf("Error opening device.\n");
      return;
    }
  }

  ~Audio() {
    if(device) ao_close(device);
    ao_shutdown();
  }

  void play(char *pcm, size_t size) {
    ao_play(device, pcm, size);
  }

private:
  ao_device *device;
};

int main()
{
  size_t channels = 2;
  size_t ms[] = { 120, 240, 480, 960, 1920, 2880 };

  std::vector<std::string> packets;
  unsigned int csrc = 42;
  
  double sin_x = 0;
  size_t ts = 0;

  printf("========== Encode ==========\n");

  { // Encode
    struct lrtp_t *lrtp = lrtp_init(KEY, SSRC);

    struct lrtp_profile_t *profile =
      lrtp_create_profile(lrtp, PROFILE_OPUS, csrc,
                          //OPTION_RAW_PKG_SIZE, pkg_size,
                          OPTION_END);

    char packet[16*1024];
    size_t packetsize = sizeof(packet);
    
    int err;
    OpusEncoder *opus = opus_encoder_create(FS, channels,
                                            OPUS_APPLICATION_AUDIO, &err);
    printf("Opus create err: %d\n", err);

    opus_encoder_ctl(opus, OPUS_SET_BITRATE(32000));// [500;512000]
    opus_encoder_ctl(opus, OPUS_SET_COMPLEXITY(10)); // [0;10]
    opus_encoder_ctl(opus, OPUS_SET_SIGNAL(OPUS_AUTO));	
    //opus_encoder_ctl(opus, OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND));

    int cnt = 0;
    size_t timestamp = 0;
    size_t idx = 0;
    for(unsigned int ts = 0; ts < FS / 10; ts++) {
      printf("packet #%d\n", ts);

      printf("idx: %d\n", idx);
      size_t pcmsize = ms[idx] / (48000.0 / FS); // Number of samples pr channel
      short *pcm = new short[100000/*pcmsize * channels*/];
      for(int i = 0 ; i < pcmsize; i++) {
        sin_x++;

        if((int)sin_x % FS == 0) {
          idx++;// = rand() % (sizeof(ms)/sizeof(size_t));
          idx = idx % (sizeof(ms)/sizeof(size_t));
        }
        
        double amp1 = sin((2*M_PI/(double)FS)*(double)sin_x * AF1) * SHRT_MAX;
        double amp2 = sin((2*M_PI/(double)FS)*(double)sin_x * AF2) * SHRT_MAX;
        
        pcm[i*2]   = (short)(sin(2*M_PI/FS*(double)sin_x * F1) * amp1);
        pcm[i*2+1] = (short)(sin(2*M_PI/FS*(double)sin_x * F2) * amp2);
      }

      // Master timestamp is sample number in 48kHz (Opus RFC states this)
      timestamp += pcmsize * 48000 / FS;

      //      size_t pcmsize = pcmsize * channels * sizeof(short);

      char frame[pcmsize];
      int framesize = sizeof(frame);
      framesize = opus_encode(opus, pcm, pcmsize,
                              (unsigned char*)frame, framesize);

      if(framesize < 0) {
        printf("Opus error: %s\n", opus_strerror(framesize));	
      }

      printf("Opus Packet: %d bytes compressed to %d bytes\n",
             channels * pcmsize * sizeof(short), framesize);

      int ret = lrtp_enqueue_frame(profile, frame, framesize);
      while( (ret = lrtp_pack(lrtp, packet, sizeof(packet))) != 0) {
        std::string p;
        p.append(packet, ret);
        packets.push_back(p);
      }

      delete[] pcm;
    }

    opus_encoder_destroy(opus);
    lrtp_destroy_profile(lrtp, csrc);
    lrtp_close(lrtp);
  }

  printf("========== Decode ==========\n");

  { // Decode
    struct lrtp_t *lrtp = lrtp_init(KEY, SSRC);

    struct lrtp_profile_t *profile =
      lrtp_create_profile(lrtp, PROFILE_OPUS, csrc,
                          //OPTION_RAW_PKG_SIZE, pkg_size,
                          OPTION_END);

    int err;
    OpusDecoder *opus = opus_decoder_create(FS, channels, &err);
    printf("Opus create err: %d\n", err);

    int idx = (sizeof(ms)/sizeof(size_t)) - 1;
    printf("idx: %d\n", idx);

    Audio audio;

    char frame[16*1024];
    
    int cnt = 0;
    std::vector<std::string>::iterator i = packets.begin();
    while(i != packets.end()) {
      size_t packetsize = i->size();
      const char *packet = i->data();
      unsigned int ts;

      //      printf("unpack sz: %d - %p\n", packetsize, packet);

      lrtp_unpack(lrtp, packet, packetsize);
      int n = 0;
      int ret;
      while((ret = lrtp_dequeue_frame(lrtp, frame, sizeof(frame), &csrc, &ts))
            != 0) {
        size_t pcmsize = 16*1024;//ms[idx] / (48000 / FS);
        short *pcm = new short[pcmsize * channels];
        //printf("pcmsize %d\n", pcmsize); fflush(stdout);
        int res = opus_decode(opus, (const unsigned char*)frame, ret,
                              pcm, pcmsize, 0);

        //        printf("Decompressed %d bytes\n", res);
        n += res;
        //      pcmsize = res * channels * sizeof(short);

        audio.play((char *)pcm, res * channels * sizeof(short));

        delete[] pcm;
      }

      printf("ratio: %d => %d\n", packetsize, n * channels);

      i++;
    }


    /*

    std::vector<std::string>::iterator i = packets.begin();
    while(i != packets.end()) {
      size_t packetsize = i->size();
      printf("unpack sz: %d\n", packetsize);
      const char *packet = i->data();
      unsigned int ts;

      framesize = sizeof(frame);

      lrtp_unpack(lrtp, packet, packetsize, frame, &framesize, &csrc, &ts);
      printf("Got %d bytes, csrc %d, ts: %d\n", framesize, csrc, ts);

      size_t pcmsize = 16*1024;//ms[idx] / (48000 / FS);
      short *pcm = new short[pcmsize * channels];
      printf("pcmsize %d\n", pcmsize); fflush(stdout);
      int res = opus_decode(opus, (const unsigned char*)frame, framesize,
                            pcm, pcmsize, 0);
      framesize = sizeof(frame);

      printf("Decompressed %d bytes\n", res);
      //      pcmsize = res * channels * sizeof(short);

			audio.play((char *)pcm, res * channels * sizeof(short));

      delete[] pcm;
      i++;
    }
    */
    opus_decoder_destroy(opus);
    lrtp_destroy_profile(lrtp, csrc);
    lrtp_close(lrtp);
  }

  return 0;
}