25  * audioresample resamples raw audio buffers to different sample rates using

    25  * <refsect2>

    26  * Audioresample resamples raw audio buffers to different sample rates using

    28  * <refsect2>

    38  * Last reviewed on 2006-03-02 (0.10.4)

    29  * <title>Example launch line</title>

    30  * |[

    31  * gst-launch -v filesrc location=sine.ogg ! oggdemux ! vorbisdec ! audioconvert ! audioresample ! audio/x-raw-int, rate=8000 ! alsasink

    32  * ]| Decode an Ogg/Vorbis downsample to 8Khz and play sound through alsa.

    33  * To create the Ogg/Vorbis file refer to the documentation of vorbisenc.

    34  * </refsect2>

    35  */

    36 

    37 /* TODO:

    38  *  - Enable SSE/ARM optimizations and select at runtime

    52 #if defined AUDIORESAMPLE_FORMAT_AUTO

    53 GST_DEBUG_CATEGORY_STATIC (audioresample_debug);

    53 #define OIL_ENABLE_UNSTABLE_API

    54 #define GST_CAT_DEFAULT audioresample_debug

    54 #include <liboil/liboilprofile.h>

    55 

    55 #include <liboil/liboil.h>

    56 /* elementfactory information */

    56 #endif

    57 static const GstElementDetails gst_audioresample_details =

    57 

    58 GST_ELEMENT_DETAILS ("Audio scaler",

    58 GST_DEBUG_CATEGORY (audio_resample_debug);

    59     "Filter/Converter/Audio",

    59 #define GST_CAT_DEFAULT audio_resample_debug

    60     "Resample audio",

    61     "David Schleef <ds@schleef.org>");

    62 

    63 #define DEFAULT_FILTERLEN       16

    64   PROP_QUALITY,

    68   PROP_FILTERLEN

    65   PROP_FILTER_LENGTH

    70     "audio/x-raw-float, " \

    73     "audio/x-raw-int, " \

    71       "rate = (int) [ 1, MAX ], "	\

    74       "rate = (int) [ 1, MAX ], " \

    74       "width = (int) { 32, 64 }; " \

    77       "width = (int) 16, " \

    78       "depth = (int) 16, " \

    79       "signed = (boolean) true;" \

    81       "signed = (boolean) true; " \

    86       "signed = (boolean) true;" \

    82     "audio/x-raw-int, " \

    87     "audio/x-raw-float, " \

    83       "rate = (int) [ 1, MAX ], " \

    88       "rate = (int) [ 1, MAX ], "	\

    86       "width = (int) 24, " \

    91       "width = (int) 32; " \

    87       "depth = (int) 24, " \

    92     "audio/x-raw-float, " \

    88       "signed = (boolean) true; " \

    93       "rate = (int) [ 1, MAX ], "	\

    89     "audio/x-raw-int, " \

    90       "rate = (int) [ 1, MAX ], " \

    93       "width = (int) 16, " \

    96       "width = (int) 64" \

    94       "depth = (int) 16, " \

    95       "signed = (boolean) true; " \

    96     "audio/x-raw-int, " \

    97       "rate = (int) [ 1, MAX ], " \

    98       "channels = (int) [ 1, MAX ], " \

    99       "endianness = (int) BYTE_ORDER, " \

   100       "width = (int) 8, " \

   101       "depth = (int) 8, " \

   102       "signed = (boolean) true" \

   105 /* If TRUE integer arithmetic resampling is faster and will be used if appropiate */

    99 static GstStaticPadTemplate gst_audioresample_sink_template =

   106 #if defined AUDIORESAMPLE_FORMAT_INT

   107 static gboolean gst_audio_resample_use_int = TRUE;

   108 #elif defined AUDIORESAMPLE_FORMAT_FLOAT

   109 static gboolean gst_audio_resample_use_int = FALSE;

   110 #else

   111 static gboolean gst_audio_resample_use_int = FALSE;

   112 #endif

   113 

   114 static GstStaticPadTemplate gst_audio_resample_sink_template =

   118 static GstStaticPadTemplate gst_audio_resample_src_template =

   103 static GstStaticPadTemplate gst_audioresample_src_template =

   122 static void gst_audio_resample_set_property (GObject * object,

   107 static void gst_audioresample_set_property (GObject * object,

   124 static void gst_audio_resample_get_property (GObject * object,

   109 static void gst_audioresample_get_property (GObject * object,

   128 static gboolean gst_audio_resample_get_unit_size (GstBaseTransform * base,

   113 static gboolean audioresample_get_unit_size (GstBaseTransform * base,

   130 static GstCaps *gst_audio_resample_transform_caps (GstBaseTransform * base,

   115 static GstCaps *audioresample_transform_caps (GstBaseTransform * base,

   132 static void gst_audio_resample_fixate_caps (GstBaseTransform * base,

   117 static gboolean audioresample_transform_size (GstBaseTransform * trans,

   133     GstPadDirection direction, GstCaps * caps, GstCaps * othercaps);

   134 static gboolean gst_audio_resample_transform_size (GstBaseTransform * trans,

   137 static gboolean gst_audio_resample_set_caps (GstBaseTransform * base,

   120 static gboolean audioresample_set_caps (GstBaseTransform * base,

   139 static GstFlowReturn gst_audio_resample_transform (GstBaseTransform * base,

   122 static GstFlowReturn audioresample_pushthrough (GstAudioresample *

   123     audioresample);

   124 static GstFlowReturn audioresample_transform (GstBaseTransform * base,

   141 static gboolean gst_audio_resample_event (GstBaseTransform * base,

   126 static gboolean audioresample_event (GstBaseTransform * base, GstEvent * event);

   142     GstEvent * event);

   127 static gboolean audioresample_start (GstBaseTransform * base);

   143 static gboolean gst_audio_resample_start (GstBaseTransform * base);

   128 static gboolean audioresample_stop (GstBaseTransform * base);

   144 static gboolean gst_audio_resample_stop (GstBaseTransform * base);

   129 

   145 static gboolean gst_audio_resample_query (GstPad * pad, GstQuery * query);

   130 static gboolean audioresample_query (GstPad * pad, GstQuery * query);

   146 static const GstQueryType *gst_audio_resample_query_type (GstPad * pad);

   131 static const GstQueryType *audioresample_query_type (GstPad * pad);

   147 

   132 

   148 GST_BOILERPLATE (GstAudioResample, gst_audio_resample, GstBaseTransform,

   133 #define DEBUG_INIT(bla) \

   149     GST_TYPE_BASE_TRANSFORM);

   134   GST_DEBUG_CATEGORY_INIT (audioresample_debug, "audioresample", 0, "audio resampling element");

   135 

   136 GST_BOILERPLATE_FULL (GstAudioresample, gst_audioresample, GstBaseTransform,

   137     GST_TYPE_BASE_TRANSFORM, DEBUG_INIT);

   152 gst_audio_resample_base_init (gpointer g_class)

   140 gst_audioresample_base_init (gpointer g_class)

   157       gst_static_pad_template_get (&gst_audio_resample_src_template));

   145       gst_static_pad_template_get (&gst_audioresample_src_template));

   159       gst_static_pad_template_get (&gst_audio_resample_sink_template));

   147       gst_static_pad_template_get (&gst_audioresample_sink_template));

   160 

   148 

   161   gst_element_class_set_details_simple (gstelement_class, "Audio resampler",

   149   gst_element_class_set_details (gstelement_class, &gst_audioresample_details);

   162       "Filter/Converter/Audio", "Resamples audio",

   163       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");

   167 gst_audio_resample_class_init (GstAudioResampleClass * klass)

   153 gst_audioresample_class_init (GstAudioresampleClass * klass)

   168 {

   154 {

   169   GObjectClass *gobject_class = (GObjectClass *) klass;

   155   GObjectClass *gobject_class;

   170 

   156 

   171   gobject_class->set_property = gst_audio_resample_set_property;

   157   gobject_class = (GObjectClass *) klass;

   172   gobject_class->get_property = gst_audio_resample_get_property;

   158 

   173 

   159   gobject_class->set_property = gst_audioresample_set_property;

   174   g_object_class_install_property (gobject_class, PROP_QUALITY,

   160   gobject_class->get_property = gst_audioresample_get_property;

   175       g_param_spec_int ("quality", "Quality", "Resample quality with 0 being "

   161 

   176           "the lowest and 10 being the best",

   162   g_object_class_install_property (gobject_class, PROP_FILTERLEN,

   177           SPEEX_RESAMPLER_QUALITY_MIN, SPEEX_RESAMPLER_QUALITY_MAX,

   163       g_param_spec_int ("filter_length", "filter_length", "filter_length",

   178           SPEEX_RESAMPLER_QUALITY_DEFAULT,

   164           0, G_MAXINT, DEFAULT_FILTERLEN,

   196       GST_DEBUG_FUNCPTR (gst_audio_resample_start);

   168       GST_DEBUG_FUNCPTR (audioresample_start);

   198       GST_DEBUG_FUNCPTR (gst_audio_resample_stop);

   170       GST_DEBUG_FUNCPTR (audioresample_stop);

   200       GST_DEBUG_FUNCPTR (gst_audio_resample_transform_size);

   172       GST_DEBUG_FUNCPTR (audioresample_transform_size);

   202       GST_DEBUG_FUNCPTR (gst_audio_resample_get_unit_size);

   174       GST_DEBUG_FUNCPTR (audioresample_get_unit_size);

   204       GST_DEBUG_FUNCPTR (gst_audio_resample_transform_caps);

   176       GST_DEBUG_FUNCPTR (audioresample_transform_caps);

   205   GST_BASE_TRANSFORM_CLASS (klass)->fixate_caps =

   206       GST_DEBUG_FUNCPTR (gst_audio_resample_fixate_caps);

   208       GST_DEBUG_FUNCPTR (gst_audio_resample_set_caps);

   178       GST_DEBUG_FUNCPTR (audioresample_set_caps);

   210       GST_DEBUG_FUNCPTR (gst_audio_resample_transform);

   180       GST_DEBUG_FUNCPTR (audioresample_transform);

   212       GST_DEBUG_FUNCPTR (gst_audio_resample_event);

   182       GST_DEBUG_FUNCPTR (audioresample_event);

   218 gst_audio_resample_init (GstAudioResample * resample,

   189 gst_audioresample_init (GstAudioresample * audioresample,

   219     GstAudioResampleClass * klass)

   190     GstAudioresampleClass * klass)

   220 {

   191 {

   221   GstBaseTransform *trans = GST_BASE_TRANSFORM (resample);

   192   GstBaseTransform *trans;

   222 

   193 

   223   resample->quality = SPEEX_RESAMPLER_QUALITY_DEFAULT;

   194   trans = GST_BASE_TRANSFORM (audioresample);

   224 

   195 

   225   resample->need_discont = FALSE;

   196   /* buffer alloc passthrough is too impossible. FIXME, it

   226 

   197    * is trivial in the passthrough case. */

   227   gst_pad_set_query_function (trans->srcpad, gst_audio_resample_query);

   198   gst_pad_set_bufferalloc_function (trans->sinkpad, NULL);

   228   gst_pad_set_query_type_function (trans->srcpad,

   199 

   229       gst_audio_resample_query_type);

   200   audioresample->filter_length = DEFAULT_FILTERLEN;

   201 

   202   audioresample->need_discont = FALSE;

   203 

   204   gst_pad_set_query_function (trans->srcpad, audioresample_query);

   205   gst_pad_set_query_type_function (trans->srcpad, audioresample_query_type);

   234 gst_audio_resample_start (GstBaseTransform * base)

   210 audioresample_start (GstBaseTransform * base)

   235 {

   211 {

   236   GstAudioResample *resample = GST_AUDIO_RESAMPLE (base);

   212   GstAudioresample *audioresample = GST_AUDIORESAMPLE (base);

   237 

   213 

   238   resample->next_offset = -1;

   214   audioresample->resample = resample_new ();

   239   resample->next_ts = -1;

   215   audioresample->ts_offset = -1;

   240   resample->next_upstream_ts = -1;

   216   audioresample->offset = -1;

   217   audioresample->next_ts = -1;

   218 

   219   resample_set_filter_length (audioresample->resample,

   220       audioresample->filter_length);

   246 gst_audio_resample_stop (GstBaseTransform * base)

   226 audioresample_stop (GstBaseTransform * base)

   247 {

   227 {

   248   GstAudioResample *resample = GST_AUDIO_RESAMPLE (base);

   228   GstAudioresample *audioresample = GST_AUDIORESAMPLE (base);

   249 

   229 

   250   if (resample->state) {

   230   if (audioresample->resample) {

   251     resample->funcs->destroy (resample->state);

   231     resample_free (audioresample->resample);

   252     resample->state = NULL;

   232     audioresample->resample = NULL;

   253   }

   233   }

   254 

   234 

   255   resample->funcs = NULL;

   235   gst_caps_replace (&audioresample->sinkcaps, NULL);

   256 

   236   gst_caps_replace (&audioresample->srccaps, NULL);

   257   g_free (resample->tmp_in);

   258   resample->tmp_in = NULL;

   259   resample->tmp_in_size = 0;

   260 

   261   g_free (resample->tmp_out);

   262   resample->tmp_out = NULL;

   263   resample->tmp_out_size = 0;

   264 

   265   gst_caps_replace (&resample->sinkcaps, NULL);

   266   gst_caps_replace (&resample->srccaps, NULL);

   272 gst_audio_resample_get_unit_size (GstBaseTransform * base, GstCaps * caps,

   242 audioresample_get_unit_size (GstBaseTransform * base, GstCaps * caps,

   279   g_return_val_if_fail (size != NULL, FALSE);

   249   g_assert (size);

   285 

   255   g_return_val_if_fail (ret, FALSE);

   286   if (G_UNLIKELY (!ret))

   256 

   287     return FALSE;

   257   *size = width * channels / 8;

   288 

   289   *size = (width / 8) * channels;

   295 gst_audio_resample_transform_caps (GstBaseTransform * base,

   263 audioresample_transform_caps (GstBaseTransform * base,

   301 

   267   GstStructure *structure;

   302   /* transform single caps into input_caps + input_caps with the rate

   268 

   303    * field set to our supported range. This ensures that upstream knows

   269   /* transform caps gives one single caps so we can just replace

   304    * about downstream's prefered rate(s) and can negotiate accordingly. */

   270    * the rate property with our range. */

   306 

   272   structure = gst_caps_get_structure (res, 0);

   307   /* first, however, check if the caps contain a range for the rate field, in

   273   gst_structure_set (structure, "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);

   308    * which case that side isn't going to care much about the exact sample rate

   309    * chosen and we should just assume things will get fixated to something sane

   310    * and we may just as well offer our full range instead of the range in the

   311    * caps. If the rate is not an int range value, it's likely to express a

   312    * real preference or limitation and we should maintain that structure as

   313    * preference by putting it first into the transformed caps, and only add

   314    * our full rate range as second option  */

   315   s = gst_caps_get_structure (res, 0);

   316   val = gst_structure_get_value (s, "rate");

   317   if (val == NULL || GST_VALUE_HOLDS_INT_RANGE (val)) {

   318     /* overwrite existing range, or add field if it doesn't exist yet */

   319     gst_structure_set (s, "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);

   320   } else {

   321     /* append caps with full range to existing caps with non-range rate field */

   322     s = gst_structure_copy (s);

   323     gst_structure_set (s, "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);

   324     gst_caps_append_structure (res, s);

   325   }

   330 /* Fixate rate to the allowed rate that has the smallest difference */

   278 static gboolean

   331 static void

   279 resample_set_state_from_caps (ResampleState * state, GstCaps * incaps,

   332 gst_audio_resample_fixate_caps (GstBaseTransform * base,

   280     GstCaps * outcaps, gint * channels, gint * inrate, gint * outrate)

   333     GstPadDirection direction, GstCaps * caps, GstCaps * othercaps)

   334 {

   335   GstStructure *s;

   336   gint rate;

   337 

   338   s = gst_caps_get_structure (caps, 0);

   339   if (G_UNLIKELY (!gst_structure_get_int (s, "rate", &rate)))

   340     return;

   341 

   342   s = gst_caps_get_structure (othercaps, 0);

   343   gst_structure_fixate_field_nearest_int (s, "rate", rate);

   344 }

   345 

   346 static const SpeexResampleFuncs *

   347 gst_audio_resample_get_funcs (gint width, gboolean fp)

   348 {

   349   const SpeexResampleFuncs *funcs = NULL;

   350 

   351   if (gst_audio_resample_use_int && (width == 8 || width == 16) && !fp)

   352     funcs = &int_funcs;

   353   else if ((!gst_audio_resample_use_int && (width == 8 || width == 16) && !fp)

   354       || (width == 32 && fp))

   355     funcs = &float_funcs;

   356   else if ((width == 64 && fp) || ((width == 32 || width == 24) && !fp))

   357     funcs = &double_funcs;

   358   else

   359     g_assert_not_reached ();

   360 

   361   return funcs;

   362 }

   363 

   364 static SpeexResamplerState *

   365 gst_audio_resample_init_state (GstAudioResample * resample, gint width,

   366     gint channels, gint inrate, gint outrate, gint quality, gboolean fp)

   367 {

   368   SpeexResamplerState *ret = NULL;

   369   gint err = RESAMPLER_ERR_SUCCESS;

   370   const SpeexResampleFuncs *funcs = gst_audio_resample_get_funcs (width, fp);

   371 

   372   ret = funcs->init (channels, inrate, outrate, quality, &err);

   373 

   374   if (G_UNLIKELY (err != RESAMPLER_ERR_SUCCESS)) {

   375     GST_ERROR_OBJECT (resample, "Failed to create resampler state: %s",

   376         funcs->strerror (err));

   377     return NULL;

   378   }

   379 

   380   funcs->skip_zeros (ret);

   381 

   382   return ret;

   383 }

   384 

   385 static gboolean

   386 gst_audio_resample_update_state (GstAudioResample * resample, gint width,

   387     gint channels, gint inrate, gint outrate, gint quality, gboolean fp)

   388 {

   389   gboolean ret = TRUE;

   390   gboolean updated_latency = FALSE;

   391 

   392   updated_latency = (resample->inrate != inrate

   393       || quality != resample->quality) && resample->state != NULL;

   394 

   395   if (resample->state == NULL) {

   396     ret = TRUE;

   397   } else if (resample->channels != channels || fp != resample->fp

   398       || width != resample->width) {

   399     resample->funcs->destroy (resample->state);

   400     resample->state =

   401         gst_audio_resample_init_state (resample, width, channels, inrate,

   402         outrate, quality, fp);

   403 

   404     resample->funcs = gst_audio_resample_get_funcs (width, fp);

   405     ret = (resample->state != NULL);

   406   } else if (resample->inrate != inrate || resample->outrate != outrate) {

   407     gint err = RESAMPLER_ERR_SUCCESS;

   408 

   409     err = resample->funcs->set_rate (resample->state, inrate, outrate);

   410 

   411     if (G_UNLIKELY (err != RESAMPLER_ERR_SUCCESS))

   412       GST_ERROR_OBJECT (resample, "Failed to update rate: %s",

   413           resample->funcs->strerror (err));

   414 

   415     ret = (err == RESAMPLER_ERR_SUCCESS);

   416   } else if (quality != resample->quality) {

   417     gint err = RESAMPLER_ERR_SUCCESS;

   418 

   419     err = resample->funcs->set_quality (resample->state, quality);

   420 

   421     if (G_UNLIKELY (err != RESAMPLER_ERR_SUCCESS))

   422       GST_ERROR_OBJECT (resample, "Failed to update quality: %s",

   423           resample->funcs->strerror (err));

   424 

   425     ret = (err == RESAMPLER_ERR_SUCCESS);

   426   }

   427 

   428   resample->width = width;

   429   resample->channels = channels;

   430   resample->fp = fp;

   431   resample->quality = quality;

   432   resample->inrate = inrate;

   433   resample->outrate = outrate;

   434 

   435   if (updated_latency)

   436     gst_element_post_message (GST_ELEMENT (resample),

   437         gst_message_new_latency (GST_OBJECT (resample)));

   438 

   439   return ret;

   440 }

   441 

   442 static void

   443 gst_audio_resample_reset_state (GstAudioResample * resample)

   444 {

   445   if (resample->state)

   446     resample->funcs->reset_mem (resample->state);

   447 }

   448 

   449 static gboolean

   450 gst_audio_resample_parse_caps (GstCaps * incaps,

   451     GstCaps * outcaps, gint * width, gint * channels, gint * inrate,

   452     gint * outrate, gboolean * fp)

   456   gint mywidth, myinrate, myoutrate, mychannels;

   284   gint myinrate, myoutrate;

   457   gboolean myfp;

   285   int mychannels;

   286   gint width, depth;

   287   ResampleFormat format;

   464   if (g_str_equal (gst_structure_get_name (structure), "audio/x-raw-float"))

   294   /* get width */

   465     myfp = TRUE;

   295   ret = gst_structure_get_int (structure, "width", &width);

   466   else

   296   if (!ret)

   467     myfp = FALSE;

   297     goto no_width;

   468 

   298 

   299   /* figure out the format */

   300   if (g_str_equal (gst_structure_get_name (structure), "audio/x-raw-float")) {

   301     if (width == 32)

   302       format = RESAMPLE_FORMAT_F32;

   303     else if (width == 64)

   304       format = RESAMPLE_FORMAT_F64;

   305     else

   306       goto wrong_depth;

   307   } else {

   308     /* for int, depth and width must be the same */

   309     ret = gst_structure_get_int (structure, "depth", &depth);

   310     if (!ret || width != depth)

   311       goto not_equal;

   312 

   313     if (width == 16)

   314       format = RESAMPLE_FORMAT_S16;

   315     else if (width == 32)

   316       format = RESAMPLE_FORMAT_S32;

   317     else

   318       goto wrong_depth;

   319   }

   471   ret &= gst_structure_get_int (structure, "width", &mywidth);

   322   if (!ret)

   472   if (G_UNLIKELY (!ret))

   477   if (G_UNLIKELY (!ret))

   327   if (!ret)

   486   if (width)

   336 

   487     *width = mywidth;

   337   resample_set_format (state, format);

   488   if (fp)

   338   resample_set_n_channels (state, mychannels);

   489     *fp = myfp;

   339   resample_set_input_rate (state, myinrate);

   340   resample_set_output_rate (state, myoutrate);

   506 static gint

   372 static gboolean

   507 _gcd (gint a, gint b)

   373 audioresample_transform_size (GstBaseTransform * base,

   508 {

   509   while (b != 0) {

   510     int temp = a;

   511 

   512     a = b;

   513     b = temp % b;

   514   }

   515 

   516   return ABS (a);

   517 }

   518 

   519 static gboolean

   520 gst_audio_resample_transform_size (GstBaseTransform * base,

   540   /* Get sample width -> bytes_per_samp, channels, inrate, outrate */

   393   /* if the caps are the ones that _set_caps got called with; we can use

   541   ret =

   394    * our own state; otherwise we'll have to create a state */

   542       gst_audio_resample_parse_caps (caps, othercaps, &bytes_per_samp,

   395   if (gst_caps_is_equal (sinkcaps, audioresample->sinkcaps) &&

   543       &channels, &inrate, &outrate, NULL);

   396       gst_caps_is_equal (srccaps, audioresample->srccaps)) {

   544   if (G_UNLIKELY (!ret)) {

   397     use_internal = TRUE;

   545     GST_ERROR_OBJECT (base, "Wrong caps");

   398     state = audioresample->resample;

   546     return FALSE;

   399   } else {

   547   }

   400     GST_DEBUG_OBJECT (audioresample,

   548   /* Number of samples in either buffer is size / (width*channels) ->

   401         "caps are not the set caps, creating state");

   549    * calculate the factor */

   402     state = resample_new ();

   550   bytes_per_samp = bytes_per_samp * channels / 8;

   403     resample_set_filter_length (state, audioresample->filter_length);

   551   /* Convert source buffer size to samples */

   404     resample_set_state_from_caps (state, sinkcaps, srccaps, NULL, NULL, NULL);

   552   size /= bytes_per_samp;

   405   }

   553 

   554   /* Simplify the conversion ratio factors */

   555   gcd = _gcd (inrate, outrate);

   556   ratio_num = inrate / gcd;

   557   ratio_den = outrate / gcd;

   560     /* asked to convert size of an incoming buffer. Round up the output size */

   408     /* asked to convert size of an incoming buffer */

   561     *othersize = (size * ratio_den + ratio_num - 1) / ratio_num;

   409     *othersize = resample_get_output_size_for_input (state, size);

   562     *othersize *= bytes_per_samp;

   564     /* asked to convert size of an outgoing buffer. Round down the input size */

   411     /* asked to convert size of an outgoing buffer */

   565     *othersize = (size * ratio_num) / ratio_den;

   412     *othersize = resample_get_input_size_for_output (state, size);

   566     *othersize *= bytes_per_samp;

   413   }

   567   }

   414   g_assert (*othersize % state->sample_size == 0);

   568 

   415 

   569   GST_LOG_OBJECT (base, "transformed size %d to %d", size * bytes_per_samp,

   416   /* we make room for one extra sample, given that the resampling filter

   570       *othersize);

   417    * can output an extra one for non-integral i_rate/o_rate */

   418   GST_LOG_OBJECT (base, "transformed size %d to %d", size, *othersize);

   419 

   420   if (!use_internal) {

   421     resample_free (state);

   422   }

   576 gst_audio_resample_set_caps (GstBaseTransform * base, GstCaps * incaps,

   428 audioresample_set_caps (GstBaseTransform * base, GstCaps * incaps,

   580   gint width = 0, inrate = 0, outrate = 0, channels = 0;

   432   gint inrate, outrate;

   581   gboolean fp;

   433   int channels;

   582   GstAudioResample *resample = GST_AUDIO_RESAMPLE (base);

   434   GstAudioresample *audioresample = GST_AUDIORESAMPLE (base);

   583 

   435 

   584   GST_LOG ("incaps %" GST_PTR_FORMAT ", outcaps %"

   436   GST_DEBUG_OBJECT (base, "incaps %" GST_PTR_FORMAT ", outcaps %"

   587   ret = gst_audio_resample_parse_caps (incaps, outcaps,

   439   ret = resample_set_state_from_caps (audioresample->resample, incaps, outcaps,

   588       &width, &channels, &inrate, &outrate, &fp);

   440       &channels, &inrate, &outrate);

   589 

   441 

   590   if (G_UNLIKELY (!ret))

   442   g_return_val_if_fail (ret, FALSE);

   591     return FALSE;

   443 

   592 

   444   audioresample->channels = channels;

   593   ret =

   445   GST_DEBUG_OBJECT (audioresample, "set channels to %d", channels);

   594       gst_audio_resample_update_state (resample, width, channels, inrate,

   446   audioresample->i_rate = inrate;

   595       outrate, resample->quality, fp);

   447   GST_DEBUG_OBJECT (audioresample, "set i_rate to %d", inrate);

   596 

   448   audioresample->o_rate = outrate;

   597   if (G_UNLIKELY (!ret))

   449   GST_DEBUG_OBJECT (audioresample, "set o_rate to %d", outrate);

   598     return FALSE;

   602   gst_caps_replace (&resample->sinkcaps, incaps);

   453   gst_caps_replace (&audioresample->sinkcaps, incaps);

   603   gst_caps_replace (&resample->srccaps, outcaps);

   454   gst_caps_replace (&audioresample->srccaps, outcaps);

   608 #define GST_MAXINT24 (8388607)

   459 static gboolean

   609 #define GST_MININT24 (-8388608)

   460 audioresample_event (GstBaseTransform * base, GstEvent * event)

   610 

   461 {

   611 #if (G_BYTE_ORDER == G_LITTLE_ENDIAN)

   462   GstAudioresample *audioresample;

   612 #define GST_READ_UINT24 GST_READ_UINT24_LE

   463 

   613 #define GST_WRITE_UINT24 GST_WRITE_UINT24_LE

   464   audioresample = GST_AUDIORESAMPLE (base);

   614 #else

   465 

   615 #define GST_READ_UINT24 GST_READ_UINT24_BE

   466   switch (GST_EVENT_TYPE (event)) {

   616 #define GST_WRITE_UINT24 GST_WRITE_UINT24_BE

   467     case GST_EVENT_FLUSH_START:

   617 #endif

   468       break;

   618 

   469     case GST_EVENT_FLUSH_STOP:

   619 static void

   470       resample_input_flush (audioresample->resample);

   620 gst_audio_resample_convert_buffer (GstAudioResample * resample,

   471       audioresample->ts_offset = -1;

   621     const guint8 * in, guint8 * out, guint len, gboolean inverse)

   472       audioresample->next_ts = -1;

   622 {

   473       audioresample->offset = -1;

   623   len *= resample->channels;

   474       break;

   624 

   475     case GST_EVENT_NEWSEGMENT:

   625   if (inverse) {

   476       resample_input_pushthrough (audioresample->resample);

   626     if (gst_audio_resample_use_int && resample->width == 8 && !resample->fp) {

   477       audioresample_pushthrough (audioresample);

   627       gint8 *o = (gint8 *) out;

   478       audioresample->ts_offset = -1;

   628       gint16 *i = (gint16 *) in;

   479       audioresample->next_ts = -1;

   629       gint32 tmp;

   480       audioresample->offset = -1;

   630 

   481       break;

   631       while (len) {

   482     case GST_EVENT_EOS:

   632         tmp = *i + (G_MAXINT8 >> 1);

   483       resample_input_eos (audioresample->resample);

   633         *o = CLAMP (tmp >> 8, G_MININT8, G_MAXINT8);

   484       audioresample_pushthrough (audioresample);

   634         o++;

   485       break;

   635         i++;

   486     default:

   636         len--;

   487       break;

   637       }

   488   }

   638     } else if (!gst_audio_resample_use_int && resample->width == 8

   489   parent_class->event (base, event);

   639         && !resample->fp) {

   490 

   640       gint8 *o = (gint8 *) out;

   491   return TRUE;

   641       gfloat *i = (gfloat *) in;

   492 }

   642       gfloat tmp;

   493 

   643 

   494 static GstFlowReturn

   644       while (len) {

   495 audioresample_do_output (GstAudioresample * audioresample, GstBuffer * outbuf)

   645         tmp = *i;

   496 {

   646         *o = (gint8) CLAMP (tmp * G_MAXINT8 + 0.5, G_MININT8, G_MAXINT8);

   497   int outsize;

   647         o++;

   498   int outsamples;

   648         i++;

   499   ResampleState *r;

   649         len--;

   500 

   650       }

   501   r = audioresample->resample;

   651     } else if (!gst_audio_resample_use_int && resample->width == 16

   502 

   652         && !resample->fp) {

   503   outsize = resample_get_output_size (r);

   653       gint16 *o = (gint16 *) out;

   504   GST_LOG_OBJECT (audioresample, "audioresample can give me %d bytes", outsize);

   654       gfloat *i = (gfloat *) in;

   505 

   655       gfloat tmp;

   506   /* protect against mem corruption */

   656 

   507   if (outsize > GST_BUFFER_SIZE (outbuf)) {

   657       while (len) {

   508     GST_WARNING_OBJECT (audioresample,

   658         tmp = *i;

   509         "overriding audioresample's outsize %d with outbuffer's size %d",

   659         *o = (gint16) CLAMP (tmp * G_MAXINT16 + 0.5, G_MININT16, G_MAXINT16);

   510         outsize, GST_BUFFER_SIZE (outbuf));

   660         o++;

   511     outsize = GST_BUFFER_SIZE (outbuf);

   661         i++;

   512   }

   662         len--;

   513   /* catch possibly wrong size differences */

   663       }

   514   if (GST_BUFFER_SIZE (outbuf) - outsize > r->sample_size) {

   664     } else if (resample->width == 24 && !resample->fp) {

   515     GST_WARNING_OBJECT (audioresample,

   665       guint8 *o = (guint8 *) out;

   516         "audioresample's outsize %d too far from outbuffer's size %d",

   666       gdouble *i = (gdouble *) in;

   517         outsize, GST_BUFFER_SIZE (outbuf));

   667       gdouble tmp;

   518   }

   668 

   519 

   669       while (len) {

   520   outsize = resample_get_output_data (r, GST_BUFFER_DATA (outbuf), outsize);

   670         tmp = *i;

   521   outsamples = outsize / r->sample_size;

   671         GST_WRITE_UINT24 (o, (gint32) CLAMP (tmp * GST_MAXINT24 + 0.5,

   522   GST_LOG_OBJECT (audioresample, "resample gave me %d bytes or %d samples",

   672                 GST_MININT24, GST_MAXINT24));

   523       outsize, outsamples);

   673         o += 3;

   524 

   674         i++;

   525   GST_BUFFER_OFFSET (outbuf) = audioresample->offset;

   675         len--;

   526   GST_BUFFER_TIMESTAMP (outbuf) = audioresample->next_ts;

   676       }

   527 

   677     } else if (resample->width == 32 && !resample->fp) {

   528   if (audioresample->ts_offset != -1) {

   678       gint32 *o = (gint32 *) out;

   529     audioresample->offset += outsamples;

   679       gdouble *i = (gdouble *) in;

   530     audioresample->ts_offset += outsamples;

   680       gdouble tmp;

   531     audioresample->next_ts =

   681 

   532         gst_util_uint64_scale_int (audioresample->ts_offset, GST_SECOND,

   682       while (len) {

   533         audioresample->o_rate);

   683         tmp = *i;

   534     GST_BUFFER_OFFSET_END (outbuf) = audioresample->offset;

   684         *o = (gint32) CLAMP (tmp * G_MAXINT32 + 0.5, G_MININT32, G_MAXINT32);

   535 

   685         o++;

   536     /* we calculate DURATION as the difference between "next" timestamp

   686         i++;

   537      * and current timestamp so we ensure a contiguous stream, instead of

   687         len--;

   538      * having rounding errors. */

   688       }

   539     GST_BUFFER_DURATION (outbuf) = audioresample->next_ts -

   689     } else {

   540         GST_BUFFER_TIMESTAMP (outbuf);

   690       g_assert_not_reached ();

   691     }

   693     if (gst_audio_resample_use_int && resample->width == 8 && !resample->fp) {

   542     /* no valid offset know, we can still sortof calculate the duration though */

   694       gint8 *i = (gint8 *) in;

   543     GST_BUFFER_DURATION (outbuf) =

   695       gint16 *o = (gint16 *) out;

   544         gst_util_uint64_scale_int (outsamples, GST_SECOND,

   696       gint32 tmp;

   545         audioresample->o_rate);

   697 

   546   }

   698       while (len) {

   547 

   699         tmp = *i;

   548   /* check for possible mem corruption */

   700         *o = tmp << 8;

   549   if (outsize > GST_BUFFER_SIZE (outbuf)) {

   701         o++;

   550     /* this is an error that when it happens, would need fixing in the

   702         i++;

   551      * resample library; we told it we wanted only GST_BUFFER_SIZE (outbuf),

   703         len--;

   552      * and it gave us more ! */

   704       }

   553     GST_WARNING_OBJECT (audioresample,

   705     } else if (!gst_audio_resample_use_int && resample->width == 8

   554         "audioresample, you memory corrupting bastard. "

   706         && !resample->fp) {

   555         "you gave me outsize %d while my buffer was size %d",

   707       gint8 *i = (gint8 *) in;

   556         outsize, GST_BUFFER_SIZE (outbuf));

   708       gfloat *o = (gfloat *) out;

   557     return GST_FLOW_ERROR;

   709       gfloat tmp;

   558   }

   710 

   559   /* catch possibly wrong size differences */

   711       while (len) {

   560   if (GST_BUFFER_SIZE (outbuf) - outsize > r->sample_size) {

   712         tmp = *i;

   561     GST_WARNING_OBJECT (audioresample,

   713         *o = tmp / G_MAXINT8;

   562         "audioresample's written outsize %d too far from outbuffer's size %d",

   714         o++;

   563         outsize, GST_BUFFER_SIZE (outbuf));

   715         i++;

   564   }

   716         len--;

   565   GST_BUFFER_SIZE (outbuf) = outsize;

   717       }

   566 

   718     } else if (!gst_audio_resample_use_int && resample->width == 16

   567   if (G_UNLIKELY (audioresample->need_discont)) {

   719         && !resample->fp) {

   568     GST_DEBUG_OBJECT (audioresample,

   720       gint16 *i = (gint16 *) in;

   569         "marking this buffer with the DISCONT flag");

   721       gfloat *o = (gfloat *) out;

   570     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);

   722       gfloat tmp;

   571     audioresample->need_discont = FALSE;

   723 

   572   }

   724       while (len) {

   573 

   725         tmp = *i;

   574   GST_LOG_OBJECT (audioresample, "transformed to buffer of %d bytes, ts %"

   726         *o = tmp / G_MAXINT16;

   575       GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT ", offset %"

   727         o++;

   576       G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT,

   728         i++;

   577       outsize, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),

   729         len--;

   578       GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)),

   730       }

   579       GST_BUFFER_OFFSET (outbuf), GST_BUFFER_OFFSET_END (outbuf));

   731     } else if (resample->width == 24 && !resample->fp) {

   580 

   732       guint8 *i = (guint8 *) in;

   581 

   733       gdouble *o = (gdouble *) out;

   582   return GST_FLOW_OK;

   734       gdouble tmp;

   583 }

   735       guint32 tmp2;

   584 

   736 

   585 static gboolean

   737       while (len) {

   586 audioresample_check_discont (GstAudioresample * audioresample,

   738         tmp2 = GST_READ_UINT24 (i);

   739         if (tmp2 & 0x00800000)

   740           tmp2 |= 0xff000000;

   741         tmp = (gint32) tmp2;

   742         *o = tmp / GST_MAXINT24;

   743         o++;

   744         i += 3;

   745         len--;

   746       }

   747     } else if (resample->width == 32 && !resample->fp) {

   748       gint32 *i = (gint32 *) in;

   749       gdouble *o = (gdouble *) out;

   750       gdouble tmp;

   751 

   752       while (len) {

   753         tmp = *i;

   754         *o = tmp / G_MAXINT32;

   755         o++;

   756         i++;

   757         len--;

   758       }

   759     } else {

   760       g_assert_not_reached ();

   761     }

   762   }

   763 }

   764 

   765 static void

   766 gst_audio_resample_push_drain (GstAudioResample * resample)

   767 {

   768   GstBuffer *buf;

   769   GstBaseTransform *trans = GST_BASE_TRANSFORM (resample);

   770   GstFlowReturn res;

   771   gint outsize;

   772   guint out_len, out_processed;

   773   gint err;

   774   guint num, den, len;

   775   guint8 *outtmp = NULL;

   776   gboolean need_convert = FALSE;

   777 

   778   if (!resample->state)

   779     return;

   780 

   781   /* Don't drain samples if we were resetted. */

   782   if (resample->next_ts == -1)

   783     return;

   784 

   785   need_convert = (resample->funcs->width != resample->width);

   786 

   787   resample->funcs->get_ratio (resample->state, &num, &den);

   788 

   789   out_len = resample->funcs->get_input_latency (resample->state);

   790   out_len = out_processed = (out_len * den + num - 1) / num;

   791   outsize = (resample->width / 8) * out_len * resample->channels;

   792 

   793   if (need_convert) {

   794     guint outsize_tmp =

   795         (resample->funcs->width / 8) * out_len * resample->channels;

   796     if (outsize_tmp <= resample->tmp_out_size) {

   797       outtmp = resample->tmp_out;

   798     } else {

   799       resample->tmp_out_size = outsize_tmp;

   800       resample->tmp_out = outtmp = g_realloc (resample->tmp_out, outsize_tmp);

   801     }

   802   }

   803 

   804   res =

   805       gst_pad_alloc_buffer_and_set_caps (trans->srcpad, GST_BUFFER_OFFSET_NONE,

   806       outsize, GST_PAD_CAPS (trans->srcpad), &buf);

   807 

   808   if (G_UNLIKELY (res != GST_FLOW_OK)) {

   809     GST_WARNING_OBJECT (resample, "failed allocating buffer of %d bytes",

   810         outsize);

   811     return;

   812   }

   813 

   814   len = resample->funcs->get_input_latency (resample->state);

   815 

   816   err =

   817       resample->funcs->process (resample->state,

   818       NULL, &len, (need_convert) ? outtmp : GST_BUFFER_DATA (buf),

   819       &out_processed);

   820 

   821   if (G_UNLIKELY (err != RESAMPLER_ERR_SUCCESS)) {

   822     GST_WARNING_OBJECT (resample, "Failed to process drain: %s",

   823         resample->funcs->strerror (err));

   824     gst_buffer_unref (buf);

   825     return;

   826   }

   827 

   828   if (G_UNLIKELY (out_processed == 0)) {

   829     GST_WARNING_OBJECT (resample, "Failed to get drain, dropping buffer");

   830     gst_buffer_unref (buf);

   831     return;

   832   }

   833 

   834   /* If we wrote more than allocated something is really wrong now

   835    * and we should better abort immediately */

   836   g_assert (out_len >= out_processed);

   837 

   838   if (need_convert)

   839     gst_audio_resample_convert_buffer (resample, outtmp, GST_BUFFER_DATA (buf),

   840         out_processed, TRUE);

   841 

   842   GST_BUFFER_DURATION (buf) =

   843       GST_FRAMES_TO_CLOCK_TIME (out_processed, resample->outrate);

   844   GST_BUFFER_SIZE (buf) =

   845       out_processed * resample->channels * (resample->width / 8);

   846 

   847   if (GST_CLOCK_TIME_IS_VALID (resample->next_ts)) {

   848     GST_BUFFER_OFFSET (buf) = resample->next_offset;

   849     GST_BUFFER_OFFSET_END (buf) = resample->next_offset + out_processed;

   850     GST_BUFFER_TIMESTAMP (buf) = resample->next_ts;

   851 

   852     resample->next_ts += GST_BUFFER_DURATION (buf);

   853     resample->next_offset += out_processed;

   854   }

   855 

   856   GST_LOG_OBJECT (resample,

   857       "Pushing drain buffer of %u bytes with timestamp %" GST_TIME_FORMAT

   858       " duration %" GST_TIME_FORMAT " offset %" G_GUINT64_FORMAT " offset_end %"

   859       G_GUINT64_FORMAT, GST_BUFFER_SIZE (buf),

   860       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),

   861       GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_BUFFER_OFFSET (buf),

   862       GST_BUFFER_OFFSET_END (buf));

   863 

   864   res = gst_pad_push (trans->srcpad, buf);

   865 

   866   if (G_UNLIKELY (res != GST_FLOW_OK))

   867     GST_WARNING_OBJECT (resample, "Failed to push drain: %s",

   868         gst_flow_get_name (res));

   869 

   870   return;

   871 }

   872 

   873 static gboolean

   874 gst_audio_resample_event (GstBaseTransform * base, GstEvent * event)

   875 {

   876   GstAudioResample *resample = GST_AUDIO_RESAMPLE (base);

   877 

   878   switch (GST_EVENT_TYPE (event)) {

   879     case GST_EVENT_FLUSH_STOP:

   880       gst_audio_resample_reset_state (resample);

   881       resample->next_offset = -1;

   882       resample->next_ts = -1;

   883       resample->next_upstream_ts = -1;

   884       break;

   885     case GST_EVENT_NEWSEGMENT:

   886       gst_audio_resample_push_drain (resample);

   887       gst_audio_resample_reset_state (resample);

   888       resample->next_offset = -1;

   889       resample->next_ts = -1;

   890       resample->next_upstream_ts = -1;

   891       break;

   892     case GST_EVENT_EOS:

   893       gst_audio_resample_push_drain (resample);

   894       gst_audio_resample_reset_state (resample);

   895       break;

   896     default:

   897       break;

   898   }

   899 

   900   return parent_class->event (base, event);

   901 }

   902 

   903 static gboolean

   904 gst_audio_resample_check_discont (GstAudioResample * resample,

   908       resample->next_upstream_ts != GST_CLOCK_TIME_NONE &&

   590       audioresample->prev_ts != GST_CLOCK_TIME_NONE &&

   909       timestamp != resample->next_upstream_ts) {

   591       audioresample->prev_duration != GST_CLOCK_TIME_NONE &&

   592       timestamp != audioresample->prev_ts + audioresample->prev_duration) {

   914     GstClockTimeDiff diff = timestamp - resample->next_upstream_ts;

   597     GstClockTimeDiff diff = timestamp -

   915 

   598         (audioresample->prev_ts + audioresample->prev_duration);

   916     if (ABS (diff) > (GST_SECOND + resample->inrate - 1) / resample->inrate) {

   599 

   917       GST_WARNING_OBJECT (resample,

   600     if (ABS (diff) > GST_SECOND / audioresample->i_rate) {

   918           "encountered timestamp discontinuity of %s%" GST_TIME_FORMAT,

   601       GST_WARNING_OBJECT (audioresample,

   919           (diff < 0) ? "-" : "", GST_TIME_ARGS ((GstClockTime) ABS (diff)));

   602           "encountered timestamp discontinuity of %" G_GINT64_FORMAT, diff);

   928 gst_audio_resample_process (GstAudioResample * resample, GstBuffer * inbuf,

   611 audioresample_transform (GstBaseTransform * base, GstBuffer * inbuf,

   931   guint32 in_len, in_processed;

   614   GstAudioresample *audioresample;

   932   guint32 out_len, out_processed;

   615   ResampleState *r;

   933   gint err = RESAMPLER_ERR_SUCCESS;

   616   guchar *data, *datacopy;

   934   guint8 *in_tmp = NULL, *out_tmp = NULL;

   935   gboolean need_convert = (resample->funcs->width != resample->width);

   936 

   937   in_len = GST_BUFFER_SIZE (inbuf) / resample->channels;

   938   out_len = GST_BUFFER_SIZE (outbuf) / resample->channels;

   939 

   940   in_len /= (resample->width / 8);

   941   out_len /= (resample->width / 8);

   942 

   943   in_processed = in_len;

   944   out_processed = out_len;

   945 

   946   if (need_convert) {

   947     guint in_size_tmp =

   948         in_len * resample->channels * (resample->funcs->width / 8);

   949     guint out_size_tmp =

   950         out_len * resample->channels * (resample->funcs->width / 8);

   951 

   952     if (in_size_tmp <= resample->tmp_in_size) {

   953       in_tmp = resample->tmp_in;

   954     } else {

   955       resample->tmp_in = in_tmp = g_realloc (resample->tmp_in, in_size_tmp);

   956       resample->tmp_in_size = in_size_tmp;

   957     }

   958 

   959     gst_audio_resample_convert_buffer (resample, GST_BUFFER_DATA (inbuf),

   960         in_tmp, in_len, FALSE);

   961 

   962     if (out_size_tmp <= resample->tmp_out_size) {

   963       out_tmp = resample->tmp_out;

   964     } else {

   965       resample->tmp_out = out_tmp = g_realloc (resample->tmp_out, out_size_tmp);

   966       resample->tmp_out_size = out_size_tmp;

   967     }

   968   }

   969 

   970   if (need_convert) {

   971     err = resample->funcs->process (resample->state,

   972         in_tmp, &in_processed, out_tmp, &out_processed);

   973   } else {

   974     err = resample->funcs->process (resample->state,

   975         (const guint8 *) GST_BUFFER_DATA (inbuf), &in_processed,

   976         (guint8 *) GST_BUFFER_DATA (outbuf), &out_processed);

   977   }

   978 

   979   if (G_UNLIKELY (in_len != in_processed))

   980     GST_WARNING_OBJECT (resample, "Converted %d of %d input samples",

   981         in_processed, in_len);

   982 

   983   if (out_len != out_processed) {

   984     if (out_processed == 0) {

   985       GST_DEBUG_OBJECT (resample, "Converted to 0 samples, buffer dropped");

   986 

   987       return GST_BASE_TRANSFORM_FLOW_DROPPED;

   988     }

   989 

   990     /* If we wrote more than allocated something is really wrong now

   991      * and we should better abort immediately */

   992     g_assert (out_len >= out_processed);

   993   }

   994 

   995   if (G_UNLIKELY (err != RESAMPLER_ERR_SUCCESS)) {

   996     GST_ERROR_OBJECT (resample, "Failed to convert data: %s",

   997         resample->funcs->strerror (err));

   998     return GST_FLOW_ERROR;

   999   } else {

  1000 

  1001     if (need_convert)

  1002       gst_audio_resample_convert_buffer (resample, out_tmp,

  1003           GST_BUFFER_DATA (outbuf), out_processed, TRUE);

  1004 

  1005     GST_BUFFER_DURATION (outbuf) =

  1006         GST_FRAMES_TO_CLOCK_TIME (out_processed, resample->outrate);

  1007     GST_BUFFER_SIZE (outbuf) =

  1008         out_processed * resample->channels * (resample->width / 8);

  1009 

  1010     if (GST_CLOCK_TIME_IS_VALID (resample->next_ts)) {

  1011       GST_BUFFER_TIMESTAMP (outbuf) = resample->next_ts;

  1012       GST_BUFFER_OFFSET (outbuf) = resample->next_offset;

  1013       GST_BUFFER_OFFSET_END (outbuf) = resample->next_offset + out_processed;

  1014 

  1015       resample->next_ts += GST_BUFFER_DURATION (outbuf);

  1016       resample->next_offset += out_processed;

  1017     }

  1018 

  1019     GST_LOG_OBJECT (resample,

  1020         "Converted to buffer of %u bytes with timestamp %" GST_TIME_FORMAT

  1021         ", duration %" GST_TIME_FORMAT ", offset %" G_GUINT64_FORMAT

  1022         ", offset_end %" G_GUINT64_FORMAT, GST_BUFFER_SIZE (outbuf),

  1023         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),

  1024         GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)),

  1025         GST_BUFFER_OFFSET (outbuf), GST_BUFFER_OFFSET_END (outbuf));

  1026 

  1027     return GST_FLOW_OK;

  1028   }

  1029 }

  1030 

  1031 static GstFlowReturn

  1032 gst_audio_resample_transform (GstBaseTransform * base, GstBuffer * inbuf,

  1033     GstBuffer * outbuf)

  1034 {

  1035   GstAudioResample *resample = GST_AUDIO_RESAMPLE (base);

  1036   guint8 *data;

  1039   guint outsamples, insamples;

   619 

  1040   GstFlowReturn ret;

   620   audioresample = GST_AUDIORESAMPLE (base);

  1041 

   621   r = audioresample->resample;

  1042   if (resample->state == NULL) {

  1043     if (G_UNLIKELY (!(resample->state =

  1044                 gst_audio_resample_init_state (resample, resample->width,

  1045                     resample->channels, resample->inrate, resample->outrate,

  1046                     resample->quality, resample->fp))))

  1047       return GST_FLOW_ERROR;

  1048 

  1049     resample->funcs =

  1050         gst_audio_resample_get_funcs (resample->width, resample->fp);

  1051   }

  1057   GST_LOG_OBJECT (resample, "transforming buffer of %ld bytes, ts %"

   627   GST_LOG_OBJECT (audioresample, "transforming buffer of %ld bytes, ts %"