git.sesse.net Git - ffmpeg/blob - libavfilter/audio.c

   1 /*
   2  * This file is part of Libav.
   3  *
   4  * Libav is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * Libav is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with Libav; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "libavutil/audioconvert.h"
  20
  21 #include "audio.h"
  22 #include "avfilter.h"
  23 #include "internal.h"
  24
  25 AVFilterBufferRef *ff_null_get_audio_buffer(AVFilterLink *link, int perms,
  26                                             int nb_samples)
  27 {
  28     return ff_get_audio_buffer(link->dst->outputs[0], perms, nb_samples);
  29 }
  30
  31 AVFilterBufferRef *ff_default_get_audio_buffer(AVFilterLink *link, int perms,
  32                                                int nb_samples)
  33 {
  34     AVFilterBufferRef *samplesref = NULL;
  35     uint8_t **data;
  36     int planar      = av_sample_fmt_is_planar(link->format);
  37     int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);
  38     int planes      = planar ? nb_channels : 1;
  39     int linesize;
  40
  41     if (!(data = av_mallocz(sizeof(*data) * planes)))
  42         goto fail;
  43
  44     if (av_samples_alloc(data, &linesize, nb_channels, nb_samples, link->format, 0) < 0)
  45         goto fail;
  46
  47     samplesref = avfilter_get_audio_buffer_ref_from_arrays(data, linesize, perms,
  48                                                            nb_samples, link->format,
  49                                                            link->channel_layout);
  50     if (!samplesref)
  51         goto fail;
  52
  53     av_freep(&data);
  54
  55 fail:
  56     if (data)
  57         av_freep(&data[0]);
  58     av_freep(&data);
  59     return samplesref;
  60 }
  61
  62 AVFilterBufferRef *ff_get_audio_buffer(AVFilterLink *link, int perms,
  63                                        int nb_samples)
  64 {
  65     AVFilterBufferRef *ret = NULL;
  66
  67     if (link->dstpad->get_audio_buffer)
  68         ret = link->dstpad->get_audio_buffer(link, perms, nb_samples);
  69
  70     if (!ret)
  71         ret = ff_default_get_audio_buffer(link, perms, nb_samples);
  72
  73     if (ret)
  74         ret->type = AVMEDIA_TYPE_AUDIO;
  75
  76     return ret;
  77 }
  78
  79 AVFilterBufferRef* avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
  80                                                              int linesize,int perms,
  81                                                              int nb_samples,
  82                                                              enum AVSampleFormat sample_fmt,
  83                                                              uint64_t channel_layout)
  84 {
  85     int planes;
  86     AVFilterBuffer    *samples    = av_mallocz(sizeof(*samples));
  87     AVFilterBufferRef *samplesref = av_mallocz(sizeof(*samplesref));
  88
  89     if (!samples || !samplesref)
  90         goto fail;
  91
  92     samplesref->buf         = samples;
  93     samplesref->buf->free   = ff_avfilter_default_free_buffer;
  94     if (!(samplesref->audio = av_mallocz(sizeof(*samplesref->audio))))
  95         goto fail;
  96
  97     samplesref->audio->nb_samples     = nb_samples;
  98     samplesref->audio->channel_layout = channel_layout;
  99     samplesref->audio->planar         = av_sample_fmt_is_planar(sample_fmt);
 100
 101     planes = samplesref->audio->planar ? av_get_channel_layout_nb_channels(channel_layout) : 1;
 102
 103     /* make sure the buffer gets read permission or it's useless for output */
 104     samplesref->perms = perms | AV_PERM_READ;
 105
 106     samples->refcount  = 1;
 107     samplesref->type   = AVMEDIA_TYPE_AUDIO;
 108     samplesref->format = sample_fmt;
 109
 110     memcpy(samples->data, data,
 111            FFMIN(FF_ARRAY_ELEMS(samples->data), planes)*sizeof(samples->data[0]));
 112     memcpy(samplesref->data, samples->data, sizeof(samples->data));
 113
 114     samples->linesize[0] = samplesref->linesize[0] = linesize;
 115
 116     if (planes > FF_ARRAY_ELEMS(samples->data)) {
 117         samples->   extended_data = av_mallocz(sizeof(*samples->extended_data) *
 118                                                planes);
 119         samplesref->extended_data = av_mallocz(sizeof(*samplesref->extended_data) *
 120                                                planes);
 121
 122         if (!samples->extended_data || !samplesref->extended_data)
 123             goto fail;
 124
 125         memcpy(samples->   extended_data, data, sizeof(*data)*planes);
 126         memcpy(samplesref->extended_data, data, sizeof(*data)*planes);
 127     } else {
 128         samples->extended_data    = samples->data;
 129         samplesref->extended_data = samplesref->data;
 130     }
 131
 132     samplesref->pts = AV_NOPTS_VALUE;
 133
 134     return samplesref;
 135
 136 fail:
 137     if (samples && samples->extended_data != samples->data)
 138         av_freep(&samples->extended_data);
 139     if (samplesref) {
 140         av_freep(&samplesref->audio);
 141         if (samplesref->extended_data != samplesref->data)
 142             av_freep(&samplesref->extended_data);
 143     }
 144     av_freep(&samplesref);
 145     av_freep(&samples);
 146     return NULL;
 147 }
 148
 149 void ff_null_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
 150 {
 151     ff_filter_samples(link->dst->outputs[0], samplesref);
 152 }
 153
 154 /* FIXME: samplesref is same as link->cur_buf. Need to consider removing the redundant parameter. */
 155 void ff_default_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
 156 {
 157     AVFilterLink *outlink = NULL;
 158
 159     if (inlink->dst->output_count)
 160         outlink = inlink->dst->outputs[0];
 161
 162     if (outlink) {
 163         outlink->out_buf = ff_default_get_audio_buffer(inlink, AV_PERM_WRITE,
 164                                                        samplesref->audio->nb_samples);
 165         outlink->out_buf->pts                = samplesref->pts;
 166         outlink->out_buf->audio->sample_rate = samplesref->audio->sample_rate;
 167         ff_filter_samples(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
 168         avfilter_unref_buffer(outlink->out_buf);
 169         outlink->out_buf = NULL;
 170     }
 171     avfilter_unref_buffer(samplesref);
 172     inlink->cur_buf = NULL;
 173 }
 174
 175 void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
 176 {
 177     void (*filter_samples)(AVFilterLink *, AVFilterBufferRef *);
 178     AVFilterPad *dst = link->dstpad;
 179
 180     FF_DPRINTF_START(NULL, filter_samples); ff_dlog_link(NULL, link, 1);
 181
 182     if (!(filter_samples = dst->filter_samples))
 183         filter_samples = ff_default_filter_samples;
 184
 185     /* prepare to copy the samples if the buffer has insufficient permissions */
 186     if ((dst->min_perms & samplesref->perms) != dst->min_perms ||
 187         dst->rej_perms & samplesref->perms) {
 188         int  i, planar = av_sample_fmt_is_planar(samplesref->format);
 189         int planes = !planar ? 1:
 190                      av_get_channel_layout_nb_channels(samplesref->audio->channel_layout);
 191
 192         av_log(link->dst, AV_LOG_DEBUG,
 193                "Copying audio data in avfilter (have perms %x, need %x, reject %x)\n",
 194                samplesref->perms, link->dstpad->min_perms, link->dstpad->rej_perms);
 195
 196         link->cur_buf = ff_default_get_audio_buffer(link, dst->min_perms,
 197                                                     samplesref->audio->nb_samples);
 198         link->cur_buf->pts                = samplesref->pts;
 199         link->cur_buf->audio->sample_rate = samplesref->audio->sample_rate;
 200
 201         /* Copy actual data into new samples buffer */
 202         for (i = 0; i < planes; i++)
 203             memcpy(link->cur_buf->extended_data[i], samplesref->extended_data[i], samplesref->linesize[0]);
 204
 205         avfilter_unref_buffer(samplesref);
 206     } else
 207         link->cur_buf = samplesref;
 208
 209     filter_samples(link, link->cur_buf);
 210 }
 211