AUDIO RECORDで取得した音声の音量を数値で表す。

Question

前提・実現したいこと

Androidアプリでkotlinを用いて、スマホのマイクから認識した音声をSurfaceviewを用いて波形データを表示する機能を実装しました。
音声取得はAudioRECORDを用いています。

スタートボタンを押すと、音声取得が始まり、音が大きければ波形が大きく、小さければ小さく表示されるという一般的な波形データを時間経過とともに表示します。
その波形データから、数値も同時に表示することはできないかと考えています。
音が大きければ(波形がおおきければ)、数値も上がり、小さければ下がる、といった音量レベルみたいなものを数値で表せないかと思っております。
波形を分析するにはRMS(二条平均平方根)を用いると可能らしいのですが、限定はせず色々と模索しています。

何か使えそうな検索ワードや、機能があれば教えていただければと思います。
以下、音声取得から波形を表すコードです。

SurfaceView.kt

import android.annotation.SuppressLint
import android.content.Context
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import android.util.Log
import android.view.SurfaceHolder
import android.view.SurfaceView

@SuppressLint("ViewConstructor")
class VisualizerSurfaceView// 線の太さ、アンチエイリアス、色、とか

// この2つを書いてフォーカスを当てないとSurfaceViewが動かない？
//        isFocusable = true
//        requestFocus()
    (context: Context, surface: SurfaceView) : SurfaceView(context), SurfaceHolder.Callback, Runnable {

    private val _paint = Paint()
    private var _buffer: ShortArray = ShortArray(0)
    private var _holder: SurfaceHolder = surface.holder
    private var _thread: Thread? = null

    override fun run() {
        while (_thread != null) {
            doDraw(_holder)
        }
    }

    init {
        _holder.addCallback(this)
        _paint.strokeWidth = 2f
        _paint.isAntiAlias = true
        _paint.color = Color.WHITE
    }

    override fun surfaceCreated(holder: SurfaceHolder?) {
        if (holder != null) {
            val canvas = holder.lockCanvas()

            holder.unlockCanvasAndPost(canvas)
        }
    }

    override fun surfaceChanged(holder: SurfaceHolder?, format: Int, width: Int, height: Int) {
        _thread = Thread(this)
        _thread?.start()
    }

    override fun surfaceDestroyed(holder: SurfaceHolder?) {
        _thread = null
    }

    fun update(buffer: ShortArray, size: Int) {
        _buffer = buffer.copyOf(size)
//      postInvalidate()
    }

    private fun doDraw(holder: SurfaceHolder) {
        if (_buffer.isEmpty()) {
            return
        }

        try {
            val canvas: Canvas = holder.lockCanvas()

            canvas.drawColor(Color.BLACK)

            val baseLine: Float = canvas.height / 2f
            var oldX = 0f
            var oldY: Float = baseLine

            for ((index, _) in _buffer.withIndex()) {
                val x: Float = canvas.width.toFloat() / _buffer.size.toFloat() * index.toFloat()
                val y: Float = _buffer[index] / 128 + baseLine

                canvas.drawLine(oldX, oldY, x, y, _paint)

                oldX = x
                oldY = y
            }

            _buffer = ShortArray(0)

            holder.unlockCanvasAndPost(canvas)
        } catch (e: Exception) {
            Log.e(this.javaClass.name, "doDraw", e)
        }
    }
}

MainActivity.kt

import android.annotation.SuppressLint
import android.content.Intent
import android.media.AudioFormat
import android.media.AudioRecord
import android.media.MediaRecorder
import android.os.AsyncTask
import android.os.Bundle
import android.os.Parcel
import android.os.Parcelable
import android.support.v7.app.AppCompatActivity
import android.view.SurfaceView
import android.view.inputmethod.EditorInfo
import android.widget.Button
import android.widget.TextView
import kotlinx.android.synthetic.main.activity_main.*
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch


class MainActivity() : AppCompatActivity(), Parcelable {

    private var _record: Record? = null
    private var _isRecording = false
    private var _visualizer: VisualizerSurfaceView? = null
    private var _button: Button? = null

    constructor(parcel: Parcel) : this() {
        _isRecording = parcel.readByte() != 0.toByte()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        

        val surface = findViewById<SurfaceView>(R.id.visualizer)
        _visualizer = VisualizerSurfaceView(this, surface)

        _button = this.findViewById(R.id.buttonStart)
        _button?.setOnClickListener {
            if(_isRecording)
                stopRecord()
            else
                doRecord()
        }
    }

    override fun onPause() {
        super.onPause()
        stopRecord()
    }

    @SuppressLint("SetTextI18n")
    private fun stopRecord(){
        _isRecording = false
        _button?.text = "start"
        _record?.cancel(true)
    }

    @SuppressLint("SetTextI18n")
    private fun doRecord(){
        _isRecording = true
        _button?.text = "stop"

        // AsyncTaskは使い捨て１回こっきりなので毎回作ります
        _record = Record()
        _record?.execute()
    }

    @SuppressLint("StaticFieldLeak")
    inner class Record : AsyncTask<Void, DoubleArray, Void>() {
        override fun doInBackground(vararg params: Void): Void? {
            // サンプリングレート。1秒あたりのサンプル数
            // （8000, 11025, 22050, 44100, エミュでは8kbじゃないとだめ？）
            val sampleRate = 8000

            // 最低限のバッファサイズ
            val minBufferSize = AudioRecord.getMinBufferSize(
                sampleRate,
                AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_PCM_16BIT) * 2

            // バッファサイズが取得できない。サンプリングレート等の設定を端末がサポートしていない可能性がある。
            if(minBufferSize < 0){
                return null
            }

            val audioRecord = AudioRecord(
                MediaRecorder.AudioSource.MIC,
                sampleRate,
                AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_PCM_16BIT,
                minBufferSize)

            val sec = 1
            val buffer = ShortArray(sampleRate * (16 / 8) * 1 * sec)

            audioRecord.startRecording()

            try {
                while (_isRecording) {
                    val readSize = audioRecord.read(buffer, 0, minBufferSize)

                    if (readSize < 0) {
                        break
                    }
                    if (readSize == 0) {
                        continue
                    }

                    _visualizer?.update(buffer, readSize)
                }
            } finally {
                audioRecord.stop()
                audioRecord.release()
            }

            return null
        }
    }

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeByte(if (_isRecording) 1 else 0)
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<MainActivity> {
        override fun createFromParcel(parcel: Parcel): MainActivity {
            return MainActivity(parcel)
        }

        override fun newArray(size: Int): Array<MainActivity?> {
            return arrayOfNulls(size)
        }
    }
}

Comments

[t_obara]

「音声レベルメーター 算出」とかでググればそれなりに出てきますが、kotlinでのソースコード丸のままが欲しいのでしょうか？

[yoursong]

コメントありがとうございます。
教えていただいた通り、検索して見ましたら大体は同じようなことを考えておりました。
私、kotlinもAndroidも習いたてて、今後使うことはないのですが、ある課題で、短期間で本題の機能を実装しなければならない状態のため、kotlinコードがあると大変助かります。

Answer 1

たんにピーク値をとっていけばいいんでは。

Comments

[yoursong]

回答ありがとうございます。
仰る通り、波形の振幅のピーク値から算出できるのではないかと考えているのですが、
どのようにコードを書き加えていいものか、何度検索しても検討がつかない状況です。
何か参考になるサイトや検索ワードがありましたら教えていただけると助かります。

[y_waiwai]

マイナスのピークとプラスのピーク取って差分を求めればいいのでは。
あまりに基本的なもんなんでサイトと言われても困りますね