2013年11月28日木曜日

[Scala]WAVファイルを無音区間で自動分割するために知っておくべきこと

僕は英語の練習をしているとき、CDなどでネイティブの人の発音を聞き取る練習をしたり、それを真似て発音してみたりするのですが、聞いているCDなどの音楽ファイルのトラックの区切りが章毎になっていたりすると、ちょっと聞き取れなかった部分だけを再生しようと思って戻るボタンを押しても、章の最初に戻っちゃったりして、「そんな戻んなくていいんだよ~!」って歯がゆい思いしたりします。戻るボタン長押しで巻き戻しできたりもするのですが、これも面倒くさい。そんな時に、音楽ファイルを1文づつ自動的に分割してくれるものがあったら便利です。それで、そんな機能のある無料アプリを探して試して見たんですが、自分の思うようなアプリを見つけることができなかったので、どうせなら自分で作ることにしました。

本記事は、音声ファイルを扱ったことがなかった僕が、Scalaを使ってWAVファイルを無音区間で自動分割するまでに必要だと思った基本的なことをまとめたものです。

Index

音は波の流れ

ほとんどの人が知ってると思いますが、音は空気の振動です。つまり波です。コンピュータで使う音声ファイルもこの波を表現することで音を作っているようです。

波の流れが1つだったらモノラル、2つだったらステレオ

モノラルとかステレオとかよく耳にします。ステレオの方がいい音だということはなんとなく知っていますが、これは一体なんなんだ?
どうやら、ステレオというのは、波の流れが2つある音のことをいうようです。違う音の流れが2つあって、左右の耳にそれぞれ違う音が聞こえると音に立体感がでて臨場感が増すといった感じでしょうか。それに対して、モノラルは波の流れが1つしかないもののことをいうようです。そして、1つの音の流れのことをチャンネルといって、ステレオの場合はチャンネルが2つ、モノラルはチャンネルが1つという表現をするようですね。

波の振幅の大きさが音の大きさ

音が空気の振動ということは分かりましたが、音の大きさは、空気の振動とどう関係しているんだ?
これは、振動の振れ幅が大きほど大きく聞こえ、小さい程小さく聞こえるようなんですね。

波の振動数(周波数)が音の高さ

音の大きさ以外に音を表現するときによく使われるのは、音の高さですよね。ちなみに、僕は音痴なので、自分の歌声の音の高さはあまりわかりませんが、多くの人は、音の高さを判別できる耳を持っていることだと思います。この音の高低というのは、波が1秒間に上下を往復する回数によって決まるみたいです。つまり、振動数ですね。よくHz(ヘルツ)とかって単位で表されたりしてるやつですね。振動数が大きくなると、音は高く聞こえ、小さくなると音は低く聞こえるようです。耳というのは、振幅と振動数を音量と高低に変換する装置だったんですね。

量子化とは、波をデジタル化すること

量子化っていっても物理学の量子論に登場する量子化ではありません。量子化とは連続的な波をコンピュータで扱えるようにデジタル化することです。実際の波は、時間と空間に連続的に分布しているので、連続的な量を扱うことができないコンピュータでは、扱えないんですね。音の大きさも高低も離散的に的に表現しなきゃいけない。物理学の量子論も、場の振動を離散的に扱うことを量子化と読んでますよね。これに似ていることから量子化と名付けられたのかもしれません。
実際に音の波を量子化すると、振幅は、8ビットや16ビットなどの整数で、時間も一定間隔毎に区切られて扱われるようです。

サンプルとは、音波のある時刻での振幅のこと

音声ファイルでは、ある時刻における振幅のことをサンプルと呼んでいるようですね。CDなどでは、1つのサンプルは、16ビットの整数で表現されているようです。このサンプルを一定間隔に並べて擬似的に波を表現しようというわけですね。

音声ファイルは、サンプルの連続で構成されている

サンプルというのは、振幅つまり音の大きさの量子化ことでした。音波の時間軸も量子化しないとコンピュータでは扱うことができません。波を一定感覚毎に切って並べていっているのが音声ファイルなんですね。サンプルを基本的に圧縮せずに、そのまま並べてあるのがWAVファイルのようです。なので、音は何も欠損がなく生のままの音が記述されています。そのかわりファイルサイズは大きくなるようです。それに対してい、mp3やwmaなどは、サンプルなどを圧縮しているので、音に欠損があるがファイルサイズは小さく抑えられるようです。音に欠損があると言っても、人間がほとんど識別できない音を除いているので音質にはほとんど影響がないようです。

サンプルレートとは、1秒間のサンプル数のこと

音声ファイルがサンプルの並びだということは分かりました。今度は、それをどういう頻度で読み取るかということです。振動数にあたるところですね。音声ファイルでは、振動数で表現するよりも、1秒間に読み取るサンプル数で表現したほうが分かりやすいのかもしれません。これをサンプルレートと呼びます。

複数のチャンネルを総称してブロックという

音声ファイルは、複数のチャンネルも扱うことができます。同時刻のサンプルは、ファイル内では隣同士に並んでいます。ステレオの場合は同時刻に2つのサンプルが並んでいます。このように複数のチャンネルのサンプルが並んでいる領域をブロックと呼ぶらしいです。1つのサンプルのサイズが16ビットだったら、ステレオの場合のブロックサイズは32ビット、モノラルの場合は16ビットということになります。

WAVファイルは、情報の部分とサンプルデータ部分で構成される

音声ファイルは、単にサンプルが並んでいるだけではありません。他の多くのファイルフォーマットと同じようにヘッダー情報も記述されています。
WAVファイルは、ヘッダーと複数のチャンクという単位に分かれて構成されいます。

・ヘッダー

WAVファイルは、次のヘッダーから必ず始まります。
文字列'RIFF'(4byte)
これ以降のチャンクのサイズ(4byte)
文字列'WAVE'(4byte)

・チャンク

ヘッダー以降は、次のチャンクの連続です。
チャンク名(4byte)
これ以降のチャンクのサイズ(4byte)
内容

必須のチャンクはfmtdataの2つです。あと、アーティスト名やアルバム情報などが入っているLISTチャンクがあることもあります。

・fmtチャンク

fmtチャンクはの構造です。
文字列'fmt'(4byte)
これ以降のチャンクのサイズ(4byte)
PCMの種類。リニアPCMは0x0001(2byte)
チャンネル数(2byte)
サンプリング・レート(4byte)
1秒間のバイト数(4byte)
ブロックサイズ(2byte)
サンプルサイズ(2byte)
拡張領域のサイズ(2byte)
拡張領域(任意)
Scalaでは、ケースクラスで表現しました。
    case class AudioHeader(
      val pcmType: Short,
      val numOfChannels: Short,
      val samplingRate: Int,
      val bytesInSec: Int,
      val blockSize: Short,
      val sampleSizeInBits: Short,
      val extSize: Short
    )

・LISTチャンク

LISTチャンクにもいろいろ種類があるようですが、INFOにアーティストやアルバム情報が入っているようです。
INFO LISTの構造です。
文字列'fmt'(4byte)
これ以降のチャンクのサイズ(4byte)
文字列'INFO'(4byte)
4文字のタグ名(4byte)
タグのサイズ(4byte)
内容
4文字のタグ名(4byte)
タグのサイズ(4byte)
内容
...以下タグの繰り返し
タグにはいろんな種類があるようです。
10 
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 
    object Info {

      val ISRC = "ISRC" // メディア元
      val ICRD = "ICRD" // 作成日
      val IPRD = "IPRD" // アルバム名
      val INAM = "INAM" // 曲名
      val IGNR = "IGNR" // ジャンル
      val ICMT = "ICMT" // コメント
      val IART = "IART" // アーティスト
      val ICMS = "ICMS" // 著作権代理人
      val ICOP = "ICOP" // 著作権情報
      val IENG = "IENG" // 録音エンジニア
      val ISFT = "ISFT" // ソフトウェア
      val IKEY = "IKEY" // キーワード
      val ITCH = "ITEC" // エンコード技術者
      val ISBJ = "ISBJ" // タイトル
      val ITRK = "ITRK" // トラック番号
      val ITOC = "ITOC" // 目次

    }

・dataチャンク

文字列'fmt'(4byte)
これ以降のチャンクのサイズ(4byte)
以降はサンプルの連続
サンプルは、ブロック毎に並んでいて、ステレオの場合は左右の順にならんでいます。

サンプルやサイズを表す数字はByteBufferを使って整数型に変換すると便利

サンプルやサイズを表す数字は、バイト順がリトルエンディアンになっているので、Scalaの整数型に変換するときには注意が必要です。例えば、僕は16bitのサンプルは、次のようにしてShort型に変換しました。
def readShort( in: InputStream ) = readBytes( in, 2 ).map( b => ByteBuffer.wrap( b ).order( ByteOrder.LITTLE_ENDIAN ).getShort )

無音の条件としてサンプルの絶対値がとても小さい値

音声ファイルを無音区間で区切るときは、無音とは何かを定義する必要があります。音の大きさはサンプルが表す数字の絶対値の大きさなので、この値がある程度小さいものを無音とすればよいでしょう。音声ファイルや人によって違うと思うのでいろいろ実験してみて都合のよい大きさを選ぶとよいでしょう。僕の場合は100以下を無音としました。

無音が一定時間続くことが条件

無音が続いてる時間も決める必要があります。あまり細かく区切りすぎると、文の途中で切れちゃったりしますし、無音時間を長くすると、1つのトラックに複数の文が入ってきたりしちゃいますよね。やはり、これも音声ファイルによって変わってきますので、いろいろ実験して適切な無音の長さを選ぶとよいでしょう。僕の場合は10000回無音のサンプルが続いたところで区切るようにしました。

ソースコード

WAVファイルを無音区間で分割するScalaのプログラムです。
split関数が分割する関数です。
10 
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 
21 
22 
23 
24 
25 
26 
27 
28 
29 
30 
31 
32 
33 
34 
35 
36 
37 
38 
39 
40 
41 
42 
43 
44 
45 
46 
47 
48 
49 
50 
51 
52 
53 
54 
55 
56 
57 
58 
59 
60 
61 
62 
63 
64 
65 
66 
67 
68 
69 
70 
71 
72 
73 
74 
75 
76 
77 
78 
79 
80 
81 
82 
83 
84 
85 
86 
87 
88 
89 
90 
91 
92 
93 
94 
95 
96 
97 
98 
99 
100 
101 
102 
103 
104 
105 
106 
107 
108 
109 
110 
111 
112 
113 
114 
115 
116 
117 
118 
119 
120 
121 
122 
123 
124 
125 
126 
127 
128 
129 
130 
131 
132 
133 
134 
135 
136 
137 
138 
139 
140 
141 
142 
143 
144 
145 
146 
147 
148 
149 
150 
151 
152 
153 
154 
155 
156 
157 
158 
159 
160 
161 
162 
163 
164 
165 
166 
167 
168 
169 
170 
171 
172 
173 
174 
175 
176 
177 
178 
179 
180 
181 
182 
183 
184 
185 
186 
187 
188 
189 
190 
191 
192 
193 
194 
195 
196 
197 
198 
199 
200 
201 
202 
203 
204 
205 
206 
207 
208 
209 
210 
211 
212 
213 
214 
215 
216 
217 
218 
219 
220 
221 
222 
223 
224 
225 
226 
227 
228 
229 
230 
231 
232 
233 
234 
235 
236 
237 
238 
239 
240 
241 
242 
243 
244 
245 
246 
247 
248 
249 
250 
251 
252 
253 
254 
255 
256 
257 
258 
259 
260 
261 
262 
263 
264 
265 
266 
267 
268 
269 
270 
271 
272 
273 
274 
275 
276 
277 
278 
279 
280 
281 
282 
283 
284 
285 
286 
287 
288 
289 
290 
291 
292 
293 
294 
295 
296 
297 
298 
299 
300 
301 
302 
303 
304 
305 
306 
307 
308 
309 
310 
311 
312 
313 
314 
315 
316 
317 
318 
319 
320 
321 
322 
323 
324 
325 
326 
327 
328 
329 
330 
331 
332 
333 
334 
335 
336 
337 
338 
339 
340 
341 
342 
343 
344 
345 
346 
347 
348 
349 
350 
351 
352 
353 
354 
355 
356 
357 
358 
359 
360 
361 
362 
363 
364 
365 
366 
367 
368 
369 
370 
371 
372 
373 
374 
375 
376 
377 
package wavspliter {

  import java.io._
  import java.nio.{ ByteBuffer, ByteOrder }
  import scala.math._

  object Main {
    import WaveSpliter._

    def main( args: Array[String] ) {

      val silent = 100 // 無音の定義
      val nsilent = 10000 // 無音の持続時間
      val minsize = 200000 // 分割ファイルの最小サイズ

      // コマンドライン引数のチェック
      val (idir, ifile, odir) = args match {
        // 引数が2つある場合。入力ファイルと出力ディレクトリ
        case Array( x, y ) => 
          val f = new File(x)
          (f.getParent, convRegex(f.getName), y)
        // 引数が1つの場合。
        case Array( x ) => 
          val f = new File(x)
          (f.getParent, convRegex(f.getName), f.getParent)
        case _ => throw new Exception("invalid number of arguments")
      }

      val matcher: File => Boolean = _.getAbsolutePath.matches(ifile)
      val splitter = split(new File(odir), silent, nsilent, minsize) _

      ((new File( idir )).listFiles filter matcher) foreach splitter

    }

  }

  object WaveSpliter {

    object Info {

      val ISRC = "ISRC" // メディア元
      val ICRD = "ICRD" // 作成日
      val IPRD = "IPRD" // アルバム名
      val INAM = "INAM" // 曲名
      val IGNR = "IGNR" // ジャンル
      val ICMT = "ICMT" // コメント
      val IART = "IART" // アーティスト
      val ICMS = "ICMS" // 著作権代理人
      val ICOP = "ICOP" // 著作権情報
      val IENG = "IENG" // 録音エンジニア
      val ISFT = "ISFT" // ソフトウェア
      val IKEY = "IKEY" // キーワード
      val ITCH = "ITEC" // エンコード技術者
      val ISBJ = "ISBJ" // タイトル
      val ITRK = "ITRK" // トラック番号
      val ITOC = "ITOC" // 目次

    }

    // fmt フォーマット
    case class AudioHeader(
      val pcmType          : Short,
      val numOfChannels    : Short,
      val samplingRate     : Int,
      val bytesInSec       : Int,
      val blockSize        : Short,
      val sampleSizeInBits : Short,
      val extSize          : Short
    )

    // Wavファイル
    case class WaveFile(
      info        : Map[String, String]// INFO
      audioHeader : AudioHeader, // fmt
      data        : Array[Byte]// sample data
      eachBlock   : (List[Short] => Unit) => Unit // 各ブロックを読む関数
    )

    // バイト列に変換する型クラス
    trait Bytable {
      def toBytes: Array[Byte]
    }

    // IntのBytable
    class BytableInt( x: Int ) extends Bytable {
      def toBytes: Array[Byte] = ByteBuffer.allocate( 4 ).order( ByteOrder.LITTLE_ENDIAN ).putInt( x ).array()
    }

    // ShortのBytable
    class BytableShort( x: Short ) extends Bytable {
      def toBytes: Array[Byte] = ByteBuffer.allocate( 2 ).order( ByteOrder.LITTLE_ENDIAN ).putShort( x ).array()
    }

    // StringのBytable
    class BytableString( x: String ) extends Bytable {
      def toBytes: Array[Byte] = x.getBytes
    }

    // INFOのBytable
    class BytableInfo( x: Map[String, String] ) extends Bytable {
      def toBytes: Array[Byte] = {
        val out = new ByteArrayOutputStream
        x.foreach { case (k, v) =>
          val (size, desc) = byteDesc( v )
          write( out, k )
          write( out, size )
          write( out, desc )
        }
        out.toByteArray
      }
      private def byteDesc( x: String ): (Int, Array[Byte]) = {
        val bs = x.getBytes
        val size = bs.size
        val mod = size % 4
        val ary = new Array[Byte]( mod )
        (size + mod,  bs ++ ary)
      }
    }

    // fmtのBytable
    class BytableAudioHeader( ah: AudioHeader ) extends Bytable {
      def toBytes: Array[Byte] = {
        val out = new ByteArrayOutputStream
        write( out, ah.pcmType )
        write( out, ah.numOfChannels )
        write( out, ah.samplingRate )
        write( out, ah.bytesInSec )
        write( out, ah.blockSize )
        write( out, ah.sampleSizeInBits )
        write( out, ah.extSize )
        out.toByteArray
      }
    }

    // 暗黙の型変換
    implicit def toBytable( x: Int ): Bytable = new BytableInt( x )
    implicit def toBytable( x: Short ): Bytable = new BytableShort( x )
    implicit def toBytable( x: String ): Bytable = new BytableString( x )
    implicit def toBytable( x: Map[String, String] ): Bytable = new BytableInfo( x )
    implicit def toBytable( x: AudioHeader ): Bytable = new BytableAudioHeader( x )

    // Emptyだったら例外を投げる
    def get_![A]( a: Option[A] ): A = a match {
      case Some( x ) => x
      case _ => throw new Exception( "option is empty!" )
    }

    def write( out: OutputStream, x: Array[Byte] ) = out.write( x )

    // Bytable型をOutputStreamに書き込む
    def write( out: OutputStream, x: Bytable ) = out.write( x.toBytes )

    // wavファイルを出力する
    def write( file: File, info: Map[String, String], audioHeader: AudioHeader, data: Array[Byte] ): Unit = {
      val out = new BufferedOutputStream( new FileOutputStream( file ) )
      val infoBytes = info.toBytes
      val ahBytes = audioHeader.toBytes

      val infoSize = infoBytes.size
      val listSize = 4 + infoSize // 'INFO' + infoSize
      val fmtSize = ahBytes.size // ahSize
      val dataSize = data.size // dataSize
      val fSize = 4 + listSize + fmtSize + dataSize // 'WAVE' + listSize + fmtSize + dataSize
      
      write( out, "RIFF" )
      write( out, fSize )
      write( out, "WAVE" )
      write( out, "LIST" )
      write( out, listSize )
      write( out, "INFO" )
      write( out, infoBytes )
      write( out, "fmt " )
      write( out, fmtSize )
      write( out, ahBytes )
      write( out, "data" )
      write( out, dataSize )
      write( out, data )
      out.flush
      out.close
    }

    def readBytes( in: InputStream, size: Int ) = {
      val bytes = new Array[Byte]( size )
      if( in.read( bytes ) < size ) None
      else Some( bytes )
    }

    // InputStreamから文字列を読み取る
    def readString( in: InputStream, size: Int ) = readBytes( in, size ).map( b => new String( b ) )

    // InputStreamからIntを読み取る
    def readInt( in: InputStream ) = readBytes( in, 4 ).map( b => ByteBuffer.wrap( b ).order( ByteOrder.LITTLE_ENDIAN ).getInt )

    // InputStreamからShortを読み取る
    def readShort( in: InputStream ) = readBytes( in, 2 ).map( b => ByteBuffer.wrap( b ).order( ByteOrder.LITTLE_ENDIAN ).getShort )

    // 一部をInputStreamに変換する
    def readAsInputStream( in: InputStream, size: Int ) = readBytes( in, size ).map( toInputStream )

    // バイト列をInputStreamに変換する
    def toInputStream( bytes: Array[Byte] ) = new ByteArrayInputStream( bytes )

    // チャンクの名前とサイズを読み取る
    def readChunkHeader( in: InputStream ) = for {
      name <- readString( in, 4 )
      size <- readInt( in )
    } yield ( name, size )

    // 全てのチャンクを読み取って、各チャンクをfuncに渡す
    def readChunk( in: InputStream )( func: PartialFunction[(String, Array[Byte])Unit] ): Unit = readChunkHeader( in ) match {
      case None => ()
      case Some( (tag, size) ) => readBytes( in, size ).foreach { bs =>
        if( func.isDefinedAt( (tag, bs) ) ) func( (tag, bs) )
        readChunk( in )( func )
      }
    }

    // INFOのLISTチャンクを読み取る
    def readListChunk( in: InputStream ): Map[String, String] = readString( in, 4 ) match {
      case Some( "INFO" ) => 

        def readInfoItem: Option[(String, String)] = for {
          tag <- readString( in, 4 )
          size <- readInt( in )
          desc <- readString( in, size )
        } yield {
          readBytes( in, size % 2 )
          ( tag, desc )
        }

        def readInfo( x: Option[(String, String)] ): List[(String, String)] = x match {
          case Some( y ) => y :: readInfo( readInfoItem )
          case _ => Nil
        }

        readInfo( readInfoItem ).toMap
      case _ => Map[String, String]()
    }

    // fmtチャンクを読み取る
    def readFmtChunk( in: InputStream ) = AudioHeader(
      get_!( readShort( in ) ),
      get_!( readShort( in ) ),
      get_!( readInt( in ) ),
      get_!( readInt( in ) )// byte/sec
      get_!( readShort( in ) )// 
      get_!( readShort( in ) )// bit/sample
      get_!( readShort( in ) )
    )

    // LIST, fmt, dataチャンクを読み取る
    def readChunks( in: InputStream ):(Map[String, String]AudioHeader, Array[Byte]) = {
      var info = Map[String, String]()
      var audioHeader: AudioHeader = null
      var data: Array[Byte] = null

      readChunk( in ) {
        case ("data", bs) => data = bs
        case ("LIST", bs) => info = readListChunk( toInputStream( bs ) )
        case ("fmt ", bs) => audioHeader = readFmtChunk( toInputStream( bs ) )
      }

      if( data == null ) throw new Exception("data chunk is null")
      if( audioHeader == null ) throw new Exception("fmt chunk is null")
      ( info, audioHeader, data )
    }

    // ブロックを読み取る
    def readBlock( data: InputStream, nChan: Short ): List[Short] = {

      def func( data: InputStream, nChan: Short, cnt: Int ): List[Short] = if( cnt == nChan ) {
        readShort( data ).toList
      } else if( cnt < nChan ) readShort( data ) match {
        case None => Nil
        case Some( x ) => func( data, nChan, cnt + 1 ) match {
          case Nil => Nil
          case xs => x :: xs
        }
      } else Nil

      func( data, nChan, 1 )
    }

    def convRegex( s: String ) = s.replaceAll("""\.""""""\\.""").replaceAll("""\*"""""".*""")

    // WAVファイルを開く
    def openWave( file: File ): WaveFile = {

      val in = new BufferedInputStream( new FileInputStream( file ) )
      val riff = get_!(readString( in, 4 ))
      val fileSize = get_!(readInt( in ))
      val wave = get_!(readString( in, 4 ))

      val (info, audioHeader, data) = readChunks( in )

      in.close

      WaveFile(info, audioHeader, data, { func =>
        val in = toInputStream( data )
        var block = readBlock( in, audioHeader.numOfChannels )
        while( block != Nil ) {
          func( block )
          block = readBlock( in, audioHeader.numOfChannels )
        }
      } )
    }

    // wavファイルを無音区間で分割する
    def split( odir: File, silent: Int, nsilent: Int, minsize: Int )( input: File ) = {

      val wf = openWave( input )

      // wavファイルを解析する為のマップ
      //val map = new scala.collection.mutable.HashMap[Int, Int]

      var output = new ByteArrayOutputStream
      var cnt1 = 0
      var cnt2 = 0
      wf.eachBlock { xs =>
        if( abs(xs.head) < silent ) cnt1 += 1
        else {

          // 無音の連続回数を記録する
          //if( cnt1 > 0 ) {
          //  map.get( cnt1 ) match {
          //    case Some( n ) => map.update( cnt1, n + 1 )
          //    case None => map.update( cnt1, 1 )
          //  }
          //}

          if( cnt1 > nsilent && output.size > minsize ) {
            cnt2 += 1
            val bytes = output.toByteArray
            val size = output.size
            val (b1, b2 ) = bytes.splitAt( size - nsilent/)
            WaveSpliter.write(
              outputFile( input, odir, cnt2 ),
              wf.info + (Info.ITRK -> cnt2.toString, Info.INAM -> "English Phrase"Info.IGNR -> "English"),
              wf.audioHeader,
              b1
            )
            output = new ByteArrayOutputStream
            output.write( b2 )
          }
          cnt1 = 0
        }
        xs.foreach { x =>  output.write( x.toBytes ) }
      }

      WaveSpliter.write(
        outputFile( input, odir, cnt2 + 1 ),
        wf.info + (Info.ITRK -> (cnt2 + 1).toString, Info.INAM -> "English Phrase"Info.IGNR -> "English"),
        wf.audioHeader,
        output.toByteArray
      )

      // wavファイル内の無音の連続区間を長い順に表示する
      //var n = 0;
      //map.toList.sortWith { case ((x, _), (y, _)) => x > y }.foreach { case (k, v) =>
      //  n += v
      //  println( k + ": " + v + ", " + n )
      //}

    }

    // 出力ファイルを作成する
    def outputFile( input: File, odir: File, idx: Int ) = {
      val ofile = input.getName.replaceAll("""\.([^\.]+)$""""_%d.out.$1".format( idx ) )
      val opath = "%s\\%s".format(odir.getPath, ofile)
      println("%s" format opath)
      new File( opath )
    }

  }

}

0 件のコメント:

コメントを投稿