MALossyConverter.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MALossyConverter.hpp"

#include "core/MANum.hpp"

#include <MCBinaryData.hpp>
#include <MCLog.hpp>
#include <MCThreadLocalData.hpp>

#include <vorbis/codec.h>
#include <vorbis/vorbisenc.h>
#if defined(__unix__) || defined(__MINGW32__) || defined(__MINGW64__)
#define OV_EXCLUDE_STATIC_CALLBACKS 1
#endif
#include <vorbis/vorbisfile.h>
#include <ivorbisfile.h>

#include <lame.h>

#include <boost/scoped_ptr.hpp>

namespace
{
MCThreadLocalData<MCBinaryData> CodingBuffer(true);
MCThreadLocalData<MCBinaryData> DecodingBuffer(true);
 
void CheckStaticAudioCodingVariables()
{
  if (unlikely(!CodingBuffer.get()))
  {
    CodingBuffer.reset(new MCBinaryData(10000));
  }
  if (unlikely(!DecodingBuffer.get()))
  {
    DecodingBuffer.reset(new MCBinaryData(10000));
  }
}


size_t ReadOgg(void* dst, size_t size1, size_t size2, void* fh)
{
  MCBinaryData* Data = reinterpret_cast<MCBinaryData*>(fh);
  size_t Len = Data->GetRemainingCapacity(size1*size2);

  memcpy(dst, &Data->GetData()[Data->GetPosition()], Len);
  Data->IncrementPosition(Len);
  return Len;
}


int SeekOgg(void* fh, ogg_int64_t to, int type)
{
  MCBinaryData* Data = reinterpret_cast<MCBinaryData*>(fh);

  if (to < 0)
  {
    MC_WARNING("Can't go back in Ogg Vorbis decoding... (%d)", (int)to);
    return -1;
  }
  switch (type)
  {
    case SEEK_CUR:
      if (Data->GetRemainingCapacity((unsigned int)to) < (unsigned int)to)
      {
        Data->SetPosition(Data->GetSize());
        return -1;
      } else {
        Data->IncrementPosition(to);
      }
      break;

    case SEEK_END:
      if (Data->GetSize() < (int)to)
      {
        Data->SetPosition(0);
        return -1;
      }
      Data->SetPosition(Data->GetSize()-(int)to);
      break;

    case SEEK_SET:
      if (Data->GetSize() < (int)to)
      {
        Data->SetPosition(Data->GetSize());
        return -1;
      }
      Data->SetPosition((int)to);
      break;

    default:
      return -1;
  }
  return 0;
}


int CloseOgg(void*)
{
  return 0;
}


long TellOgg(void* fh)
{
  MCBinaryData* Data = reinterpret_cast<MCBinaryData*>(fh);

  return (long)Data->GetPosition();
}
}

MCBinaryData* MALossyConverter::EncodeToOggVorbis(const MCBinaryData& raw_data, const int sample_rate,
                                                  const int channels, const int quality)
{
  if (raw_data.GetSize() <= 0)
    return nullptr;

  boost::scoped_ptr<ogg_stream_state> OggStream(new ogg_stream_state);
  boost::scoped_ptr<ogg_packet> OggPacket(new ogg_packet);
  boost::scoped_ptr<ogg_page> OggPage(new ogg_page);
  boost::scoped_ptr<vorbis_info> VorbisInfo(new vorbis_info);
  boost::scoped_ptr<vorbis_comment> VorbisComment(new vorbis_comment);
  boost::scoped_ptr<vorbis_dsp_state> VorbisDsp(new vorbis_dsp_state);
  boost::scoped_ptr<vorbis_block> VorbisBlock(new vorbis_block);
  boost::scoped_ptr<ogg_packet> Header(new ogg_packet);
  boost::scoped_ptr<ogg_packet> HeaderComment(new ogg_packet);
  boost::scoped_ptr<ogg_packet> HeaderCode(new ogg_packet);
  int Quality = (int)MANum<int>(quality, -2, 320);

  CheckStaticAudioCodingVariables();
  CodingBuffer->Allocate(raw_data.GetSize()*2);
  vorbis_info_init(&*VorbisInfo);
  if (Quality <= 10)
  {
    // VBR encoding
    if (vorbis_encode_init_vbr(&*VorbisInfo, channels, sample_rate, (float)Quality / 10))
    {
      MC_WARNING("Ogg Vorbis initialization failed.");
      return nullptr;
    }
  } else {
    Quality = MCMax(Quality, 32);
    // CBR encoding
    if (vorbis_encode_init(&*VorbisInfo, channels, sample_rate, -1, Quality*1000, -1))
    {
      MC_WARNING("Ogg Vorbis initialization failed.");
      return nullptr;
    }
  }
  vorbis_comment_init(&*VorbisComment);
  vorbis_analysis_init(&*VorbisDsp, &*VorbisInfo);
  vorbis_block_init(&*VorbisDsp, &*VorbisBlock);
  ogg_stream_init(&*OggStream, MCRand(0, 1000000));
  // Write the header
  vorbis_analysis_headerout(&*VorbisDsp, &*VorbisComment, &*Header, &*HeaderComment, &*HeaderCode);
  ogg_stream_packetin(&*OggStream, &*Header);
  ogg_stream_packetin(&*OggStream, &*HeaderComment);
  ogg_stream_packetin(&*OggStream, &*HeaderCode);
  while (true)
  {
    int Result = ogg_stream_flush(&*OggStream, &*OggPage);

    if (Result == 0)
      break;

    memcpy(&CodingBuffer->GetData()[CodingBuffer->GetPosition()], (const char*)OggPage->header, OggPage->header_len);
    CodingBuffer->IncrementPosition(OggPage->header_len);
    memcpy(&CodingBuffer->GetData()[CodingBuffer->GetPosition()], (const char*)OggPage->body, OggPage->body_len);
    CodingBuffer->IncrementPosition(OggPage->body_len);
  }
  // Encode the audio data to Ogg Vorbis
  int Position = 0;
  const int SliceSize = 1024;

  while (Position < raw_data.GetSize())
  {
    int Size = ((raw_data.GetSize()-Position < SliceSize) ? raw_data.GetSize()-Position : SliceSize);
    float** Buffer = vorbis_analysis_buffer(&*VorbisDsp, Size);
    char* RawDataPtr = (char*)&raw_data.GetData()[Position];

    // Uninterleave samples
    if (channels == 2)
    {
      for (int i = 0; i < Size / 4 ; ++i)
      {
        Buffer[0][i] = ((RawDataPtr[i*4+1] << 8) | (0x00ff & (int)RawDataPtr[i*4])) / 32768.f;
        Buffer[1][i] = ((RawDataPtr[i*4+3] << 8) | (0x00ff & (int)RawDataPtr[i*4+2])) / 32768.f;
      }
      vorbis_analysis_wrote(&*VorbisDsp, Size / 4);
    } else {
      for (int i = 0; i < Size / 2 ; ++i)
      {
        Buffer[0][i] = ((RawDataPtr[i*2+1] << 8) | (0x00ff & (int)RawDataPtr[i*2])) / 32768.f;
      }
      vorbis_analysis_wrote(&*VorbisDsp, Size / 2);
    }

    while (vorbis_analysis_blockout(&*VorbisDsp, &*VorbisBlock) == 1)
    {
      vorbis_analysis(&*VorbisBlock, nullptr);
      vorbis_bitrate_addblock(&*VorbisBlock);

      while (vorbis_bitrate_flushpacket(&*VorbisDsp, &*OggPacket))
      {
        ogg_stream_packetin(&*OggStream, &*OggPacket);

        while (true)
        {
          int Result = ogg_stream_pageout(&*OggStream, &*OggPage);

          if (Result == 0)
            break;

          memcpy(&CodingBuffer->GetData()[CodingBuffer->GetPosition()], (const char*)OggPage->header, OggPage->header_len);
          CodingBuffer->IncrementPosition(OggPage->header_len);
          memcpy(&CodingBuffer->GetData()[CodingBuffer->GetPosition()], (const char*)OggPage->body, OggPage->body_len);
          CodingBuffer->IncrementPosition(OggPage->body_len);
        }
      }
    }
    Position += Size;
  }
  // Finalize and close the file
  vorbis_analysis_wrote(&*VorbisDsp, 0);
  while (vorbis_analysis_blockout(&*VorbisDsp, &*VorbisBlock) == 1)
  {
    vorbis_analysis(&*VorbisBlock, nullptr);
    vorbis_bitrate_addblock(&*VorbisBlock);

    while (vorbis_bitrate_flushpacket(&*VorbisDsp, &*OggPacket))
    {
      ogg_stream_packetin(&*OggStream, &*OggPacket);

      while (true)
      {
        int Result = ogg_stream_pageout(&*OggStream, &*OggPage);

        if (Result == 0)
          break;

        memcpy(&CodingBuffer->GetData()[CodingBuffer->GetPosition()], (const char*)OggPage->header, OggPage->header_len);
        CodingBuffer->IncrementPosition(OggPage->header_len);
        memcpy(&CodingBuffer->GetData()[CodingBuffer->GetPosition()], (const char*)OggPage->body, OggPage->body_len);
        CodingBuffer->IncrementPosition(OggPage->body_len);

        if (ogg_page_eos(&*OggPage) > 0)
          break;
      }
    }
  }
  // Close the stream
  ogg_stream_clear(&*OggStream);
  vorbis_block_clear(&*VorbisBlock);
  vorbis_dsp_clear(&*VorbisDsp);
  vorbis_comment_clear(&*VorbisComment);
  vorbis_info_clear(&*VorbisInfo);
  // Return the encoded data
  MCBinaryData* Data = new MCBinaryData(CodingBuffer->GetPosition());

  memcpy(Data->GetData(), CodingBuffer->GetData(), CodingBuffer->GetPosition());
  return Data;
}


MCBinaryData* MALossyConverter::DecodeFromOggVorbis(MCBinaryData& ogg_data, int& sample_rate, int& channels)
{
  if (ogg_data.GetSize() <= 0)
    return nullptr;

  int OldPosition = ogg_data.GetPosition();
  boost::scoped_ptr<OggVorbis_File> VorbisFile(new OggVorbis_File);
  ov_callbacks Callbacks;

  memset(&*VorbisFile, 0, sizeof(OggVorbis_File));
  ogg_data.SetPosition(0);
  Callbacks.read_func = ReadOgg;
  Callbacks.seek_func = SeekOgg;
  Callbacks.close_func = CloseOgg;
  Callbacks.tell_func = TellOgg;
  // Check the Ogg Vorbis data integrity
  if (ov_open_callbacks(&ogg_data, &*VorbisFile, nullptr, -1, Callbacks) < 0)
  {
    MC_WARNING("Corrupt Ogg Vorbis data.");
    ov_clear(&*VorbisFile);
    ogg_data.SetPosition(OldPosition);
    return nullptr;
  }
  // Extract the stream properties
  channels = ov_info(&*VorbisFile, -1)->channels;
  sample_rate = ov_info(&*VorbisFile, -1)->rate;
  // Decode the Ogg Vorbis data
  int Position = 0;
  int DesiredSize = ov_pcm_total(&*VorbisFile, -1)*2*channels;
  MCBinaryData* DecodedData = new MCBinaryData(DesiredSize);

  // Fill the buffer
  while (DesiredSize != 0)
  {
    int Section = 0;
    long Ret = 0;

    Ret = ov_read(&*VorbisFile, (char*)&DecodedData->GetData()[Position], DesiredSize, 0, 2, 1, &Section);
    if (Ret == 0 || DesiredSize < 10)
    {
      return DecodedData;
    } else
    if (Ret < 0)
    {
      delete DecodedData;
      MC_WARNING("Corrupt vorbis file");
      ov_clear(&*VorbisFile);
      ogg_data.SetPosition(OldPosition);
      return nullptr;
    } else {
      Position += Ret;
      DesiredSize -= Ret;
    }
  }

  // Clean up
  ov_clear(&*VorbisFile);
  ogg_data.SetPosition(OldPosition);
  return DecodedData;
}


MCBinaryData* MALossyConverter::QuickDecodeFromOggVorbis(MCBinaryData& ogg_data, int& sample_rate, int& channels)
{
  if (ogg_data.GetSize() <= 0)
    return nullptr;

  int OldPosition = ogg_data.GetPosition();
  boost::scoped_ptr<vorbisidec::OggVorbis_File> VorbisFile(new vorbisidec::OggVorbis_File);
  vorbisidec::ov_callbacks Callbacks;

  memset(&*VorbisFile, 0, sizeof(vorbisidec::OggVorbis_File));
  ogg_data.SetPosition(0);
  Callbacks.read_func = ReadOgg;
  Callbacks.seek_func = SeekOgg;
  Callbacks.close_func = CloseOgg;
  Callbacks.tell_func = TellOgg;
  // Check the Ogg Vorbis data integrity
  if (vorbisidec::ov_open_callbacks(&ogg_data, &*VorbisFile, nullptr, -1, Callbacks) < 0)
  {
    MC_WARNING("Corrupt Ogg Vorbis data.");
    vorbisidec::ov_clear(&*VorbisFile);
    ogg_data.SetPosition(OldPosition);
    return nullptr;
  }
  // Extract the stream properties
  channels = vorbisidec::ov_info(&*VorbisFile, -1)->channels;
  sample_rate = vorbisidec::ov_info(&*VorbisFile, -1)->rate;
  // Decode the Ogg Vorbis data
  int Position = 0;
  int DesiredSize = vorbisidec::ov_pcm_total(&*VorbisFile, -1)*2*channels;
  MCBinaryData* DecodedData = new MCBinaryData(DesiredSize);

  // Fill the buffer
  while (DesiredSize != 0)
  {
    int Section = 0;
    long Ret = 0;

    Ret = vorbisidec::ov_read(&*VorbisFile, (char*)&DecodedData->GetData()[Position], DesiredSize, &Section);
    if (Ret == 0 || DesiredSize < 10)
    {
      return DecodedData;
    } else
    if (Ret < 0)
    {
      delete DecodedData;
      MC_WARNING("Corrupt vorbis file");
      vorbisidec::ov_clear(&*VorbisFile);
      ogg_data.SetPosition(OldPosition);
      return nullptr;
    } else {
      Position += Ret;
      DesiredSize -= Ret;
    }
  }

  // Clean up
  vorbisidec::ov_clear(&*VorbisFile);
  ogg_data.SetPosition(OldPosition);
  return DecodedData;
}


MCBinaryData* MALossyConverter::EncodeToMp3(const MCBinaryData& raw_data, const int sample_rate,
                                            const int channels, const int quality)
{
  if (raw_data.GetSize() <= 0)
    return nullptr;

  lame::lame_t lame = lame::lame_init();
  int Quality = (int)MANum<int>(quality, 0, 320);

  CheckStaticAudioCodingVariables();
  CodingBuffer->Allocate(raw_data.GetSize()*2);
  // Set mp3 encoding parameters
  lame::lame_set_in_samplerate(lame, sample_rate);
  if (channels == 1)
  {
    lame::lame_set_num_channels(lame, 1);
    lame::lame_set_mode(lame, lame::MONO);
  } else {
    lame::lame_set_num_channels(lame, 2);
    lame::lame_set_mode(lame, lame::JOINT_STEREO);
  }
  lame::lame_set_findReplayGain(lame, 0);
  if (Quality <= 9)
  {
    // VBR encoding
    lame::lame_set_VBR(lame, lame::vbr_mtrh);
    lame::lame_set_VBR_q(lame, Quality);
    lame::lame_set_quality(lame, 0);
  } else {
    // CBR encoding
    Quality = MCMax(Quality, 48);

    lame::lame_set_VBR(lame, lame::vbr_off);
    lame::lame_set_brate(lame, Quality);
  }
  lame::lame_init_params(lame);

  int Count = 0;

  if (channels == 2)
  {
    Count += lame_encode_buffer_interleaved(lame, (short*)(void*)raw_data.GetData(), raw_data.GetSize() / 4,
                                            CodingBuffer->GetData(), CodingBuffer->GetSize());
  } else {
    Count += lame_encode_buffer(lame, (short*)(void*)raw_data.GetData(), nullptr, raw_data.GetSize() / 2,
                                CodingBuffer->GetData(), CodingBuffer->GetSize());
  }
  Count += lame_encode_flush(lame, &CodingBuffer->GetData()[Count], CodingBuffer->GetSize()-Count);
  // Return the encoded data
  MCBinaryData* Data = new MCBinaryData(Count);

  memcpy(Data->GetData(), CodingBuffer->GetData(), Count);
  lame_close(lame);
  return Data;
}


MCBinaryData* MALossyConverter::DecodeFromMp3(MCBinaryData& mp3_data, unsigned int orig_size,
                                              int& sample_rate, int& channels)
{
  if (mp3_data.GetSize() <= 0)
    return nullptr;

  void* handler = lame::hip_decode_init();
  lame::mp3data_struct Mp3Header;
  MC::BinaryDataSPtr RightChannel(new MCBinaryData(mp3_data.GetSize()*50));

  memset(&Mp3Header, 0, sizeof(Mp3Header));
  CheckStaticAudioCodingVariables();
  DecodingBuffer->Allocate(mp3_data.GetSize()*50);
  int Count = 0;

  for (int i = 0; i < mp3_data.GetSize(); i += 128)
  {
    Count += lame::hip_decode1_headers(handler, &mp3_data.GetData()[i],
                                       mp3_data.GetSize()-i < 128 ? mp3_data.GetSize()-i : 128,
                                       (short*)(void*)&DecodingBuffer->GetData()[Count],
                                       (short*)(void*)&RightChannel->GetData()[Count],
                                       &Mp3Header)*2;
  }
  channels = Mp3Header.stereo;
  sample_rate = Mp3Header.samplerate;
  lame::hip_decode_exit(handler);
  // Return the encoded data (skip the delay in the beginning)
  // Unfortunately, the mp3 encoding adds some non-deterministic delays before/after the waveform.
  // The bigger silence is the starting part, therefore, half of the whole addition is cut from
  // the beginning.
  int DropCount = 0;
  MCBinaryData* Data = new MCBinaryData(Count*channels-DropCount*channels);

  if (orig_size > 0 && Count > (int)orig_size && Count-(int)orig_size / channels > 0)
  {
    DropCount = (Count-orig_size / channels) / 2;
  }
  if (channels == 1)
  {
    short* MonoBuffer = (short*)(void*)&DecodingBuffer->GetData()[DropCount*2];
    unsigned char* TargetBuffer = Data->GetData();

    for (int i = DropCount; i < Count / 2; ++i)
    {
      TargetBuffer[0] = (unsigned char)(MonoBuffer[0] & 0xff);
      TargetBuffer[1] = (unsigned char)((MonoBuffer[0] >> 8) & 0xff);
      MonoBuffer++;
      TargetBuffer += 2;
    }
  } else {
    short* LeftBuffer = (short*)(void*)&DecodingBuffer->GetData()[DropCount*2];
    short* RightBuffer = (short*)(void*)&RightChannel->GetData()[DropCount*2];
    unsigned char* TargetBuffer = Data->GetData();

    for (int i = DropCount; i < Count / 2; ++i)
    {
      TargetBuffer[0] = (unsigned char)(LeftBuffer[0] & 0xff);
      TargetBuffer[1] = (unsigned char)((LeftBuffer[0] >> 8) & 0xff);
      TargetBuffer[2] = (unsigned char)(RightBuffer[0] & 0xff);
      TargetBuffer[3] = (unsigned char)((RightBuffer[0] >> 8) & 0xff);
      LeftBuffer++;
      RightBuffer++;
      TargetBuffer += 4;
    }
  }
  return Data;
}