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/codecs/opus/interface/opus_interface.h"
12#include "webrtc/modules/audio_coding/codecs/opus/opus_inst.h"
13
14#include <stdlib.h>
15#include <string.h>
16
17enum {
18  /* Maximum supported frame size in WebRTC is 60 ms. */
19  kWebRtcOpusMaxEncodeFrameSizeMs = 60,
20
21  /* The format allows up to 120 ms frames. Since we don't control the other
22   * side, we must allow for packets of that size. NetEq is currently limited
23   * to 60 ms on the receive side. */
24  kWebRtcOpusMaxDecodeFrameSizeMs = 120,
25
26  /* Maximum sample count per channel is 48 kHz * maximum frame size in
27   * milliseconds. */
28  kWebRtcOpusMaxFrameSizePerChannel = 48 * kWebRtcOpusMaxDecodeFrameSizeMs,
29
30  /* Default frame size, 20 ms @ 48 kHz, in samples (for one channel). */
31  kWebRtcOpusDefaultFrameSize = 960,
32};
33
34int16_t WebRtcOpus_EncoderCreate(OpusEncInst** inst, int32_t channels) {
35  OpusEncInst* state;
36  if (inst != NULL) {
37    state = (OpusEncInst*) calloc(1, sizeof(OpusEncInst));
38    if (state) {
39      int error;
40      /* Default to VoIP application for mono, and AUDIO for stereo. */
41      int application = (channels == 1) ? OPUS_APPLICATION_VOIP :
42          OPUS_APPLICATION_AUDIO;
43
44      state->encoder = opus_encoder_create(48000, channels, application,
45                                           &error);
46      if (error == OPUS_OK && state->encoder != NULL) {
47        *inst = state;
48        return 0;
49      }
50      free(state);
51    }
52  }
53  return -1;
54}
55
56int16_t WebRtcOpus_EncoderFree(OpusEncInst* inst) {
57  if (inst) {
58    opus_encoder_destroy(inst->encoder);
59    free(inst);
60    return 0;
61  } else {
62    return -1;
63  }
64}
65
66int16_t WebRtcOpus_Encode(OpusEncInst* inst, int16_t* audio_in, int16_t samples,
67                          int16_t length_encoded_buffer, uint8_t* encoded) {
68  opus_int16* audio = (opus_int16*) audio_in;
69  unsigned char* coded = encoded;
70  int res;
71
72  if (samples > 48 * kWebRtcOpusMaxEncodeFrameSizeMs) {
73    return -1;
74  }
75
76  res = opus_encode(inst->encoder, audio, samples, coded,
77                    length_encoded_buffer);
78
79  if (res > 0) {
80    return res;
81  }
82  return -1;
83}
84
85int16_t WebRtcOpus_SetBitRate(OpusEncInst* inst, int32_t rate) {
86  if (inst) {
87    return opus_encoder_ctl(inst->encoder, OPUS_SET_BITRATE(rate));
88  } else {
89    return -1;
90  }
91}
92
93int16_t WebRtcOpus_SetPacketLossRate(OpusEncInst* inst, int32_t loss_rate) {
94  if (inst) {
95    return opus_encoder_ctl(inst->encoder,
96                            OPUS_SET_PACKET_LOSS_PERC(loss_rate));
97  } else {
98    return -1;
99  }
100}
101
102int16_t WebRtcOpus_SetMaxPlaybackRate(OpusEncInst* inst, int32_t frequency_hz) {
103  opus_int32 set_bandwidth;
104
105  if (!inst)
106    return -1;
107
108  if (frequency_hz <= 8000) {
109    set_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
110  } else if (frequency_hz <= 12000) {
111    set_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
112  } else if (frequency_hz <= 16000) {
113    set_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
114  } else if (frequency_hz <= 24000) {
115    set_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
116  } else {
117    set_bandwidth = OPUS_BANDWIDTH_FULLBAND;
118  }
119  return opus_encoder_ctl(inst->encoder,
120                          OPUS_SET_MAX_BANDWIDTH(set_bandwidth));
121}
122
123int16_t WebRtcOpus_EnableFec(OpusEncInst* inst) {
124  if (inst) {
125    return opus_encoder_ctl(inst->encoder, OPUS_SET_INBAND_FEC(1));
126  } else {
127    return -1;
128  }
129}
130
131int16_t WebRtcOpus_DisableFec(OpusEncInst* inst) {
132  if (inst) {
133    return opus_encoder_ctl(inst->encoder, OPUS_SET_INBAND_FEC(0));
134  } else {
135    return -1;
136  }
137}
138
139int16_t WebRtcOpus_SetComplexity(OpusEncInst* inst, int32_t complexity) {
140  if (inst) {
141    return opus_encoder_ctl(inst->encoder, OPUS_SET_COMPLEXITY(complexity));
142  } else {
143    return -1;
144  }
145}
146
147int16_t WebRtcOpus_DecoderCreate(OpusDecInst** inst, int channels) {
148  int error_l;
149  int error_r;
150  OpusDecInst* state;
151
152  if (inst != NULL) {
153    /* Create Opus decoder state. */
154    state = (OpusDecInst*) calloc(1, sizeof(OpusDecInst));
155    if (state == NULL) {
156      return -1;
157    }
158
159    /* Create new memory for left and right channel, always at 48000 Hz. */
160    state->decoder_left = opus_decoder_create(48000, channels, &error_l);
161    state->decoder_right = opus_decoder_create(48000, channels, &error_r);
162    if (error_l == OPUS_OK && error_r == OPUS_OK && state->decoder_left != NULL
163        && state->decoder_right != NULL) {
164      /* Creation of memory all ok. */
165      state->channels = channels;
166      state->prev_decoded_samples = kWebRtcOpusDefaultFrameSize;
167      *inst = state;
168      return 0;
169    }
170
171    /* If memory allocation was unsuccessful, free the entire state. */
172    if (state->decoder_left) {
173      opus_decoder_destroy(state->decoder_left);
174    }
175    if (state->decoder_right) {
176      opus_decoder_destroy(state->decoder_right);
177    }
178    free(state);
179  }
180  return -1;
181}
182
183int16_t WebRtcOpus_DecoderFree(OpusDecInst* inst) {
184  if (inst) {
185    opus_decoder_destroy(inst->decoder_left);
186    opus_decoder_destroy(inst->decoder_right);
187    free(inst);
188    return 0;
189  } else {
190    return -1;
191  }
192}
193
194int WebRtcOpus_DecoderChannels(OpusDecInst* inst) {
195  return inst->channels;
196}
197
198int16_t WebRtcOpus_DecoderInitNew(OpusDecInst* inst) {
199  int error = opus_decoder_ctl(inst->decoder_left, OPUS_RESET_STATE);
200  if (error == OPUS_OK) {
201    return 0;
202  }
203  return -1;
204}
205
206int16_t WebRtcOpus_DecoderInit(OpusDecInst* inst) {
207  int error = opus_decoder_ctl(inst->decoder_left, OPUS_RESET_STATE);
208  if (error == OPUS_OK) {
209    return 0;
210  }
211  return -1;
212}
213
214int16_t WebRtcOpus_DecoderInitSlave(OpusDecInst* inst) {
215  int error = opus_decoder_ctl(inst->decoder_right, OPUS_RESET_STATE);
216  if (error == OPUS_OK) {
217    return 0;
218  }
219  return -1;
220}
221
222/* |frame_size| is set to maximum Opus frame size in the normal case, and
223 * is set to the number of samples needed for PLC in case of losses.
224 * It is up to the caller to make sure the value is correct. */
225static int DecodeNative(OpusDecoder* inst, const int16_t* encoded,
226                        int16_t encoded_bytes, int frame_size,
227                        int16_t* decoded, int16_t* audio_type) {
228  unsigned char* coded = (unsigned char*) encoded;
229  opus_int16* audio = (opus_int16*) decoded;
230
231  int res = opus_decode(inst, coded, encoded_bytes, audio, frame_size, 0);
232
233  /* TODO(tlegrand): set to DTX for zero-length packets? */
234  *audio_type = 0;
235
236  if (res > 0) {
237    return res;
238  }
239  return -1;
240}
241
242static int DecodeFec(OpusDecoder* inst, const int16_t* encoded,
243                     int16_t encoded_bytes, int frame_size,
244                     int16_t* decoded, int16_t* audio_type) {
245  unsigned char* coded = (unsigned char*) encoded;
246  opus_int16* audio = (opus_int16*) decoded;
247
248  int res = opus_decode(inst, coded, encoded_bytes, audio, frame_size, 1);
249
250  /* TODO(tlegrand): set to DTX for zero-length packets? */
251  *audio_type = 0;
252
253  if (res > 0) {
254    return res;
255  }
256  return -1;
257}
258
259int16_t WebRtcOpus_DecodeNew(OpusDecInst* inst, const uint8_t* encoded,
260                             int16_t encoded_bytes, int16_t* decoded,
261                             int16_t* audio_type) {
262  int16_t* coded = (int16_t*)encoded;
263  int decoded_samples;
264
265  decoded_samples = DecodeNative(inst->decoder_left, coded, encoded_bytes,
266                                 kWebRtcOpusMaxFrameSizePerChannel,
267                                 decoded, audio_type);
268  if (decoded_samples < 0) {
269    return -1;
270  }
271
272  /* Update decoded sample memory, to be used by the PLC in case of losses. */
273  inst->prev_decoded_samples = decoded_samples;
274
275  return decoded_samples;
276}
277
278int16_t WebRtcOpus_Decode(OpusDecInst* inst, const int16_t* encoded,
279                          int16_t encoded_bytes, int16_t* decoded,
280                          int16_t* audio_type) {
281  int decoded_samples;
282  int i;
283
284  /* If mono case, just do a regular call to the decoder.
285   * If stereo, call to WebRtcOpus_Decode() gives left channel as output, and
286   * calls to WebRtcOpus_Decode_slave() give right channel as output.
287   * This is to make stereo work with the current setup of NetEQ, which
288   * requires two calls to the decoder to produce stereo. */
289
290  decoded_samples = DecodeNative(inst->decoder_left, encoded, encoded_bytes,
291                                 kWebRtcOpusMaxFrameSizePerChannel, decoded,
292                                 audio_type);
293  if (decoded_samples < 0) {
294    return -1;
295  }
296  if (inst->channels == 2) {
297    /* The parameter |decoded_samples| holds the number of samples pairs, in
298     * case of stereo. Number of samples in |decoded| equals |decoded_samples|
299     * times 2. */
300    for (i = 0; i < decoded_samples; i++) {
301      /* Take every second sample, starting at the first sample. This gives
302       * the left channel. */
303      decoded[i] = decoded[i * 2];
304    }
305  }
306
307  /* Update decoded sample memory, to be used by the PLC in case of losses. */
308  inst->prev_decoded_samples = decoded_samples;
309
310  return decoded_samples;
311}
312
313int16_t WebRtcOpus_DecodeSlave(OpusDecInst* inst, const int16_t* encoded,
314                               int16_t encoded_bytes, int16_t* decoded,
315                               int16_t* audio_type) {
316  int decoded_samples;
317  int i;
318
319  decoded_samples = DecodeNative(inst->decoder_right, encoded, encoded_bytes,
320                                 kWebRtcOpusMaxFrameSizePerChannel, decoded,
321                                 audio_type);
322  if (decoded_samples < 0) {
323    return -1;
324  }
325  if (inst->channels == 2) {
326    /* The parameter |decoded_samples| holds the number of samples pairs, in
327     * case of stereo. Number of samples in |decoded| equals |decoded_samples|
328     * times 2. */
329    for (i = 0; i < decoded_samples; i++) {
330      /* Take every second sample, starting at the second sample. This gives
331       * the right channel. */
332      decoded[i] = decoded[i * 2 + 1];
333    }
334  } else {
335    /* Decode slave should never be called for mono packets. */
336    return -1;
337  }
338
339  return decoded_samples;
340}
341
342int16_t WebRtcOpus_DecodePlc(OpusDecInst* inst, int16_t* decoded,
343                             int16_t number_of_lost_frames) {
344  int16_t audio_type = 0;
345  int decoded_samples;
346  int plc_samples;
347
348  /* The number of samples we ask for is |number_of_lost_frames| times
349   * |prev_decoded_samples_|. Limit the number of samples to maximum
350   * |kWebRtcOpusMaxFrameSizePerChannel|. */
351  plc_samples = number_of_lost_frames * inst->prev_decoded_samples;
352  plc_samples = (plc_samples <= kWebRtcOpusMaxFrameSizePerChannel) ?
353      plc_samples : kWebRtcOpusMaxFrameSizePerChannel;
354  decoded_samples = DecodeNative(inst->decoder_left, NULL, 0, plc_samples,
355                                 decoded, &audio_type);
356  if (decoded_samples < 0) {
357    return -1;
358  }
359
360  return decoded_samples;
361}
362
363int16_t WebRtcOpus_DecodePlcMaster(OpusDecInst* inst, int16_t* decoded,
364                                   int16_t number_of_lost_frames) {
365  int decoded_samples;
366  int16_t audio_type = 0;
367  int plc_samples;
368  int i;
369
370  /* If mono case, just do a regular call to the decoder.
371   * If stereo, call to WebRtcOpus_DecodePlcMaster() gives left channel as
372   * output, and calls to WebRtcOpus_DecodePlcSlave() give right channel as
373   * output. This is to make stereo work with the current setup of NetEQ, which
374   * requires two calls to the decoder to produce stereo. */
375
376  /* The number of samples we ask for is |number_of_lost_frames| times
377   * |prev_decoded_samples_|. Limit the number of samples to maximum
378   * |kWebRtcOpusMaxFrameSizePerChannel|. */
379  plc_samples = number_of_lost_frames * inst->prev_decoded_samples;
380  plc_samples = (plc_samples <= kWebRtcOpusMaxFrameSizePerChannel) ?
381      plc_samples : kWebRtcOpusMaxFrameSizePerChannel;
382  decoded_samples = DecodeNative(inst->decoder_left, NULL, 0, plc_samples,
383                                 decoded, &audio_type);
384  if (decoded_samples < 0) {
385    return -1;
386  }
387
388  if (inst->channels == 2) {
389    /* The parameter |decoded_samples| holds the number of sample pairs, in
390     * case of stereo. The original number of samples in |decoded| equals
391     * |decoded_samples| times 2. */
392    for (i = 0; i < decoded_samples; i++) {
393      /* Take every second sample, starting at the first sample. This gives
394       * the left channel. */
395      decoded[i] = decoded[i * 2];
396    }
397  }
398
399  return decoded_samples;
400}
401
402int16_t WebRtcOpus_DecodePlcSlave(OpusDecInst* inst, int16_t* decoded,
403                                  int16_t number_of_lost_frames) {
404  int decoded_samples;
405  int16_t audio_type = 0;
406  int plc_samples;
407  int i;
408
409  /* Calls to WebRtcOpus_DecodePlcSlave() give right channel as output.
410   * The function should never be called in the mono case. */
411  if (inst->channels != 2) {
412    return -1;
413  }
414
415  /* The number of samples we ask for is |number_of_lost_frames| times
416   *  |prev_decoded_samples_|. Limit the number of samples to maximum
417   *  |kWebRtcOpusMaxFrameSizePerChannel|. */
418  plc_samples = number_of_lost_frames * inst->prev_decoded_samples;
419  plc_samples = (plc_samples <= kWebRtcOpusMaxFrameSizePerChannel)
420      ? plc_samples : kWebRtcOpusMaxFrameSizePerChannel;
421  decoded_samples = DecodeNative(inst->decoder_right, NULL, 0, plc_samples,
422                                 decoded, &audio_type);
423  if (decoded_samples < 0) {
424    return -1;
425  }
426
427  /* The parameter |decoded_samples| holds the number of sample pairs,
428   * The original number of samples in |decoded| equals |decoded_samples|
429   * times 2. */
430  for (i = 0; i < decoded_samples; i++) {
431    /* Take every second sample, starting at the second sample. This gives
432     * the right channel. */
433    decoded[i] = decoded[i * 2 + 1];
434  }
435
436  return decoded_samples;
437}
438
439int16_t WebRtcOpus_DecodeFec(OpusDecInst* inst, const uint8_t* encoded,
440                             int16_t encoded_bytes, int16_t* decoded,
441                             int16_t* audio_type) {
442  int16_t* coded = (int16_t*)encoded;
443  int decoded_samples;
444  int fec_samples;
445
446  if (WebRtcOpus_PacketHasFec(encoded, encoded_bytes) != 1) {
447    return 0;
448  }
449
450  fec_samples = opus_packet_get_samples_per_frame(encoded, 48000);
451
452  decoded_samples = DecodeFec(inst->decoder_left, coded, encoded_bytes,
453                              fec_samples, decoded, audio_type);
454  if (decoded_samples < 0) {
455    return -1;
456  }
457
458  return decoded_samples;
459}
460
461int WebRtcOpus_DurationEst(OpusDecInst* inst,
462                           const uint8_t* payload,
463                           int payload_length_bytes) {
464  int frames, samples;
465  frames = opus_packet_get_nb_frames(payload, payload_length_bytes);
466  if (frames < 0) {
467    /* Invalid payload data. */
468    return 0;
469  }
470  samples = frames * opus_packet_get_samples_per_frame(payload, 48000);
471  if (samples < 120 || samples > 5760) {
472    /* Invalid payload duration. */
473    return 0;
474  }
475  return samples;
476}
477
478int WebRtcOpus_FecDurationEst(const uint8_t* payload,
479                              int payload_length_bytes) {
480  int samples;
481  if (WebRtcOpus_PacketHasFec(payload, payload_length_bytes) != 1) {
482    return 0;
483  }
484
485  samples = opus_packet_get_samples_per_frame(payload, 48000);
486  if (samples < 480 || samples > 5760) {
487    /* Invalid payload duration. */
488    return 0;
489  }
490  return samples;
491}
492
493int WebRtcOpus_PacketHasFec(const uint8_t* payload,
494                            int payload_length_bytes) {
495  int frames, channels, payload_length_ms;
496  int n;
497  opus_int16 frame_sizes[48];
498  const unsigned char *frame_data[48];
499
500  if (payload == NULL || payload_length_bytes <= 0)
501    return 0;
502
503  /* In CELT_ONLY mode, packets should not have FEC. */
504  if (payload[0] & 0x80)
505    return 0;
506
507  payload_length_ms = opus_packet_get_samples_per_frame(payload, 48000) / 48;
508  if (10 > payload_length_ms)
509    payload_length_ms = 10;
510
511  channels = opus_packet_get_nb_channels(payload);
512
513  switch (payload_length_ms) {
514    case 10:
515    case 20: {
516      frames = 1;
517      break;
518    }
519    case 40: {
520      frames = 2;
521      break;
522    }
523    case 60: {
524      frames = 3;
525      break;
526    }
527    default: {
528      return 0; // It is actually even an invalid packet.
529    }
530  }
531
532  /* The following is to parse the LBRR flags. */
533  if (opus_packet_parse(payload, payload_length_bytes, NULL, frame_data,
534                        frame_sizes, NULL) < 0) {
535    return 0;
536  }
537
538  if (frame_sizes[0] <= 1) {
539    return 0;
540  }
541
542  for (n = 0; n < channels; n++) {
543    if (frame_data[0][0] & (0x80 >> ((n + 1) * (frames + 1) - 1)))
544      return 1;
545  }
546
547  return 0;
548}
549