static int control(struct af_instance *af, int cmd, void *arg) { struct priv *p = af->priv; switch (cmd) { case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; struct mp_audio *out = af->data; in->format = AF_FORMAT_FLOATP; mp_audio_copy_config(out, in); if (p->rubber) rubberband_delete(p->rubber); int opts = p->opt_transients | p->opt_detector | p->opt_phase | p->opt_window | p->opt_smoothing | p->opt_formant | p->opt_pitch | p-> opt_channels | RubberBandOptionProcessRealTime; p->rubber = rubberband_new(in->rate, in->channels.num, opts, 1.0, 1.0); if (!p->rubber) { MP_FATAL(af, "librubberband initialization failed.\n"); return AF_ERROR; } update_speed(af, p->speed); update_pitch(af, p->pitch); control(af, AF_CONTROL_RESET, NULL); return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE; } case AF_CONTROL_SET_PLAYBACK_SPEED: { update_speed(af, *(double *)arg); return AF_OK; } case AF_CONTROL_RESET: if (p->rubber) rubberband_reset(p->rubber); talloc_free(p->pending); p->pending = NULL; p->rubber_delay = 0; return AF_OK; case AF_CONTROL_COMMAND: { char **args = arg; if (!strcmp(args[0], "set-pitch")) { char *endptr; double pitch = strtod(args[1], &endptr); if (*endptr || pitch < 0.01 || pitch > 100.0) return CONTROL_ERROR; update_pitch(af, pitch); return CONTROL_OK; } else { return CONTROL_ERROR; } } } return AF_UNKNOWN; }
static int control(struct af_instance *af, int cmd, void *arg) { switch (cmd) { case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; struct mp_audio *out = af->data; if (!test_conversion(in->format, out->format)) return AF_DETACH; if ((in->format & AF_FORMAT_BITS_MASK) == AF_FORMAT_24BIT) { mp_audio_set_format(out, af_fmt_change_bits(in->format, 32)); } else if ((in->format & AF_FORMAT_BITS_MASK) == AF_FORMAT_32BIT) { mp_audio_set_format(out, af_fmt_change_bits(in->format, 24)); } else { abort(); } out->rate = in->rate; mp_audio_set_channels(out, &in->channels); assert(test_conversion(in->format, out->format)); return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE; } case AF_CONTROL_SET_FORMAT: { mp_audio_set_format(af->data, *(int*)arg); return AF_OK; } } return AF_UNKNOWN; }
static int control(struct af_instance *af, int cmd, void *arg) { struct priv *priv = af->priv; switch (cmd) { case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; struct mp_audio *out = af->data; force_in_params(af, in); mp_audio_copy_config(out, in); force_out_params(af, out); if (in->nch != out->nch || in->bps != out->bps) { MP_ERR(af, "Forced input/output formats are incompatible.\n"); return AF_ERROR; } if (priv->fail) { MP_ERR(af, "Failing on purpose.\n"); return AF_ERROR; } return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE; } } return AF_UNKNOWN; }
// Filter len bytes of input, put result into outbuf. static int filter_n_bytes(struct dec_audio *da, struct mp_audio_buffer *outbuf, int len) { int error = 0; struct mp_audio config; mp_audio_buffer_get_format(da->decode_buffer, &config); while (mp_audio_buffer_samples(da->decode_buffer) < len) { int maxlen = mp_audio_buffer_get_write_available(da->decode_buffer); if (maxlen < DECODE_MAX_UNIT) break; struct mp_audio buffer; mp_audio_buffer_get_write_buffer(da->decode_buffer, maxlen, &buffer); buffer.samples = 0; error = da->ad_driver->decode_audio(da, &buffer, maxlen); if (error < 0) break; // Commit the data just read as valid data mp_audio_buffer_finish_write(da->decode_buffer, buffer.samples); // Format change if (!mp_audio_config_equals(&da->decoded, &config)) { // If there are still samples left in the buffer, let them drain // first, and don't signal a format change to the caller yet. if (mp_audio_buffer_samples(da->decode_buffer) > 0) break; error = -2; break; } } // Filter struct mp_audio filter_data; mp_audio_buffer_peek(da->decode_buffer, &filter_data); filter_data.rate = da->afilter->input.rate; // due to playback speed change len = MPMIN(filter_data.samples, len); filter_data.samples = len; bool eof = filter_data.samples == 0 && error < 0; if (af_filter(da->afilter, &filter_data, eof ? AF_FILTER_FLAG_EOF : 0) < 0) return -1; mp_audio_buffer_append(outbuf, &filter_data); if (eof && filter_data.samples > 0) error = 0; // don't end playback yet // remove processed data from decoder buffer: mp_audio_buffer_skip(da->decode_buffer, len); // Assume the filter chain is drained from old data at this point. // (If not, the remaining old data is discarded.) if (error == -2) { if (!reinit_audio_buffer(da)) error = -1; // switch to invalid format } return error; }
static int control(struct af_instance *af, int cmd, void *arg) { struct priv *p = af->priv; switch (cmd) { case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; struct mp_audio *out = af->data; if (af_to_avformat(in->format) == AV_SAMPLE_FMT_NONE) mp_audio_set_format(in, AF_FORMAT_FLOAT); // Removing this requires fixing AVFrame.data vs. AVFrame.extended_data if (in->channels.num > AV_NUM_DATA_POINTERS) return AF_ERROR; if (!mp_chmap_is_lavc(&in->channels)) mp_chmap_reorder_to_lavc(&in->channels); // will always work if (!recreate_graph(af, in)) return AF_ERROR; AVFilterLink *l_out = p->out->inputs[0]; out->rate = l_out->sample_rate; mp_audio_set_format(out, af_from_avformat(l_out->format)); struct mp_chmap out_cm; mp_chmap_from_lavc(&out_cm, l_out->channel_layout); mp_audio_set_channels(out, &out_cm); if (!mp_audio_config_valid(out) || out->channels.num > AV_NUM_DATA_POINTERS) return AF_ERROR; p->timebase_out = l_out->time_base; return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE; } case AF_CONTROL_GET_METADATA: if (p->metadata) { *(struct mp_tags *)arg = *p->metadata; return CONTROL_OK; } return CONTROL_NA; case AF_CONTROL_RESET: reset(af); return AF_OK; } return AF_UNKNOWN; }
static int decode_audio(struct dec_audio *da, struct mp_audio *buffer, int maxlen) { struct ad_mpg123_context *con = da->priv; void *buf = buffer->planes[0]; int ret; if (con->new_format) { ret = set_format(da); if (ret == MPG123_OK) { return 0; // let caller handle format change } else if (ret == MPG123_NEED_MORE) { con->need_data = true; } else { goto mpg123_fail; } } if (con->need_data) { if (feed_new_packet(da) < 0) return -1; } if (!mp_audio_config_equals(&da->decoded, buffer)) return 0; size_t got_now = 0; ret = mpg123_replace_buffer(con->handle, buf, maxlen * con->sample_size); if (ret != MPG123_OK) goto mpg123_fail; ret = mpg123_decode_frame(con->handle, NULL, NULL, &got_now); int got_samples = got_now / con->sample_size; buffer->samples += got_samples; da->pts_offset += got_samples; if (ret == MPG123_NEW_FORMAT) { con->new_format = true; } else if (ret == MPG123_NEED_MORE) { con->need_data = true; } else if (ret != MPG123_OK && ret != MPG123_DONE) { goto mpg123_fail; } update_info(da); return 0; mpg123_fail: MP_ERR(da, "mpg123 decoding error: %s\n", mpg123_strerror(con->handle)); return -1; }
static int control(struct af_instance *af, int cmd, void *arg) { struct priv *p = af->priv; switch (cmd) { case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; struct mp_audio *out = af->data; if (af_to_avformat(in->format) == AV_SAMPLE_FMT_NONE) mp_audio_set_format(in, AF_FORMAT_FLOAT); if (!mp_chmap_is_lavc(&in->channels)) mp_chmap_reorder_to_lavc(&in->channels); // will always work if (!recreate_graph(af, in)) return AF_ERROR; AVFilterLink *l_out = p->out->inputs[0]; out->rate = l_out->sample_rate; mp_audio_set_format(out, af_from_avformat(l_out->format)); struct mp_chmap out_cm; mp_chmap_from_lavc(&out_cm, l_out->channel_layout); if (!out_cm.num || out_cm.num != l_out->channels) mp_chmap_from_channels(&out_cm, l_out->channels); mp_audio_set_channels(out, &out_cm); if (!mp_audio_config_valid(out)) return AF_ERROR; p->timebase_out = l_out->time_base; // Blatantly incorrect; we don't know what the filters do. af->mul = out->rate / (double)in->rate; return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE; } } return AF_UNKNOWN; }
static int control(struct af_instance *af, int cmd, void *arg) { switch (cmd) { case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; struct mp_audio *out = af->data; if (!test_conversion(in->format, out->format)) return AF_DETACH; out->rate = in->rate; mp_audio_set_channels(out, &in->channels); return mp_audio_config_equals(in, &orig_in) ? AF_OK : AF_FALSE; } case AF_CONTROL_SET_FORMAT: { mp_audio_set_format(af->data, *(int*)arg); return AF_OK; } } return AF_UNKNOWN; }
// Initialization and runtime control static int control(struct af_instance *af, int cmd, void *arg) { af_ac3enc_t *s = af->priv; static const int default_bit_rate[AC3_MAX_CHANNELS+1] = \ {0, 96000, 192000, 256000, 384000, 448000, 448000}; switch (cmd){ case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; if (AF_FORMAT_IS_SPECIAL(in->format) || in->nch < s->cfg_min_channel_num) return AF_DETACH; mp_audio_set_format(in, s->in_sampleformat); if (in->rate != 48000 && in->rate != 44100 && in->rate != 32000) in->rate = 48000; af->data->rate = in->rate; mp_chmap_reorder_to_lavc(&in->channels); if (in->nch > AC3_MAX_CHANNELS) mp_audio_set_num_channels(in, AC3_MAX_CHANNELS); mp_audio_set_format(af->data, AF_FORMAT_AC3_BE); mp_audio_set_num_channels(af->data, 2); if (!mp_audio_config_equals(in, &orig_in)) return AF_FALSE; s->in_samples = AC3_FRAME_SIZE; if (s->cfg_add_iec61937_header) { s->out_samples = AC3_FRAME_SIZE; } else { s->out_samples = AC3_MAX_CODED_FRAME_SIZE / af->data->sstride; } af->mul = s->out_samples / (double)s->in_samples; mp_audio_buffer_reinit(s->pending, in); MP_DBG(af, "af_lavcac3enc reinit: %d, %d, %f, %d.\n", in->nch, in->rate, af->mul, s->in_samples); int bit_rate = s->bit_rate ? s->bit_rate : default_bit_rate[in->nch]; if (s->lavc_actx->channels != in->nch || s->lavc_actx->sample_rate != in->rate || s->lavc_actx->bit_rate != bit_rate) { avcodec_close(s->lavc_actx); // Put sample parameters s->lavc_actx->channels = in->nch; s->lavc_actx->channel_layout = mp_chmap_to_lavc(&in->channels); s->lavc_actx->sample_rate = in->rate; s->lavc_actx->bit_rate = bit_rate; if (avcodec_open2(s->lavc_actx, s->lavc_acodec, NULL) < 0) { MP_ERR(af, "Couldn't open codec %s, br=%d.\n", "ac3", bit_rate); return AF_ERROR; } } if (s->lavc_actx->frame_size != AC3_FRAME_SIZE) { MP_ERR(af, "lavcac3enc: unexpected ac3 " "encoder frame size %d\n", s->lavc_actx->frame_size); return AF_ERROR; } return AF_OK; } } return AF_UNKNOWN; }
// Filter len bytes of input, put result into outbuf. static int filter_n_bytes(struct dec_audio *da, struct mp_audio_buffer *outbuf, int len) { bool format_change = false; int error = 0; assert(len > 0); // would break EOF logic below while (mp_audio_buffer_samples(da->decode_buffer) < len) { // Check for a format change struct mp_audio config; mp_audio_buffer_get_format(da->decode_buffer, &config); format_change = !mp_audio_config_equals(&da->decoded, &config); if (format_change) { error = AD_EOF; // drain remaining data left in the current buffer break; } if (da->decoded.samples > 0) { int copy = MPMIN(da->decoded.samples, len); struct mp_audio append = da->decoded; append.samples = copy; mp_audio_buffer_append(da->decode_buffer, &append); mp_audio_skip_samples(&da->decoded, copy); da->pts_offset += copy; continue; } error = da->ad_driver->decode_packet(da); if (error < 0) break; } if (error == AD_WAIT) return error; // Filter struct mp_audio filter_data; mp_audio_buffer_peek(da->decode_buffer, &filter_data); filter_data.rate = da->afilter->input.rate; // due to playback speed change len = MPMIN(filter_data.samples, len); filter_data.samples = len; bool eof = error == AD_EOF && filter_data.samples == 0; if (af_filter(da->afilter, &filter_data, eof ? AF_FILTER_FLAG_EOF : 0) < 0) return AD_ERR; mp_audio_buffer_append(outbuf, &filter_data); if (error == AD_EOF && filter_data.samples > 0) error = 0; // don't end playback yet // remove processed data from decoder buffer: mp_audio_buffer_skip(da->decode_buffer, len); // if format was changed, and all data was drained, execute the format change if (format_change && eof) { error = AD_NEW_FMT; if (!reinit_audio_buffer(da)) error = AD_ERR; // switch to invalid format } return error; }
// Initialization and runtime control static int control(struct af_instance *af, int cmd, void *arg) { af_ac3enc_t *s = af->priv; static const int default_bit_rate[AC3_MAX_CHANNELS+1] = \ {0, 96000, 192000, 256000, 384000, 448000, 448000}; switch (cmd){ case AF_CONTROL_REINIT: { struct mp_audio *in = arg; struct mp_audio orig_in = *in; if (!af_fmt_is_pcm(in->format) || in->nch < s->cfg_min_channel_num) return AF_DETACH; // At least currently, the AC3 encoder doesn't export sample rates. in->rate = 48000; select_encode_format(s->lavc_actx, in); af->data->rate = in->rate; mp_audio_set_format(af->data, AF_FORMAT_S_AC3); mp_audio_set_num_channels(af->data, 2); if (!mp_audio_config_equals(in, &orig_in)) return AF_FALSE; if (s->cfg_add_iec61937_header) { s->out_samples = AC3_FRAME_SIZE; } else { s->out_samples = AC3_MAX_CODED_FRAME_SIZE / af->data->sstride; } mp_audio_copy_config(s->input, in); talloc_free(s->pending); s->pending = NULL; MP_DBG(af, "reinit: %d, %d, %d.\n", in->nch, in->rate, s->in_samples); int bit_rate = s->bit_rate ? s->bit_rate : default_bit_rate[in->nch]; if (s->lavc_actx->channels != in->nch || s->lavc_actx->sample_rate != in->rate || s->lavc_actx->bit_rate != bit_rate) { avcodec_close(s->lavc_actx); // Put sample parameters s->lavc_actx->sample_fmt = af_to_avformat(in->format); s->lavc_actx->channels = in->nch; s->lavc_actx->channel_layout = mp_chmap_to_lavc(&in->channels); s->lavc_actx->sample_rate = in->rate; s->lavc_actx->bit_rate = bit_rate; if (avcodec_open2(s->lavc_actx, s->lavc_acodec, NULL) < 0) { MP_ERR(af, "Couldn't open codec %s, br=%d.\n", "ac3", bit_rate); return AF_ERROR; } if (s->lavc_actx->frame_size < 1) { MP_ERR(af, "encoder didn't specify input frame size\n"); return AF_ERROR; } } s->in_samples = s->lavc_actx->frame_size; mp_audio_realloc(s->input, s->in_samples); s->input->samples = 0; s->encoder_buffered = 0; return AF_OK; } case AF_CONTROL_RESET: if (avcodec_is_open(s->lavc_actx)) avcodec_flush_buffers(s->lavc_actx); talloc_free(s->pending); s->pending = NULL; s->input->samples = 0; s->encoder_buffered = 0; return AF_OK; } return AF_UNKNOWN; }