path: root/src/encoder/encoderffmpegcore.cpp

#include "encoder/encoderffmpegcore.h"

#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <QtDebug>

#include "encoder/encodercallback.h"
#include "errordialoghandler.h"


//
// FFMPEG changed their variable/define names in 1.0
// smallest number that is AV_/AV compatible avcodec version is
// 54/59/100 which is 3554148
//

// Constructor
#if LIBAVCODEC_VERSION_INT > 3544932
EncoderFfmpegCore::EncoderFfmpegCore(EncoderCallback* pCallback,
                                     AVCodecID codec)
#else
EncoderFfmpegCore::EncoderFfmpegCore(EncoderCallback* pCallback, CodecID codec)
#endif
{
    m_bStreamInitialized = false;
    m_pCallback = pCallback;

    m_pEncodeFormatCtx = NULL;
    m_pEncoderAudioStream = NULL;
    m_pEncoderAudioCodec = NULL;
    m_pEncoderFormat = NULL;


    m_pSamples = NULL;
    m_pFltSamples = NULL;
    m_iAudioInputFrameSize = -1;

    memset(m_SBuffer, 0x00, (65355 * 2));
    m_lBufferSize = 0;
    m_iAudioCpyLen = 0;
    m_iFltAudioCpyLen = 0;

    m_SCcodecId = codec;
    m_lBitrate = 128000;
    m_lDts = 0;
    m_lPts = 0;
    m_lRecordedBytes = 0;

}

// Destructor  //call flush before any encoder gets deleted
EncoderFfmpegCore::~EncoderFfmpegCore() {

    qDebug() << "EncoderFfmpegCore::~EncoderFfmpegCore()";
    av_freep(&m_pSamples);
    av_freep(&m_pFltSamples);

    avio_open_dyn_buf(&m_pEncodeFormatCtx->pb);
    if (av_write_trailer(m_pEncodeFormatCtx) != 0) {
        qDebug() << "Multiplexer: failed to write a trailer.";
    } else {
        unsigned char *l_strBuffer = NULL;
        int l_iBufferLen = 0;
        l_iBufferLen = avio_close_dyn_buf(m_pEncodeFormatCtx->pb,
                                          (uint8_t**)(&l_strBuffer));
        m_pCallback->write(NULL, l_strBuffer, 0, l_iBufferLen);
        av_free(l_strBuffer);
    }


    if (m_pStream != NULL) {
        avcodec_close(m_pStream->codec);
    }

    if (m_pEncodeFormatCtx != NULL) {
        av_free(m_pEncodeFormatCtx);
    }

    // Close buffer
    delete m_pResample;
}

void EncoderFfmpegCore::setEncoderSettings(const EncoderSettings& settings)
{
    m_lBitrate = settings.getQuality() * 1000;
}

//call sendPackages() or write() after 'flush()' as outlined in enginebroadcast.cpp
void EncoderFfmpegCore::flush() {
}


//  Get new random serial number
//  -> returns random number

int EncoderFfmpegCore::getSerial() {
    int l_iSerial = 0;
    return l_iSerial;
}

void EncoderFfmpegCore::encodeBuffer(const CSAMPLE *samples, const int size) {
    unsigned char *l_strBuffer = NULL;
    int l_iBufferLen = 0;
    //int l_iAudioCpyLen = m_iAudioInputFrameSize *
    //                     av_get_bytes_per_sample(m_pEncoderAudioStream->codec->sample_fmt) *
    //                     m_pEncoderAudioStream->codec->channels;
    long l_iLeft = size;
    long j = 0;
    unsigned int l_iBufPos = 0;
    unsigned int l_iPos = 0;

    // TODO(XXX): Get rid of repeated malloc here!
    float *l_fNormalizedSamples = (float *)malloc(size * sizeof(float));

    // We use normalized floats in the engine [-1.0, 1.0] and FFMPEG expects
    // samples in the range [-1.0, 1.0] so no conversion is required.
    for (j = 0; j < size; j++) {
        l_fNormalizedSamples[j] = samples[j];
    }

    // In MP3 this writes Header same In ogg
    // They are written once front of the encoded stuff
    if (m_bStreamInitialized == false) {
        m_bStreamInitialized = true;
        // Write a header.
        avio_open_dyn_buf(&m_pEncodeFormatCtx->pb);
        if (avformat_write_header(m_pEncodeFormatCtx, NULL) != 0) {
            qDebug() << "EncoderFfmpegCore::encodeBuffer: failed to write a header.";
            return;
        }

        l_iBufferLen = avio_close_dyn_buf(m_pEncodeFormatCtx->pb,
                                          (uint8_t**)(&l_strBuffer));
        m_pCallback->write(NULL, l_strBuffer, 0, l_iBufferLen);
        av_free(l_strBuffer);
    }

    while (l_iLeft > (m_iFltAudioCpyLen / 4)) {
        memset(m_pFltSamples, 0x00, m_iFltAudioCpyLen);

        for (j = 0; j < m_iFltAudioCpyLen / 4; j++) {
            if (m_lBufferSize > 0) {
                m_pFltSamples[j] = m_SBuffer[ l_iBufPos++ ];
                m_lBufferSize--;
                m_lRecordedBytes++;
            } else {
                m_pFltSamples[j] = l_fNormalizedSamples[l_iPos++];
                l_iLeft--;
                m_lRecordedBytes++;
            }

            if (l_iLeft <= 0) {
                qDebug() << "ffmpegencodercore: No samples left.. for encoding!";
                break;
            }
        }

        m_lBufferSize = 0;

        // Open dynamic buffer for writing next bytes
        if (avio_open_dyn_buf(&m_pEncodeFormatCtx->pb) < 0) {
            qDebug() << "Can't alloc Dyn buffer!";
            return;
        }

        // Write it to buffer (FILE) and then close buffer for waiting
        // Next encoded buffe to come or we stop encode
        if (! writeAudioFrame(m_pEncodeFormatCtx, m_pEncoderAudioStream)) {
            l_iBufferLen = avio_close_dyn_buf(m_pEncodeFormatCtx->pb,
                                              (uint8_t**)(&l_strBuffer));
            m_pCallback->write(NULL, l_strBuffer, 0, l_iBufferLen);
            av_free(l_strBuffer);
        }
    }

    // Keep things clean
    memset(m_SBuffer, 0x00, 65535);

    for (j = 0; j < l_iLeft; j++) {
        m_SBuffer[ j ] = l_fNormalizedSamples[ l_iPos++ ];
    }
    m_lBufferSize = l_iLeft;
    free(l_fNormalizedSamples);
}

// Originally called from enginebroadcast.cpp to update metadata information
// when streaming, however, this causes pops
//
// Currently this method is used before init() once to save artist, title and album
//
void EncoderFfmpegCore::updateMetaData(const QString& artist, const QString& title, const QString& album) {
    qDebug() << "ffmpegencodercore: UpdateMetadata: !" << artist << " - " << title <<
             " - " << album;
    m_strMetaDataTitle = title;
    m_strMetaDataArtist = artist;
    m_strMetaDataAlbum = album;
}

int EncoderFfmpegCore::initEncoder(
        mixxx::audio::SampleRate sampleRate, QString* pUserErrorMessage) {
#ifndef avformat_alloc_output_context2
    qDebug() << "EncoderFfmpegCore::initEncoder: Old Style initialization";
    m_pEncodeFormatCtx = avformat_alloc_context();
#endif

    m_lSampleRate = sampleRate;
    QString codecString;

#if LIBAVCODEC_VERSION_INT > 3544932
    if (m_SCcodecId == AV_CODEC_ID_MP3) {
#else
    if (m_SCcodecId == CODEC_ID_MP3) {
#endif // LIBAVCODEC_VERSION_INT > 3544932
        qDebug() << "EncoderFfmpegCore::initEncoder: Codec MP3";
        codecString = "Codec MP3";
#ifdef avformat_alloc_output_context2
        avformat_alloc_output_context2(&m_pEncodeFormatCtx, NULL, NULL, "output.mp3");
#else
        m_pEncoderFormat = av_guess_format(NULL, "output.mp3", NULL);
#endif // avformat_alloc_output_context2

#if LIBAVCODEC_VERSION_INT > 3544932
    } else if (m_SCcodecId == AV_CODEC_ID_AAC) {
#else
    } else if (m_SCcodecId == CODEC_ID_AAC) {
#endif // LIBAVCODEC_VERSION_INT > 3544932
        qDebug() << "EncoderFfmpegCore::initEncoder: Codec M4A";
        codecString = "Codec M4A";
#ifdef avformat_alloc_output_context2
        avformat_alloc_output_context2(&m_pEncodeFormatCtx<