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/audio_coding/neteq4/audio_decoder_impl.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: 17.7 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/audio_coding/neteq4/audio_decoder_impl.h"
12
13#include <assert.h>
14#include <string.h>  // memmove
15
16#ifdef WEBRTC_CODEC_CELT
17#include "webrtc/modules/audio_coding/codecs/celt/include/celt_interface.h"
18#endif
19#include "webrtc/modules/audio_coding/codecs/cng/include/webrtc_cng.h"
20#include "webrtc/modules/audio_coding/codecs/g711/include/g711_interface.h"
21#ifdef WEBRTC_CODEC_G722
22#include "webrtc/modules/audio_coding/codecs/g722/include/g722_interface.h"
23#endif
24#ifdef WEBRTC_CODEC_ILBC
25#include "webrtc/modules/audio_coding/codecs/ilbc/interface/ilbc.h"
26#endif
27#ifdef WEBRTC_CODEC_ISACFX
28#include "webrtc/modules/audio_coding/codecs/isac/fix/interface/isacfix.h"
29#endif
30#ifdef WEBRTC_CODEC_ISAC
31#include "webrtc/modules/audio_coding/codecs/isac/main/interface/isac.h"
32#endif
33#ifdef WEBRTC_CODEC_OPUS
34#include "webrtc/modules/audio_coding/codecs/opus/interface/opus_interface.h"
35#endif
36#ifdef WEBRTC_CODEC_PCM16
37#include "webrtc/modules/audio_coding/codecs/pcm16b/include/pcm16b.h"
38#endif
39
40namespace webrtc {
41
42// PCMu
43int AudioDecoderPcmU::Decode(const uint8_t* encoded, size_t encoded_len,
44                              int16_t* decoded, SpeechType* speech_type) {
45  int16_t temp_type = 1;  // Default is speech.
46  int16_t ret = WebRtcG711_DecodeU(
47      state_, reinterpret_cast<int16_t*>(const_cast<uint8_t*>(encoded)),
48      static_cast<int16_t>(encoded_len), decoded, &temp_type);
49  *speech_type = ConvertSpeechType(temp_type);
50  return ret;
51}
52
53int AudioDecoderPcmU::PacketDuration(const uint8_t* encoded,
54                                     size_t encoded_len) {
55  // One encoded byte per sample per channel.
56  return static_cast<int>(encoded_len / channels_);
57}
58
59// PCMa
60int AudioDecoderPcmA::Decode(const uint8_t* encoded, size_t encoded_len,
61                              int16_t* decoded, SpeechType* speech_type) {
62  int16_t temp_type = 1;  // Default is speech.
63  int16_t ret = WebRtcG711_DecodeA(
64      state_, reinterpret_cast<int16_t*>(const_cast<uint8_t*>(encoded)),
65      static_cast<int16_t>(encoded_len), decoded, &temp_type);
66  *speech_type = ConvertSpeechType(temp_type);
67  return ret;
68}
69
70int AudioDecoderPcmA::PacketDuration(const uint8_t* encoded,
71                                     size_t encoded_len) {
72  // One encoded byte per sample per channel.
73  return static_cast<int>(encoded_len / channels_);
74}
75
76// PCM16B
77#ifdef WEBRTC_CODEC_PCM16
78AudioDecoderPcm16B::AudioDecoderPcm16B(enum NetEqDecoder type)
79    : AudioDecoder(type) {
80  assert(type == kDecoderPCM16B ||
81         type == kDecoderPCM16Bwb ||
82         type == kDecoderPCM16Bswb32kHz ||
83         type == kDecoderPCM16Bswb48kHz);
84}
85
86int AudioDecoderPcm16B::Decode(const uint8_t* encoded, size_t encoded_len,
87                               int16_t* decoded, SpeechType* speech_type) {
88  int16_t temp_type = 1;  // Default is speech.
89  int16_t ret = WebRtcPcm16b_DecodeW16(
90      state_, reinterpret_cast<int16_t*>(const_cast<uint8_t*>(encoded)),
91      static_cast<int16_t>(encoded_len), decoded, &temp_type);
92  *speech_type = ConvertSpeechType(temp_type);
93  return ret;
94}
95
96int AudioDecoderPcm16B::PacketDuration(const uint8_t* encoded,
97                                       size_t encoded_len) {
98  // Two encoded byte per sample per channel.
99  return static_cast<int>(encoded_len / (2 * channels_));
100}
101
102AudioDecoderPcm16BMultiCh::AudioDecoderPcm16BMultiCh(
103    enum NetEqDecoder type)
104    : AudioDecoderPcm16B(kDecoderPCM16B) {  // This will be changed below.
105  codec_type_ = type;  // Changing to actual type here.
106  switch (codec_type_) {
107    case kDecoderPCM16B_2ch:
108    case kDecoderPCM16Bwb_2ch:
109    case kDecoderPCM16Bswb32kHz_2ch:
110    case kDecoderPCM16Bswb48kHz_2ch:
111      channels_ = 2;
112      break;
113    case kDecoderPCM16B_5ch:
114      channels_ = 5;
115      break;
116    default:
117      assert(false);
118  }
119}
120#endif
121
122// iLBC
123#ifdef WEBRTC_CODEC_ILBC
124AudioDecoderIlbc::AudioDecoderIlbc() : AudioDecoder(kDecoderILBC) {
125  WebRtcIlbcfix_DecoderCreate(reinterpret_cast<iLBC_decinst_t**>(&state_));
126}
127
128AudioDecoderIlbc::~AudioDecoderIlbc() {
129  WebRtcIlbcfix_DecoderFree(static_cast<iLBC_decinst_t*>(state_));
130}
131
132int AudioDecoderIlbc::Decode(const uint8_t* encoded, size_t encoded_len,
133                             int16_t* decoded, SpeechType* speech_type) {
134  int16_t temp_type = 1;  // Default is speech.
135  int16_t ret = WebRtcIlbcfix_Decode(static_cast<iLBC_decinst_t*>(state_),
136                                     reinterpret_cast<const int16_t*>(encoded),
137                                     static_cast<int16_t>(encoded_len), decoded,
138                                     &temp_type);
139  *speech_type = ConvertSpeechType(temp_type);
140  return ret;
141}
142
143int AudioDecoderIlbc::DecodePlc(int num_frames, int16_t* decoded) {
144  return WebRtcIlbcfix_NetEqPlc(static_cast<iLBC_decinst_t*>(state_),
145                                decoded, num_frames);
146}
147
148int AudioDecoderIlbc::Init() {
149  return WebRtcIlbcfix_Decoderinit30Ms(static_cast<iLBC_decinst_t*>(state_));
150}
151#endif
152
153// iSAC float
154#ifdef WEBRTC_CODEC_ISAC
155AudioDecoderIsac::AudioDecoderIsac() : AudioDecoder(kDecoderISAC) {
156  WebRtcIsac_Create(reinterpret_cast<ISACStruct**>(&state_));
157  WebRtcIsac_SetDecSampRate(static_cast<ISACStruct*>(state_), 16000);
158}
159
160AudioDecoderIsac::~AudioDecoderIsac() {
161  WebRtcIsac_Free(static_cast<ISACStruct*>(state_));
162}
163
164int AudioDecoderIsac::Decode(const uint8_t* encoded, size_t encoded_len,
165                             int16_t* decoded, SpeechType* speech_type) {
166  int16_t temp_type = 1;  // Default is speech.
167  int16_t ret = WebRtcIsac_Decode(static_cast<ISACStruct*>(state_),
168                                  reinterpret_cast<const uint16_t*>(encoded),
169                                  static_cast<int16_t>(encoded_len), decoded,
170                                  &temp_type);
171  *speech_type = ConvertSpeechType(temp_type);
172  return ret;
173}
174
175int AudioDecoderIsac::DecodeRedundant(const uint8_t* encoded,
176                                      size_t encoded_len, int16_t* decoded,
177                                      SpeechType* speech_type) {
178  int16_t temp_type = 1;  // Default is speech.
179  int16_t ret = WebRtcIsac_DecodeRcu(static_cast<ISACStruct*>(state_),
180                                     reinterpret_cast<const uint16_t*>(encoded),
181                                     static_cast<int16_t>(encoded_len), decoded,
182                                     &temp_type);
183  *speech_type = ConvertSpeechType(temp_type);
184  return ret;
185}
186
187int AudioDecoderIsac::DecodePlc(int num_frames, int16_t* decoded) {
188  return WebRtcIsac_DecodePlc(static_cast<ISACStruct*>(state_),
189                                 decoded, num_frames);
190}
191
192int AudioDecoderIsac::Init() {
193  return WebRtcIsac_DecoderInit(static_cast<ISACStruct*>(state_));
194}
195
196int AudioDecoderIsac::IncomingPacket(const uint8_t* payload,
197                                     size_t payload_len,
198                                     uint16_t rtp_sequence_number,
199                                     uint32_t rtp_timestamp,
200                                     uint32_t arrival_timestamp) {
201  return WebRtcIsac_UpdateBwEstimate(static_cast<ISACStruct*>(state_),
202                                     reinterpret_cast<const uint16_t*>(payload),
203                                     static_cast<int32_t>(payload_len),
204                                     rtp_sequence_number,
205                                     rtp_timestamp,
206                                     arrival_timestamp);
207}
208
209int AudioDecoderIsac::ErrorCode() {
210  return WebRtcIsac_GetErrorCode(static_cast<ISACStruct*>(state_));
211}
212
213// iSAC SWB
214AudioDecoderIsacSwb::AudioDecoderIsacSwb() : AudioDecoderIsac() {
215  codec_type_ = kDecoderISACswb;
216  WebRtcIsac_SetDecSampRate(static_cast<ISACStruct*>(state_), 32000);
217}
218
219// iSAC FB
220AudioDecoderIsacFb::AudioDecoderIsacFb() : AudioDecoderIsacSwb() {
221  codec_type_ = kDecoderISACfb;
222}
223#endif
224
225// iSAC fix
226#ifdef WEBRTC_CODEC_ISACFX
227AudioDecoderIsacFix::AudioDecoderIsacFix() : AudioDecoder(kDecoderISAC) {
228  WebRtcIsacfix_Create(reinterpret_cast<ISACFIX_MainStruct**>(&state_));
229}
230
231AudioDecoderIsacFix::~AudioDecoderIsacFix() {
232  WebRtcIsacfix_Free(static_cast<ISACFIX_MainStruct*>(state_));
233}
234
235int AudioDecoderIsacFix::Decode(const uint8_t* encoded, size_t encoded_len,
236                                int16_t* decoded, SpeechType* speech_type) {
237  int16_t temp_type = 1;  // Default is speech.
238  int16_t ret = WebRtcIsacfix_Decode(static_cast<ISACFIX_MainStruct*>(state_),
239                                     reinterpret_cast<const uint16_t*>(encoded),
240                                     static_cast<int16_t>(encoded_len), decoded,
241                                     &temp_type);
242  *speech_type = ConvertSpeechType(temp_type);
243  return ret;
244}
245
246int AudioDecoderIsacFix::Init() {
247  return WebRtcIsacfix_DecoderInit(static_cast<ISACFIX_MainStruct*>(state_));
248}
249
250int AudioDecoderIsacFix::IncomingPacket(const uint8_t* payload,
251                                        size_t payload_len,
252                                        uint16_t rtp_sequence_number,
253                                        uint32_t rtp_timestamp,
254                                        uint32_t arrival_timestamp) {
255  return WebRtcIsacfix_UpdateBwEstimate(
256      static_cast<ISACFIX_MainStruct*>(state_),
257      reinterpret_cast<const uint16_t*>(payload),
258      static_cast<int32_t>(payload_len),
259      rtp_sequence_number, rtp_timestamp, arrival_timestamp);
260}
261
262int AudioDecoderIsacFix::ErrorCode() {
263  return WebRtcIsacfix_GetErrorCode(static_cast<ISACFIX_MainStruct*>(state_));
264}
265#endif
266
267// G.722
268#ifdef WEBRTC_CODEC_G722
269AudioDecoderG722::AudioDecoderG722() : AudioDecoder(kDecoderG722) {
270  WebRtcG722_CreateDecoder(reinterpret_cast<G722DecInst**>(&state_));
271}
272
273AudioDecoderG722::~AudioDecoderG722() {
274  WebRtcG722_FreeDecoder(static_cast<G722DecInst*>(state_));
275}
276
277int AudioDecoderG722::Decode(const uint8_t* encoded, size_t encoded_len,
278                             int16_t* decoded, SpeechType* speech_type) {
279  int16_t temp_type = 1;  // Default is speech.
280  int16_t ret = WebRtcG722_Decode(
281      static_cast<G722DecInst*>(state_),
282      const_cast<int16_t*>(reinterpret_cast<const int16_t*>(encoded)),
283      static_cast<int16_t>(encoded_len), decoded, &temp_type);
284  *speech_type = ConvertSpeechType(temp_type);
285  return ret;
286}
287
288int AudioDecoderG722::Init() {
289  return WebRtcG722_DecoderInit(static_cast<G722DecInst*>(state_));
290}
291
292int AudioDecoderG722::PacketDuration(const uint8_t* encoded,
293                                     size_t encoded_len) {
294  // 1/2 encoded byte per sample per channel.
295  return static_cast<int>(2 * encoded_len / channels_);
296}
297
298AudioDecoderG722Stereo::AudioDecoderG722Stereo()
299    : AudioDecoderG722(),
300      state_left_(state_),  // Base member |state_| is used for left channel.
301      state_right_(NULL) {
302  channels_ = 2;
303  // |state_left_| already created by the base class AudioDecoderG722.
304  WebRtcG722_CreateDecoder(reinterpret_cast<G722DecInst**>(&state_right_));
305}
306
307AudioDecoderG722Stereo::~AudioDecoderG722Stereo() {
308  // |state_left_| will be freed by the base class AudioDecoderG722.
309  WebRtcG722_FreeDecoder(static_cast<G722DecInst*>(state_right_));
310}
311
312int AudioDecoderG722Stereo::Decode(const uint8_t* encoded, size_t encoded_len,
313                                   int16_t* decoded, SpeechType* speech_type) {
314  int16_t temp_type = 1;  // Default is speech.
315  // De-interleave the bit-stream into two separate payloads.
316  uint8_t* encoded_deinterleaved = new uint8_t[encoded_len];
317  SplitStereoPacket(encoded, encoded_len, encoded_deinterleaved);
318  // Decode left and right.
319  int16_t ret = WebRtcG722_Decode(
320      static_cast<G722DecInst*>(state_left_),
321      reinterpret_cast<int16_t*>(encoded_deinterleaved),
322      static_cast<int16_t>(encoded_len / 2), decoded, &temp_type);
323  if (ret >= 0) {
324    int decoded_len = ret;
325    ret = WebRtcG722_Decode(
326      static_cast<G722DecInst*>(state_right_),
327      reinterpret_cast<int16_t*>(&encoded_deinterleaved[encoded_len / 2]),
328      static_cast<int16_t>(encoded_len / 2), &decoded[decoded_len], &temp_type);
329    if (ret == decoded_len) {
330      decoded_len += ret;
331      // Interleave output.
332      for (int k = decoded_len / 2; k < decoded_len; k++) {
333          int16_t temp = decoded[k];
334          memmove(&decoded[2 * k - decoded_len + 2],
335                  &decoded[2 * k - decoded_len + 1],
336                  (decoded_len - k - 1) * sizeof(int16_t));
337          decoded[2 * k - decoded_len + 1] = temp;
338      }
339      ret = decoded_len;  // Return total number of samples.
340    }
341  }
342  *speech_type = ConvertSpeechType(temp_type);
343  delete [] encoded_deinterleaved;
344  return ret;
345}
346
347int AudioDecoderG722Stereo::Init() {
348  int ret = WebRtcG722_DecoderInit(static_cast<G722DecInst*>(state_right_));
349  if (ret != 0) {
350    return ret;
351  }
352  return AudioDecoderG722::Init();
353}
354
355// Split the stereo packet and place left and right channel after each other
356// in the output array.
357void AudioDecoderG722Stereo::SplitStereoPacket(const uint8_t* encoded,
358                                               size_t encoded_len,
359                                               uint8_t* encoded_deinterleaved) {
360  assert(encoded);
361  // Regroup the 4 bits/sample so |l1 l2| |r1 r2| |l3 l4| |r3 r4| ...,
362  // where "lx" is 4 bits representing left sample number x, and "rx" right
363  // sample. Two samples fit in one byte, represented with |...|.
364  for (size_t i = 0; i + 1 < encoded_len; i += 2) {
365    uint8_t right_byte = ((encoded[i] & 0x0F) << 4) + (encoded[i + 1] & 0x0F);
366    encoded_deinterleaved[i] = (encoded[i] & 0xF0) + (encoded[i + 1] >> 4);
367    encoded_deinterleaved[i + 1] = right_byte;
368  }
369
370  // Move one byte representing right channel each loop, and place it at the
371  // end of the bytestream vector. After looping the data is reordered to:
372  // |l1 l2| |l3 l4| ... |l(N-1) lN| |r1 r2| |r3 r4| ... |r(N-1) r(N)|,
373  // where N is the total number of samples.
374  for (size_t i = 0; i < encoded_len / 2; i++) {
375    uint8_t right_byte = encoded_deinterleaved[i + 1];
376    memmove(&encoded_deinterleaved[i + 1], &encoded_deinterleaved[i + 2],
377            encoded_len - i - 2);
378    encoded_deinterleaved[encoded_len - 1] = right_byte;
379  }
380}
381#endif
382
383// CELT
384#ifdef WEBRTC_CODEC_CELT
385AudioDecoderCelt::AudioDecoderCelt(enum NetEqDecoder type)
386    : AudioDecoder(type) {
387  assert(type == kDecoderCELT_32 || type == kDecoderCELT_32_2ch);
388  if (type == kDecoderCELT_32) {
389    channels_ = 1;
390  } else {
391    channels_ = 2;
392  }
393  WebRtcCelt_CreateDec(reinterpret_cast<CELT_decinst_t**>(&state_),
394                       static_cast<int>(channels_));
395}
396
397AudioDecoderCelt::~AudioDecoderCelt() {
398  WebRtcCelt_FreeDec(static_cast<CELT_decinst_t*>(state_));
399}
400
401int AudioDecoderCelt::Decode(const uint8_t* encoded, size_t encoded_len,
402                             int16_t* decoded, SpeechType* speech_type) {
403  int16_t temp_type = 1;  // Default to speech.
404  int ret = WebRtcCelt_DecodeUniversal(static_cast<CELT_decinst_t*>(state_),
405                                       encoded, static_cast<int>(encoded_len),
406                                       decoded, &temp_type);
407  *speech_type = ConvertSpeechType(temp_type);
408  if (ret < 0) {
409    return -1;
410  }
411  // Return the total number of samples.
412  return ret * static_cast<int>(channels_);
413}
414
415int AudioDecoderCelt::Init() {
416  return WebRtcCelt_DecoderInit(static_cast<CELT_decinst_t*>(state_));
417}
418
419bool AudioDecoderCelt::HasDecodePlc() const { return true; }
420
421int AudioDecoderCelt::DecodePlc(int num_frames, int16_t* decoded) {
422  int ret = WebRtcCelt_DecodePlc(static_cast<CELT_decinst_t*>(state_),
423                                 decoded, num_frames);
424  if (ret < 0) {
425    return -1;
426  }
427  // Return the total number of samples.
428  return ret * static_cast<int>(channels_);
429}
430#endif
431
432// Opus
433#ifdef WEBRTC_CODEC_OPUS
434AudioDecoderOpus::AudioDecoderOpus(enum NetEqDecoder type)
435    : AudioDecoder(type) {
436  if (type == kDecoderOpus_2ch) {
437    channels_ = 2;
438  } else {
439    channels_ = 1;
440  }
441  WebRtcOpus_DecoderCreate(reinterpret_cast<OpusDecInst**>(&state_),
442                           static_cast<int>(channels_));
443}
444
445AudioDecoderOpus::~AudioDecoderOpus() {
446  WebRtcOpus_DecoderFree(static_cast<OpusDecInst*>(state_));
447}
448
449int AudioDecoderOpus::Decode(const uint8_t* encoded, size_t encoded_len,
450                             int16_t* decoded, SpeechType* speech_type) {
451  int16_t temp_type = 1;  // Default is speech.
452  int16_t ret = WebRtcOpus_DecodeNew(static_cast<OpusDecInst*>(state_), encoded,
453                                     static_cast<int16_t>(encoded_len), decoded,
454                                     &temp_type);
455  if (ret > 0)
456    ret *= static_cast<int16_t>(channels_);  // Return total number of samples.
457  *speech_type = ConvertSpeechType(temp_type);
458  return ret;
459}
460
461int AudioDecoderOpus::Init() {
462  return WebRtcOpus_DecoderInitNew(static_cast<OpusDecInst*>(state_));
463}
464
465int AudioDecoderOpus::PacketDuration(const uint8_t* encoded,
466                                     size_t encoded_len) {
467  return WebRtcOpus_DurationEst(static_cast<OpusDecInst*>(state_),
468                                encoded, static_cast<int>(encoded_len));
469}
470#endif
471
472AudioDecoderCng::AudioDecoderCng(enum NetEqDecoder type)
473    : AudioDecoder(type) {
474  assert(type == kDecoderCNGnb || type == kDecoderCNGwb ||
475         kDecoderCNGswb32kHz || type == kDecoderCNGswb48kHz);
476  WebRtcCng_CreateDec(reinterpret_cast<CNG_dec_inst**>(&state_));
477  assert(state_);
478}
479
480AudioDecoderCng::~AudioDecoderCng() {
481  if (state_) {
482    WebRtcCng_FreeDec(static_cast<CNG_dec_inst*>(state_));
483  }
484}
485
486int AudioDecoderCng::Init() {
487  assert(state_);
488  return WebRtcCng_InitDec(static_cast<CNG_dec_inst*>(state_));
489}
490
491}  // namespace webrtc
Note: See TracBrowser for help on using the repository browser.