00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "libavutil/avassert.h"
00023 #include "libavutil/channel_layout.h"
00024 #include "libavutil/common.h"
00025
00026 #include "audio.h"
00027 #include "avfilter.h"
00028 #include "internal.h"
00029
00030 AVFilterBufferRef *ff_null_get_audio_buffer(AVFilterLink *link, int perms,
00031 int nb_samples)
00032 {
00033 return ff_get_audio_buffer(link->dst->outputs[0], perms, nb_samples);
00034 }
00035
00036 AVFilterBufferRef *ff_default_get_audio_buffer(AVFilterLink *link, int perms,
00037 int nb_samples)
00038 {
00039 AVFilterBufferRef *samplesref = NULL;
00040 uint8_t **data;
00041 int planar = av_sample_fmt_is_planar(link->format);
00042 int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);
00043 int planes = planar ? nb_channels : 1;
00044 int linesize;
00045 int full_perms = AV_PERM_READ | AV_PERM_WRITE | AV_PERM_PRESERVE |
00046 AV_PERM_REUSE | AV_PERM_REUSE2 | AV_PERM_ALIGN;
00047
00048 av_assert1(!(perms & ~(full_perms | AV_PERM_NEG_LINESIZES)));
00049
00050 if (!(data = av_mallocz(sizeof(*data) * planes)))
00051 goto fail;
00052
00053 if (av_samples_alloc(data, &linesize, nb_channels, nb_samples, link->format, 0) < 0)
00054 goto fail;
00055
00056 samplesref = avfilter_get_audio_buffer_ref_from_arrays(data, linesize, full_perms,
00057 nb_samples, link->format,
00058 link->channel_layout);
00059 if (!samplesref)
00060 goto fail;
00061
00062 samplesref->audio->sample_rate = link->sample_rate;
00063
00064 av_freep(&data);
00065
00066 fail:
00067 if (data)
00068 av_freep(&data[0]);
00069 av_freep(&data);
00070 return samplesref;
00071 }
00072
00073 AVFilterBufferRef *ff_get_audio_buffer(AVFilterLink *link, int perms,
00074 int nb_samples)
00075 {
00076 AVFilterBufferRef *ret = NULL;
00077
00078 if (link->dstpad->get_audio_buffer)
00079 ret = link->dstpad->get_audio_buffer(link, perms, nb_samples);
00080
00081 if (!ret)
00082 ret = ff_default_get_audio_buffer(link, perms, nb_samples);
00083
00084 if (ret)
00085 ret->type = AVMEDIA_TYPE_AUDIO;
00086
00087 return ret;
00088 }
00089
00090 AVFilterBufferRef* avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
00091 int linesize,int perms,
00092 int nb_samples,
00093 enum AVSampleFormat sample_fmt,
00094 uint64_t channel_layout)
00095 {
00096 int planes;
00097 AVFilterBuffer *samples = av_mallocz(sizeof(*samples));
00098 AVFilterBufferRef *samplesref = av_mallocz(sizeof(*samplesref));
00099
00100 if (!samples || !samplesref)
00101 goto fail;
00102
00103 samplesref->buf = samples;
00104 samplesref->buf->free = ff_avfilter_default_free_buffer;
00105 if (!(samplesref->audio = av_mallocz(sizeof(*samplesref->audio))))
00106 goto fail;
00107
00108 samplesref->audio->nb_samples = nb_samples;
00109 samplesref->audio->channel_layout = channel_layout;
00110
00111 planes = av_sample_fmt_is_planar(sample_fmt) ?
00112 av_get_channel_layout_nb_channels(channel_layout) : 1;
00113
00114
00115 samplesref->perms = perms | AV_PERM_READ;
00116
00117 samples->refcount = 1;
00118 samplesref->type = AVMEDIA_TYPE_AUDIO;
00119 samplesref->format = sample_fmt;
00120
00121 memcpy(samples->data, data,
00122 FFMIN(FF_ARRAY_ELEMS(samples->data), planes)*sizeof(samples->data[0]));
00123 memcpy(samplesref->data, samples->data, sizeof(samples->data));
00124
00125 samples->linesize[0] = samplesref->linesize[0] = linesize;
00126
00127 if (planes > FF_ARRAY_ELEMS(samples->data)) {
00128 samples-> extended_data = av_mallocz(sizeof(*samples->extended_data) *
00129 planes);
00130 samplesref->extended_data = av_mallocz(sizeof(*samplesref->extended_data) *
00131 planes);
00132
00133 if (!samples->extended_data || !samplesref->extended_data)
00134 goto fail;
00135
00136 memcpy(samples-> extended_data, data, sizeof(*data)*planes);
00137 memcpy(samplesref->extended_data, data, sizeof(*data)*planes);
00138 } else {
00139 samples->extended_data = samples->data;
00140 samplesref->extended_data = samplesref->data;
00141 }
00142
00143 samplesref->pts = AV_NOPTS_VALUE;
00144
00145 return samplesref;
00146
00147 fail:
00148 if (samples && samples->extended_data != samples->data)
00149 av_freep(&samples->extended_data);
00150 if (samplesref) {
00151 av_freep(&samplesref->audio);
00152 if (samplesref->extended_data != samplesref->data)
00153 av_freep(&samplesref->extended_data);
00154 }
00155 av_freep(&samplesref);
00156 av_freep(&samples);
00157 return NULL;
00158 }
00159
00160 static int default_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)
00161 {
00162 return ff_filter_frame(link->dst->outputs[0], frame);
00163 }
00164
00165 int ff_filter_samples_framed(AVFilterLink *link, AVFilterBufferRef *samplesref)
00166 {
00167 int (*filter_frame)(AVFilterLink *, AVFilterBufferRef *);
00168 AVFilterPad *src = link->srcpad;
00169 AVFilterPad *dst = link->dstpad;
00170 int64_t pts;
00171 AVFilterBufferRef *buf_out;
00172 int ret;
00173
00174 FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1);
00175
00176 if (link->closed) {
00177 avfilter_unref_buffer(samplesref);
00178 return AVERROR_EOF;
00179 }
00180
00181 if (!(filter_frame = dst->filter_frame))
00182 filter_frame = default_filter_frame;
00183
00184 av_assert1((samplesref->perms & src->min_perms) == src->min_perms);
00185 samplesref->perms &= ~ src->rej_perms;
00186
00187
00188 if ((dst->min_perms & samplesref->perms) != dst->min_perms ||
00189 dst->rej_perms & samplesref->perms) {
00190 av_log(link->dst, AV_LOG_DEBUG,
00191 "Copying audio data in avfilter (have perms %x, need %x, reject %x)\n",
00192 samplesref->perms, link->dstpad->min_perms, link->dstpad->rej_perms);
00193
00194 buf_out = ff_default_get_audio_buffer(link, dst->min_perms,
00195 samplesref->audio->nb_samples);
00196 if (!buf_out) {
00197 avfilter_unref_buffer(samplesref);
00198 return AVERROR(ENOMEM);
00199 }
00200 buf_out->pts = samplesref->pts;
00201 buf_out->audio->sample_rate = samplesref->audio->sample_rate;
00202
00203
00204 av_samples_copy(buf_out->extended_data, samplesref->extended_data,
00205 0, 0, samplesref->audio->nb_samples,
00206 av_get_channel_layout_nb_channels(link->channel_layout),
00207 link->format);
00208
00209 avfilter_unref_buffer(samplesref);
00210 } else
00211 buf_out = samplesref;
00212
00213 link->cur_buf = buf_out;
00214 pts = buf_out->pts;
00215 ret = filter_frame(link, buf_out);
00216 ff_update_link_current_pts(link, pts);
00217 return ret;
00218 }
00219
00220 int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
00221 {
00222 int insamples = samplesref->audio->nb_samples, inpos = 0, nb_samples;
00223 AVFilterBufferRef *pbuf = link->partial_buf;
00224 int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);
00225 int ret = 0;
00226
00227 av_assert1(samplesref->format == link->format);
00228 av_assert1(samplesref->audio->channel_layout == link->channel_layout);
00229 av_assert1(samplesref->audio->sample_rate == link->sample_rate);
00230
00231 if (!link->min_samples ||
00232 (!pbuf &&
00233 insamples >= link->min_samples && insamples <= link->max_samples)) {
00234 return ff_filter_samples_framed(link, samplesref);
00235 }
00236
00237 while (insamples) {
00238 if (!pbuf) {
00239 AVRational samples_tb = { 1, link->sample_rate };
00240 int perms = link->dstpad->min_perms | AV_PERM_WRITE;
00241 pbuf = ff_get_audio_buffer(link, perms, link->partial_buf_size);
00242 if (!pbuf) {
00243 av_log(link->dst, AV_LOG_WARNING,
00244 "Samples dropped due to memory allocation failure.\n");
00245 return 0;
00246 }
00247 avfilter_copy_buffer_ref_props(pbuf, samplesref);
00248 pbuf->pts = samplesref->pts +
00249 av_rescale_q(inpos, samples_tb, link->time_base);
00250 pbuf->audio->nb_samples = 0;
00251 }
00252 nb_samples = FFMIN(insamples,
00253 link->partial_buf_size - pbuf->audio->nb_samples);
00254 av_samples_copy(pbuf->extended_data, samplesref->extended_data,
00255 pbuf->audio->nb_samples, inpos,
00256 nb_samples, nb_channels, link->format);
00257 inpos += nb_samples;
00258 insamples -= nb_samples;
00259 pbuf->audio->nb_samples += nb_samples;
00260 if (pbuf->audio->nb_samples >= link->min_samples) {
00261 ret = ff_filter_samples_framed(link, pbuf);
00262 pbuf = NULL;
00263 }
00264 }
00265 avfilter_unref_buffer(samplesref);
00266 link->partial_buf = pbuf;
00267 return ret;
00268 }