1
2
3
4
5
6
7
8
9
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
|
/*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/common_types.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/modules/utility/source/coder.h"
namespace webrtc {
AudioCoder::AudioCoder(uint32_t instanceID)
: _acm(AudioCodingModule::Create(instanceID)),
_receiveCodec(),
_encodeTimestamp(0),
_encodedData(NULL),
_encodedLengthInBytes(0),
_decodeTimestamp(0)
{
_acm->InitializeReceiver();
_acm->RegisterTransportCallback(this);
}
AudioCoder::~AudioCoder()
{
}
int32_t AudioCoder::SetEncodeCodec(const CodecInst& codecInst)
{
if(_acm->RegisterSendCodec((CodecInst&)codecInst) == -1)
{
return -1;
}
return 0;
}
int32_t AudioCoder::SetDecodeCodec(const CodecInst& codecInst)
{
if(_acm->RegisterReceiveCodec((CodecInst&)codecInst) == -1)
{
return -1;
}
memcpy(&_receiveCodec,&codecInst,sizeof(CodecInst));
return 0;
}
int32_t AudioCoder::Decode(AudioFrame& decodedAudio,
uint32_t sampFreqHz,
const int8_t* incomingPayload,
size_t payloadLength)
{
if (payloadLength > 0)
{
const uint8_t payloadType = _receiveCodec.pltype;
_decodeTimestamp += _receiveCodec.pacsize;
if(_acm->IncomingPayload((const uint8_t*) incomingPayload,
payloadLength,
payloadType,
_decodeTimestamp) == -1)
{
return -1;
}
}
return _acm->PlayoutData10Ms((uint16_t)sampFreqHz, &decodedAudio);
}
int32_t AudioCoder::PlayoutData(AudioFrame& decodedAudio,
uint16_t& sampFreqHz)
{
return _acm->PlayoutData10Ms(sampFreqHz, &decodedAudio);
}
int32_t AudioCoder::Encode(const AudioFrame& audio,
int8_t* encodedData,
size_t& encodedLengthInBytes)
{
// Fake a timestamp in case audio doesn't contain a correct timestamp.
// Make a local copy of the audio frame since audio is const
AudioFrame audioFrame;
audioFrame.CopyFrom(audio);
audioFrame.timestamp_ = _encodeTimestamp;
_encodeTimestamp += static_cast<uint32_t>(audioFrame.samples_per_channel_);
// For any codec with a frame size that is longer than 10 ms the encoded
// length in bytes should be zero until a a full frame has been encoded.
_encodedLengthInBytes = 0;
if(_acm->Add10MsData((AudioFrame&)audioFrame) == -1)
{
return -1;
}
_encodedData = encodedData;
encodedLengthInBytes = _encodedLengthInBytes;
return 0;
}
int32_t AudioCoder::SendData(
FrameType /* frameType */,
uint8_t /* payloadType */,
uint32_t /* timeStamp */,
const uint8_t* payloadData,
size_t payloadSize,
const RTPFragmentationHeader* /* fragmentation*/)
{
memcpy(_encodedData,payloadData,sizeof(uint8_t) * payloadSize);
_encodedLengthInBytes = payloadSize;
return 0;
}
} // namespace webrtc
|
