libhb/audio_remap.c

   1 /* audio_remap.c
   2  *
   3  * Copyright (c) 2003-2015 HandBrake Team
   4  * This file is part of the HandBrake source code
   5  * Homepage: <http://handbrake.fr/>
   6  * It may be used under the terms of the GNU General Public License v2.
   7  * For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
   8  */
   9
  10 #include "common.h"
  11 #include "hbffmpeg.h"
  12 #include "audio_remap.h"
  13
  14 // source: libavutil/channel_layout.h
  15 hb_chan_map_t hb_libav_chan_map =
  16 {
  17     {
  18         AV_CH_FRONT_LEFT,
  19         AV_CH_FRONT_RIGHT,
  20         AV_CH_FRONT_CENTER,
  21         AV_CH_LOW_FREQUENCY,
  22         AV_CH_BACK_LEFT,
  23         AV_CH_BACK_RIGHT,
  24         AV_CH_FRONT_LEFT_OF_CENTER,
  25         AV_CH_FRONT_RIGHT_OF_CENTER,
  26         AV_CH_BACK_CENTER,
  27         AV_CH_SIDE_LEFT,
  28         AV_CH_SIDE_RIGHT,
  29         0
  30     }
  31 };
  32
  33 // source: liba52 documentation
  34 hb_chan_map_t hb_liba52_chan_map =
  35 {
  36     {
  37         AV_CH_LOW_FREQUENCY,
  38         AV_CH_FRONT_LEFT,
  39         AV_CH_FRONT_CENTER,
  40         AV_CH_FRONT_RIGHT,
  41         AV_CH_BACK_CENTER,
  42         AV_CH_SIDE_LEFT,
  43         AV_CH_SIDE_RIGHT,
  44         0
  45     }
  46 };
  47
  48 // source: http://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9
  49 hb_chan_map_t hb_vorbis_chan_map =
  50 {
  51     {
  52         AV_CH_FRONT_LEFT,
  53         AV_CH_FRONT_CENTER,
  54         AV_CH_FRONT_RIGHT,
  55         AV_CH_SIDE_LEFT,
  56         AV_CH_SIDE_RIGHT,
  57         AV_CH_BACK_LEFT,
  58         AV_CH_BACK_CENTER,
  59         AV_CH_BACK_RIGHT,
  60         AV_CH_LOW_FREQUENCY,
  61         0
  62     }
  63 };
  64
  65 // source: https://developer.apple.com/library/mac/#documentation/musicaudio/reference/CoreAudioDataTypesRef/Reference/reference.html
  66 hb_chan_map_t hb_aac_chan_map =
  67 {
  68     {
  69         AV_CH_FRONT_CENTER,
  70         AV_CH_FRONT_LEFT_OF_CENTER,
  71         AV_CH_FRONT_RIGHT_OF_CENTER,
  72         AV_CH_FRONT_LEFT,
  73         AV_CH_FRONT_RIGHT,
  74         AV_CH_SIDE_LEFT,
  75         AV_CH_SIDE_RIGHT,
  76         AV_CH_BACK_LEFT,
  77         AV_CH_BACK_RIGHT,
  78         AV_CH_BACK_CENTER,
  79         AV_CH_LOW_FREQUENCY,
  80         0
  81     }
  82 };
  83
  84 static void remap_planar(uint8_t **samples, int nsamples,
  85                          int nchannels, int *remap_table)
  86 {
  87     int ii;
  88     uint8_t *tmp_buf[HB_AUDIO_REMAP_MAX_CHANNELS];
  89     memcpy(tmp_buf, samples, nchannels * sizeof(uint8_t*));
  90     for (ii = 0; ii < nchannels; ii++)
  91     {
  92         samples[ii] = tmp_buf[remap_table[ii]];
  93     }
  94 }
  95
  96 static void remap_u8_interleaved(uint8_t **samples, int nsamples,
  97                                  int nchannels, int *remap_table)
  98 {
  99     int ii, jj;
 100     uint8_t *samples_u8 = (*samples);
 101     uint8_t tmp_buf[HB_AUDIO_REMAP_MAX_CHANNELS];
 102     for (ii = 0; ii < nsamples; ii++)
 103     {
 104         memcpy(tmp_buf, samples_u8, nchannels * sizeof(uint8_t));
 105         for (jj = 0; jj < nchannels; jj++)
 106         {
 107             samples_u8[jj] = tmp_buf[remap_table[jj]];
 108         }
 109         samples_u8 += nchannels;
 110     }
 111 }
 112
 113 static void remap_s16_interleaved(uint8_t **samples, int nsamples,
 114                                   int nchannels, int *remap_table)
 115 {
 116     int ii, jj;
 117     int16_t *samples_s16 = (int16_t*)(*samples);
 118     int16_t tmp_buf[HB_AUDIO_REMAP_MAX_CHANNELS];
 119     for (ii = 0; ii < nsamples; ii++)
 120     {
 121         memcpy(tmp_buf, samples_s16, nchannels * sizeof(int16_t));
 122         for (jj = 0; jj < nchannels; jj++)
 123         {
 124             samples_s16[jj] = tmp_buf[remap_table[jj]];
 125         }
 126         samples_s16 += nchannels;
 127     }
 128 }
 129
 130 static void remap_s32_interleaved(uint8_t **samples, int nsamples,
 131                                   int nchannels, int *remap_table)
 132 {
 133     int ii, jj;
 134     int32_t *samples_s32 = (int32_t*)(*samples);
 135     int32_t tmp_buf[HB_AUDIO_REMAP_MAX_CHANNELS];
 136     for (ii = 0; ii < nsamples; ii++)
 137     {
 138         memcpy(tmp_buf, samples_s32, nchannels * sizeof(int32_t));
 139         for (jj = 0; jj < nchannels; jj++)
 140         {
 141             samples_s32[jj] = tmp_buf[remap_table[jj]];
 142         }
 143         samples_s32 += nchannels;
 144     }
 145 }
 146
 147 static void remap_flt_interleaved(uint8_t **samples, int nsamples,
 148                                   int nchannels, int *remap_table)
 149 {
 150     int ii, jj;
 151     float *samples_flt = (float*)(*samples);
 152     float tmp_buf[HB_AUDIO_REMAP_MAX_CHANNELS];
 153     for (ii = 0; ii < nsamples; ii++)
 154     {
 155         memcpy(tmp_buf, samples_flt, nchannels * sizeof(float));
 156         for (jj = 0; jj < nchannels; jj++)
 157         {
 158             samples_flt[jj] = tmp_buf[remap_table[jj]];
 159         }
 160         samples_flt += nchannels;
 161     }
 162 }
 163
 164 static void remap_dbl_interleaved(uint8_t **samples, int nsamples,
 165                                   int nchannels, int *remap_table)
 166 {
 167     int ii, jj;
 168     double *samples_dbl = (double*)(*samples);
 169     double tmp_buf[HB_AUDIO_REMAP_MAX_CHANNELS];
 170     for (ii = 0; ii < nsamples; ii++)
 171     {
 172         memcpy(tmp_buf, samples_dbl, nchannels * sizeof(double));
 173         for (jj = 0; jj < nchannels; jj++)
 174         {
 175             samples_dbl[jj] = tmp_buf[remap_table[jj]];
 176         }
 177         samples_dbl += nchannels;
 178     }
 179 }
 180
 181 hb_audio_remap_t* hb_audio_remap_init(enum AVSampleFormat sample_fmt,
 182                                       hb_chan_map_t *channel_map_out,
 183                                       hb_chan_map_t *channel_map_in)
 184 {
 185     hb_audio_remap_t *remap = calloc(1, sizeof(hb_audio_remap_t));
 186     if (remap == NULL)
 187     {
 188         hb_error("hb_audio_remap_init: failed to allocate remap");
 189         goto fail;
 190     }
 191
 192     // sample format
 193     switch (sample_fmt)
 194     {
 195         case AV_SAMPLE_FMT_U8P:
 196         case AV_SAMPLE_FMT_S16P:
 197         case AV_SAMPLE_FMT_S32P:
 198         case AV_SAMPLE_FMT_FLTP:
 199         case AV_SAMPLE_FMT_DBLP:
 200             remap->remap = &remap_planar;
 201             break;
 202
 203         case AV_SAMPLE_FMT_U8:
 204             remap->remap = &remap_u8_interleaved;
 205             break;
 206
 207         case AV_SAMPLE_FMT_S16:
 208             remap->remap = &remap_s16_interleaved;
 209             break;
 210
 211         case AV_SAMPLE_FMT_S32:
 212             remap->remap = &remap_s32_interleaved;
 213             break;
 214
 215         case AV_SAMPLE_FMT_FLT:
 216             remap->remap = &remap_flt_interleaved;
 217             break;
 218
 219         case AV_SAMPLE_FMT_DBL:
 220             remap->remap = &remap_dbl_interleaved;
 221             break;
 222
 223         default:
 224             hb_error("hb_audio_remap_init: unsupported sample format '%s'",
 225                      av_get_sample_fmt_name(sample_fmt));
 226             goto fail;
 227     }
 228
 229     // input/output channel order
 230     if (channel_map_in == NULL || channel_map_out == NULL)
 231     {
 232         hb_error("hb_audio_remap_init: invalid channel map(s)");
 233         goto fail;
 234     }
 235     remap->channel_map_in  = channel_map_in;
 236     remap->channel_map_out = channel_map_out;
 237
 238     // remap can't be done until the channel layout has been set
 239     remap->remap_needed = 0;
 240
 241     return remap;
 242
 243 fail:
 244     hb_audio_remap_free(remap);
 245     return NULL;
 246 }
 247
 248 void hb_audio_remap_set_channel_layout(hb_audio_remap_t *remap,
 249                                        uint64_t channel_layout)
 250 {
 251     if (remap != NULL)
 252     {
 253         int ii;
 254         remap->remap_needed = 0;
 255
 256         // sanitize the layout
 257         if (channel_layout == AV_CH_LAYOUT_STEREO_DOWNMIX)
 258         {
 259             channel_layout = AV_CH_LAYOUT_STEREO;
 260         }
 261         remap->nchannels = av_get_channel_layout_nb_channels(channel_layout);
 262
 263         // in some cases, remapping is not necessary and/or supported
 264         if (remap->nchannels > HB_AUDIO_REMAP_MAX_CHANNELS)
 265         {
 266             hb_log("hb_audio_remap_set_channel_layout: too many channels (%d)",
 267                    remap->nchannels);
 268             return;
 269         }
 270         if (remap->channel_map_in == remap->channel_map_out)
 271         {
 272             return;
 273         }
 274
 275         // build the table and check whether remapping is necessary
 276         hb_audio_remap_build_table(remap->channel_map_out,
 277                                    remap->channel_map_in, channel_layout,
 278                                    remap->table);
 279         for (ii = 0; ii < remap->nchannels; ii++)
 280         {
 281             if (remap->table[ii] != ii)
 282             {
 283                 remap->remap_needed = 1;
 284                 break;
 285             }
 286         }
 287     }
 288 }
 289
 290
 291 void hb_audio_remap_free(hb_audio_remap_t *remap)
 292 {
 293     if (remap != NULL)
 294     {
 295         free(remap);
 296     }
 297 }
 298
 299 void hb_audio_remap(hb_audio_remap_t *remap, uint8_t **samples, int nsamples)
 300 {
 301     if (remap != NULL && remap->remap_needed)
 302     {
 303         remap->remap(samples, nsamples, remap->nchannels, remap->table);
 304     }
 305 }
 306
 307 void hb_audio_remap_build_table(hb_chan_map_t *channel_map_out,
 308                                 hb_chan_map_t *channel_map_in,
 309                                 uint64_t channel_layout,
 310                                 int *remap_table)
 311 {
 312     int ii, jj, nchannels, out_chan_idx, remap_idx;
 313     uint64_t *channels_in, *channels_out;
 314
 315     if (channel_layout == AV_CH_LAYOUT_STEREO_DOWNMIX)
 316     {
 317         // Dolby Surround is Stereo when it comes to remapping
 318         channel_layout = AV_CH_LAYOUT_STEREO;
 319     }
 320     nchannels = av_get_channel_layout_nb_channels(channel_layout);
 321
 322     // clear remap table before (re-)building it
 323     memset(remap_table, 0, nchannels * sizeof(int));
 324
 325     out_chan_idx = 0;
 326     channels_in  = channel_map_in ->channel_order_map;
 327     channels_out = channel_map_out->channel_order_map;
 328     for (ii = 0; channels_out[ii] && out_chan_idx < nchannels; ii++)
 329     {
 330         if (channel_layout & channels_out[ii])
 331         {
 332             remap_idx = 0;
 333             for (jj = 0; channels_in[jj] && remap_idx < nchannels; jj++)
 334             {
 335                 if (channels_out[ii] == channels_in[jj])
 336                 {
 337                     remap_table[out_chan_idx++] = remap_idx++;
 338                     break;
 339                 }
 340                 else if (channel_layout & channels_in[jj])
 341                 {
 342                     remap_idx++;
 343                 }
 344             }
 345         }
 346     }
 347 }