Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(274)

Side by Side Diff: webrtc/api/audio_codecs/audio_decoder.cc

Issue 2668523004: Move AudioDecoder and related stuff to the api/ directory (Closed)
Patch Set: more review fixes Created 3 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 /* 1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 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 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 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
11 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h" 11 #include "webrtc/api/audio_codecs/audio_decoder.h"
12 12
13 #include <assert.h> 13 #include <assert.h>
14 #include <memory> 14 #include <memory>
15 #include <utility> 15 #include <utility>
16 16
17 #include "webrtc/base/array_view.h" 17 #include "webrtc/base/array_view.h"
18 #include "webrtc/base/checks.h" 18 #include "webrtc/base/checks.h"
19 #include "webrtc/base/sanitizer.h" 19 #include "webrtc/base/sanitizer.h"
20 #include "webrtc/base/trace_event.h" 20 #include "webrtc/base/trace_event.h"
21 #include "webrtc/modules/audio_coding/codecs/legacy_encoded_audio_frame.h"
22 21
23 namespace webrtc { 22 namespace webrtc {
24 23
24 namespace {
25
26 class OldStyleEncodedFrame final : public AudioDecoder::EncodedAudioFrame {
27 public:
28 OldStyleEncodedFrame(AudioDecoder* decoder, rtc::Buffer&& payload)
29 : decoder_(decoder), payload_(std::move(payload)) {}
30
31 size_t Duration() const override {
32 const int ret = decoder_->PacketDuration(payload_.data(), payload_.size());
33 return ret < 0 ? 0 : static_cast<size_t>(ret);
34 }
35
36 rtc::Optional<DecodeResult> Decode(
37 rtc::ArrayView<int16_t> decoded) const override {
38 auto speech_type = AudioDecoder::kSpeech;
39 const int ret = decoder_->Decode(
40 payload_.data(), payload_.size(), decoder_->SampleRateHz(),
41 decoded.size() * sizeof(int16_t), decoded.data(), &speech_type);
42 return ret < 0 ? rtc::Optional<DecodeResult>()
43 : rtc::Optional<DecodeResult>(
44 {static_cast<size_t>(ret), speech_type});
45 }
46
47 private:
48 AudioDecoder* const decoder_;
49 const rtc::Buffer payload_;
50 };
51
52 } // namespace
53
25 AudioDecoder::ParseResult::ParseResult() = default; 54 AudioDecoder::ParseResult::ParseResult() = default;
26 AudioDecoder::ParseResult::ParseResult(ParseResult&& b) = default; 55 AudioDecoder::ParseResult::ParseResult(ParseResult&& b) = default;
27 AudioDecoder::ParseResult::ParseResult(uint32_t timestamp, 56 AudioDecoder::ParseResult::ParseResult(uint32_t timestamp,
28 int priority, 57 int priority,
29 std::unique_ptr<EncodedAudioFrame> frame) 58 std::unique_ptr<EncodedAudioFrame> frame)
30 : timestamp(timestamp), priority(priority), frame(std::move(frame)) { 59 : timestamp(timestamp), priority(priority), frame(std::move(frame)) {
31 RTC_DCHECK_GE(priority, 0); 60 RTC_DCHECK_GE(priority, 0);
32 } 61 }
33 62
34 AudioDecoder::ParseResult::~ParseResult() = default; 63 AudioDecoder::ParseResult::~ParseResult() = default;
35 64
36 AudioDecoder::ParseResult& AudioDecoder::ParseResult::operator=( 65 AudioDecoder::ParseResult& AudioDecoder::ParseResult::operator=(
37 ParseResult&& b) = default; 66 ParseResult&& b) = default;
38 67
39 std::vector<AudioDecoder::ParseResult> AudioDecoder::ParsePayload( 68 std::vector<AudioDecoder::ParseResult> AudioDecoder::ParsePayload(
40 rtc::Buffer&& payload, 69 rtc::Buffer&& payload,
41 uint32_t timestamp) { 70 uint32_t timestamp) {
42 std::vector<ParseResult> results; 71 std::vector<ParseResult> results;
43 std::unique_ptr<EncodedAudioFrame> frame( 72 std::unique_ptr<EncodedAudioFrame> frame(
44 new LegacyEncodedAudioFrame(this, std::move(payload))); 73 new OldStyleEncodedFrame(this, std::move(payload)));
45 results.emplace_back(timestamp, 0, std::move(frame)); 74 results.emplace_back(timestamp, 0, std::move(frame));
46 return results; 75 return results;
47 } 76 }
48 77
49 int AudioDecoder::Decode(const uint8_t* encoded, size_t encoded_len, 78 int AudioDecoder::Decode(const uint8_t* encoded,
50 int sample_rate_hz, size_t max_decoded_bytes, 79 size_t encoded_len,
51 int16_t* decoded, SpeechType* speech_type) { 80 int sample_rate_hz,
81 size_t max_decoded_bytes,
82 int16_t* decoded,
83 SpeechType* speech_type) {
52 TRACE_EVENT0("webrtc", "AudioDecoder::Decode"); 84 TRACE_EVENT0("webrtc", "AudioDecoder::Decode");
53 rtc::MsanCheckInitialized(rtc::MakeArrayView(encoded, encoded_len)); 85 rtc::MsanCheckInitialized(rtc::MakeArrayView(encoded, encoded_len));
54 int duration = PacketDuration(encoded, encoded_len); 86 int duration = PacketDuration(encoded, encoded_len);
55 if (duration >= 0 && 87 if (duration >= 0 &&
56 duration * Channels() * sizeof(int16_t) > max_decoded_bytes) { 88 duration * Channels() * sizeof(int16_t) > max_decoded_bytes) {
57 return -1; 89 return -1;
58 } 90 }
59 return DecodeInternal(encoded, encoded_len, sample_rate_hz, decoded, 91 return DecodeInternal(encoded, encoded_len, sample_rate_hz, decoded,
60 speech_type); 92 speech_type);
61 } 93 }
62 94
63 int AudioDecoder::DecodeRedundant(const uint8_t* encoded, size_t encoded_len, 95 int AudioDecoder::DecodeRedundant(const uint8_t* encoded,
64 int sample_rate_hz, size_t max_decoded_bytes, 96 size_t encoded_len,
65 int16_t* decoded, SpeechType* speech_type) { 97 int sample_rate_hz,
98 size_t max_decoded_bytes,
99 int16_t* decoded,
100 SpeechType* speech_type) {
66 TRACE_EVENT0("webrtc", "AudioDecoder::DecodeRedundant"); 101 TRACE_EVENT0("webrtc", "AudioDecoder::DecodeRedundant");
67 rtc::MsanCheckInitialized(rtc::MakeArrayView(encoded, encoded_len)); 102 rtc::MsanCheckInitialized(rtc::MakeArrayView(encoded, encoded_len));
68 int duration = PacketDurationRedundant(encoded, encoded_len); 103 int duration = PacketDurationRedundant(encoded, encoded_len);
69 if (duration >= 0 && 104 if (duration >= 0 &&
70 duration * Channels() * sizeof(int16_t) > max_decoded_bytes) { 105 duration * Channels() * sizeof(int16_t) > max_decoded_bytes) {
71 return -1; 106 return -1;
72 } 107 }
73 return DecodeRedundantInternal(encoded, encoded_len, sample_rate_hz, decoded, 108 return DecodeRedundantInternal(encoded, encoded_len, sample_rate_hz, decoded,
74 speech_type); 109 speech_type);
75 } 110 }
76 111
77 int AudioDecoder::DecodeRedundantInternal(const uint8_t* encoded, 112 int AudioDecoder::DecodeRedundantInternal(const uint8_t* encoded,
78 size_t encoded_len, 113 size_t encoded_len,
79 int sample_rate_hz, int16_t* decoded, 114 int sample_rate_hz,
115 int16_t* decoded,
80 SpeechType* speech_type) { 116 SpeechType* speech_type) {
81 return DecodeInternal(encoded, encoded_len, sample_rate_hz, decoded, 117 return DecodeInternal(encoded, encoded_len, sample_rate_hz, decoded,
82 speech_type); 118 speech_type);
83 } 119 }
84 120
85 bool AudioDecoder::HasDecodePlc() const { return false; } 121 bool AudioDecoder::HasDecodePlc() const {
122 return false;
123 }
86 124
87 size_t AudioDecoder::DecodePlc(size_t num_frames, int16_t* decoded) { 125 size_t AudioDecoder::DecodePlc(size_t num_frames, int16_t* decoded) {
88 return 0; 126 return 0;
89 } 127 }
90 128
91 int AudioDecoder::IncomingPacket(const uint8_t* payload, 129 int AudioDecoder::IncomingPacket(const uint8_t* payload,
92 size_t payload_len, 130 size_t payload_len,
93 uint16_t rtp_sequence_number, 131 uint16_t rtp_sequence_number,
94 uint32_t rtp_timestamp, 132 uint32_t rtp_timestamp,
95 uint32_t arrival_timestamp) { 133 uint32_t arrival_timestamp) {
96 return 0; 134 return 0;
97 } 135 }
98 136
99 int AudioDecoder::ErrorCode() { return 0; } 137 int AudioDecoder::ErrorCode() {
138 return 0;
139 }
100 140
101 int AudioDecoder::PacketDuration(const uint8_t* encoded, 141 int AudioDecoder::PacketDuration(const uint8_t* encoded,
102 size_t encoded_len) const { 142 size_t encoded_len) const {
103 return kNotImplemented; 143 return kNotImplemented;
104 } 144 }
105 145
106 int AudioDecoder::PacketDurationRedundant(const uint8_t* encoded, 146 int AudioDecoder::PacketDurationRedundant(const uint8_t* encoded,
107 size_t encoded_len) const { 147 size_t encoded_len) const {
108 return kNotImplemented; 148 return kNotImplemented;
109 } 149 }
(...skipping 10 matching lines...) Expand all
120 return kSpeech; 160 return kSpeech;
121 case 2: 161 case 2:
122 return kComfortNoise; 162 return kComfortNoise;
123 default: 163 default:
124 assert(false); 164 assert(false);
125 return kSpeech; 165 return kSpeech;
126 } 166 }
127 } 167 }
128 168
129 } // namespace webrtc 169 } // namespace webrtc
OLDNEW
« no previous file with comments | « webrtc/api/audio_codecs/audio_decoder.h ('k') | webrtc/api/audio_codecs/audio_decoder_factory.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698