aft: Change return type of make_status_items() to void.
[paraslash.git] / 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 Andre Noll <maan@tuebingen.mpg.de>
6 *
7 * Licensed under the GPL v2, see file 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 "buffer_tree.h"
54 #include "filter.h"
55 #include "error.h"
56 #include "string.h"
57 #include "opus_common.h"
58
59 /** 120ms at 48000 */
60 #define MAX_FRAME_SIZE (960*6)
61
62 struct opusdec_context {
63 OpusMSDecoder *st;
64 opus_int64 packet_count;
65 int total_links;
66 bool stream_init;
67 ogg_sync_state oy;
68 ogg_stream_state os;
69 ogg_page ogg_page;
70 bool eos;
71 int channels;
72 uint16_t preskip;
73 bool have_opus_stream;
74 bool have_more;
75 ogg_int32_t opus_serialno;
76 };
77
78 static int opusdec_execute(struct btr_node *btrn, const char *cmd,
79 char **result)
80 {
81 struct filter_node *fn = btr_context(btrn);
82 struct opusdec_context *ctx = fn->private_data;
83
84 return decoder_execute(cmd, 48000, ctx->channels, result);
85 }
86
87 static void opusdec_open(struct filter_node *fn)
88 {
89 struct opusdec_context *ctx = para_calloc(sizeof(*ctx));
90
91 ogg_sync_init(&ctx->oy);
92 fn->private_data = ctx;
93 }
94
95 static void opusdec_close(struct filter_node *fn)
96 {
97 struct opusdec_context *ctx = fn->private_data;
98
99 if (ctx->st) {
100 opus_multistream_decoder_destroy(ctx->st);
101 if (ctx->stream_init)
102 ogg_stream_clear(&ctx->os);
103 ogg_sync_clear(&ctx->oy);
104 }
105 free(ctx);
106 fn->private_data = NULL;
107 }
108
109 /* Process an Opus header and setup the opus decoder based on it. */
110 static int opusdec_init(ogg_packet *op, struct opusdec_context *ctx)
111 {
112 int ret;
113 struct opus_header header;
114
115 ctx->st = NULL;
116 ret = opus_parse_header((char *)op->packet, op->bytes, &header);
117 if (ret < 0)
118 return ret;
119 PARA_INFO_LOG("detected header v%d\n", header.version);
120 ctx->channels = header.channels;
121 ctx->preskip = header.preskip;
122 ctx->st = opus_multistream_decoder_create(48000, header.channels,
123 header.nb_streams, header.nb_coupled, header.stream_map, &ret);
124 if (ret != OPUS_OK || !ctx->st) {
125 PARA_ERROR_LOG("%s\n", opus_strerror(ret));
126 return -E_CREATE_OPUS_DECODER;
127 }
128 if (header.gain != 0) {
129 ret = opus_multistream_decoder_ctl(ctx->st,
130 OPUS_SET_GAIN(header.gain));
131 if (ret != OPUS_OK) {
132 PARA_ERROR_LOG("%s\n", opus_strerror(ret));
133 return -E_OPUS_SET_GAIN;
134 }
135 PARA_INFO_LOG("playback gain: %fdB\n", header.gain / 256.);
136 }
137 PARA_INFO_LOG("%d channel(s), 48KHz\n", ctx->channels);
138 return 1;
139 }
140
141 static void opusdec_add_output(short *pcm, int frames_available,
142 struct btr_node *btrn, struct opusdec_context *ctx)
143 {
144 int num_frames, bytes;
145 uint16_t tmp_skip;
146
147 tmp_skip = PARA_MIN((int)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, void *context)
211 {
212 struct filter_node *fn = context;
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, void *context)
273 {
274 struct filter_node *fn = context;
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 const struct filter lsg_filter_cmd_com_opusdec_user_data = {
287 .open = opusdec_open,
288 .close = opusdec_close,
289 .pre_select = opusdec_pre_select,
290 .post_select = opusdec_post_select,
291 .execute = opusdec_execute,
292 };