---
title: "AudioBlockMap"
language: "en"
type: "Symbol"
summary: "AudioBlockMap[f, audio, dur] applies f to non-overlapping partitions of length dur in audio. AudioBlockMap[f, audio, {dur, offset}] applies f to partitions with offset offset in audio. AudioBlockMap[f, audio, {dur, offset, wfun}] applies f after applying wfun to partitions in audio."
keywords: 
- audio partition
- block map
- partition map
- audio apply
- audio editing
- audio analysis
- audio block map
- audio local filtering
- audio local analysis
canonical_url: "https://reference.wolfram.com/language/ref/AudioBlockMap.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Audio Representation"
    link: "https://reference.wolfram.com/language/guide/AudioRepresentation.en.md"
  - 
    title: "Audio Analysis"
    link: "https://reference.wolfram.com/language/guide/AudioAnalysis.en.md"
related_functions: 
  - 
    title: "AudioLocalMeasurements"
    link: "https://reference.wolfram.com/language/ref/AudioLocalMeasurements.en.md"
  - 
    title: "AudioPartition"
    link: "https://reference.wolfram.com/language/ref/AudioPartition.en.md"
  - 
    title: "AudioIntervals"
    link: "https://reference.wolfram.com/language/ref/AudioIntervals.en.md"
  - 
    title: "BlockMap"
    link: "https://reference.wolfram.com/language/ref/BlockMap.en.md"
  - 
    title: "ArrayFilter"
    link: "https://reference.wolfram.com/language/ref/ArrayFilter.en.md"
  - 
    title: "MovingMap"
    link: "https://reference.wolfram.com/language/ref/MovingMap.en.md"
---
# AudioBlockMap

AudioBlockMap[f, audio, dur] applies f to non-overlapping partitions of length dur in audio. 

AudioBlockMap[f, audio, {dur, offset}] applies f to partitions with offset offset in audio. 

AudioBlockMap[f, audio, {dur, offset, wfun}] applies f after applying wfun to partitions in audio.

## Details and Options

* ``AudioBlockMap[f, audio, …]`` returns a ``TimeSeries`` whose values are the results of ``f`` applied to the partitions of ``audio``. The times are the centers of the corresponding partitions.

[image]

* Function ``f`` can work on different forms of the partition data using named arguments:

|                    |                                            |
| ------------------ | ------------------------------------------ |
| #AudioData or #1   | raw audio data of each partition (default) |
| #FourierData       | Fourier transform of each partition        |
| #MagnitudeSpectrum | magnitude of the Fourier transform         |
| #PowerSpectrum     | power spectrum of each partition           |

* Time variables ``dur`` and ``offset`` can be given as a scalar in seconds, or a time or sample ``Quantity`` object.

* The smoothing window ``wfun`` can be specified using a window function that will be sampled between $-1/2$ and $1/2$ or a list of values resampled to the length of the partition. By default, no smoothing is performed, which is equivalent to ``DirichletWindow``.

* The following options can be given:

|                   |                 |                                              |
| ----------------- | --------------- | -------------------------------------------- |
| Alignment         | Center          | alignment of the time stamps with partitions |
| FourierParameters | {-1, 1}         | Fourier parameters                           |
| MetaInformation   | None            | include additional metainformation           |
| MissingDataMethod | None            | method to use for missing values             |
| Padding           | Automatic       | padding scheme                               |
| PaddingSize       | Automatic       | amount of padding                            |
| ResamplingMethod  | "Interpolation" | the method to use for resampling paths       |

* Possible settings for ``Alignment`` include:

|        |                                                  |
| ------ | ------------------------------------------------ |
| Left   | return times at the beginning of each partition  |
| Center | return times at the center of each partition     |
| Right  | return times at the end of each partition        |
| a      | scaled alignment between -1 (left) and 1 (right) |

* Possible settings for ``Padding`` include:

|             |                                                    |
| ----------- | -------------------------------------------------- |
| None        | no padding, dropping partitions with fewer samples |
| 0           | zero (silence) padding                             |
| val         | a constant value                                   |
| "Fixed"     | repetitions of the boundary value                  |
| "Periodic"  | cyclic repetitions of the complete audio           |
| "Reflected" | reflections of the audio at the boundary           |
| "Reversed"  | reversals of the complete audio                    |

---

## Examples (16)

### Basic Examples (1)

Apply a function to partitions of an audio object:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-vvehy)"]\);

In[2]:= max = AudioBlockMap[Max, a, Quantity[20, "Milliseconds"]]

Out[2]=
TemporalData[TimeSeries, {CompressedData["«580»"], {{0.01, 1.79, 0.02}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, 
  {MetaInformation -> None, MissingDataMethod -> None, ResamplingMethod -> 
    {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 14.3]
```

Plot the result along with the audio waveform:

```wl
In[3]:= Show[AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All], ListLinePlot[max, PlotStyle -> Red]]

Out[3]= [image]
```

### Scope (7)

#### Function Specification (5)

The function ``f`` can return any value supported by ``TimeSeries`` :

```wl
In[1]:=
a = Import["ExampleData/rule30.wav"];
stdev = AudioBlockMap[StandardDeviation, a, .04]

Out[1]=
TemporalData[TimeSeries, {CompressedData["«556»"], 
  {{0.02, 1.78, 0.04}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, 
  {MetaInformation -> None, MissingDataMethod -> None, ResamplingMethod -> 
    {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 14.3]

In[2]:= Show[AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All], ListLinePlot[stdev, PlotStyle -> Red, PlotRange -> {-1, 1}]]

Out[2]= [image]
```

Compute a pair of minimum and maximum values on each partition:

```wl
In[3]:= minmax = AudioBlockMap[MinMax, a, .04]

Out[3]=
TemporalData[TimeSeries, {CompressedData["«316»"], {{0.02, 1.78, 0.04}}, 1, 
  {"Continuous", 1}, {"Discrete", 1}, 2, {MetaInformation -> None, MissingDataMethod -> None, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 2}}, False, 
 14.3]

In[4]:= Show[AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All], ListLinePlot[minmax, PlotStyle -> {Orange, Darker[Green]}, PlotRange -> {-1, 1}]]

Out[4]= [image]
```

---

The function ``f`` does not need to return numeric output:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-sxbd6)"]\);

In[2]:= f[values_] := Blend[{Green, Yellow, Red}, Max[values]]
```

This function returns a color proportional to the maximum value in the partition:

```wl
In[3]:= colors = AudioBlockMap[f, AudioNormalize@a, .05]["Values"]

Out[3]= {RGBColor[1., 0.19911861419677734, 0.], RGBColor[1., 0.7966030836105347, 0.], RGBColor[1., 0.8985105752944946, 0.], RGBColor[1., 0.851738691329956, 0.], RGBColor[1., 0.9425804615020752, 0.], RGBColor[1., 0.9972656965255737, 0.], RGBColor[1., 0.9392 ... ., 0.], RGBColor[0.006755235139280558, 1., 0.], RGBColor[0.003988805692642927, 1., 0.], RGBColor[0.006755235139280558, 1., 0.], RGBColor[0.006755235139280558, 1., 0.], RGBColor[0.006755235139280558, 1., 0.], RGBColor[0.003988805692642927, 1., 0.]}
```

Plot the result alongside the waveform:

```wl
In[4]:=
Column[{AudioPlot[a, FrameTicks -> None, ImageSize -> Medium], 
	ArrayPlot[{colors}, ImageSize -> Medium]}]

Out[4]= [image]
```

---

The function ``f`` can operate on the Fourier transform of the partition data:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-sxbd6)"]\);
```

Compute the phase of the 100th components of the Fourier transform:

```wl
In[2]:= res = AudioBlockMap[Arg@#FourierData[[100]]&, AudioNormalize@a, .05]

Out[2]=
TemporalData[TimeSeries, {{{1.2836781723163153, 0.373441178707563, -0.7819596569555938, 
    -2.8166807684191997, -1.8037571236821162, -0.4110181898721697, 0.5914500849478596, 
    1.86365029220035, 2.7858711520576196, -2.805616496310021, -2.063220 ... 426303855}}, 1, {"Continuous", 1}, 
  {"Discrete", 1}, 1, {ValueDimensions -> 1, DateFunction -> Automatic, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, MissingDataMethod -> None, 
   MetaInformation -> None}}, False, 314.1]
```

Plot the result alongside the waveform:

```wl
In[3]:= Show[ListLinePlot[res, PlotStyle -> Red, PlotRange -> All], AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All]]

Out[3]= [image]
```

---

The function ``f`` can operate on the magnitude spectrum of the partition data:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-sxbd6)"]\);
```

Find the position of the second biggest peak in the magnitude spectrum:

```wl
In[2]:= res = AudioBlockMap[FindPeaks[#MagnitudeSpectrum][[2, 1]]&, AudioNormalize@a, .05]

Out[2]=
TemporalData[TimeSeries, {{{10, 10, 10, 10, 10, 19, 6, 6, 6, 24, 10, 10, 6, 10, 5, 5, 10, 17, 5, 5, 
    17, 17, 17, 17, 17, 17, 9, 10, 17, 8, 7, 8, 10, 10, 7, 10, 82}}, 
  {{0.024988662131519276, 1.824172335600907, 0.04997732426303855}}, 1, {"Continuous", 1}, 
  {"Discrete", 1}, 1, {ValueDimensions -> 1, DateFunction -> Automatic, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, MissingDataMethod -> None, 
   MetaInformation -> None}}, False, 314.1]
```

Plot the result alongside the waveform:

```wl
In[3]:= Show[ListLinePlot[res, PlotStyle -> Red, PlotRange -> All], AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All]]

Out[3]= [image]
```

---

The function ``f`` can operate on the power spectrum of the partition data:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-sxbd6)"]\);
```

Filter each power spectrum with a lowpass filter to smooth the result:

```wl
In[2]:= res = AudioBlockMap[LowpassFilter[#PowerSpectrum, .4]&, AudioNormalize@a, .05]

Out[2]=
TemporalData[TimeSeries, {CompressedData["«218370»"], 
  {{0.024988662131519276, 1.824172335600907, 0.04997732426303855}}, 1, {"Continuous", 1}, 
  {"Discrete", 1}, 552, {ValueDimensions -> 552, DateFunction -> Automatic, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, MissingDataMethod -> None, 
   MetaInformation -> None}}, False, 314.1]
```

Plot the smoothed spectrogram:

```wl
In[3]:= MatrixPlot[Log@res["Values"]]

Out[3]= [image]
```

#### Partition Specification (2)

Compute maximum value of non-overlapping segments of 0.05 seconds:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-vvehy)"]\);

In[2]:= max = AudioBlockMap[Max, a, 0.05]

Out[2]=
TemporalData[TimeSeries, {{{0.3403729498386383, 0.22745445370674133, 0.20816674828529358, 
    0.21701711416244507, 0.19986571371555328, 0.1895199418067932, 0.20047609508037567, 
    0.11203344911336899, 0.12253181636333466, 0.37800225615501404, 0. ...  1.824172335600907, 0.04997732426303855}}, 1, {"Continuous", 1}, 
  {"Discrete", 1}, 1, {MetaInformation -> None, MissingDataMethod -> None, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 
 14.3]
```

Plot the result along with the audio waveform:

```wl
In[3]:= Show[AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All], ListLinePlot[max, PlotStyle -> Red]]

Out[3]= [image]
```

Use 0.02 seconds of overlap between segments:

```wl
In[4]:= max = AudioBlockMap[Max, a, {0.05, 0.02}]

Out[4]=
TemporalData[TimeSeries, {CompressedData["«418»"], 
  {{0.024988662131519276, 1.8049886621315192, 0.02}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, 
  {MetaInformation -> None, MissingDataMethod -> None, ResamplingMethod -> 
    {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 14.3]
```

Plot the result along with the audio waveform:

```wl
In[5]:= Show[AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All], ListLinePlot[max, PlotStyle -> Red]]

Out[5]= [image]
```

Use a smoothing window:

```wl
In[6]:= max = AudioBlockMap[Max, a, {0.05, 0.02, HammingWindow}]

Out[6]=
TemporalData[TimeSeries, {CompressedData["«516»"], 
  {{0.024988662131519276, 1.8049886621315192, 0.02}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, 
  {MetaInformation -> None, MissingDataMethod -> None, ResamplingMethod -> 
    {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 14.3]
```

Plot the result along with the audio waveform:

```wl
In[7]:= Show[AudioPlot[a, AspectRatio -> 1 / 2, PlotRange -> All], ListLinePlot[max, PlotStyle -> Red]]

Out[7]= [image]
```

---

The partition size and the offset can be specified as a time ``Quantity``, a ``"Samples"`` ``Quantity``, or a number, interpreted as duration in seconds:

```wl
In[1]:=
a = Import["ExampleData/rule30.wav"];
AudioBlockMap[Max, a, 1]

Out[1]=
TemporalData[TimeSeries, {{{0.3984496593475342, 0.10937833786010742}}, {{0.5, 1.5, 1.}}, 1, 
  {"Continuous", 1}, {"Discrete", 1}, 1, {MetaInformation -> None, MissingDataMethod -> None, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 
 14.3]

In[2]:= % == AudioBlockMap[Max, a, Quantity[1, "Seconds"]]

Out[2]= True
```

Specify the number of samples to include in each partition:

```wl
In[3]:= AudioBlockMap[Max, a, Quantity[44100, "Samples"]]

Out[3]=
TemporalData[TimeSeries, {{{0.3984496593475342, 0.10937833786010742}}, {{0.5, 1.5, 1.}}, 1, 
  {"Continuous", 1}, {"Discrete", 1}, 1, {MetaInformation -> None, MissingDataMethod -> None, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 
 14.3]
```

### Options (2)

#### Alignment (1)

The time stamps of the resulting ``TimeSeries`` are by default placed in the center of each partition:

```wl
In[1]:= audio = Import["ExampleData/rule30.wav"];

In[2]:= audioplot = AudioPlot[audio, AspectRatio -> 1 / 2, PlotRange -> All, PlotRangePadding -> Scaled[.05], GridLines -> {Table[i, {i, 0, QuantityMagnitude@Duration@audio, .3}], None}];

In[3]:=
max = AudioBlockMap[Max, audio, .3];
Show[audioplot, 
	ListPlot[max, PlotStyle -> Red, Filling -> Axis, PlotMarkers -> Automatic, PlotRange -> {-1, 1}]]

Out[3]= [image]
```

Center alignment is the same as ``Alignment -> 0`` :

```wl
In[4]:=
max = AudioBlockMap[Max, audio, .3, Alignment -> 0];
Show[audioplot, 
	ListPlot[max, PlotStyle -> Red, Filling -> Axis, PlotMarkers -> Automatic, PlotRange -> {-1, 1}]]

Out[4]= [image]
```

Use ``Alignment -> Right`` to return the computed property at the end of each partition:

```wl
In[5]:=
max = AudioBlockMap[Max, audio, .3, Alignment -> Right];
Show[audioplot, 
	ListPlot[max, PlotStyle -> Red, Filling -> Axis, PlotMarkers -> Automatic, PlotRange -> {-1, 1}]]

Out[5]= [image]
```

Use a custom alignment:

```wl
In[6]:=
max = AudioBlockMap[Max, audio, .3, Alignment -> -.5];
Show[audioplot, 
	ListPlot[max, PlotStyle -> Red, Filling -> Axis, PlotMarkers -> Automatic, PlotRange -> {-1, 1}]]

Out[6]= [image]
```

#### Padding (1)

By default, incomplete partitions are padded with 0 on the right:

```wl
In[1]:=
audio = Audio[Range[10.], SampleRate -> 1];
AudioBlockMap[#&, audio, 4, Padding -> Automatic]["Values"]

Out[1]= {{1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 0., 0.}}
```

Specify a different padding scheme:

```wl
In[2]:= AudioBlockMap[#&, audio, 4, Padding -> "Periodic"]["Values"]

Out[2]= {{1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 1., 2.}}
```

Use ``Padding -> None`` to drop the incomplete partitions from computation:

```wl
In[3]:= AudioBlockMap[#&, audio, 4, Padding -> None]["Values"]

Out[3]= {{1., 2., 3., 4.}, {5., 6., 7., 8.}}
```

### Applications (3)

Compute the instantaneous amplitude in dB RMS:

```wl
In[1]:=
a = Import["ExampleData/rule30.wav"];
dBrms = AudioBlockMap[20Log10[Sqrt@Mean[# ^ 2]]&, a, {Quantity[50, "Milliseconds"], Quantity[5, "Milliseconds"]}];ListLinePlot[dBrms]

Out[1]= [image]
```

Visualize the histogram of the instantaneous amplitude in dB RMS:

```wl
In[2]:= Histogram[dBrms, 40]

Out[2]= [image]
```

Estimate its distribution:

```wl
In[3]:= \[ScriptCapitalD] = KernelMixtureDistribution[dBrms, 1]

Out[3]= DataDistribution["KernelMixture", {CompressedData["«258»"], "Gaussian", CompressedData["«1494»"], 1.}, 1, 361]
```

Use the resulting distribution to perform analysis, including visualizing distribution functions:

```wl
In[4]:= Table[Plot[f[\[ScriptCapitalD], x], {x, -50, 0}, Filling -> Axis, PlotLabel -> f], {f, {PDF, CDF}}]

Out[4]= [image]

In[5]:= Moment[\[ScriptCapitalD], 1]

Out[5]= -30.7904

In[6]:= Quantile[\[ScriptCapitalD], 0.95]//Quiet

Out[6]= -18.3478
```

---

Build an audio compressor:

```wl
In[1]:=
a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-vvehy)"]\);
AudioPlot[a]

Out[1]= [image]
```

Compute the RMS amplitude of the signal with a threshold of 0.02:

```wl
In[2]:= amplitude = AudioBlockMap[Max[.02, Sqrt@Mean[# ^ 2]]&, a, {.01, .005}]

Out[2]=
TemporalData[TimeSeries, {CompressedData["«2704»"], {{0.004988662131519274, 1.8009070294784582, 0.004988662131519274}}, 1, 
  {"Continuous", 1}, {"Discrete", 1}, 1, {MetaInformation -> None, MissingDataMethod -> None, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, False, 
 12.1]
```

Compress the dynamic range of the signal:

```wl
In[3]:= AudioNormalize[a / Audio[amplitude]]

Out[3]= \!\(\*AudioBox["![Embedded Audio Player](audio://content-eftpo)"]\)

In[4]:= AudioPlot[%]

Out[4]= [image]
```

---

Create a visualization for audio amplitude:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-vvehy)"]\);

In[2]:= m = AudioBlockMap[{Hue[Max@#], Disk[{0, 0}, Max@#]}&, a, {.1, .01, HannWindow}]

Out[2]=
TemporalData[TimeSeries, {{{{Hue[0.269386887550354], Disk[{0, 0}, 0.269386887550354]}, 
    {Hue[0.269386887550354], Disk[{0, 0}, 0.269386887550354]}, {Hue[0.22745445370674133], 
     Disk[{0, 0}, 0.22745445370674133]}, {Hue[0.22745445370674133], 
 ... 1.8459183673469388, 0.009977324263038548}}, 1, {"Continuous", 1}, {"Discrete", 1}, 2, 
  {MetaInformation -> None, MissingDataMethod -> None, ResamplingMethod -> 
    {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 2}}, False, 14.3]

In[3]:= Graphics[{Opacity[.5], MapThread[{#1[[1]], Translate[#1[[2]], {#2, 0}]}&, {m["Values"], m["Times"]}]}]

Out[3]= [image]
```

### Properties & Relations (1)

Many ``AudioLocalMeasurements`` properties can be computed using ``AudioBlockMap`` :

```wl
In[1]:= a = Import["ExampleData/rule30.wav"];

In[2]:= AudioBlockMap[Max, a, {.5, .5, None}, Padding -> None] == AudioLocalMeasurements[a, "Max", PartitionGranularity -> {.5, .5, None}, PaddingSize -> 0]

Out[2]= True
```

### Interactive Examples (1)

Create a dynamic visualization for the amplitude of a signal:

```wl
In[1]:= a = \!\(\*AudioBox["![Embedded Audio Player](audio://content-sxbd6)"]\);
```

Define a color function that is green for zero and red for one:

```wl
In[2]:=
cf[x_] := Blend[{Green, Yellow, Red}, x]
Table[cf[i], {i, 0, 1, .1}]

Out[2]= {RGBColor[0., 1., 0.], RGBColor[0.2, 1., 0.], RGBColor[0.4, 1., 0.], RGBColor[0.6000000000000001, 1., 0.], RGBColor[0.8, 1., 0.], RGBColor[1., 1., 0.], RGBColor[1., 0.7999999999999998, 0.], RGBColor[1., 0.5999999999999999, 0.], RGBColor[1., 0.3999999999999999, 0.], RGBColor[1., 0.19999999999999996, 0.], RGBColor[1., 0., 0.]}
```

Compute a list of colors and disks whose radius is proportional to the amplitude:

```wl
In[3]:=
fps = 30;disks = AudioBlockMap[{cf[Max@#], Disk[{0, 0}, Max@#]}&, a, {.1, 1 / fps}]["Values"];
RandomSample[disks, 2]

Out[3]= {{RGBColor[1., 0.21167635917663574, 0.], Disk[{0, 0}, 0.894162]}, {RGBColor[0.9062166213989258, 1., 0.], Disk[{0, 0}, 0.453108]}}
```

Animate the result:

```wl
In[4]:=
ListAnimate[Table[
	Graphics[d, PlotRange -> 1], {d, disks}], fps, TransitionEffect -> "Fade"]

Out[4]= DynamicModule[«8»]
```

Animate with some overlap:

```wl
In[5]:=
ListAnimate[Table[
	Graphics[d, PlotRange -> 1], {d, Rest@FoldList[Flatten@Append[#1 /. Opacity[x_] -> Opacity[Clip[x - .1, {0, 1}]], {Opacity[1], #2}]&, {}, disks]}], fps, TransitionEffect -> "Fade"]

Out[5]= DynamicModule[«8»]
```

### Neat Examples (1)

Reverse the values in the partition and construct a new audio object:

```wl
In[1]:=
a = Import["ExampleData/rule30.wav"];
AudioBlockMap[Reverse, a, {0.3, 0.1}]["Values"]//Flatten//Audio

Out[1]= \!\(\*AudioBox["![Embedded Audio Player](audio://content-bwbad)"]\)
```

## See Also

* [`AudioLocalMeasurements`](https://reference.wolfram.com/language/ref/AudioLocalMeasurements.en.md)
* [`AudioPartition`](https://reference.wolfram.com/language/ref/AudioPartition.en.md)
* [`AudioIntervals`](https://reference.wolfram.com/language/ref/AudioIntervals.en.md)
* [`BlockMap`](https://reference.wolfram.com/language/ref/BlockMap.en.md)
* [`ArrayFilter`](https://reference.wolfram.com/language/ref/ArrayFilter.en.md)
* [`MovingMap`](https://reference.wolfram.com/language/ref/MovingMap.en.md)

## Related Guides

* [Audio Representation](https://reference.wolfram.com/language/guide/AudioRepresentation.en.md)
* [Audio Analysis](https://reference.wolfram.com/language/guide/AudioAnalysis.en.md)

## History

* [Introduced in 2016 (11.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn110.en.md) \| [Updated in 2017 (11.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn111.en.md) ▪ [2019 (12.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn120.en.md)