Line data Source code
1 : /*
2 : * Copyright (c) 2015 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/audio_coding/codecs/g722/audio_decoder_g722.h"
12 :
13 : #include <string.h>
14 :
15 : #include "webrtc/base/checks.h"
16 : #include "webrtc/modules/audio_coding/codecs/legacy_encoded_audio_frame.h"
17 : #include "webrtc/modules/audio_coding/codecs/g722/g722_interface.h"
18 :
19 : namespace webrtc {
20 :
21 0 : AudioDecoderG722::AudioDecoderG722() {
22 0 : WebRtcG722_CreateDecoder(&dec_state_);
23 0 : WebRtcG722_DecoderInit(dec_state_);
24 0 : }
25 :
26 0 : AudioDecoderG722::~AudioDecoderG722() {
27 0 : WebRtcG722_FreeDecoder(dec_state_);
28 0 : }
29 :
30 0 : bool AudioDecoderG722::HasDecodePlc() const {
31 0 : return false;
32 : }
33 :
34 0 : int AudioDecoderG722::DecodeInternal(const uint8_t* encoded,
35 : size_t encoded_len,
36 : int sample_rate_hz,
37 : int16_t* decoded,
38 : SpeechType* speech_type) {
39 0 : RTC_DCHECK_EQ(SampleRateHz(), sample_rate_hz);
40 0 : int16_t temp_type = 1; // Default is speech.
41 : size_t ret =
42 0 : WebRtcG722_Decode(dec_state_, encoded, encoded_len, decoded, &temp_type);
43 0 : *speech_type = ConvertSpeechType(temp_type);
44 0 : return static_cast<int>(ret);
45 : }
46 :
47 0 : void AudioDecoderG722::Reset() {
48 0 : WebRtcG722_DecoderInit(dec_state_);
49 0 : }
50 :
51 0 : std::vector<AudioDecoder::ParseResult> AudioDecoderG722::ParsePayload(
52 : rtc::Buffer&& payload,
53 : uint32_t timestamp) {
54 0 : return LegacyEncodedAudioFrame::SplitBySamples(this, std::move(payload),
55 0 : timestamp, 8, 16);
56 : }
57 :
58 0 : int AudioDecoderG722::PacketDuration(const uint8_t* encoded,
59 : size_t encoded_len) const {
60 : // 1/2 encoded byte per sample per channel.
61 0 : return static_cast<int>(2 * encoded_len / Channels());
62 : }
63 :
64 0 : int AudioDecoderG722::SampleRateHz() const {
65 0 : return 16000;
66 : }
67 :
68 0 : size_t AudioDecoderG722::Channels() const {
69 0 : return 1;
70 : }
71 :
72 0 : AudioDecoderG722Stereo::AudioDecoderG722Stereo() {
73 0 : WebRtcG722_CreateDecoder(&dec_state_left_);
74 0 : WebRtcG722_CreateDecoder(&dec_state_right_);
75 0 : WebRtcG722_DecoderInit(dec_state_left_);
76 0 : WebRtcG722_DecoderInit(dec_state_right_);
77 0 : }
78 :
79 0 : AudioDecoderG722Stereo::~AudioDecoderG722Stereo() {
80 0 : WebRtcG722_FreeDecoder(dec_state_left_);
81 0 : WebRtcG722_FreeDecoder(dec_state_right_);
82 0 : }
83 :
84 0 : int AudioDecoderG722Stereo::DecodeInternal(const uint8_t* encoded,
85 : size_t encoded_len,
86 : int sample_rate_hz,
87 : int16_t* decoded,
88 : SpeechType* speech_type) {
89 0 : RTC_DCHECK_EQ(SampleRateHz(), sample_rate_hz);
90 0 : int16_t temp_type = 1; // Default is speech.
91 : // De-interleave the bit-stream into two separate payloads.
92 0 : uint8_t* encoded_deinterleaved = new uint8_t[encoded_len];
93 0 : SplitStereoPacket(encoded, encoded_len, encoded_deinterleaved);
94 : // Decode left and right.
95 0 : size_t decoded_len = WebRtcG722_Decode(dec_state_left_, encoded_deinterleaved,
96 0 : encoded_len / 2, decoded, &temp_type);
97 0 : size_t ret = WebRtcG722_Decode(
98 0 : dec_state_right_, &encoded_deinterleaved[encoded_len / 2],
99 0 : encoded_len / 2, &decoded[decoded_len], &temp_type);
100 0 : if (ret == decoded_len) {
101 0 : ret += decoded_len; // Return total number of samples.
102 : // Interleave output.
103 0 : for (size_t k = ret / 2; k < ret; k++) {
104 0 : int16_t temp = decoded[k];
105 0 : memmove(&decoded[2 * k - ret + 2], &decoded[2 * k - ret + 1],
106 0 : (ret - k - 1) * sizeof(int16_t));
107 0 : decoded[2 * k - ret + 1] = temp;
108 : }
109 : }
110 0 : *speech_type = ConvertSpeechType(temp_type);
111 0 : delete[] encoded_deinterleaved;
112 0 : return static_cast<int>(ret);
113 : }
114 :
115 0 : int AudioDecoderG722Stereo::SampleRateHz() const {
116 0 : return 16000;
117 : }
118 :
119 0 : size_t AudioDecoderG722Stereo::Channels() const {
120 0 : return 2;
121 : }
122 :
123 0 : void AudioDecoderG722Stereo::Reset() {
124 0 : WebRtcG722_DecoderInit(dec_state_left_);
125 0 : WebRtcG722_DecoderInit(dec_state_right_);
126 0 : }
127 :
128 0 : std::vector<AudioDecoder::ParseResult> AudioDecoderG722Stereo::ParsePayload(
129 : rtc::Buffer&& payload,
130 : uint32_t timestamp) {
131 0 : return LegacyEncodedAudioFrame::SplitBySamples(this, std::move(payload),
132 0 : timestamp, 2 * 8, 16);
133 : }
134 :
135 : // Split the stereo packet and place left and right channel after each other
136 : // in the output array.
137 0 : void AudioDecoderG722Stereo::SplitStereoPacket(const uint8_t* encoded,
138 : size_t encoded_len,
139 : uint8_t* encoded_deinterleaved) {
140 : // Regroup the 4 bits/sample so |l1 l2| |r1 r2| |l3 l4| |r3 r4| ...,
141 : // where "lx" is 4 bits representing left sample number x, and "rx" right
142 : // sample. Two samples fit in one byte, represented with |...|.
143 0 : for (size_t i = 0; i + 1 < encoded_len; i += 2) {
144 0 : uint8_t right_byte = ((encoded[i] & 0x0F) << 4) + (encoded[i + 1] & 0x0F);
145 0 : encoded_deinterleaved[i] = (encoded[i] & 0xF0) + (encoded[i + 1] >> 4);
146 0 : encoded_deinterleaved[i + 1] = right_byte;
147 : }
148 :
149 : // Move one byte representing right channel each loop, and place it at the
150 : // end of the bytestream vector. After looping the data is reordered to:
151 : // |l1 l2| |l3 l4| ... |l(N-1) lN| |r1 r2| |r3 r4| ... |r(N-1) r(N)|,
152 : // where N is the total number of samples.
153 0 : for (size_t i = 0; i < encoded_len / 2; i++) {
154 0 : uint8_t right_byte = encoded_deinterleaved[i + 1];
155 0 : memmove(&encoded_deinterleaved[i + 1], &encoded_deinterleaved[i + 2],
156 0 : encoded_len - i - 2);
157 0 : encoded_deinterleaved[encoded_len - 1] = right_byte;
158 : }
159 0 : }
160 :
161 : } // namespace webrtc
|
