libswresample/swresample_frame.c

   1 /*
   2  * Copyright (c) 2014 Luca Barbato <lu_zero@gentoo.org>
   3  * Copyright (c) 2014 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "swresample_internal.h"
  23 #include "libavutil/frame.h"
  24 #include "libavutil/opt.h"
  25
  26 int swr_config_frame(SwrContext *s, const AVFrame *out, const AVFrame *in)
  27 {
  28     swr_close(s);
  29
  30     if (in) {
  31         if (av_opt_set_int(s, "icl", in->channel_layout, 0) < 0)
  32             goto fail;
  33         if (av_opt_set_int(s, "isf", in->format, 0) < 0)
  34             goto fail;
  35         if (av_opt_set_int(s, "isr", in->sample_rate, 0) < 0)
  36             goto fail;
  37     }
  38
  39     if (out) {
  40         if (av_opt_set_int(s, "ocl", out->channel_layout, 0) < 0)
  41             goto fail;
  42         if (av_opt_set_int(s, "osf", out->format,  0) < 0)
  43             goto fail;
  44         if (av_opt_set_int(s, "osr", out->sample_rate, 0) < 0)
  45             goto fail;
  46     }
  47
  48     return 0;
  49 fail:
  50     av_log(s, AV_LOG_ERROR, "Failed to set option\n");
  51     return AVERROR(EINVAL);
  52 }
  53
  54 static int config_changed(SwrContext *s,
  55                           const AVFrame *out, const AVFrame *in)
  56 {
  57     int ret = 0;
  58
  59     if (in) {
  60         if (s->in_ch_layout   != in->channel_layout ||
  61             s->in_sample_rate != in->sample_rate ||
  62             s->in_sample_fmt  != in->format) {
  63             ret |= AVERROR_INPUT_CHANGED;
  64         }
  65     }
  66
  67     if (out) {
  68         if (s->out_ch_layout   != out->channel_layout ||
  69             s->out_sample_rate != out->sample_rate ||
  70             s->out_sample_fmt  != out->format) {
  71             ret |= AVERROR_OUTPUT_CHANGED;
  72         }
  73     }
  74
  75     return ret;
  76 }
  77
  78 static inline int convert_frame(SwrContext *s,
  79                                 AVFrame *out, const AVFrame *in)
  80 {
  81     int ret;
  82     uint8_t **out_data = NULL;
  83     const uint8_t **in_data = NULL;
  84     int out_nb_samples = 0, in_nb_samples = 0;
  85
  86     if (out) {
  87         out_data       = out->extended_data;
  88         out_nb_samples = out->nb_samples;
  89     }
  90
  91     if (in) {
  92         in_data       = (const uint8_t **)in->extended_data;
  93         in_nb_samples = in->nb_samples;
  94     }
  95
  96     ret = swr_convert(s, out_data, out_nb_samples, in_data, in_nb_samples);
  97
  98     if (ret < 0) {
  99         if (out)
 100             out->nb_samples = 0;
 101         return ret;
 102     }
 103
 104     if (out)
 105         out->nb_samples = ret;
 106
 107     return 0;
 108 }
 109
 110 static inline int available_samples(AVFrame *out)
 111 {
 112     int bytes_per_sample = av_get_bytes_per_sample(out->format);
 113     int samples = out->linesize[0] / bytes_per_sample;
 114
 115     if (av_sample_fmt_is_planar(out->format)) {
 116         return samples;
 117     } else {
 118         int channels = av_get_channel_layout_nb_channels(out->channel_layout);
 119         return samples / channels;
 120     }
 121 }
 122
 123 int swr_convert_frame(SwrContext *s,
 124                       AVFrame *out, const AVFrame *in)
 125 {
 126     int ret, setup = 0;
 127
 128     if (!swr_is_initialized(s)) {
 129         if ((ret = swr_config_frame(s, out, in)) < 0)
 130             return ret;
 131         if ((ret = swr_init(s)) < 0)
 132             return ret;
 133         setup = 1;
 134     } else {
 135         // return as is or reconfigure for input changes?
 136         if ((ret = config_changed(s, out, in)))
 137             return ret;
 138     }
 139
 140     if (out) {
 141         if (!out->linesize[0]) {
 142             out->nb_samples =   swr_get_delay(s, s->out_sample_rate)
 143                               + in->nb_samples*(int64_t)s->out_sample_rate / s->in_sample_rate
 144                               + 3;
 145             if ((ret = av_frame_get_buffer(out, 0)) < 0) {
 146                 if (setup)
 147                     swr_close(s);
 148                 return ret;
 149             }
 150         } else {
 151             if (!out->nb_samples)
 152                 out->nb_samples = available_samples(out);
 153         }
 154     }
 155
 156     return convert_frame(s, out, in);
 157 }
 158