git.sesse.net Git - kdenlive/blob - src/lib/audio/audioEnvelope.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2012 by Simon Andreas Eugster (simon.eu@gmail.com)      *
   3  *   This file is part of kdenlive. See www.kdenlive.org.                  *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  ***************************************************************************/
  10
  11 #include "audioEnvelope.h"
  12
  13 #include "audioStreamInfo.h"
  14 #include <QImage>
  15 #include <QTime>
  16 #include <cmath>
  17 #include <iostream>
  18
  19 AudioEnvelope::AudioEnvelope(Mlt::Producer *producer) :
  20     m_envelope(NULL),
  21     m_producer(producer),
  22     m_envelopeSize(producer->get_length()),
  23     m_envelopeStdDevCalculated(false),
  24     m_envelopeIsNormalized(false)
  25 {
  26     m_info = new AudioInfo(m_producer);
  27 }
  28
  29 AudioEnvelope::~AudioEnvelope()
  30 {
  31     if (m_envelope != NULL) {
  32         delete[] m_envelope;
  33     }
  34     delete m_info;
  35 }
  36
  37
  38
  39 const int64_t *AudioEnvelope::envelope()
  40 {
  41     if (m_envelope == NULL) {
  42         loadEnvelope();
  43     }
  44     return m_envelope;
  45 }
  46 int AudioEnvelope::envelopeSize() const
  47 {
  48     return m_envelopeSize;
  49 }
  50
  51
  52
  53
  54 void AudioEnvelope::loadEnvelope()
  55 {
  56     Q_ASSERT(m_envelope == NULL);
  57
  58     std::cout << "Loading envelope ..." << std::endl;
  59
  60     int samplingRate = m_info->info(0)->samplingRate();
  61     mlt_audio_format format_s16 = mlt_audio_s16;
  62     int channels = 1;
  63
  64     Mlt::Frame *frame;
  65     int64_t position;
  66     int samples;
  67
  68     m_envelope = new int64_t[m_envelopeSize];
  69     m_envelopeMax = 0;
  70     m_envelopeMean = 0;
  71
  72     QTime t;
  73     t.start();
  74     for (int i = 0; i < m_envelopeSize; i++) {
  75
  76         frame = m_producer->get_frame(i);
  77         position = mlt_frame_get_position(frame->get_frame());
  78         samples = mlt_sample_calculator(m_producer->get_fps(), samplingRate, position);
  79
  80         int16_t *data = static_cast<int16_t*>(frame->get_audio(format_s16, samplingRate, channels, samples));
  81
  82         int64_t sum = 0;
  83         for (int k = 0; k < samples; k++) {
  84             sum += fabs(data[k]);
  85         }
  86         m_envelope[i] = sum;
  87
  88         m_envelopeMean += sum;
  89         if (sum > m_envelopeMax) {
  90             m_envelopeMax = sum;
  91         }
  92     }
  93     m_envelopeMean /= m_envelopeSize;
  94     std::cout << "Calculating the envelope (" << m_envelopeSize << " frames) took "
  95               << t.elapsed() << " ms." << std::endl;
  96 }
  97
  98 int64_t AudioEnvelope::loadStdDev()
  99 {
 100     if (m_envelopeStdDevCalculated) {
 101         std::cout << "Standard deviation already calculated, not re-calculating." << std::endl;
 102     } else {
 103
 104         if (m_envelope == NULL) {
 105             loadEnvelope();
 106         }
 107
 108         m_envelopeStdDev = 0;
 109         for (int i = 0; i < m_envelopeSize; i++) {
 110             m_envelopeStdDev += sqrt((m_envelope[i]-m_envelopeMean)*(m_envelope[i]-m_envelopeMean)/m_envelopeSize);
 111         }
 112         m_envelopeStdDevCalculated = true;
 113
 114     }
 115     return m_envelopeStdDev;
 116 }
 117
 118 void AudioEnvelope::normalizeEnvelope(bool clampTo0)
 119 {
 120     if (m_envelope == NULL) {
 121         loadEnvelope();
 122     }
 123
 124     if (!m_envelopeIsNormalized) {
 125
 126         m_envelopeMax = 0;
 127         int64_t newMean = 0;
 128         for (int i = 0; i < m_envelopeSize; i++) {
 129
 130             m_envelope[i] -= m_envelopeMean;
 131
 132             if (clampTo0) {
 133                 if (m_envelope[i] < 0) { m_envelope[i] = 0; }
 134             }
 135
 136             if (m_envelope[i] > m_envelopeMax) {
 137                 m_envelopeMax = m_envelope[i];
 138             }
 139
 140             newMean += m_envelope[i];
 141         }
 142         m_envelopeMean = newMean / m_envelopeSize;
 143
 144         m_envelopeIsNormalized = true;
 145     }
 146
 147 }
 148
 149 QImage AudioEnvelope::drawEnvelope()
 150 {
 151     if (m_envelope == NULL) {
 152         loadEnvelope();
 153     }
 154
 155     QImage img(m_envelopeSize, 400, QImage::Format_ARGB32);
 156     img.fill(qRgb(255,255,255));
 157     double fy;
 158     for (int x = 0; x < img.width(); x++) {
 159         fy = m_envelope[x]/double(m_envelopeMax) * img.height();
 160         for (int y = img.height()-1; y > img.height()-1-fy; y--) {
 161             img.setPixel(x,y, qRgb(50, 50, 50));
 162         }
 163     }
 164     return img;
 165 }
 166
 167 void AudioEnvelope::dumpInfo() const
 168 {
 169     if (m_envelope == NULL) {
 170         std::cout << "Envelope not generated, no information available." << std::endl;
 171     } else {
 172         std::cout << "Envelope info" << std::endl
 173                   << "* size = " << m_envelopeSize << std::endl
 174                   << "* max = " << m_envelopeMax << std::endl
 175                   << "* µ = " << m_envelopeMean << std::endl
 176                      ;
 177         if (m_envelopeStdDevCalculated) {
 178             std::cout << "* s = " << m_envelopeStdDev << std::endl;
 179         }
 180     }
 181 }