Note: We no longer publish the latest version of our code here. We primarily use a kumc-bmi github organization. The heron ETL repository, in particular, is not public. Peers in the informatics community should see MultiSiteDev for details on requesting access.

source: webrtc/webrtc/modules/media_file/source/media_file_utility.cc @ 0:4bda6873e34c

pub_scrub_3792 tip
Last change on this file since 0:4bda6873e34c was 0:4bda6873e34c, checked in by Michael Prittie <mprittie@…>, 6 years ago

Scrubbed password for publication.

File size: 71.6 KB
Line 
1/*
2 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include "webrtc/modules/media_file/source/media_file_utility.h"
12
13#include <assert.h>
14#include <sys/stat.h>
15#include <sys/types.h>
16
17#include "webrtc/common_types.h"
18#include "webrtc/engine_configurations.h"
19#include "webrtc/modules/interface/module_common_types.h"
20#include "webrtc/system_wrappers/interface/file_wrapper.h"
21#include "webrtc/system_wrappers/interface/trace.h"
22
23#ifdef WEBRTC_MODULE_UTILITY_VIDEO
24    #include "avi_file.h"
25#endif
26
27namespace {
28enum WaveFormats
29{
30    kWaveFormatPcm   = 0x0001,
31    kWaveFormatALaw  = 0x0006,
32    kWaveFormatMuLaw = 0x0007
33};
34
35// First 16 bytes the WAVE header. ckID should be "RIFF", wave_ckID should be
36// "WAVE" and ckSize is the chunk size (4 + n)
37struct WAVE_RIFF_header
38{
39    int8_t  ckID[4];
40    int32_t ckSize;
41    int8_t  wave_ckID[4];
42};
43
44// First 8 byte of the format chunk. fmt_ckID should be "fmt ". fmt_ckSize is
45// the chunk size (16, 18 or 40 byte)
46struct WAVE_CHUNK_header
47{
48   int8_t  fmt_ckID[4];
49   int32_t fmt_ckSize;
50};
51}  // unnamed namespace
52
53namespace webrtc {
54ModuleFileUtility::ModuleFileUtility(const int32_t id)
55    : _wavFormatObj(),
56      _dataSize(0),
57      _readSizeBytes(0),
58      _id(id),
59      _stopPointInMs(0),
60      _startPointInMs(0),
61      _playoutPositionMs(0),
62      _bytesWritten(0),
63      codec_info_(),
64      _codecId(kCodecNoCodec),
65      _bytesPerSample(0),
66      _readPos(0),
67      _reading(false),
68      _writing(false),
69      _tempData()
70#ifdef WEBRTC_MODULE_UTILITY_VIDEO
71      ,
72      _aviAudioInFile(0),
73      _aviVideoInFile(0),
74      _aviOutFile(0)
75#endif
76{
77    WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
78                 "ModuleFileUtility::ModuleFileUtility()");
79    memset(&codec_info_,0,sizeof(CodecInst));
80    codec_info_.pltype = -1;
81#ifdef WEBRTC_MODULE_UTILITY_VIDEO
82    memset(&_videoCodec,0,sizeof(_videoCodec));
83#endif
84}
85
86ModuleFileUtility::~ModuleFileUtility()
87{
88    WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
89                 "ModuleFileUtility::~ModuleFileUtility()");
90#ifdef WEBRTC_MODULE_UTILITY_VIDEO
91    delete _aviAudioInFile;
92    delete _aviVideoInFile;
93#endif
94}
95
96#ifdef WEBRTC_MODULE_UTILITY_VIDEO
97int32_t ModuleFileUtility::InitAviWriting(
98    const char* filename,
99    const CodecInst& audioCodecInst,
100    const VideoCodec& videoCodecInst,
101    const bool videoOnly /*= false*/)
102{
103    _writing = false;
104
105    delete _aviOutFile;
106    _aviOutFile = new AviFile( );
107
108    AVISTREAMHEADER videoStreamHeader;
109    videoStreamHeader.fccType = AviFile::MakeFourCc('v', 'i', 'd', 's');
110
111#ifdef VIDEOCODEC_I420
112    if (strncmp(videoCodecInst.plName, "I420", 7) == 0)
113    {
114        videoStreamHeader.fccHandler = AviFile::MakeFourCc('I','4','2','0');
115    }
116#endif
117#ifdef VIDEOCODEC_VP8
118    if (strncmp(videoCodecInst.plName, "VP8", 7) == 0)
119    {
120        videoStreamHeader.fccHandler = AviFile::MakeFourCc('V','P','8','0');
121    }
122#endif
123    if (videoStreamHeader.fccHandler == 0)
124    {
125        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
126                     "InitAviWriting() Codec not supported");
127
128        return -1;
129    }
130    videoStreamHeader.dwScale                = 1;
131    videoStreamHeader.dwRate                 = videoCodecInst.maxFramerate;
132    videoStreamHeader.dwSuggestedBufferSize  = videoCodecInst.height *
133        (videoCodecInst.width >> 1) * 3;
134    videoStreamHeader.dwQuality              = (uint32_t)-1;
135    videoStreamHeader.dwSampleSize           = 0;
136    videoStreamHeader.rcFrame.top            = 0;
137    videoStreamHeader.rcFrame.bottom         = videoCodecInst.height;
138    videoStreamHeader.rcFrame.left           = 0;
139    videoStreamHeader.rcFrame.right          = videoCodecInst.width;
140
141    BITMAPINFOHEADER bitMapInfoHeader;
142    bitMapInfoHeader.biSize         = sizeof(BITMAPINFOHEADER);
143    bitMapInfoHeader.biHeight       = videoCodecInst.height;
144    bitMapInfoHeader.biWidth        = videoCodecInst.width;
145    bitMapInfoHeader.biPlanes       = 1;
146    bitMapInfoHeader.biBitCount     = 12;
147    bitMapInfoHeader.biClrImportant = 0;
148    bitMapInfoHeader.biClrUsed      = 0;
149    bitMapInfoHeader.biCompression  = videoStreamHeader.fccHandler;
150    bitMapInfoHeader.biSizeImage    = bitMapInfoHeader.biWidth *
151        bitMapInfoHeader.biHeight * bitMapInfoHeader.biBitCount / 8;
152
153    if (_aviOutFile->CreateVideoStream(
154        videoStreamHeader,
155        bitMapInfoHeader,
156        NULL,
157        0) != 0)
158    {
159        return -1;
160    }
161
162    if(!videoOnly)
163    {
164        AVISTREAMHEADER audioStreamHeader;
165        audioStreamHeader.fccType = AviFile::MakeFourCc('a', 'u', 'd', 's');
166        // fccHandler is the FOURCC of the codec for decoding the stream.
167        // It's an optional parameter that is not used by audio streams.
168        audioStreamHeader.fccHandler   = 0;
169        audioStreamHeader.dwScale      = 1;
170
171        WAVEFORMATEX waveFormatHeader;
172        waveFormatHeader.cbSize          = 0;
173        waveFormatHeader.nChannels       = 1;
174
175        if (strncmp(audioCodecInst.plname, "PCMU", 4) == 0)
176        {
177            audioStreamHeader.dwSampleSize = 1;
178            audioStreamHeader.dwRate       = 8000;
179            audioStreamHeader.dwQuality    = (uint32_t)-1;
180            audioStreamHeader.dwSuggestedBufferSize = 80;
181
182            waveFormatHeader.nAvgBytesPerSec = 8000;
183            waveFormatHeader.nSamplesPerSec  = 8000;
184            waveFormatHeader.wBitsPerSample  = 8;
185            waveFormatHeader.nBlockAlign     = 1;
186            waveFormatHeader.wFormatTag      = kWaveFormatMuLaw;
187
188        } else if (strncmp(audioCodecInst.plname, "PCMA", 4) == 0)
189        {
190            audioStreamHeader.dwSampleSize = 1;
191            audioStreamHeader.dwRate       = 8000;
192            audioStreamHeader.dwQuality    = (uint32_t)-1;
193            audioStreamHeader.dwSuggestedBufferSize = 80;
194
195            waveFormatHeader.nAvgBytesPerSec = 8000;
196            waveFormatHeader.nSamplesPerSec  = 8000;
197            waveFormatHeader.wBitsPerSample  = 8;
198            waveFormatHeader.nBlockAlign     = 1;
199            waveFormatHeader.wFormatTag      = kWaveFormatALaw;
200
201        } else if (strncmp(audioCodecInst.plname, "L16", 3) == 0)
202        {
203            audioStreamHeader.dwSampleSize = 2;
204            audioStreamHeader.dwRate       = audioCodecInst.plfreq;
205            audioStreamHeader.dwQuality    = (uint32_t)-1;
206            audioStreamHeader.dwSuggestedBufferSize =
207                (audioCodecInst.plfreq/100) * 2;
208
209            waveFormatHeader.nAvgBytesPerSec = audioCodecInst.plfreq * 2;
210            waveFormatHeader.nSamplesPerSec  = audioCodecInst.plfreq;
211            waveFormatHeader.wBitsPerSample  = 16;
212            waveFormatHeader.nBlockAlign     = 2;
213            waveFormatHeader.wFormatTag      = kWaveFormatPcm;
214        } else
215        {
216            return -1;
217        }
218
219        if(_aviOutFile->CreateAudioStream(
220            audioStreamHeader,
221            waveFormatHeader) != 0)
222        {
223            return -1;
224        }
225
226
227        if( InitWavCodec(waveFormatHeader.nSamplesPerSec,
228            waveFormatHeader.nChannels,
229            waveFormatHeader.wBitsPerSample,
230            waveFormatHeader.wFormatTag) != 0)
231        {
232            return -1;
233        }
234    }
235    _aviOutFile->Create(filename);
236    _writing = true;
237    return 0;
238}
239
240int32_t ModuleFileUtility::WriteAviAudioData(
241    const int8_t* buffer,
242    uint32_t bufferLengthInBytes)
243{
244    if( _aviOutFile != 0)
245    {
246        return _aviOutFile->WriteAudio(
247            reinterpret_cast<const uint8_t*>(buffer),
248            bufferLengthInBytes);
249    }
250    else
251    {
252        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "AVI file not initialized");
253        return -1;
254    }
255}
256
257int32_t ModuleFileUtility::WriteAviVideoData(
258        const int8_t* buffer,
259        uint32_t bufferLengthInBytes)
260{
261    if( _aviOutFile != 0)
262    {
263        return _aviOutFile->WriteVideo(
264            reinterpret_cast<const uint8_t*>(buffer),
265            bufferLengthInBytes);
266    }
267    else
268    {
269        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "AVI file not initialized");
270        return -1;
271    }
272}
273
274
275int32_t ModuleFileUtility::CloseAviFile( )
276{
277    if( _reading && _aviAudioInFile)
278    {
279        delete _aviAudioInFile;
280        _aviAudioInFile = 0;
281    }
282
283    if( _reading && _aviVideoInFile)
284    {
285        delete _aviVideoInFile;
286        _aviVideoInFile = 0;
287    }
288
289    if( _writing && _aviOutFile)
290    {
291        delete _aviOutFile;
292        _aviOutFile = 0;
293    }
294    return 0;
295}
296
297
298int32_t ModuleFileUtility::InitAviReading(const char* filename, bool videoOnly,
299                                          bool loop)
300{
301    _reading = false;
302    delete _aviVideoInFile;
303    _aviVideoInFile = new AviFile( );
304
305    if ((_aviVideoInFile != 0) && _aviVideoInFile->Open(AviFile::AVI_VIDEO,
306                                                        filename, loop) == -1)
307    {
308        WEBRTC_TRACE(kTraceError, kTraceVideo, -1,
309                     "Unable to open AVI file (video)");
310        return -1;
311    }
312
313
314    AVISTREAMHEADER videoInStreamHeader;
315    BITMAPINFOHEADER bitmapInfo;
316    char codecConfigParameters[AviFile::CODEC_CONFIG_LENGTH] = {};
317    int32_t configLength = 0;
318    if( _aviVideoInFile->GetVideoStreamInfo(videoInStreamHeader, bitmapInfo,
319                                            codecConfigParameters,
320                                            configLength) != 0)
321    {
322        return -1;
323    }
324    _videoCodec.width = static_cast<uint16_t>(
325        videoInStreamHeader.rcFrame.right);
326    _videoCodec.height = static_cast<uint16_t>(
327        videoInStreamHeader.rcFrame.bottom);
328    _videoCodec.maxFramerate = static_cast<uint8_t>(
329        videoInStreamHeader.dwRate);
330
331    const size_t plnameLen = sizeof(_videoCodec.plName) / sizeof(char);
332    if (bitmapInfo.biCompression == AviFile::MakeFourCc('I','4','2','0'))
333    {
334        strncpy(_videoCodec.plName, "I420", plnameLen);
335       _videoCodec.codecType = kVideoCodecI420;
336    }
337    else if (bitmapInfo.biCompression ==
338             AviFile::MakeFourCc('V', 'P', '8', '0'))
339    {
340        strncpy(_videoCodec.plName, "VP8", plnameLen);
341        _videoCodec.codecType = kVideoCodecVP8;
342    }
343    else
344    {
345        return -1;
346    }
347
348    if(!videoOnly)
349    {
350        delete _aviAudioInFile;
351        _aviAudioInFile = new AviFile();
352
353        if ( (_aviAudioInFile != 0) &&
354            _aviAudioInFile->Open(AviFile::AVI_AUDIO, filename, loop) == -1)
355        {
356            WEBRTC_TRACE(kTraceError, kTraceVideo, -1,
357                         "Unable to open AVI file (audio)");
358            return -1;
359        }
360
361        WAVEFORMATEX waveHeader;
362        if(_aviAudioInFile->GetAudioStreamInfo(waveHeader) != 0)
363        {
364            return -1;
365        }
366        if(InitWavCodec(waveHeader.nSamplesPerSec, waveHeader.nChannels,
367                        waveHeader.wBitsPerSample, waveHeader.wFormatTag) != 0)
368        {
369            return -1;
370        }
371    }
372    _reading = true;
373    return 0;
374}
375
376int32_t ModuleFileUtility::ReadAviAudioData(
377    int8_t*  outBuffer,
378    const uint32_t bufferLengthInBytes)
379{
380    if(_aviAudioInFile == 0)
381    {
382        WEBRTC_TRACE(kTraceError, kTraceVideo, -1, "AVI file not opened.");
383        return -1;
384    }
385
386    int32_t length = bufferLengthInBytes;
387    if(_aviAudioInFile->ReadAudio(
388        reinterpret_cast<uint8_t*>(outBuffer),
389        length) != 0)
390    {
391        return -1;
392    }
393    else
394    {
395        return length;
396    }
397}
398
399int32_t ModuleFileUtility::ReadAviVideoData(
400    int8_t* outBuffer,
401    const uint32_t bufferLengthInBytes)
402{
403    if(_aviVideoInFile == 0)
404    {
405        WEBRTC_TRACE(kTraceError, kTraceVideo, -1, "AVI file not opened.");
406        return -1;
407    }
408
409    int32_t length = bufferLengthInBytes;
410    if( _aviVideoInFile->ReadVideo(
411        reinterpret_cast<uint8_t*>(outBuffer),
412        length) != 0)
413    {
414        return -1;
415    } else {
416        return length;
417    }
418}
419
420int32_t ModuleFileUtility::VideoCodecInst(VideoCodec& codecInst)
421{
422    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
423               "ModuleFileUtility::CodecInst(codecInst= 0x%x)", &codecInst);
424
425   if(!_reading)
426    {
427        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
428                     "CodecInst: not currently reading audio file!");
429        return -1;
430    }
431    memcpy(&codecInst,&_videoCodec,sizeof(VideoCodec));
432    return 0;
433}
434#endif
435
436int32_t ModuleFileUtility::ReadWavHeader(InStream& wav)
437{
438    WAVE_RIFF_header RIFFheaderObj;
439    WAVE_CHUNK_header CHUNKheaderObj;
440    // TODO (hellner): tmpStr and tmpStr2 seems unnecessary here.
441    char tmpStr[6] = "FOUR";
442    unsigned char tmpStr2[4];
443    int32_t i, len;
444    bool dataFound = false;
445    bool fmtFound = false;
446    int8_t dummyRead;
447
448
449    _dataSize = 0;
450    len = wav.Read(&RIFFheaderObj, sizeof(WAVE_RIFF_header));
451    if(len != sizeof(WAVE_RIFF_header))
452    {
453        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
454                     "Not a wave file (too short)");
455        return -1;
456    }
457
458    for (i = 0; i < 4; i++)
459    {
460        tmpStr[i] = RIFFheaderObj.ckID[i];
461    }
462    if(strcmp(tmpStr, "RIFF") != 0)
463    {
464        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
465                     "Not a wave file (does not have RIFF)");
466        return -1;
467    }
468    for (i = 0; i < 4; i++)
469    {
470        tmpStr[i] = RIFFheaderObj.wave_ckID[i];
471    }
472    if(strcmp(tmpStr, "WAVE") != 0)
473    {
474        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
475                     "Not a wave file (does not have WAVE)");
476        return -1;
477    }
478
479    len = wav.Read(&CHUNKheaderObj, sizeof(WAVE_CHUNK_header));
480
481    // WAVE files are stored in little endian byte order. Make sure that the
482    // data can be read on big endian as well.
483    // TODO (hellner): little endian to system byte order should be done in
484    //                 in a subroutine.
485    memcpy(tmpStr2, &CHUNKheaderObj.fmt_ckSize, 4);
486    CHUNKheaderObj.fmt_ckSize =
487        (int32_t) ((uint32_t) tmpStr2[0] +
488                         (((uint32_t)tmpStr2[1])<<8) +
489                         (((uint32_t)tmpStr2[2])<<16) +
490                         (((uint32_t)tmpStr2[3])<<24));
491
492    memcpy(tmpStr, CHUNKheaderObj.fmt_ckID, 4);
493
494    while ((len == sizeof(WAVE_CHUNK_header)) && (!fmtFound || !dataFound))
495    {
496        if(strcmp(tmpStr, "fmt ") == 0)
497        {
498            len = wav.Read(&_wavFormatObj, sizeof(WAVE_FMTINFO_header));
499
500            memcpy(tmpStr2, &_wavFormatObj.formatTag, 2);
501            _wavFormatObj.formatTag =
502                (WaveFormats) ((uint32_t)tmpStr2[0] +
503                               (((uint32_t)tmpStr2[1])<<8));
504            memcpy(tmpStr2, &_wavFormatObj.nChannels, 2);
505            _wavFormatObj.nChannels =
506                (int16_t) ((uint32_t)tmpStr2[0] +
507                                 (((uint32_t)tmpStr2[1])<<8));
508            memcpy(tmpStr2, &_wavFormatObj.nSamplesPerSec, 4);
509            _wavFormatObj.nSamplesPerSec =
510                (int32_t) ((uint32_t)tmpStr2[0] +
511                                 (((uint32_t)tmpStr2[1])<<8) +
512                                 (((uint32_t)tmpStr2[2])<<16) +
513                                 (((uint32_t)tmpStr2[3])<<24));
514            memcpy(tmpStr2, &_wavFormatObj.nAvgBytesPerSec, 4);
515            _wavFormatObj.nAvgBytesPerSec =
516                (int32_t) ((uint32_t)tmpStr2[0] +
517                                 (((uint32_t)tmpStr2[1])<<8) +
518                                 (((uint32_t)tmpStr2[2])<<16) +
519                                 (((uint32_t)tmpStr2[3])<<24));
520            memcpy(tmpStr2, &_wavFormatObj.nBlockAlign, 2);
521            _wavFormatObj.nBlockAlign =
522                (int16_t) ((uint32_t)tmpStr2[0] +
523                                 (((uint32_t)tmpStr2[1])<<8));
524            memcpy(tmpStr2, &_wavFormatObj.nBitsPerSample, 2);
525            _wavFormatObj.nBitsPerSample =
526                (int16_t) ((uint32_t)tmpStr2[0] +
527                                 (((uint32_t)tmpStr2[1])<<8));
528
529            for (i = 0;
530                 i < (CHUNKheaderObj.fmt_ckSize -
531                      (int32_t)sizeof(WAVE_FMTINFO_header));
532                 i++)
533            {
534                len = wav.Read(&dummyRead, 1);
535                if(len != 1)
536                {
537                    WEBRTC_TRACE(kTraceError, kTraceFile, _id,
538                                 "File corrupted, reached EOF (reading fmt)");
539                    return -1;
540                }
541            }
542            fmtFound = true;
543        }
544        else if(strcmp(tmpStr, "data") == 0)
545        {
546            _dataSize = CHUNKheaderObj.fmt_ckSize;
547            dataFound = true;
548            break;
549        }
550        else
551        {
552            for (i = 0; i < (CHUNKheaderObj.fmt_ckSize); i++)
553            {
554                len = wav.Read(&dummyRead, 1);
555                if(len != 1)
556                {
557                    WEBRTC_TRACE(kTraceError, kTraceFile, _id,
558                                 "File corrupted, reached EOF (reading other)");
559                    return -1;
560                }
561            }
562        }
563
564        len = wav.Read(&CHUNKheaderObj, sizeof(WAVE_CHUNK_header));
565
566        memcpy(tmpStr2, &CHUNKheaderObj.fmt_ckSize, 4);
567        CHUNKheaderObj.fmt_ckSize =
568            (int32_t) ((uint32_t)tmpStr2[0] +
569                             (((uint32_t)tmpStr2[1])<<8) +
570                             (((uint32_t)tmpStr2[2])<<16) +
571                             (((uint32_t)tmpStr2[3])<<24));
572
573        memcpy(tmpStr, CHUNKheaderObj.fmt_ckID, 4);
574    }
575
576    // Either a proper format chunk has been read or a data chunk was come
577    // across.
578    if( (_wavFormatObj.formatTag != kWaveFormatPcm) &&
579        (_wavFormatObj.formatTag != kWaveFormatALaw) &&
580        (_wavFormatObj.formatTag != kWaveFormatMuLaw))
581    {
582        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
583                     "Coding formatTag value=%d not supported!",
584                     _wavFormatObj.formatTag);
585        return -1;
586    }
587    if((_wavFormatObj.nChannels < 1) ||
588        (_wavFormatObj.nChannels > 2))
589    {
590        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
591                     "nChannels value=%d not supported!",
592                     _wavFormatObj.nChannels);
593        return -1;
594    }
595
596    if((_wavFormatObj.nBitsPerSample != 8) &&
597        (_wavFormatObj.nBitsPerSample != 16))
598    {
599        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
600                     "nBitsPerSample value=%d not supported!",
601                     _wavFormatObj.nBitsPerSample);
602        return -1;
603    }
604
605    // Calculate the number of bytes that 10 ms of audio data correspond to.
606    if(_wavFormatObj.formatTag == kWaveFormatPcm)
607    {
608        // TODO (hellner): integer division for 22050 and 11025 would yield
609        //                 the same result as the else statement. Remove those
610        //                 special cases?
611        if(_wavFormatObj.nSamplesPerSec == 44100)
612        {
613            _readSizeBytes = 440 * _wavFormatObj.nChannels *
614                (_wavFormatObj.nBitsPerSample / 8);
615        } else if(_wavFormatObj.nSamplesPerSec == 22050) {
616            _readSizeBytes = 220 * _wavFormatObj.nChannels *
617                (_wavFormatObj.nBitsPerSample / 8);
618        } else if(_wavFormatObj.nSamplesPerSec == 11025) {
619            _readSizeBytes = 110 * _wavFormatObj.nChannels *
620                (_wavFormatObj.nBitsPerSample / 8);
621        } else {
622            _readSizeBytes = (_wavFormatObj.nSamplesPerSec/100) *
623              _wavFormatObj.nChannels * (_wavFormatObj.nBitsPerSample / 8);
624        }
625
626    } else {
627        _readSizeBytes = (_wavFormatObj.nSamplesPerSec/100) *
628            _wavFormatObj.nChannels * (_wavFormatObj.nBitsPerSample / 8);
629    }
630    return 0;
631}
632
633int32_t ModuleFileUtility::InitWavCodec(uint32_t samplesPerSec,
634                                        uint32_t channels,
635                                        uint32_t bitsPerSample,
636                                        uint32_t formatTag)
637{
638    codec_info_.pltype   = -1;
639    codec_info_.plfreq   = samplesPerSec;
640    codec_info_.channels = channels;
641    codec_info_.rate     = bitsPerSample * samplesPerSec;
642
643    // Calculate the packet size for 10ms frames
644    switch(formatTag)
645    {
646    case kWaveFormatALaw:
647        strcpy(codec_info_.plname, "PCMA");
648        _codecId = kCodecPcma;
649        codec_info_.pltype = 8;
650        codec_info_.pacsize  = codec_info_.plfreq / 100;
651        break;
652    case kWaveFormatMuLaw:
653        strcpy(codec_info_.plname, "PCMU");
654        _codecId = kCodecPcmu;
655        codec_info_.pltype = 0;
656        codec_info_.pacsize  = codec_info_.plfreq / 100;
657         break;
658    case kWaveFormatPcm:
659        codec_info_.pacsize  = (bitsPerSample * (codec_info_.plfreq / 100)) / 8;
660        if(samplesPerSec == 8000)
661        {
662            strcpy(codec_info_.plname, "L16");
663            _codecId = kCodecL16_8Khz;
664        }
665        else if(samplesPerSec == 16000)
666        {
667            strcpy(codec_info_.plname, "L16");
668            _codecId = kCodecL16_16kHz;
669        }
670        else if(samplesPerSec == 32000)
671        {
672            strcpy(codec_info_.plname, "L16");
673            _codecId = kCodecL16_32Khz;
674        }
675        // Set the packet size for "odd" sampling frequencies so that it
676        // properly corresponds to _readSizeBytes.
677        else if(samplesPerSec == 11025)
678        {
679            strcpy(codec_info_.plname, "L16");
680            _codecId = kCodecL16_16kHz;
681            codec_info_.pacsize = 110;
682            codec_info_.plfreq = 11000;
683        }
684        else if(samplesPerSec == 22050)
685        {
686            strcpy(codec_info_.plname, "L16");
687            _codecId = kCodecL16_16kHz;
688            codec_info_.pacsize = 220;
689            codec_info_.plfreq = 22000;
690        }
691        else if(samplesPerSec == 44100)
692        {
693            strcpy(codec_info_.plname, "L16");
694            _codecId = kCodecL16_16kHz;
695            codec_info_.pacsize = 440;
696            codec_info_.plfreq = 44000;
697        }
698        else if(samplesPerSec == 48000)
699        {
700            strcpy(codec_info_.plname, "L16");
701            _codecId = kCodecL16_16kHz;
702            codec_info_.pacsize = 480;
703            codec_info_.plfreq = 48000;
704        }
705        else
706        {
707            WEBRTC_TRACE(kTraceError, kTraceFile, _id,
708                         "Unsupported PCM frequency!");
709            return -1;
710        }
711        break;
712        default:
713            WEBRTC_TRACE(kTraceError, kTraceFile, _id,
714                         "unknown WAV format TAG!");
715            return -1;
716            break;
717    }
718    return 0;
719}
720
721int32_t ModuleFileUtility::InitWavReading(InStream& wav,
722                                          const uint32_t start,
723                                          const uint32_t stop)
724{
725
726    _reading = false;
727
728    if(ReadWavHeader(wav) == -1)
729    {
730        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
731                     "failed to read WAV header!");
732        return -1;
733    }
734
735    _playoutPositionMs = 0;
736    _readPos = 0;
737
738    if(start > 0)
739    {
740        uint8_t dummy[WAV_MAX_BUFFER_SIZE];
741        int32_t readLength;
742        if(_readSizeBytes <= WAV_MAX_BUFFER_SIZE)
743        {
744            while (_playoutPositionMs < start)
745            {
746                readLength = wav.Read(dummy, _readSizeBytes);
747                if(readLength == _readSizeBytes)
748                {
749                    _readPos += readLength;
750                    _playoutPositionMs += 10;
751                }
752                else // Must have reached EOF before start position!
753                {
754                    WEBRTC_TRACE(kTraceError, kTraceFile, _id,
755                       "InitWavReading(), EOF before start position");
756                    return -1;
757                }
758            }
759        }
760        else
761        {
762            return -1;
763        }
764    }
765    if( InitWavCodec(_wavFormatObj.nSamplesPerSec, _wavFormatObj.nChannels,
766                     _wavFormatObj.nBitsPerSample,
767                     _wavFormatObj.formatTag) != 0)
768    {
769        return -1;
770    }
771    _bytesPerSample = _wavFormatObj.nBitsPerSample / 8;
772
773
774    _startPointInMs = start;
775    _stopPointInMs = stop;
776    _reading = true;
777    return 0;
778}
779
780int32_t ModuleFileUtility::ReadWavDataAsMono(
781    InStream& wav,
782    int8_t* outData,
783    const uint32_t bufferSize)
784{
785    WEBRTC_TRACE(
786        kTraceStream,
787        kTraceFile,
788        _id,
789        "ModuleFileUtility::ReadWavDataAsMono(wav= 0x%x, outData= 0x%d,\
790 bufSize= %ld)",
791        &wav,
792        outData,
793        bufferSize);
794
795    // The number of bytes that should be read from file.
796    const uint32_t totalBytesNeeded = _readSizeBytes;
797    // The number of bytes that will be written to outData.
798    const uint32_t bytesRequested = (codec_info_.channels == 2) ?
799        totalBytesNeeded >> 1 : totalBytesNeeded;
800    if(bufferSize < bytesRequested)
801    {
802        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
803                     "ReadWavDataAsMono: output buffer is too short!");
804        return -1;
805    }
806    if(outData == NULL)
807    {
808        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
809                     "ReadWavDataAsMono: output buffer NULL!");
810        return -1;
811    }
812
813    if(!_reading)
814    {
815        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
816                     "ReadWavDataAsMono: no longer reading file.");
817        return -1;
818    }
819
820    int32_t bytesRead = ReadWavData(
821        wav,
822        (codec_info_.channels == 2) ? _tempData : (uint8_t*)outData,
823        totalBytesNeeded);
824    if(bytesRead == 0)
825    {
826        return 0;
827    }
828    if(bytesRead < 0)
829    {
830        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
831                     "ReadWavDataAsMono: failed to read data from WAV file.");
832        return -1;
833    }
834    // Output data is should be mono.
835    if(codec_info_.channels == 2)
836    {
837        for (uint32_t i = 0; i < bytesRequested / _bytesPerSample; i++)
838        {
839            // Sample value is the average of left and right buffer rounded to
840            // closest integer value. Note samples can be either 1 or 2 byte.
841            if(_bytesPerSample == 1)
842            {
843                _tempData[i] = ((_tempData[2 * i] + _tempData[(2 * i) + 1] +
844                                 1) >> 1);
845            }
846            else
847            {
848                int16_t* sampleData = (int16_t*) _tempData;
849                sampleData[i] = ((sampleData[2 * i] + sampleData[(2 * i) + 1] +
850                                  1) >> 1);
851            }
852        }
853        memcpy(outData, _tempData, bytesRequested);
854    }
855    return bytesRequested;
856}
857
858int32_t ModuleFileUtility::ReadWavDataAsStereo(
859    InStream& wav,
860    int8_t* outDataLeft,
861    int8_t* outDataRight,
862    const uint32_t bufferSize)
863{
864    WEBRTC_TRACE(
865        kTraceStream,
866        kTraceFile,
867        _id,
868        "ModuleFileUtility::ReadWavDataAsStereo(wav= 0x%x, outLeft= 0x%x,\
869 outRight= 0x%x, bufSize= %ld)",
870        &wav,
871        outDataLeft,
872        outDataRight,
873        bufferSize);
874
875    if((outDataLeft == NULL) ||
876       (outDataRight == NULL))
877    {
878        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
879                     "ReadWavDataAsMono: an input buffer is NULL!");
880        return -1;
881    }
882    if(codec_info_.channels != 2)
883    {
884        WEBRTC_TRACE(
885            kTraceError,
886            kTraceFile,
887            _id,
888            "ReadWavDataAsStereo: WAV file does not contain stereo data!");
889        return -1;
890    }
891    if(! _reading)
892    {
893        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
894                     "ReadWavDataAsStereo: no longer reading file.");
895        return -1;
896    }
897
898    // The number of bytes that should be read from file.
899    const uint32_t totalBytesNeeded = _readSizeBytes;
900    // The number of bytes that will be written to the left and the right
901    // buffers.
902    const uint32_t bytesRequested = totalBytesNeeded >> 1;
903    if(bufferSize < bytesRequested)
904    {
905        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
906                     "ReadWavData: Output buffers are too short!");
907        assert(false);
908        return -1;
909    }
910
911    int32_t bytesRead = ReadWavData(wav, _tempData, totalBytesNeeded);
912    if(bytesRead <= 0)
913    {
914        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
915                     "ReadWavDataAsStereo: failed to read data from WAV file.");
916        return -1;
917    }
918
919    // Turn interleaved audio to left and right buffer. Note samples can be
920    // either 1 or 2 bytes
921    if(_bytesPerSample == 1)
922    {
923        for (uint32_t i = 0; i < bytesRequested; i++)
924        {
925            outDataLeft[i]  = _tempData[2 * i];
926            outDataRight[i] = _tempData[(2 * i) + 1];
927        }
928    }
929    else if(_bytesPerSample == 2)
930    {
931        int16_t* sampleData = reinterpret_cast<int16_t*>(_tempData);
932        int16_t* outLeft = reinterpret_cast<int16_t*>(outDataLeft);
933        int16_t* outRight = reinterpret_cast<int16_t*>(
934            outDataRight);
935
936        // Bytes requested to samples requested.
937        uint32_t sampleCount = bytesRequested >> 1;
938        for (uint32_t i = 0; i < sampleCount; i++)
939        {
940            outLeft[i] = sampleData[2 * i];
941            outRight[i] = sampleData[(2 * i) + 1];
942        }
943    } else {
944        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
945                   "ReadWavStereoData: unsupported sample size %d!",
946                   _bytesPerSample);
947        assert(false);
948        return -1;
949    }
950    return bytesRequested;
951}
952
953int32_t ModuleFileUtility::ReadWavData(
954    InStream& wav,
955    uint8_t* buffer,
956    const uint32_t dataLengthInBytes)
957{
958    WEBRTC_TRACE(
959        kTraceStream,
960        kTraceFile,
961        _id,
962        "ModuleFileUtility::ReadWavData(wav= 0x%x, buffer= 0x%x, dataLen= %ld)",
963        &wav,
964        buffer,
965        dataLengthInBytes);
966
967
968    if(buffer == NULL)
969    {
970        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
971                     "ReadWavDataAsMono: output buffer NULL!");
972        return -1;
973    }
974
975    // Make sure that a read won't return too few samples.
976    // TODO (hellner): why not read the remaining bytes needed from the start
977    //                 of the file?
978    if((_dataSize - _readPos) < (int32_t)dataLengthInBytes)
979    {
980        // Rewind() being -1 may be due to the file not supposed to be looped.
981        if(wav.Rewind() == -1)
982        {
983            _reading = false;
984            return 0;
985        }
986        if(InitWavReading(wav, _startPointInMs, _stopPointInMs) == -1)
987        {
988            _reading = false;
989            return -1;
990        }
991    }
992
993    int32_t bytesRead = wav.Read(buffer, dataLengthInBytes);
994    if(bytesRead < 0)
995    {
996        _reading = false;
997        return -1;
998    }
999
1000    // This should never happen due to earlier sanity checks.
1001    // TODO (hellner): change to an assert and fail here since this should
1002    //                 never happen...
1003    if(bytesRead < (int32_t)dataLengthInBytes)
1004    {
1005        if((wav.Rewind() == -1) ||
1006            (InitWavReading(wav, _startPointInMs, _stopPointInMs) == -1))
1007        {
1008            _reading = false;
1009            return -1;
1010        }
1011        else
1012        {
1013            bytesRead = wav.Read(buffer, dataLengthInBytes);
1014            if(bytesRead < (int32_t)dataLengthInBytes)
1015            {
1016                _reading = false;
1017                return -1;
1018            }
1019        }
1020    }
1021
1022    _readPos += bytesRead;
1023
1024    // TODO (hellner): Why is dataLengthInBytes let dictate the number of bytes
1025    //                 to read when exactly 10ms should be read?!
1026    _playoutPositionMs += 10;
1027    if((_stopPointInMs > 0) &&
1028        (_playoutPositionMs >= _stopPointInMs))
1029    {
1030        if((wav.Rewind() == -1) ||
1031            (InitWavReading(wav, _startPointInMs, _stopPointInMs) == -1))
1032        {
1033            _reading = false;
1034        }
1035    }
1036    return bytesRead;
1037}
1038
1039int32_t ModuleFileUtility::InitWavWriting(OutStream& wav,
1040                                          const CodecInst& codecInst)
1041{
1042
1043    if(set_codec_info(codecInst) != 0)
1044    {
1045        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1046                     "codecInst identifies unsupported codec!");
1047        return -1;
1048    }
1049    _writing = false;
1050    uint32_t channels = (codecInst.channels == 0) ?
1051        1 : codecInst.channels;
1052
1053    if(STR_CASE_CMP(codecInst.plname, "PCMU") == 0)
1054    {
1055        _bytesPerSample = 1;
1056        if(WriteWavHeader(wav, 8000, _bytesPerSample, channels,
1057                          kWaveFormatMuLaw, 0) == -1)
1058        {
1059            return -1;
1060        }
1061    }else if(STR_CASE_CMP(codecInst.plname, "PCMA") == 0)
1062    {
1063        _bytesPerSample = 1;
1064        if(WriteWavHeader(wav, 8000, _bytesPerSample, channels, kWaveFormatALaw,
1065                          0) == -1)
1066        {
1067            return -1;
1068        }
1069    }
1070    else if(STR_CASE_CMP(codecInst.plname, "L16") == 0)
1071    {
1072        _bytesPerSample = 2;
1073        if(WriteWavHeader(wav, codecInst.plfreq, _bytesPerSample, channels,
1074                          kWaveFormatPcm, 0) == -1)
1075        {
1076            return -1;
1077        }
1078    }
1079    else
1080    {
1081        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1082                   "codecInst identifies unsupported codec for WAV file!");
1083        return -1;
1084    }
1085    _writing = true;
1086    _bytesWritten = 0;
1087    return 0;
1088}
1089
1090int32_t ModuleFileUtility::WriteWavData(OutStream& out,
1091                                        const int8_t*  buffer,
1092                                        const uint32_t dataLength)
1093{
1094    WEBRTC_TRACE(
1095        kTraceStream,
1096        kTraceFile,
1097        _id,
1098        "ModuleFileUtility::WriteWavData(out= 0x%x, buf= 0x%x, dataLen= %d)",
1099        &out,
1100        buffer,
1101        dataLength);
1102
1103    if(buffer == NULL)
1104    {
1105        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1106                     "WriteWavData: input buffer NULL!");
1107        return -1;
1108    }
1109
1110    if(!out.Write(buffer, dataLength))
1111    {
1112        return -1;
1113    }
1114    _bytesWritten += dataLength;
1115    return dataLength;
1116}
1117
1118
1119int32_t ModuleFileUtility::WriteWavHeader(
1120    OutStream& wav,
1121    const uint32_t freq,
1122    const uint32_t bytesPerSample,
1123    const uint32_t channels,
1124    const uint32_t format,
1125    const uint32_t lengthInBytes)
1126{
1127
1128    // Frame size in bytes for 10 ms of audio.
1129    // TODO (hellner): 44.1 kHz has 440 samples frame size. Doesn't seem to
1130    //                 be taken into consideration here!
1131    int32_t frameSize = (freq / 100) * bytesPerSample * channels;
1132
1133    // Calculate the number of full frames that the wave file contain.
1134    const int32_t dataLengthInBytes = frameSize *
1135        (lengthInBytes / frameSize);
1136
1137    int8_t tmpStr[4];
1138    int8_t tmpChar;
1139    uint32_t tmpLong;
1140
1141    memcpy(tmpStr, "RIFF", 4);
1142    wav.Write(tmpStr, 4);
1143
1144    tmpLong = dataLengthInBytes + 36;
1145    tmpChar = (int8_t)(tmpLong);
1146    wav.Write(&tmpChar, 1);
1147    tmpChar = (int8_t)(tmpLong >> 8);
1148    wav.Write(&tmpChar, 1);
1149    tmpChar = (int8_t)(tmpLong >> 16);
1150    wav.Write(&tmpChar, 1);
1151    tmpChar = (int8_t)(tmpLong >> 24);
1152    wav.Write(&tmpChar, 1);
1153
1154    memcpy(tmpStr, "WAVE", 4);
1155    wav.Write(tmpStr, 4);
1156
1157    memcpy(tmpStr, "fmt ", 4);
1158    wav.Write(tmpStr, 4);
1159
1160    tmpChar = 16;
1161    wav.Write(&tmpChar, 1);
1162    tmpChar = 0;
1163    wav.Write(&tmpChar, 1);
1164    tmpChar = 0;
1165    wav.Write(&tmpChar, 1);
1166    tmpChar = 0;
1167    wav.Write(&tmpChar, 1);
1168
1169    tmpChar = (int8_t)(format);
1170    wav.Write(&tmpChar, 1);
1171    tmpChar = 0;
1172    wav.Write(&tmpChar, 1);
1173
1174    tmpChar = (int8_t)(channels);
1175    wav.Write(&tmpChar, 1);
1176    tmpChar = 0;
1177    wav.Write(&tmpChar, 1);
1178
1179    tmpLong = freq;
1180    tmpChar = (int8_t)(tmpLong);
1181    wav.Write(&tmpChar, 1);
1182    tmpChar = (int8_t)(tmpLong >> 8);
1183    wav.Write(&tmpChar, 1);
1184    tmpChar = (int8_t)(tmpLong >> 16);
1185    wav.Write(&tmpChar, 1);
1186    tmpChar = (int8_t)(tmpLong >> 24);
1187    wav.Write(&tmpChar, 1);
1188
1189    // nAverageBytesPerSec = Sample rate * Bytes per sample * Channels
1190    tmpLong = bytesPerSample * freq * channels;
1191    tmpChar = (int8_t)(tmpLong);
1192    wav.Write(&tmpChar, 1);
1193    tmpChar = (int8_t)(tmpLong >> 8);
1194    wav.Write(&tmpChar, 1);
1195    tmpChar = (int8_t)(tmpLong >> 16);
1196    wav.Write(&tmpChar, 1);
1197    tmpChar = (int8_t)(tmpLong >> 24);
1198    wav.Write(&tmpChar, 1);
1199
1200    // nBlockAlign = Bytes per sample * Channels
1201    tmpChar = (int8_t)(bytesPerSample * channels);
1202    wav.Write(&tmpChar, 1);
1203    tmpChar = 0;
1204    wav.Write(&tmpChar, 1);
1205
1206    tmpChar = (int8_t)(bytesPerSample*8);
1207    wav.Write(&tmpChar, 1);
1208    tmpChar = 0;
1209    wav.Write(&tmpChar, 1);
1210
1211    memcpy(tmpStr, "data", 4);
1212    wav.Write(tmpStr, 4);
1213
1214    tmpLong = dataLengthInBytes;
1215    tmpChar = (int8_t)(tmpLong);
1216    wav.Write(&tmpChar, 1);
1217    tmpChar = (int8_t)(tmpLong >> 8);
1218    wav.Write(&tmpChar, 1);
1219    tmpChar = (int8_t)(tmpLong >> 16);
1220    wav.Write(&tmpChar, 1);
1221    tmpChar = (int8_t)(tmpLong >> 24);
1222    wav.Write(&tmpChar, 1);
1223
1224    return 0;
1225}
1226
1227int32_t ModuleFileUtility::UpdateWavHeader(OutStream& wav)
1228{
1229    int32_t res = -1;
1230    if(wav.Rewind() == -1)
1231    {
1232        return -1;
1233    }
1234    uint32_t channels = (codec_info_.channels == 0) ?
1235        1 : codec_info_.channels;
1236
1237    if(STR_CASE_CMP(codec_info_.plname, "L16") == 0)
1238    {
1239        res = WriteWavHeader(wav, codec_info_.plfreq, 2, channels,
1240                             kWaveFormatPcm, _bytesWritten);
1241    } else if(STR_CASE_CMP(codec_info_.plname, "PCMU") == 0) {
1242            res = WriteWavHeader(wav, 8000, 1, channels, kWaveFormatMuLaw,
1243                                 _bytesWritten);
1244    } else if(STR_CASE_CMP(codec_info_.plname, "PCMA") == 0) {
1245            res = WriteWavHeader(wav, 8000, 1, channels, kWaveFormatALaw,
1246                                 _bytesWritten);
1247    } else {
1248        // Allow calling this API even if not writing to a WAVE file.
1249        // TODO (hellner): why?!
1250        return 0;
1251    }
1252    return res;
1253}
1254
1255
1256int32_t ModuleFileUtility::InitPreEncodedReading(InStream& in,
1257                                                 const CodecInst& cinst)
1258{
1259
1260    uint8_t preEncodedID;
1261    in.Read(&preEncodedID, 1);
1262
1263    MediaFileUtility_CodecType codecType =
1264        (MediaFileUtility_CodecType)preEncodedID;
1265
1266    if(set_codec_info(cinst) != 0)
1267    {
1268        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1269                     "Pre-encoded file send codec mismatch!");
1270        return -1;
1271    }
1272    if(codecType != _codecId)
1273    {
1274        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1275                     "Pre-encoded file format codec mismatch!");
1276        return -1;
1277    }
1278    memcpy(&codec_info_,&cinst,sizeof(CodecInst));
1279    _reading = true;
1280    return 0;
1281}
1282
1283int32_t ModuleFileUtility::ReadPreEncodedData(
1284    InStream& in,
1285    int8_t* outData,
1286    const uint32_t bufferSize)
1287{
1288    WEBRTC_TRACE(
1289        kTraceStream,
1290        kTraceFile,
1291        _id,
1292        "ModuleFileUtility::ReadPreEncodedData(in= 0x%x, outData= 0x%x,\
1293 bufferSize= %d)",
1294        &in,
1295        outData,
1296        bufferSize);
1297
1298    if(outData == NULL)
1299    {
1300        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "output buffer NULL");
1301    }
1302
1303    uint32_t frameLen;
1304    uint8_t buf[64];
1305    // Each frame has a two byte header containing the frame length.
1306    int32_t res = in.Read(buf, 2);
1307    if(res != 2)
1308    {
1309        if(!in.Rewind())
1310        {
1311            // The first byte is the codec identifier.
1312            in.Read(buf, 1);
1313            res = in.Read(buf, 2);
1314        }
1315        else
1316        {
1317            return -1;
1318        }
1319    }
1320    frameLen = buf[0] + buf[1] * 256;
1321    if(bufferSize < frameLen)
1322    {
1323        WEBRTC_TRACE(
1324            kTraceError,
1325            kTraceFile,
1326            _id,
1327            "buffer not large enough to read %d bytes of pre-encoded data!",
1328            frameLen);
1329        return -1;
1330    }
1331    return in.Read(outData, frameLen);
1332}
1333
1334int32_t ModuleFileUtility::InitPreEncodedWriting(
1335    OutStream& out,
1336    const CodecInst& codecInst)
1337{
1338
1339    if(set_codec_info(codecInst) != 0)
1340    {
1341        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "CodecInst not recognized!");
1342        return -1;
1343    }
1344    _writing = true;
1345    _bytesWritten = 1;
1346     out.Write(&_codecId, 1);
1347     return 0;
1348}
1349
1350int32_t ModuleFileUtility::WritePreEncodedData(
1351    OutStream& out,
1352    const int8_t*  buffer,
1353    const uint32_t dataLength)
1354{
1355    WEBRTC_TRACE(
1356        kTraceStream,
1357        kTraceFile,
1358        _id,
1359        "ModuleFileUtility::WritePreEncodedData(out= 0x%x, inData= 0x%x,\
1360 dataLen= %d)",
1361        &out,
1362        buffer,
1363        dataLength);
1364
1365    if(buffer == NULL)
1366    {
1367        WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
1368    }
1369
1370    int32_t bytesWritten = 0;
1371    // The first two bytes is the size of the frame.
1372    int16_t lengthBuf;
1373    lengthBuf = (int16_t)dataLength;
1374    if(!out.Write(&lengthBuf, 2))
1375    {
1376       return -1;
1377    }
1378    bytesWritten = 2;
1379
1380    if(!out.Write(buffer, dataLength))
1381    {
1382        return -1;
1383    }
1384    bytesWritten += dataLength;
1385    return bytesWritten;
1386}
1387
1388int32_t ModuleFileUtility::InitCompressedReading(
1389    InStream& in,
1390    const uint32_t start,
1391    const uint32_t stop)
1392{
1393    WEBRTC_TRACE(
1394        kTraceDebug,
1395        kTraceFile,
1396        _id,
1397        "ModuleFileUtility::InitCompressedReading(in= 0x%x, start= %d,\
1398 stop= %d)",
1399        &in,
1400        start,
1401        stop);
1402
1403#if defined(WEBRTC_CODEC_AMR) || defined(WEBRTC_CODEC_AMRWB) || \
1404    defined(WEBRTC_CODEC_ILBC)
1405    int16_t read_len = 0;
1406#endif
1407    _codecId = kCodecNoCodec;
1408    _playoutPositionMs = 0;
1409    _reading = false;
1410
1411    _startPointInMs = start;
1412    _stopPointInMs = stop;
1413
1414#ifdef WEBRTC_CODEC_AMR
1415    int32_t AMRmode2bytes[9]={12,13,15,17,19,20,26,31,5};
1416#endif
1417#ifdef WEBRTC_CODEC_AMRWB
1418    int32_t AMRWBmode2bytes[10]={17,23,32,36,40,46,50,58,60,6};
1419#endif
1420
1421    // Read the codec name
1422    int32_t cnt = 0;
1423    char buf[64];
1424    do
1425    {
1426        in.Read(&buf[cnt++], 1);
1427    } while ((buf[cnt-1] != '\n') && (64 > cnt));
1428
1429    if(cnt==64)
1430    {
1431        return -1;
1432    } else {
1433        buf[cnt]=0;
1434    }
1435
1436#ifdef WEBRTC_CODEC_AMR
1437    if(!strcmp("#!AMR\n", buf))
1438    {
1439        strcpy(codec_info_.plname, "amr");
1440        codec_info_.pacsize = 160;
1441        _codecId = kCodecAmr;
1442        codec_info_.pltype = 112;
1443        codec_info_.rate = 12200;
1444        codec_info_.plfreq = 8000;
1445        codec_info_.channels = 1;
1446
1447        int16_t mode = 0;
1448        if(_startPointInMs > 0)
1449        {
1450            while (_playoutPositionMs <= _startPointInMs)
1451            {
1452                // First read byte contain the AMR mode.
1453                read_len = in.Read(buf, 1);
1454                if(read_len != 1)
1455                {
1456                    return -1;
1457                }
1458
1459                mode = (buf[0]>>3)&0xF;
1460                if((mode < 0) || (mode > 8))
1461                {
1462                    if(mode != 15)
1463                    {
1464                        return -1;
1465                    }
1466                }
1467                if(mode != 15)
1468                {
1469                    read_len = in.Read(&buf[1], AMRmode2bytes[mode]);
1470                    if(read_len != AMRmode2bytes[mode])
1471                    {
1472                        return -1;
1473                    }
1474                }
1475                _playoutPositionMs += 20;
1476            }
1477        }
1478    }
1479#endif
1480#ifdef WEBRTC_CODEC_AMRWB
1481    if(!strcmp("#!AMRWB\n", buf))
1482    {
1483        strcpy(codec_info_.plname, "amr-wb");
1484        codec_info_.pacsize = 320;
1485        _codecId = kCodecAmrWb;
1486        codec_info_.pltype = 120;
1487        codec_info_.rate = 20000;
1488        codec_info_.plfreq = 16000;
1489        codec_info_.channels = 1;
1490
1491        int16_t mode = 0;
1492        if(_startPointInMs > 0)
1493        {
1494            while (_playoutPositionMs <= _startPointInMs)
1495            {
1496                // First read byte contain the AMR mode.
1497                read_len = in.Read(buf, 1);
1498                if(read_len != 1)
1499                {
1500                    return -1;
1501                }
1502
1503                mode = (buf[0]>>3)&0xF;
1504                if((mode < 0) || (mode > 9))
1505                {
1506                    if(mode != 15)
1507                    {
1508                        return -1;
1509                    }
1510                }
1511                if(mode != 15)
1512                {
1513                    read_len = in.Read(&buf[1], AMRWBmode2bytes[mode]);
1514                    if(read_len != AMRWBmode2bytes[mode])
1515                    {
1516                        return -1;
1517                    }
1518                }
1519                _playoutPositionMs += 20;
1520            }
1521        }
1522    }
1523#endif
1524#ifdef WEBRTC_CODEC_ILBC
1525    if(!strcmp("#!iLBC20\n", buf))
1526    {
1527        codec_info_.pltype = 102;
1528        strcpy(codec_info_.plname, "ilbc");
1529        codec_info_.plfreq   = 8000;
1530        codec_info_.pacsize  = 160;
1531        codec_info_.channels = 1;
1532        codec_info_.rate     = 13300;
1533        _codecId = kCodecIlbc20Ms;
1534
1535        if(_startPointInMs > 0)
1536        {
1537            while (_playoutPositionMs <= _startPointInMs)
1538            {
1539                read_len = in.Read(buf, 38);
1540                if(read_len == 38)
1541                {
1542                    _playoutPositionMs += 20;
1543                }
1544                else
1545                {
1546                    return -1;
1547                }
1548            }
1549        }
1550    }
1551
1552    if(!strcmp("#!iLBC30\n", buf))
1553    {
1554        codec_info_.pltype = 102;
1555        strcpy(codec_info_.plname, "ilbc");
1556        codec_info_.plfreq   = 8000;
1557        codec_info_.pacsize  = 240;
1558        codec_info_.channels = 1;
1559        codec_info_.rate     = 13300;
1560        _codecId = kCodecIlbc30Ms;
1561
1562        if(_startPointInMs > 0)
1563        {
1564            while (_playoutPositionMs <= _startPointInMs)
1565            {
1566                read_len = in.Read(buf, 50);
1567                if(read_len == 50)
1568                {
1569                    _playoutPositionMs += 20;
1570                }
1571                else
1572                {
1573                    return -1;
1574                }
1575            }
1576        }
1577    }
1578#endif
1579    if(_codecId == kCodecNoCodec)
1580    {
1581        return -1;
1582    }
1583    _reading = true;
1584    return 0;
1585}
1586
1587int32_t ModuleFileUtility::ReadCompressedData(InStream& in,
1588                                              int8_t* outData,
1589                                              uint32_t bufferSize)
1590{
1591    WEBRTC_TRACE(
1592        kTraceStream,
1593        kTraceFile,
1594        _id,
1595        "ModuleFileUtility::ReadCompressedData(in=0x%x, outData=0x%x,\
1596 bytes=%ld)",
1597        &in,
1598        outData,
1599        bufferSize);
1600
1601#ifdef WEBRTC_CODEC_AMR
1602    uint32_t AMRmode2bytes[9]={12,13,15,17,19,20,26,31,5};
1603#endif
1604#ifdef WEBRTC_CODEC_AMRWB
1605    uint32_t AMRWBmode2bytes[10]={17,23,32,36,40,46,50,58,60,6};
1606#endif
1607    uint32_t bytesRead = 0;
1608
1609    if(! _reading)
1610    {
1611        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "not currently reading!");
1612        return -1;
1613    }
1614
1615#ifdef WEBRTC_CODEC_AMR
1616    if(_codecId == kCodecAmr)
1617    {
1618        int32_t res = in.Read(outData, 1);
1619        if(res != 1)
1620        {
1621            if(!in.Rewind())
1622            {
1623                InitCompressedReading(in, _startPointInMs, _stopPointInMs);
1624                res = in.Read(outData, 1);
1625                if(res != 1)
1626                {
1627                    _reading = false;
1628                    return -1;
1629                }
1630            }
1631            else
1632            {
1633                _reading = false;
1634                return -1;
1635            }
1636        }
1637         const int16_t mode = (outData[0]>>3)&0xF;
1638        if((mode < 0) ||
1639           (mode > 8))
1640        {
1641            if(mode != 15)
1642            {
1643                return -1;
1644            }
1645        }
1646        if(mode != 15)
1647        {
1648            if(bufferSize < AMRmode2bytes[mode] + 1)
1649            {
1650                WEBRTC_TRACE(
1651                    kTraceError,
1652                    kTraceFile,
1653                    _id,
1654                    "output buffer is too short to read AMR compressed data.");
1655                assert(false);
1656                return -1;
1657            }
1658            bytesRead = in.Read(&outData[1], AMRmode2bytes[mode]);
1659            if(bytesRead != AMRmode2bytes[mode])
1660            {
1661                _reading = false;
1662                return -1;
1663            }
1664            // Count the mode byte to bytes read.
1665            bytesRead++;
1666        }
1667        else
1668        {
1669            bytesRead = 1;
1670        }
1671    }
1672#endif
1673#ifdef WEBRTC_CODEC_AMRWB
1674    if(_codecId == kCodecAmrWb)
1675    {
1676        int32_t res = in.Read(outData, 1);
1677        if(res != 1)
1678        {
1679            if(!in.Rewind())
1680            {
1681                InitCompressedReading(in, _startPointInMs, _stopPointInMs);
1682                res = in.Read(outData, 1);
1683                if(res != 1)
1684                {
1685                    _reading = false;
1686                    return -1;
1687                }
1688            }
1689            else
1690            {
1691                _reading = false;
1692                return -1;
1693            }
1694        }
1695         int16_t mode = (outData[0]>>3)&0xF;
1696        if((mode < 0) ||
1697           (mode > 8))
1698        {
1699            if(mode != 15)
1700            {
1701                return -1;
1702            }
1703        }
1704        if(mode != 15)
1705        {
1706            if(bufferSize < AMRWBmode2bytes[mode] + 1)
1707            {
1708                WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1709                           "output buffer is too short to read AMRWB\
1710 compressed.");
1711                assert(false);
1712                return -1;
1713            }
1714             bytesRead = in.Read(&outData[1], AMRWBmode2bytes[mode]);
1715            if(bytesRead != AMRWBmode2bytes[mode])
1716            {
1717                _reading = false;
1718                return -1;
1719            }
1720            bytesRead++;
1721        }
1722        else
1723        {
1724            bytesRead = 1;
1725        }
1726    }
1727#endif
1728#ifdef WEBRTC_CODEC_ILBC
1729    if((_codecId == kCodecIlbc20Ms) ||
1730        (_codecId == kCodecIlbc30Ms))
1731    {
1732        uint32_t byteSize = 0;
1733         if(_codecId == kCodecIlbc30Ms)
1734        {
1735            byteSize = 50;
1736        }
1737        if(_codecId == kCodecIlbc20Ms)
1738        {
1739            byteSize = 38;
1740        }
1741        if(bufferSize < byteSize)
1742        {
1743            WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1744                           "output buffer is too short to read ILBC compressed\
1745 data.");
1746            assert(false);
1747            return -1;
1748        }
1749
1750        bytesRead = in.Read(outData, byteSize);
1751        if(bytesRead != byteSize)
1752        {
1753            if(!in.Rewind())
1754            {
1755                InitCompressedReading(in, _startPointInMs, _stopPointInMs);
1756                bytesRead = in.Read(outData, byteSize);
1757                if(bytesRead != byteSize)
1758                {
1759                    _reading = false;
1760                    return -1;
1761                }
1762            }
1763            else
1764            {
1765                _reading = false;
1766                return -1;
1767            }
1768        }
1769    }
1770#endif
1771    if(bytesRead == 0)
1772    {
1773        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1774                     "ReadCompressedData() no bytes read, codec not supported");
1775        return -1;
1776    }
1777
1778    _playoutPositionMs += 20;
1779    if((_stopPointInMs > 0) &&
1780        (_playoutPositionMs >= _stopPointInMs))
1781    {
1782        if(!in.Rewind())
1783        {
1784            InitCompressedReading(in, _startPointInMs, _stopPointInMs);
1785        }
1786        else
1787        {
1788            _reading = false;
1789        }
1790    }
1791    return bytesRead;
1792}
1793
1794int32_t ModuleFileUtility::InitCompressedWriting(
1795    OutStream& out,
1796    const CodecInst& codecInst)
1797{
1798    WEBRTC_TRACE(kTraceDebug, kTraceFile, _id,
1799               "ModuleFileUtility::InitCompressedWriting(out= 0x%x,\
1800 codecName= %s)",
1801               &out, codecInst.plname);
1802
1803    _writing = false;
1804
1805#ifdef WEBRTC_CODEC_AMR
1806    if(STR_CASE_CMP(codecInst.plname, "amr") == 0)
1807    {
1808        if(codecInst.pacsize == 160)
1809        {
1810            memcpy(&codec_info_,&codecInst,sizeof(CodecInst));
1811            _codecId = kCodecAmr;
1812            out.Write("#!AMR\n",6);
1813            _writing = true;
1814            return 0;
1815        }
1816    }
1817#endif
1818#ifdef WEBRTC_CODEC_AMRWB
1819    if(STR_CASE_CMP(codecInst.plname, "amr-wb") == 0)
1820    {
1821        if(codecInst.pacsize == 320)
1822        {
1823            memcpy(&codec_info_,&codecInst,sizeof(CodecInst));
1824            _codecId = kCodecAmrWb;
1825            out.Write("#!AMRWB\n",8);
1826            _writing = true;
1827            return 0;
1828        }
1829    }
1830#endif
1831#ifdef WEBRTC_CODEC_ILBC
1832    if(STR_CASE_CMP(codecInst.plname, "ilbc") == 0)
1833    {
1834        if(codecInst.pacsize == 160)
1835        {
1836            _codecId = kCodecIlbc20Ms;
1837            out.Write("#!iLBC20\n",9);
1838        }
1839        else if(codecInst.pacsize == 240)
1840        {
1841            _codecId = kCodecIlbc30Ms;
1842            out.Write("#!iLBC30\n",9);
1843        }
1844        else
1845        {
1846          WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1847                       "codecInst defines unsupported compression codec!");
1848            return -1;
1849        }
1850        memcpy(&codec_info_,&codecInst,sizeof(CodecInst));
1851        _writing = true;
1852        return 0;
1853    }
1854#endif
1855
1856    WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1857                 "codecInst defines unsupported compression codec!");
1858    return -1;
1859}
1860
1861int32_t ModuleFileUtility::WriteCompressedData(
1862    OutStream& out,
1863    const int8_t* buffer,
1864    const uint32_t dataLength)
1865{
1866    WEBRTC_TRACE(
1867        kTraceStream,
1868        kTraceFile,
1869        _id,
1870        "ModuleFileUtility::WriteCompressedData(out= 0x%x, buf= 0x%x,\
1871 dataLen= %d)",
1872        &out,
1873        buffer,
1874        dataLength);
1875
1876    if(buffer == NULL)
1877    {
1878        WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
1879    }
1880
1881    if(!out.Write(buffer, dataLength))
1882    {
1883        return -1;
1884    }
1885    return dataLength;
1886}
1887
1888int32_t ModuleFileUtility::InitPCMReading(InStream& pcm,
1889                                          const uint32_t start,
1890                                          const uint32_t stop,
1891                                          uint32_t freq)
1892{
1893    WEBRTC_TRACE(
1894        kTraceInfo,
1895        kTraceFile,
1896        _id,
1897        "ModuleFileUtility::InitPCMReading(pcm= 0x%x, start=%d, stop=%d,\
1898 freq=%d)",
1899        &pcm,
1900        start,
1901        stop,
1902        freq);
1903
1904    int8_t dummy[320];
1905    int32_t read_len;
1906
1907    _playoutPositionMs = 0;
1908    _startPointInMs = start;
1909    _stopPointInMs = stop;
1910    _reading = false;
1911
1912    if(freq == 8000)
1913    {
1914        strcpy(codec_info_.plname, "L16");
1915        codec_info_.pltype   = -1;
1916        codec_info_.plfreq   = 8000;
1917        codec_info_.pacsize  = 160;
1918        codec_info_.channels = 1;
1919        codec_info_.rate     = 128000;
1920        _codecId = kCodecL16_8Khz;
1921    }
1922    else if(freq == 16000)
1923    {
1924        strcpy(codec_info_.plname, "L16");
1925        codec_info_.pltype   = -1;
1926        codec_info_.plfreq   = 16000;
1927        codec_info_.pacsize  = 320;
1928        codec_info_.channels = 1;
1929        codec_info_.rate     = 256000;
1930        _codecId = kCodecL16_16kHz;
1931    }
1932    else if(freq == 32000)
1933    {
1934        strcpy(codec_info_.plname, "L16");
1935        codec_info_.pltype   = -1;
1936        codec_info_.plfreq   = 32000;
1937        codec_info_.pacsize  = 320;
1938        codec_info_.channels = 1;
1939        codec_info_.rate     = 512000;
1940        _codecId = kCodecL16_32Khz;
1941    }
1942
1943    // Readsize for 10ms of audio data (2 bytes per sample).
1944    _readSizeBytes = 2 * codec_info_. plfreq / 100;
1945    if(_startPointInMs > 0)
1946    {
1947        while (_playoutPositionMs < _startPointInMs)
1948        {
1949            read_len = pcm.Read(dummy, _readSizeBytes);
1950            if(read_len == _readSizeBytes)
1951            {
1952                _playoutPositionMs += 10;
1953            }
1954            else // Must have reached EOF before start position!
1955            {
1956                return -1;
1957            }
1958        }
1959    }
1960    _reading = true;
1961    return 0;
1962}
1963
1964int32_t ModuleFileUtility::ReadPCMData(InStream& pcm,
1965                                       int8_t* outData,
1966                                       uint32_t bufferSize)
1967{
1968    WEBRTC_TRACE(
1969        kTraceStream,
1970        kTraceFile,
1971        _id,
1972        "ModuleFileUtility::ReadPCMData(pcm= 0x%x, outData= 0x%x, bufSize= %d)",
1973        &pcm,
1974        outData,
1975        bufferSize);
1976
1977    if(outData == NULL)
1978    {
1979        WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
1980    }
1981
1982    // Readsize for 10ms of audio data (2 bytes per sample).
1983    uint32_t bytesRequested = 2 * codec_info_.plfreq / 100;
1984    if(bufferSize <  bytesRequested)
1985    {
1986        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
1987                   "ReadPCMData: buffer not long enough for a 10ms frame.");
1988        assert(false);
1989        return -1;
1990    }
1991
1992    uint32_t bytesRead = pcm.Read(outData, bytesRequested);
1993    if(bytesRead < bytesRequested)
1994    {
1995        if(pcm.Rewind() == -1)
1996        {
1997            _reading = false;
1998        }
1999        else
2000        {
2001            if(InitPCMReading(pcm, _startPointInMs, _stopPointInMs,
2002                              codec_info_.plfreq) == -1)
2003            {
2004                _reading = false;
2005            }
2006            else
2007            {
2008                int32_t rest = bytesRequested - bytesRead;
2009                int32_t len = pcm.Read(&(outData[bytesRead]), rest);
2010                if(len == rest)
2011                {
2012                    bytesRead += len;
2013                }
2014                else
2015                {
2016                    _reading = false;
2017                }
2018            }
2019            if(bytesRead <= 0)
2020            {
2021                WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2022                        "ReadPCMData: Failed to rewind audio file.");
2023                return -1;
2024            }
2025        }
2026    }
2027
2028    if(bytesRead <= 0)
2029    {
2030        WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
2031                   "ReadPCMData: end of file");
2032        return -1;
2033    }
2034    _playoutPositionMs += 10;
2035    if(_stopPointInMs && _playoutPositionMs >= _stopPointInMs)
2036    {
2037        if(!pcm.Rewind())
2038        {
2039            if(InitPCMReading(pcm, _startPointInMs, _stopPointInMs,
2040                              codec_info_.plfreq) == -1)
2041            {
2042                _reading = false;
2043            }
2044        }
2045    }
2046    return bytesRead;
2047}
2048
2049int32_t ModuleFileUtility::InitPCMWriting(OutStream& out, uint32_t freq)
2050{
2051
2052    if(freq == 8000)
2053    {
2054        strcpy(codec_info_.plname, "L16");
2055        codec_info_.pltype   = -1;
2056        codec_info_.plfreq   = 8000;
2057        codec_info_.pacsize  = 160;
2058        codec_info_.channels = 1;
2059        codec_info_.rate     = 128000;
2060
2061        _codecId = kCodecL16_8Khz;
2062    }
2063    else if(freq == 16000)
2064    {
2065        strcpy(codec_info_.plname, "L16");
2066        codec_info_.pltype   = -1;
2067        codec_info_.plfreq   = 16000;
2068        codec_info_.pacsize  = 320;
2069        codec_info_.channels = 1;
2070        codec_info_.rate     = 256000;
2071
2072        _codecId = kCodecL16_16kHz;
2073    }
2074    else if(freq == 32000)
2075    {
2076        strcpy(codec_info_.plname, "L16");
2077        codec_info_.pltype   = -1;
2078        codec_info_.plfreq   = 32000;
2079        codec_info_.pacsize  = 320;
2080        codec_info_.channels = 1;
2081        codec_info_.rate     = 512000;
2082
2083        _codecId = kCodecL16_32Khz;
2084    }
2085    if((_codecId != kCodecL16_8Khz) &&
2086       (_codecId != kCodecL16_16kHz) &&
2087       (_codecId != kCodecL16_32Khz))
2088    {
2089        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2090                     "CodecInst is not 8KHz PCM or 16KHz PCM!");
2091        return -1;
2092    }
2093    _writing = true;
2094    _bytesWritten = 0;
2095    return 0;
2096}
2097
2098int32_t ModuleFileUtility::WritePCMData(OutStream& out,
2099                                        const int8_t*  buffer,
2100                                        const uint32_t dataLength)
2101{
2102    WEBRTC_TRACE(
2103        kTraceStream,
2104        kTraceFile,
2105        _id,
2106        "ModuleFileUtility::WritePCMData(out= 0x%x, buf= 0x%x, dataLen= %d)",
2107        &out,
2108        buffer,
2109        dataLength);
2110
2111    if(buffer == NULL)
2112    {
2113        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer NULL");
2114    }
2115
2116    if(!out.Write(buffer, dataLength))
2117    {
2118        return -1;
2119    }
2120
2121    _bytesWritten += dataLength;
2122    return dataLength;
2123}
2124
2125int32_t ModuleFileUtility::codec_info(CodecInst& codecInst)
2126{
2127    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
2128                 "ModuleFileUtility::codec_info(codecInst= 0x%x)", &codecInst);
2129
2130    if(!_reading && !_writing)
2131    {
2132        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2133                     "CodecInst: not currently reading audio file!");
2134        return -1;
2135    }
2136    memcpy(&codecInst,&codec_info_,sizeof(CodecInst));
2137    return 0;
2138}
2139
2140int32_t ModuleFileUtility::set_codec_info(const CodecInst& codecInst)
2141{
2142
2143    _codecId = kCodecNoCodec;
2144    if(STR_CASE_CMP(codecInst.plname, "PCMU") == 0)
2145    {
2146        _codecId = kCodecPcmu;
2147    }
2148    else if(STR_CASE_CMP(codecInst.plname, "PCMA") == 0)
2149    {
2150        _codecId = kCodecPcma;
2151    }
2152    else if(STR_CASE_CMP(codecInst.plname, "L16") == 0)
2153    {
2154        if(codecInst.plfreq == 8000)
2155        {
2156            _codecId = kCodecL16_8Khz;
2157        }
2158        else if(codecInst.plfreq == 16000)
2159        {
2160            _codecId = kCodecL16_16kHz;
2161        }
2162        else if(codecInst.plfreq == 32000)
2163        {
2164            _codecId = kCodecL16_32Khz;
2165        }
2166    }
2167#ifdef WEBRTC_CODEC_AMR
2168    else if(STR_CASE_CMP(codecInst.plname, "amr") == 0)
2169    {
2170        _codecId = kCodecAmr;
2171    }
2172#endif
2173#ifdef WEBRTC_CODEC_AMRWB
2174    else if(STR_CASE_CMP(codecInst.plname, "amr-wb") == 0)
2175    {
2176        _codecId = kCodecAmrWb;
2177    }
2178#endif
2179#ifdef WEBRTC_CODEC_ILBC
2180    else if(STR_CASE_CMP(codecInst.plname, "ilbc") == 0)
2181    {
2182        if(codecInst.pacsize == 160)
2183        {
2184            _codecId = kCodecIlbc20Ms;
2185        }
2186        else if(codecInst.pacsize == 240)
2187        {
2188            _codecId = kCodecIlbc30Ms;
2189        }
2190    }
2191#endif
2192#if(defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX))
2193    else if(STR_CASE_CMP(codecInst.plname, "isac") == 0)
2194    {
2195        if(codecInst.plfreq == 16000)
2196        {
2197            _codecId = kCodecIsac;
2198        }
2199        else if(codecInst.plfreq == 32000)
2200        {
2201            _codecId = kCodecIsacSwb;
2202        }
2203    }
2204#endif
2205#ifdef WEBRTC_CODEC_ISACLC
2206    else if(STR_CASE_CMP(codecInst.plname, "isaclc") == 0)
2207    {
2208        _codecId = kCodecIsacLc;
2209    }
2210#endif
2211#ifdef WEBRTC_CODEC_G722
2212    else if(STR_CASE_CMP(codecInst.plname, "G722") == 0)
2213    {
2214        _codecId = kCodecG722;
2215    }
2216#endif
2217    else if(STR_CASE_CMP(codecInst.plname, "G7221") == 0)
2218    {
2219#ifdef WEBRTC_CODEC_G722_1
2220        if(codecInst.plfreq == 16000)
2221        {
2222            if(codecInst.rate == 16000)
2223            {
2224                _codecId = kCodecG722_1_16Kbps;
2225            }
2226            else if(codecInst.rate == 24000)
2227            {
2228                _codecId = kCodecG722_1_24Kbps;
2229            }
2230            else if(codecInst.rate == 32000)
2231            {
2232                _codecId = kCodecG722_1_32Kbps;
2233            }
2234        }
2235#endif
2236#ifdef WEBRTC_CODEC_G722_1C
2237        if(codecInst.plfreq == 32000)
2238        {
2239            if(codecInst.rate == 48000)
2240            {
2241                _codecId = kCodecG722_1c_48;
2242            }
2243            else if(codecInst.rate == 32000)
2244            {
2245                _codecId = kCodecG722_1c_32;
2246            }
2247            else if(codecInst.rate == 24000)
2248            {
2249                _codecId = kCodecG722_1c_24;
2250            }
2251        }
2252#endif
2253    }
2254#ifdef WEBRTC_CODEC_G726
2255    else if(STR_CASE_CMP(codecInst.plname, "G726-40") == 0)
2256    {
2257        _codecId = kCodecG726_40;
2258    }
2259    else if(STR_CASE_CMP(codecInst.plname, "G726-32") == 0)
2260    {
2261        _codecId = kCodecG726_24;
2262    }
2263    else if(STR_CASE_CMP(codecInst.plname, "G726-24") == 0)
2264    {
2265        _codecId = kCodecG726_32;
2266    }
2267    else if(STR_CASE_CMP(codecInst.plname, "G726-16") == 0)
2268    {
2269        _codecId = kCodecG726_16;
2270    }
2271#endif
2272#ifdef WEBRTC_CODEC_G729
2273    else if(STR_CASE_CMP(codecInst.plname, "G729") == 0)
2274    {
2275        _codecId = kCodecG729;
2276    }
2277#endif
2278#ifdef WEBRTC_CODEC_G729_1
2279    else if(STR_CASE_CMP(codecInst.plname, "G7291") == 0)
2280    {
2281        _codecId = kCodecG729_1;
2282    }
2283#endif
2284#ifdef WEBRTC_CODEC_SPEEX
2285    else if(STR_CASE_CMP(codecInst.plname, "speex") == 0)
2286    {
2287        if(codecInst.plfreq == 8000)
2288        {
2289            _codecId = kCodecSpeex8Khz;
2290        }
2291        else if(codecInst.plfreq == 16000)
2292        {
2293            _codecId = kCodecSpeex16Khz;
2294        }
2295    }
2296#endif
2297    if(_codecId == kCodecNoCodec)
2298    {
2299        return -1;
2300    }
2301    memcpy(&codec_info_, &codecInst, sizeof(CodecInst));
2302    return 0;
2303}
2304
2305int32_t ModuleFileUtility::FileDurationMs(const char* fileName,
2306                                          const FileFormats fileFormat,
2307                                          const uint32_t freqInHz)
2308{
2309
2310    if(fileName == NULL)
2311    {
2312        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "filename NULL");
2313        return -1;
2314    }
2315
2316    int32_t time_in_ms = -1;
2317    struct stat file_size;
2318    if(stat(fileName,&file_size) == -1)
2319    {
2320        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2321                     "failed to retrieve file size with stat!");
2322        return -1;
2323    }
2324    FileWrapper* inStreamObj = FileWrapper::Create();
2325    if(inStreamObj == NULL)
2326    {
2327        WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
2328                     "failed to create InStream object!");
2329        return -1;
2330    }
2331    if(inStreamObj->OpenFile(fileName, true) == -1)
2332    {
2333        delete inStreamObj;
2334        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2335                     "failed to open file %s!", fileName);
2336        return -1;
2337    }
2338
2339    switch (fileFormat)
2340    {
2341        case kFileFormatWavFile:
2342        {
2343            if(ReadWavHeader(*inStreamObj) == -1)
2344            {
2345                WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2346                             "failed to read WAV file header!");
2347                return -1;
2348            }
2349            time_in_ms = ((file_size.st_size - 44) /
2350                          (_wavFormatObj.nAvgBytesPerSec/1000));
2351            break;
2352        }
2353        case kFileFormatPcm16kHzFile:
2354        {
2355            // 16 samples per ms. 2 bytes per sample.
2356            int32_t denominator = 16*2;
2357            time_in_ms = (file_size.st_size)/denominator;
2358            break;
2359        }
2360        case kFileFormatPcm8kHzFile:
2361        {
2362            // 8 samples per ms. 2 bytes per sample.
2363            int32_t denominator = 8*2;
2364            time_in_ms = (file_size.st_size)/denominator;
2365            break;
2366        }
2367        case kFileFormatCompressedFile:
2368        {
2369            int32_t cnt = 0;
2370            int32_t read_len = 0;
2371            char buf[64];
2372            do
2373            {
2374                read_len = inStreamObj->Read(&buf[cnt++], 1);
2375                if(read_len != 1)
2376                {
2377                    return -1;
2378                }
2379            } while ((buf[cnt-1] != '\n') && (64 > cnt));
2380
2381            if(cnt == 64)
2382            {
2383                return -1;
2384            }
2385            else
2386            {
2387                buf[cnt] = 0;
2388            }
2389#ifdef WEBRTC_CODEC_AMR
2390            if(!strcmp("#!AMR\n", buf))
2391            {
2392                uint8_t dummy;
2393                read_len = inStreamObj->Read(&dummy, 1);
2394                if(read_len != 1)
2395                {
2396                    return -1;
2397                }
2398
2399                int16_t AMRMode = (dummy>>3)&0xF;
2400
2401                // TODO (hellner): use tables instead of hardcoding like this!
2402                //                 Additionally, this calculation does not
2403                //                 take octet alignment into consideration.
2404                switch (AMRMode)
2405                {
2406                        // Mode 0: 4.75 kbit/sec -> 95 bits per 20 ms frame.
2407                        // 20 ms = 95 bits ->
2408                        // file size in bytes * 8 / 95 is the number of
2409                        // 20 ms frames in the file ->
2410                        // time_in_ms = file size * 8 / 95 * 20
2411                    case 0:
2412                        time_in_ms = ((file_size.st_size)*160)/95;
2413                        break;
2414                        // Mode 1: 5.15 kbit/sec -> 103 bits per 20 ms frame.
2415                    case 1:
2416                        time_in_ms = ((file_size.st_size)*160)/103;
2417                        break;
2418                        // Mode 2: 5.90 kbit/sec -> 118 bits per 20 ms frame.
2419                    case 2:
2420                        time_in_ms = ((file_size.st_size)*160)/118;
2421                        break;
2422                        // Mode 3: 6.70 kbit/sec -> 134 bits per 20 ms frame.
2423                    case 3:
2424                        time_in_ms = ((file_size.st_size)*160)/134;
2425                        break;
2426                        // Mode 4: 7.40 kbit/sec -> 148 bits per 20 ms frame.
2427                    case 4:
2428                        time_in_ms = ((file_size.st_size)*160)/148;
2429                        break;
2430                        // Mode 5: 7.95 bit/sec -> 159 bits per 20 ms frame.
2431                    case 5:
2432                        time_in_ms = ((file_size.st_size)*160)/159;
2433                        break;
2434                        // Mode 6: 10.2 bit/sec -> 204 bits per 20 ms frame.
2435                    case 6:
2436                        time_in_ms = ((file_size.st_size)*160)/204;
2437                        break;
2438                        // Mode 7: 12.2 bit/sec -> 244 bits per 20 ms frame.
2439                    case 7:
2440                        time_in_ms = ((file_size.st_size)*160)/244;
2441                        break;
2442                        // Mode 8: SID Mode -> 39 bits per 20 ms frame.
2443                    case 8:
2444                        time_in_ms = ((file_size.st_size)*160)/39;
2445                        break;
2446                    default:
2447                        break;
2448                }
2449            }
2450#endif
2451#ifdef WEBRTC_CODEC_AMRWB
2452            if(!strcmp("#!AMRWB\n", buf))
2453            {
2454                uint8_t dummy;
2455                read_len = inStreamObj->Read(&dummy, 1);
2456                if(read_len != 1)
2457                {
2458                    return -1;
2459                }
2460
2461                // TODO (hellner): use tables instead of hardcoding like this!
2462                int16_t AMRWBMode = (dummy>>3)&0xF;
2463                switch(AMRWBMode)
2464                {
2465                        // Mode 0: 6.6 kbit/sec -> 132 bits per 20 ms frame.
2466                    case 0:
2467                        time_in_ms = ((file_size.st_size)*160)/132;
2468                        break;
2469                        // Mode 1: 8.85 kbit/sec -> 177 bits per 20 ms frame.
2470                    case 1:
2471                        time_in_ms = ((file_size.st_size)*160)/177;
2472                        break;
2473                        // Mode 2: 12.65 kbit/sec -> 253 bits per 20 ms frame.
2474                    case 2:
2475                        time_in_ms = ((file_size.st_size)*160)/253;
2476                        break;
2477                        // Mode 3: 14.25 kbit/sec -> 285 bits per 20 ms frame.
2478                    case 3:
2479                        time_in_ms = ((file_size.st_size)*160)/285;
2480                        break;
2481                        // Mode 4: 15.85 kbit/sec -> 317 bits per 20 ms frame.
2482                    case 4:
2483                        time_in_ms = ((file_size.st_size)*160)/317;
2484                        break;
2485                        // Mode 5: 18.25 kbit/sec -> 365 bits per 20 ms frame.
2486                    case 5:
2487                        time_in_ms = ((file_size.st_size)*160)/365;
2488                        break;
2489                        // Mode 6: 19.85 kbit/sec -> 397 bits per 20 ms frame.
2490                    case 6:
2491                        time_in_ms = ((file_size.st_size)*160)/397;
2492                        break;
2493                        // Mode 7: 23.05 kbit/sec -> 461 bits per 20 ms frame.
2494                    case 7:
2495                        time_in_ms = ((file_size.st_size)*160)/461;
2496                        break;
2497                        // Mode 8: 23.85 kbit/sec -> 477 bits per 20 ms frame.
2498                    case 8:
2499                        time_in_ms = ((file_size.st_size)*160)/477;
2500                        break;
2501                    default:
2502                        delete inStreamObj;
2503                        return -1;
2504                }
2505            }
2506#endif
2507#ifdef WEBRTC_CODEC_ILBC
2508            if(!strcmp("#!iLBC20\n", buf))
2509            {
2510                // 20 ms is 304 bits
2511                time_in_ms = ((file_size.st_size)*160)/304;
2512                break;
2513            }
2514            if(!strcmp("#!iLBC30\n", buf))
2515            {
2516                // 30 ms takes 400 bits.
2517                // file size in bytes * 8 / 400 is the number of
2518                // 30 ms frames in the file ->
2519                // time_in_ms = file size * 8 / 400 * 30
2520                time_in_ms = ((file_size.st_size)*240)/400;
2521                break;
2522            }
2523#endif
2524        }
2525        case kFileFormatPreencodedFile:
2526        {
2527            WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2528                         "cannot determine duration of Pre-Encoded file!");
2529            break;
2530        }
2531        default:
2532            WEBRTC_TRACE(kTraceError, kTraceFile, _id,
2533                         "unsupported file format %d!", fileFormat);
2534            break;
2535    }
2536    inStreamObj->CloseFile();
2537    delete inStreamObj;
2538    return time_in_ms;
2539}
2540
2541uint32_t ModuleFileUtility::PlayoutPositionMs()
2542{
2543    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
2544               "ModuleFileUtility::PlayoutPosition()");
2545
2546    if(_reading)
2547    {
2548        return _playoutPositionMs;
2549    }
2550    else
2551    {
2552        return 0;
2553    }
2554}
2555}  // namespace webrtc
Note: See TracBrowser for help on using the repository browser.