← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gst-libav1.0/trusty-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/aacsbr.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-09-24 17:07:00 UTC
  • mfrom: (1.1.17) (7.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20130924170700-4dg62s3pwl0pdakz
Tags: 1.2.0-1
* New upstream stable release:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/libavcodec/aacsbr.c
32
32
#include "aacsbrdata.h"
33
33
#include "fft.h"
34
34
#include "aacps.h"
 
35
#include "sbrdsp.h"
35
36
#include "libavutil/libm.h"
36
37
 
37
38
#include <stdint.h>
73
74
static VLC vlc_sbr[10];
74
75
static const int8_t vlc_sbr_lav[10] =
75
76
    { 60, 60, 24, 24, 31, 31, 12, 12, 31, 12 };
76
 
static const DECLARE_ALIGNED(16, float, zero64)[64];
77
77
 
78
78
#define SBR_INIT_VLC_STATIC(num, size) \
79
79
    INIT_VLC_STATIC(&vlc_sbr[num], 9, sbr_tmp[num].table_size / sbr_tmp[num].elem_size,     \
126
126
    ff_ps_init();
127
127
}
128
128
 
 
129
/** Places SBR in pure upsampling mode. */
 
130
static void sbr_turnoff(SpectralBandReplication *sbr) {
 
131
    sbr->start = 0;
 
132
    // Init defults used in pure upsampling mode
 
133
    sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
 
134
    sbr->m[1] = 0;
 
135
    // Reset values for first SBR header
 
136
    sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
 
137
    memset(&sbr->spectrum_params, -1, sizeof(SpectrumParameters));
 
138
}
 
139
 
129
140
av_cold void ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr)
130
141
{
131
 
    float mdct_scale;
132
 
    sbr->kx[0] = sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
133
 
    sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
 
142
    sbr->kx[0] = sbr->kx[1];
 
143
    sbr_turnoff(sbr);
134
144
    sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
135
145
    sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
136
146
    /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
137
147
     * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
138
148
     * and scale back down at synthesis. */
139
 
    mdct_scale = ac->avctx->sample_fmt == AV_SAMPLE_FMT_FLT ? 32768.0f : 1.0f;
140
 
    ff_mdct_init(&sbr->mdct,     7, 1, 1.0 / (64 * mdct_scale));
141
 
    ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * mdct_scale);
 
149
    ff_mdct_init(&sbr->mdct,     7, 1, 1.0 / (64 * 32768.0));
 
150
    ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * 32768.0);
142
151
    ff_ps_ctx_init(&sbr->ps);
 
152
    ff_sbrdsp_init(&sbr->dsp);
143
153
}
144
154
 
145
155
av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
901
911
{
902
912
    switch (bs_extension_id) {
903
913
    case EXTENSION_ID_PS:
904
 
        if (!ac->m4ac.ps) {
 
914
        if (!ac->oc[1].m4ac.ps) {
905
915
            av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
906
916
            skip_bits_long(gb, *num_bits_left); // bs_fill_bits
907
917
            *num_bits_left = 0;
909
919
#if 1
910
920
            *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps, *num_bits_left);
911
921
#else
912
 
            av_log_missing_feature(ac->avctx, "Parametric Stereo is", 0);
 
922
            av_log_missing_feature(ac->avctx, "Parametric Stereo", 0);
913
923
            skip_bits_long(gb, *num_bits_left); // bs_fill_bits
914
924
            *num_bits_left = 0;
915
925
#endif
916
926
        }
917
927
        break;
918
928
    default:
919
 
        av_log_missing_feature(ac->avctx, "Reserved SBR extensions are", 1);
 
929
        av_log_missing_feature(ac->avctx, "Reserved SBR extensions", 1);
920
930
        skip_bits_long(gb, *num_bits_left); // bs_fill_bits
921
931
        *num_bits_left = 0;
922
932
        break;
992
1002
 
993
1003
    if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
994
1004
        if (read_sbr_single_channel_element(ac, sbr, gb)) {
995
 
            sbr->start = 0;
 
1005
            sbr_turnoff(sbr);
996
1006
            return get_bits_count(gb) - cnt;
997
1007
        }
998
1008
    } else if (id_aac == TYPE_CPE) {
999
1009
        if (read_sbr_channel_pair_element(ac, sbr, gb)) {
1000
 
            sbr->start = 0;
 
1010
            sbr_turnoff(sbr);
1001
1011
            return get_bits_count(gb) - cnt;
1002
1012
        }
1003
1013
    } else {
1004
1014
        av_log(ac->avctx, AV_LOG_ERROR,
1005
1015
            "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1006
 
        sbr->start = 0;
 
1016
        sbr_turnoff(sbr);
1007
1017
        return get_bits_count(gb) - cnt;
1008
1018
    }
1009
1019
    if (get_bits1(gb)) { // bs_extended_data
1035
1045
    if (err < 0) {
1036
1046
        av_log(ac->avctx, AV_LOG_ERROR,
1037
1047
               "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1038
 
        sbr->start = 0;
 
1048
        sbr_turnoff(sbr);
1039
1049
    }
1040
1050
}
1041
1051
 
1058
1068
    sbr->reset = 0;
1059
1069
 
1060
1070
    if (!sbr->sample_rate)
1061
 
        sbr->sample_rate = 2 * ac->m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
1062
 
    if (!ac->m4ac.ext_sample_rate)
1063
 
        ac->m4ac.ext_sample_rate = 2 * ac->m4ac.sample_rate;
 
1071
        sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
 
1072
    if (!ac->oc[1].m4ac.ext_sample_rate)
 
1073
        ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1064
1074
 
1065
1075
    if (crc) {
1066
1076
        skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check
1070
1080
    //Save some state from the previous frame.
1071
1081
    sbr->kx[0] = sbr->kx[1];
1072
1082
    sbr->m[0] = sbr->m[1];
 
1083
    sbr->kx_and_m_pushed = 1;
1073
1084
 
1074
1085
    num_sbr_bits++;
1075
1086
    if (get_bits1(gb)) // bs_header_flag
1139
1150
 * @param   x       pointer to the beginning of the first sample window
1140
1151
 * @param   W       array of complex-valued samples split into subbands
1141
1152
 */
1142
 
static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in, float *x,
1143
 
                             float z[320], float W[2][32][32][2])
 
1153
static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct,
 
1154
                             SBRDSPContext *sbrdsp, const float *in, float *x,
 
1155
                             float z[320], float W[2][32][32][2], int buf_idx)
1144
1156
{
1145
 
    int i, k;
1146
 
    memcpy(W[0], W[1], sizeof(W[0]));
 
1157
    int i;
1147
1158
    memcpy(x    , x+1024, (320-32)*sizeof(x[0]));
1148
1159
    memcpy(x+288, in,         1024*sizeof(x[0]));
1149
1160
    for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
1150
1161
                               // are not supported
1151
1162
        dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
1152
 
        for (k = 0; k < 64; k++) {
1153
 
            float f = z[k] + z[k + 64] + z[k + 128] + z[k + 192] + z[k + 256];
1154
 
            z[k] = f;
1155
 
        }
1156
 
        //Shuffle to IMDCT
1157
 
        z[64] = z[0];
1158
 
        for (k = 1; k < 32; k++) {
1159
 
            z[64+2*k-1] =  z[   k];
1160
 
            z[64+2*k  ] = -z[64-k];
1161
 
        }
1162
 
        z[64+63] = z[32];
1163
 
 
 
1163
        sbrdsp->sum64x5(z);
 
1164
        sbrdsp->qmf_pre_shuffle(z);
1164
1165
        mdct->imdct_half(mdct, z, z+64);
1165
 
        for (k = 0; k < 32; k++) {
1166
 
            W[1][i][k][0] = -z[63-k];
1167
 
            W[1][i][k][1] = z[k];
1168
 
        }
 
1166
        sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
1169
1167
        x += 32;
1170
1168
    }
1171
1169
}
1175
1173
 * (14496-3 sp04 p206)
1176
1174
 */
1177
1175
static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
 
1176
                              SBRDSPContext *sbrdsp, AVFloatDSPContext *fdsp,
1178
1177
                              float *out, float X[2][38][64],
1179
1178
                              float mdct_buf[2][64],
1180
1179
                              float *v0, int *v_off, const unsigned int div)
1198
1197
                X[0][i][32+n] =  X[1][i][31-n];
1199
1198
            }
1200
1199
            mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
1201
 
            for (n = 0; n < 32; n++) {
1202
 
                v[     n] =  mdct_buf[0][63 - 2*n];
1203
 
                v[63 - n] = -mdct_buf[0][62 - 2*n];
1204
 
            }
 
1200
            sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1205
1201
        } else {
1206
 
            for (n = 1; n < 64; n+=2) {
1207
 
                X[1][i][n] = -X[1][i][n];
1208
 
            }
 
1202
            sbrdsp->neg_odd_64(X[1][i]);
1209
1203
            mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
1210
1204
            mdct->imdct_half(mdct, mdct_buf[1], X[1][i]);
1211
 
            for (n = 0; n < 64; n++) {
1212
 
                v[      n] = -mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
1213
 
                v[127 - n] =  mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
1214
 
            }
 
1205
            sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1215
1206
        }
1216
 
        dsp->vector_fmul_add(out, v                , sbr_qmf_window               , zero64, 64 >> div);
 
1207
        fdsp->vector_fmul   (out, v                , sbr_qmf_window                       , 64 >> div);
1217
1208
        dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out   , 64 >> div);
1218
1209
        dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out   , 64 >> div);
1219
1210
        dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out   , 64 >> div);
1227
1218
    }
1228
1219
}
1229
1220
 
1230
 
static void autocorrelate(const float x[40][2], float phi[3][2][2], int lag)
1231
 
{
1232
 
    int i;
1233
 
    float real_sum = 0.0f;
1234
 
    float imag_sum = 0.0f;
1235
 
    if (lag) {
1236
 
        for (i = 1; i < 38; i++) {
1237
 
            real_sum += x[i][0] * x[i+lag][0] + x[i][1] * x[i+lag][1];
1238
 
            imag_sum += x[i][0] * x[i+lag][1] - x[i][1] * x[i+lag][0];
1239
 
        }
1240
 
        phi[2-lag][1][0] = real_sum + x[ 0][0] * x[lag][0] + x[ 0][1] * x[lag][1];
1241
 
        phi[2-lag][1][1] = imag_sum + x[ 0][0] * x[lag][1] - x[ 0][1] * x[lag][0];
1242
 
        if (lag == 1) {
1243
 
            phi[0][0][0] = real_sum + x[38][0] * x[39][0] + x[38][1] * x[39][1];
1244
 
            phi[0][0][1] = imag_sum + x[38][0] * x[39][1] - x[38][1] * x[39][0];
1245
 
        }
1246
 
    } else {
1247
 
        for (i = 1; i < 38; i++) {
1248
 
            real_sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
1249
 
        }
1250
 
        phi[2][1][0] = real_sum + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
1251
 
        phi[1][0][0] = real_sum + x[38][0] * x[38][0] + x[38][1] * x[38][1];
1252
 
    }
1253
 
}
1254
 
 
1255
1221
/** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
1256
1222
 * (14496-3 sp04 p214)
1257
1223
 * Warning: This routine does not seem numerically stable.
1258
1224
 */
1259
 
static void sbr_hf_inverse_filter(float (*alpha0)[2], float (*alpha1)[2],
 
1225
static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
 
1226
                                  float (*alpha0)[2], float (*alpha1)[2],
1260
1227
                                  const float X_low[32][40][2], int k0)
1261
1228
{
1262
1229
    int k;
1263
1230
    for (k = 0; k < k0; k++) {
1264
 
        float phi[3][2][2], dk;
 
1231
        LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
 
1232
        float dk;
1265
1233
 
1266
 
        autocorrelate(X_low[k], phi, 0);
1267
 
        autocorrelate(X_low[k], phi, 1);
1268
 
        autocorrelate(X_low[k], phi, 2);
 
1234
        dsp->autocorrelate(X_low[k], phi);
1269
1235
 
1270
1236
        dk =  phi[2][1][0] * phi[1][0][0] -
1271
1237
             (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
1333
1299
 
1334
1300
/// Generate the subband filtered lowband
1335
1301
static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr,
1336
 
                      float X_low[32][40][2], const float W[2][32][32][2])
 
1302
                      float X_low[32][40][2], const float W[2][32][32][2],
 
1303
                      int buf_idx)
1337
1304
{
1338
1305
    int i, k;
1339
1306
    const int t_HFGen = 8;
1341
1308
    memset(X_low, 0, 32*sizeof(*X_low));
1342
1309
    for (k = 0; k < sbr->kx[1]; k++) {
1343
1310
        for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1344
 
            X_low[k][i][0] = W[1][i - t_HFGen][k][0];
1345
 
            X_low[k][i][1] = W[1][i - t_HFGen][k][1];
 
1311
            X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0];
 
1312
            X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1];
1346
1313
        }
1347
1314
    }
 
1315
    buf_idx = 1-buf_idx;
1348
1316
    for (k = 0; k < sbr->kx[0]; k++) {
1349
1317
        for (i = 0; i < t_HFGen; i++) {
1350
 
            X_low[k][i][0] = W[0][i + i_f - t_HFGen][k][0];
1351
 
            X_low[k][i][1] = W[0][i + i_f - t_HFGen][k][1];
 
1318
            X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
 
1319
            X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
1352
1320
        }
1353
1321
    }
1354
1322
    return 0;
1361
1329
                      const float bw_array[5], const uint8_t *t_env,
1362
1330
                      int bs_num_env)
1363
1331
{
1364
 
    int i, j, x;
 
1332
    int j, x;
1365
1333
    int g = 0;
1366
1334
    int k = sbr->kx[1];
1367
1335
    for (j = 0; j < sbr->num_patches; j++) {
1368
1336
        for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
1369
 
            float alpha[4];
1370
1337
            const int p = sbr->patch_start_subband[j] + x;
1371
1338
            while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
1372
1339
                g++;
1378
1345
                return -1;
1379
1346
            }
1380
1347
 
1381
 
            alpha[0] = alpha1[p][0] * bw_array[g] * bw_array[g];
1382
 
            alpha[1] = alpha1[p][1] * bw_array[g] * bw_array[g];
1383
 
            alpha[2] = alpha0[p][0] * bw_array[g];
1384
 
            alpha[3] = alpha0[p][1] * bw_array[g];
1385
 
 
1386
 
            for (i = 2 * t_env[0]; i < 2 * t_env[bs_num_env]; i++) {
1387
 
                const int idx = i + ENVELOPE_ADJUSTMENT_OFFSET;
1388
 
                X_high[k][idx][0] =
1389
 
                    X_low[p][idx - 2][0] * alpha[0] -
1390
 
                    X_low[p][idx - 2][1] * alpha[1] +
1391
 
                    X_low[p][idx - 1][0] * alpha[2] -
1392
 
                    X_low[p][idx - 1][1] * alpha[3] +
1393
 
                    X_low[p][idx][0];
1394
 
                X_high[k][idx][1] =
1395
 
                    X_low[p][idx - 2][1] * alpha[0] +
1396
 
                    X_low[p][idx - 2][0] * alpha[1] +
1397
 
                    X_low[p][idx - 1][1] * alpha[2] +
1398
 
                    X_low[p][idx - 1][0] * alpha[3] +
1399
 
                    X_low[p][idx][1];
1400
 
            }
 
1348
            sbr->dsp.hf_gen(X_high[k] + ENVELOPE_ADJUSTMENT_OFFSET,
 
1349
                            X_low[p]  + ENVELOPE_ADJUSTMENT_OFFSET,
 
1350
                            alpha0[p], alpha1[p], bw_array[g],
 
1351
                            2 * t_env[0], 2 * t_env[bs_num_env]);
1401
1352
        }
1402
1353
    }
1403
1354
    if (k < sbr->m[1] + sbr->kx[1])
1408
1359
 
1409
1360
/// Generate the subband filtered lowband
1410
1361
static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][38][64],
1411
 
                     const float X_low[32][40][2], const float Y[2][38][64][2],
1412
 
                     int ch)
 
1362
                     const float Y0[38][64][2], const float Y1[38][64][2],
 
1363
                     const float X_low[32][40][2], int ch)
1413
1364
{
1414
1365
    int k, i;
1415
1366
    const int i_f = 32;
1423
1374
    }
1424
1375
    for (; k < sbr->kx[0] + sbr->m[0]; k++) {
1425
1376
        for (i = 0; i < i_Temp; i++) {
1426
 
            X[0][i][k] = Y[0][i + i_f][k][0];
1427
 
            X[1][i][k] = Y[0][i + i_f][k][1];
 
1377
            X[0][i][k] = Y0[i + i_f][k][0];
 
1378
            X[1][i][k] = Y0[i + i_f][k][1];
1428
1379
        }
1429
1380
    }
1430
1381
 
1436
1387
    }
1437
1388
    for (; k < sbr->kx[1] + sbr->m[1]; k++) {
1438
1389
        for (i = i_Temp; i < i_f; i++) {
1439
 
            X[0][i][k] = Y[1][i][k][0];
1440
 
            X[1][i][k] = Y[1][i][k][1];
 
1390
            X[0][i][k] = Y1[i][k][0];
 
1391
            X[1][i][k] = Y1[i][k][1];
1441
1392
        }
1442
1393
    }
1443
1394
    return 0;
1446
1397
/** High Frequency Adjustment (14496-3 sp04 p217) and Mapping
1447
1398
 * (14496-3 sp04 p217)
1448
1399
 */
1449
 
static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
 
1400
static int sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
1450
1401
                        SBRData *ch_data, int e_a[2])
1451
1402
{
1452
1403
    int e, i, m;
1457
1408
        uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1458
1409
        int k;
1459
1410
 
 
1411
        if (sbr->kx[1] != table[0]) {
 
1412
            av_log(ac->avctx, AV_LOG_ERROR, "kx != f_table{high,low}[0]. "
 
1413
                   "Derived frequency tables were not regenerated.\n");
 
1414
            sbr_turnoff(sbr);
 
1415
            return AVERROR_BUG;
 
1416
        }
1460
1417
        for (i = 0; i < ilim; i++)
1461
1418
            for (m = table[i]; m < table[i + 1]; m++)
1462
1419
                sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
1491
1448
    }
1492
1449
 
1493
1450
    memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
 
1451
    return 0;
1494
1452
}
1495
1453
 
1496
1454
/// Estimation of current envelope (14496-3 sp04 p218)
1497
1455
static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
1498
1456
                             SpectralBandReplication *sbr, SBRData *ch_data)
1499
1457
{
1500
 
    int e, i, m;
 
1458
    int e, m;
 
1459
    int kx1 = sbr->kx[1];
1501
1460
 
1502
1461
    if (sbr->bs_interpol_freq) {
1503
1462
        for (e = 0; e < ch_data->bs_num_env; e++) {
1506
1465
            int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1507
1466
 
1508
1467
            for (m = 0; m < sbr->m[1]; m++) {
1509
 
                float sum = 0.0f;
1510
 
 
1511
 
                for (i = ilb; i < iub; i++) {
1512
 
                    sum += X_high[m + sbr->kx[1]][i][0] * X_high[m + sbr->kx[1]][i][0] +
1513
 
                           X_high[m + sbr->kx[1]][i][1] * X_high[m + sbr->kx[1]][i][1];
1514
 
                }
 
1468
                float sum = sbr->dsp.sum_square(X_high[m+kx1] + ilb, iub - ilb);
1515
1469
                e_curr[e][m] = sum * recip_env_size;
1516
1470
            }
1517
1471
        }
1529
1483
                const int den = env_size * (table[p + 1] - table[p]);
1530
1484
 
1531
1485
                for (k = table[p]; k < table[p + 1]; k++) {
1532
 
                    for (i = ilb; i < iub; i++) {
1533
 
                        sum += X_high[k][i][0] * X_high[k][i][0] +
1534
 
                               X_high[k][i][1] * X_high[k][i][1];
1535
 
                    }
 
1486
                    sum += sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb);
1536
1487
                }
1537
1488
                sum /= den;
1538
1489
                for (k = table[p]; k < table[p + 1]; k++) {
1539
 
                    e_curr[e][k - sbr->kx[1]] = sum;
 
1490
                    e_curr[e][k - kx1] = sum;
1540
1491
                }
1541
1492
            }
1542
1493
        }
1603
1554
}
1604
1555
 
1605
1556
/// Assembling HF Signals (14496-3 sp04 p220)
1606
 
static void sbr_hf_assemble(float Y[2][38][64][2], const float X_high[64][40][2],
 
1557
static void sbr_hf_assemble(float Y1[38][64][2],
 
1558
                            const float X_high[64][40][2],
1607
1559
                            SpectralBandReplication *sbr, SBRData *ch_data,
1608
1560
                            const int e_a[2])
1609
1561
{
1625
1577
    float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
1626
1578
    int indexnoise = ch_data->f_indexnoise;
1627
1579
    int indexsine  = ch_data->f_indexsine;
1628
 
    memcpy(Y[0], Y[1], sizeof(Y[0]));
1629
1580
 
1630
1581
    if (sbr->reset) {
1631
1582
        for (i = 0; i < h_SL; i++) {
1647
1598
    for (e = 0; e < ch_data->bs_num_env; e++) {
1648
1599
        for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
1649
1600
            int phi_sign = (1 - 2*(kx & 1));
 
1601
            LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
 
1602
            LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
 
1603
            float *g_filt, *q_filt;
1650
1604
 
1651
1605
            if (h_SL && e != e_a[0] && e != e_a[1]) {
 
1606
                g_filt = g_filt_tab;
 
1607
                q_filt = q_filt_tab;
1652
1608
                for (m = 0; m < m_max; m++) {
1653
1609
                    const int idx1 = i + h_SL;
1654
 
                    float g_filt = 0.0f;
1655
 
                    for (j = 0; j <= h_SL; j++)
1656
 
                        g_filt += g_temp[idx1 - j][m] * h_smooth[j];
1657
 
                    Y[1][i][m + kx][0] =
1658
 
                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
1659
 
                    Y[1][i][m + kx][1] =
1660
 
                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
 
1610
                    g_filt[m] = 0.0f;
 
1611
                    q_filt[m] = 0.0f;
 
1612
                    for (j = 0; j <= h_SL; j++) {
 
1613
                        g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
 
1614
                        q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
 
1615
                    }
1661
1616
                }
1662
1617
            } else {
1663
 
                for (m = 0; m < m_max; m++) {
1664
 
                    const float g_filt = g_temp[i + h_SL][m];
1665
 
                    Y[1][i][m + kx][0] =
1666
 
                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
1667
 
                    Y[1][i][m + kx][1] =
1668
 
                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
1669
 
                }
 
1618
                g_filt = g_temp[i + h_SL];
 
1619
                q_filt = q_temp[i];
1670
1620
            }
1671
1621
 
 
1622
            sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
 
1623
                               i + ENVELOPE_ADJUSTMENT_OFFSET);
 
1624
 
1672
1625
            if (e != e_a[0] && e != e_a[1]) {
1673
 
                for (m = 0; m < m_max; m++) {
1674
 
                    indexnoise = (indexnoise + 1) & 0x1ff;
1675
 
                    if (sbr->s_m[e][m]) {
1676
 
                        Y[1][i][m + kx][0] +=
1677
 
                            sbr->s_m[e][m] * phi[0][indexsine];
1678
 
                        Y[1][i][m + kx][1] +=
1679
 
                            sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1680
 
                    } else {
1681
 
                        float q_filt;
1682
 
                        if (h_SL) {
1683
 
                            const int idx1 = i + h_SL;
1684
 
                            q_filt = 0.0f;
1685
 
                            for (j = 0; j <= h_SL; j++)
1686
 
                                q_filt += q_temp[idx1 - j][m] * h_smooth[j];
1687
 
                        } else {
1688
 
                            q_filt = q_temp[i][m];
1689
 
                        }
1690
 
                        Y[1][i][m + kx][0] +=
1691
 
                            q_filt * sbr_noise_table[indexnoise][0];
1692
 
                        Y[1][i][m + kx][1] +=
1693
 
                            q_filt * sbr_noise_table[indexnoise][1];
1694
 
                    }
1695
 
                    phi_sign = -phi_sign;
1696
 
                }
 
1626
                sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
 
1627
                                                   q_filt, indexnoise,
 
1628
                                                   kx, m_max);
1697
1629
            } else {
1698
 
                indexnoise = (indexnoise + m_max) & 0x1ff;
1699
1630
                for (m = 0; m < m_max; m++) {
1700
 
                    Y[1][i][m + kx][0] +=
 
1631
                    Y1[i][m + kx][0] +=
1701
1632
                        sbr->s_m[e][m] * phi[0][indexsine];
1702
 
                    Y[1][i][m + kx][1] +=
 
1633
                    Y1[i][m + kx][1] +=
1703
1634
                        sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1704
1635
                    phi_sign = -phi_sign;
1705
1636
                }
1706
1637
            }
 
1638
            indexnoise = (indexnoise + m_max) & 0x1ff;
1707
1639
            indexsine = (indexsine + 1) & 3;
1708
1640
        }
1709
1641
    }
1714
1646
void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
1715
1647
                  float* L, float* R)
1716
1648
{
1717
 
    int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
 
1649
    int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1718
1650
    int ch;
1719
1651
    int nch = (id_aac == TYPE_CPE) ? 2 : 1;
 
1652
    int err;
 
1653
 
 
1654
    if (!sbr->kx_and_m_pushed) {
 
1655
        sbr->kx[0] = sbr->kx[1];
 
1656
        sbr->m[0] = sbr->m[1];
 
1657
    } else {
 
1658
        sbr->kx_and_m_pushed = 0;
 
1659
    }
1720
1660
 
1721
1661
    if (sbr->start) {
1722
1662
        sbr_dequant(sbr, id_aac);
1723
1663
    }
1724
1664
    for (ch = 0; ch < nch; ch++) {
1725
1665
        /* decode channel */
1726
 
        sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
 
1666
        sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, &sbr->dsp, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
1727
1667
                         (float*)sbr->qmf_filter_scratch,
1728
 
                         sbr->data[ch].W);
1729
 
        sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
 
1668
                         sbr->data[ch].W, sbr->data[ch].Ypos);
 
1669
        sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W, sbr->data[ch].Ypos);
 
1670
        sbr->data[ch].Ypos ^= 1;
1730
1671
        if (sbr->start) {
1731
 
            sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
 
1672
            sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
1732
1673
            sbr_chirp(sbr, &sbr->data[ch]);
1733
1674
            sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
1734
1675
                       sbr->data[ch].bw_array, sbr->data[ch].t_env,
1735
1676
                       sbr->data[ch].bs_num_env);
1736
1677
 
1737
1678
            // hf_adj
1738
 
            sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1739
 
            sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
1740
 
            sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1741
 
            sbr_hf_assemble(sbr->data[ch].Y, sbr->X_high, sbr, &sbr->data[ch],
1742
 
                            sbr->data[ch].e_a);
 
1679
            err = sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
 
1680
            if (!err) {
 
1681
                sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
 
1682
                sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
 
1683
                sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
 
1684
                                sbr->X_high, sbr, &sbr->data[ch],
 
1685
                                sbr->data[ch].e_a);
 
1686
            }
1743
1687
        }
1744
1688
 
1745
1689
        /* synthesis */
1746
 
        sbr_x_gen(sbr, sbr->X[ch], sbr->X_low, sbr->data[ch].Y, ch);
 
1690
        sbr_x_gen(sbr, sbr->X[ch],
 
1691
                  sbr->data[ch].Y[1-sbr->data[ch].Ypos],
 
1692
                  sbr->data[ch].Y[  sbr->data[ch].Ypos],
 
1693
                  sbr->X_low, ch);
1747
1694
    }
1748
1695
 
1749
 
    if (ac->m4ac.ps == 1) {
 
1696
    if (ac->oc[1].m4ac.ps == 1) {
1750
1697
        if (sbr->ps.start) {
1751
1698
            ff_ps_apply(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
1752
1699
        } else {
1755
1702
        nch = 2;
1756
1703
    }
1757
1704
 
1758
 
    sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X[0], sbr->qmf_filter_scratch,
 
1705
    sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, &sbr->dsp, &ac->fdsp,
 
1706
                      L, sbr->X[0], sbr->qmf_filter_scratch,
1759
1707
                      sbr->data[0].synthesis_filterbank_samples,
1760
1708
                      &sbr->data[0].synthesis_filterbank_samples_offset,
1761
1709
                      downsampled);
1762
1710
    if (nch == 2)
1763
 
        sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, R, sbr->X[1], sbr->qmf_filter_scratch,
 
1711
        sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, &sbr->dsp, &ac->fdsp,
 
1712
                          R, sbr->X[1], sbr->qmf_filter_scratch,
1764
1713
                          sbr->data[1].synthesis_filterbank_samples,
1765
1714
                          &sbr->data[1].synthesis_filterbank_samples_offset,
1766
1715
                          downsampled);