opusdec_filter.c

   1 /*
   2  * Copyright (c) 2002-2007 Jean-Marc Valin
   3  * Copyright (c) 2008 CSIRO
   4  * Copyright (c) 2007-2012 Xiph.Org Foundation
   5  * Copyright (C) 2012-2013 Andre Noll <maan@systemlinux.org>
   6  *
   7  * Licensed under the GPL v2. For licencing details see COPYING.
   8  */
   9
  10 /** \file opusdec_filter.c The ogg/opus decoder. */
  11
  12 /* This file is based on opusdec.c, by Jean-Marc Valin, see below. */
  13
  14 /*
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions are met:
  17  *
  18  * - Redistributions of source code must retain the above copyright notice,
  19  * this list of conditions and the following disclaimer.
  20  *
  21  * - Redistributions in binary form must reproduce the above copyright notice,
  22  * this list of conditions and the following disclaimer in the documentation
  23  * and/or other materials provided with the distribution.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
  26  * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE
  29  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38
  39 /* Silence gcc warning caused by including opus.h */
  40 #if !defined(__STDC_VERSION__)
  41 #define __STDC_VERSION__ 0
  42 #endif
  43
  44 #include <regex.h>
  45 #include <opus/opus.h>
  46 #include <opus/opus_multistream.h>
  47 #include <ogg/ogg.h>
  48 #include <math.h>
  49
  50 #include "para.h"
  51 #include "list.h"
  52 #include "sched.h"
  53 #include "ggo.h"
  54 #include "buffer_tree.h"
  55 #include "filter.h"
  56 #include "error.h"
  57 #include "string.h"
  58 #include "opus_common.h"
  59
  60 /** 120ms at 48000 */
  61 #define MAX_FRAME_SIZE (960*6)
  62
  63 struct opusdec_context {
  64         OpusMSDecoder *st;
  65         opus_int64 packet_count;
  66         int total_links;
  67         bool stream_init;
  68         ogg_sync_state oy;
  69         ogg_stream_state os;
  70         ogg_page ogg_page;
  71         bool eos;
  72         int channels;
  73         int preskip;
  74         bool have_opus_stream;
  75         bool have_more;
  76         ogg_int32_t opus_serialno;
  77 };
  78
  79 static int opusdec_execute(struct btr_node *btrn, const char *cmd,
  80                 char **result)
  81 {
  82         struct filter_node *fn = btr_context(btrn);
  83         struct opusdec_context *ctx = fn->private_data;
  84
  85         return decoder_execute(cmd, 48000, ctx->channels, result);
  86 }
  87
  88 static void opusdec_open(struct filter_node *fn)
  89 {
  90         struct opusdec_context *ctx = para_calloc(sizeof(*ctx));
  91
  92         ogg_sync_init(&ctx->oy);
  93         fn->private_data = ctx;
  94 }
  95
  96 static void opusdec_close(struct filter_node *fn)
  97 {
  98         struct opusdec_context *ctx = fn->private_data;
  99
 100         if (ctx->st) {
 101                 opus_multistream_decoder_destroy(ctx->st);
 102                 if (ctx->stream_init)
 103                         ogg_stream_clear(&ctx->os);
 104                 ogg_sync_clear(&ctx->oy);
 105         }
 106         free(ctx);
 107         fn->private_data = NULL;
 108 }
 109
 110 /* Process an Opus header and setup the opus decoder based on it. */
 111 static int opusdec_init(ogg_packet *op, struct opusdec_context *ctx)
 112 {
 113         int ret;
 114         struct opus_header header;
 115
 116         ctx->st = NULL;
 117         ret = opus_parse_header((char *)op->packet, op->bytes, &header);
 118         if (ret < 0)
 119                 return ret;
 120         PARA_INFO_LOG("detected header v%d\n", header.version);
 121         ctx->channels = header.channels;
 122         ctx->preskip = header.preskip;
 123         ctx->st = opus_multistream_decoder_create(48000, header.channels,
 124                 header.nb_streams, header.nb_coupled, header.stream_map, &ret);
 125         if (ret != OPUS_OK || !ctx->st) {
 126                 PARA_ERROR_LOG("%s\n", opus_strerror(ret));
 127                 return -E_CREATE_OPUS_DECODER;
 128         }
 129         if (header.gain != 0) {
 130                 ret = opus_multistream_decoder_ctl(ctx->st,
 131                         OPUS_SET_GAIN(header.gain));
 132                 if (ret != OPUS_OK) {
 133                         PARA_ERROR_LOG("%s\n", opus_strerror(ret));
 134                         return -E_OPUS_SET_GAIN;
 135                 }
 136                 PARA_INFO_LOG("playback gain: %fdB\n", header.gain / 256.);
 137         }
 138         PARA_INFO_LOG("%d channel(s), 48KHz\n", ctx->channels);
 139         return 1;
 140 }
 141
 142 static void opusdec_add_output(short *pcm, int frames_available,
 143                 struct btr_node *btrn, struct opusdec_context *ctx)
 144 {
 145         int tmp_skip, num_frames, bytes;
 146
 147         tmp_skip = PARA_MIN(ctx->preskip, frames_available);
 148         ctx->preskip -= tmp_skip;
 149         num_frames = frames_available - tmp_skip;
 150         if (num_frames <= 0)
 151                 return;
 152         bytes = sizeof(short) * num_frames * ctx->channels;
 153
 154         if (tmp_skip > 0) {
 155                 short *in = pcm + ctx->channels * tmp_skip;
 156                 short *out = para_malloc(bytes);
 157                 memcpy(out, in, bytes);
 158                 free(pcm);
 159                 pcm = out;
 160         }
 161         btr_add_output((char *)pcm, bytes, btrn);
 162 }
 163
 164 /* returns > 1 if packet was decoded, 0 if it was ignored, negative on errors. */
 165 static int decode_packet(struct opusdec_context *ctx, ogg_packet *op,
 166                 struct btr_node *btrn)
 167 {
 168         int ret;
 169         short *output;
 170
 171         /*
 172          * OggOpus streams are identified by a magic string in the initial
 173          * stream header.
 174          */
 175         if (op->b_o_s && op->bytes >= 8 && !memcmp(op->packet, "OpusHead", 8)) {
 176                 if (!ctx->have_opus_stream) {
 177                         ctx->opus_serialno = ctx->os.serialno;
 178                         ctx->have_opus_stream = true;
 179                         ctx->packet_count = 0;
 180                         ctx->eos = false;
 181                         ctx->total_links++;
 182                 } else
 183                         PARA_NOTICE_LOG("ignoring opus stream %llu\n",
 184                                 (long long unsigned)ctx->os.serialno);
 185         }
 186         if (!ctx->have_opus_stream || ctx->os.serialno != ctx->opus_serialno)
 187                 return 0;
 188         /* If first packet in a logical stream, process the Opus header. */
 189         if (ctx->packet_count == 0)
 190                 return opusdec_init(op, ctx);
 191         if (ctx->packet_count == 1)
 192                 return 1;
 193         /* don't care for anything except opus eos */
 194         if (op->e_o_s && ctx->os.serialno == ctx->opus_serialno)
 195                 ctx->eos = true;
 196         output = para_malloc(sizeof(short) * MAX_FRAME_SIZE * ctx->channels);
 197         ret = opus_multistream_decode(ctx->st, (unsigned char *)op->packet,
 198                 op->bytes, output, MAX_FRAME_SIZE, 0);
 199         if (ret < 0) {
 200                 PARA_ERROR_LOG("%s\n", opus_strerror(ret));
 201                 free(output);
 202                 return -E_OPUS_DECODE;
 203         }
 204         opusdec_add_output(output, ret, btrn, ctx);
 205         return 1;
 206 }
 207
 208 #define OPUSDEC_MAX_OUTPUT_SIZE (1024 * 1024)
 209
 210 static int opusdec_post_select(__a_unused struct sched *s, struct task *t)
 211 {
 212         struct filter_node *fn = container_of(t, struct filter_node, task);
 213         struct opusdec_context *ctx = fn->private_data;
 214         struct btr_node *btrn = fn->btrn;
 215         int ret;
 216         ogg_packet op;
 217
 218         ret = btr_node_status(btrn, fn->min_iqs, BTR_NT_INTERNAL);
 219         if (ret < 0) {
 220                 if (ret != -E_BTR_EOF) /* fatal error */
 221                         goto out;
 222                 if (!ctx->have_more) /* EOF */
 223                         goto out;
 224         } else if (ret == 0 && !ctx->have_more) /* nothing to do */
 225                 goto out;
 226         if (btr_get_output_queue_size(btrn) > OPUSDEC_MAX_OUTPUT_SIZE)
 227                 return 0;
 228         for (;;) {
 229                 int serial;
 230                 if (ctx->stream_init) {
 231                         ret = ogg_stream_packetout(&ctx->os, &op);
 232                         if (ret == 1)
 233                                 break;
 234                 }
 235                 while (ogg_sync_pageout(&ctx->oy, &ctx->ogg_page) != 1) {
 236                         char *btr_buf, *data;
 237                         size_t nbytes = btr_next_buffer(btrn, &btr_buf);
 238                         nbytes = PARA_MIN(nbytes, (size_t)24 * 1024);
 239                         //PARA_CRIT_LOG("nbytes: %d\n", nbytes);
 240                         ctx->have_more = false;
 241                         if (nbytes == 0)
 242                                 return 0;
 243                         data = ogg_sync_buffer(&ctx->oy, nbytes);
 244                         memcpy(data, btr_buf, nbytes);
 245                         btr_consume(btrn, nbytes);
 246                         ogg_sync_wrote(&ctx->oy, nbytes);
 247                 }
 248                 ctx->have_more = true;
 249                 serial = ogg_page_serialno(&ctx->ogg_page);
 250                 if (ctx->stream_init) {
 251                         if (serial != ctx->os.serialno)
 252                                 ogg_stream_reset_serialno(&ctx->os, serial);
 253                 } else {
 254                         ogg_stream_init(&ctx->os, serial);
 255                         ctx->stream_init = true;
 256                 }
 257                 /* Add page to the bitstream */
 258                 ogg_stream_pagein(&ctx->os, &ctx->ogg_page);
 259         }
 260         ret = decode_packet(ctx, &op, btrn);
 261         if (ret < 0)
 262                 goto out;
 263         ctx->packet_count++;
 264         if (ctx->eos)
 265                 ctx->have_opus_stream = false;
 266 out:
 267         if (ret < 0)
 268                 btr_remove_node(&fn->btrn);
 269         return ret;
 270 }
 271
 272 static void opusdec_pre_select(struct sched *s, struct task *t)
 273 {
 274         struct filter_node *fn = container_of(t, struct filter_node, task);
 275         struct opusdec_context *ctx = fn->private_data;
 276         int ret = btr_node_status(fn->btrn, fn->min_iqs, BTR_NT_INTERNAL);
 277
 278         if (ret != 0)
 279                 return sched_min_delay(s);
 280         if (ctx->have_more)
 281                 return;
 282         if (btr_get_output_queue_size(fn->btrn) <= OPUSDEC_MAX_OUTPUT_SIZE)
 283                 return sched_min_delay(s);
 284 }
 285
 286 /**
 287  * The init function of the opusdec filter.
 288  *
 289  * \param f Pointer to the filter struct to initialize.
 290  *
 291  * \sa filter::init.
 292  */
 293 void opusdec_filter_init(struct filter *f)
 294 {
 295         f->open = opusdec_open;
 296         f->close = opusdec_close;
 297         f->pre_select = opusdec_pre_select;
 298         f->post_select = opusdec_post_select;
 299         f->execute = opusdec_execute;
 300 }