Statistics
| Branch: | Revision:

ffmpeg / libavcodec / aacenc.c @ e29af818

History | View | Annotate | Download (22.4 KB)

1
/*
2
 * AAC encoder
3
 * Copyright (C) 2008 Konstantin Shishkov
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file
24
 * AAC encoder
25
 */
26

    
27
/***********************************
28
 *              TODOs:
29
 * add sane pulse detection
30
 * add temporal noise shaping
31
 ***********************************/
32

    
33
#include "avcodec.h"
34
#include "put_bits.h"
35
#include "dsputil.h"
36
#include "mpeg4audio.h"
37

    
38
#include "aac.h"
39
#include "aactab.h"
40
#include "aacenc.h"
41

    
42
#include "psymodel.h"
43

    
44
static const uint8_t swb_size_1024_96[] = {
45
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8,
46
    12, 12, 12, 12, 12, 16, 16, 24, 28, 36, 44,
47
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
48
};
49

    
50
static const uint8_t swb_size_1024_64[] = {
51
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8,
52
    12, 12, 12, 16, 16, 16, 20, 24, 24, 28, 36,
53
    40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40
54
};
55

    
56
static const uint8_t swb_size_1024_48[] = {
57
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8,
58
    12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28,
59
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
60
    96
61
};
62

    
63
static const uint8_t swb_size_1024_32[] = {
64
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8,
65
    12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28,
66
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32
67
};
68

    
69
static const uint8_t swb_size_1024_24[] = {
70
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
71
    12, 12, 12, 12, 16, 16, 16, 20, 20, 24, 24, 28, 28,
72
    32, 36, 36, 40, 44, 48, 52, 52, 64, 64, 64, 64, 64
73
};
74

    
75
static const uint8_t swb_size_1024_16[] = {
76
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77
    12, 12, 12, 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24, 24, 28, 28,
78
    32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64, 64
79
};
80

    
81
static const uint8_t swb_size_1024_8[] = {
82
    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
83
    16, 16, 16, 16, 16, 16, 16, 20, 20, 20, 20, 24, 24, 24, 28, 28,
84
    32, 36, 36, 40, 44, 48, 52, 56, 60, 64, 80
85
};
86

    
87
static const uint8_t *swb_size_1024[] = {
88
    swb_size_1024_96, swb_size_1024_96, swb_size_1024_64,
89
    swb_size_1024_48, swb_size_1024_48, swb_size_1024_32,
90
    swb_size_1024_24, swb_size_1024_24, swb_size_1024_16,
91
    swb_size_1024_16, swb_size_1024_16, swb_size_1024_8
92
};
93

    
94
static const uint8_t swb_size_128_96[] = {
95
    4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36
96
};
97

    
98
static const uint8_t swb_size_128_48[] = {
99
    4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16
100
};
101

    
102
static const uint8_t swb_size_128_24[] = {
103
    4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 20
104
};
105

    
106
static const uint8_t swb_size_128_16[] = {
107
    4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20
108
};
109

    
110
static const uint8_t swb_size_128_8[] = {
111
    4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 16, 20, 20
112
};
113

    
114
static const uint8_t *swb_size_128[] = {
115
    /* the last entry on the following row is swb_size_128_64 but is a
116
       duplicate of swb_size_128_96 */
117
    swb_size_128_96, swb_size_128_96, swb_size_128_96,
118
    swb_size_128_48, swb_size_128_48, swb_size_128_48,
119
    swb_size_128_24, swb_size_128_24, swb_size_128_16,
120
    swb_size_128_16, swb_size_128_16, swb_size_128_8
121
};
122

    
123
/** default channel configurations */
124
static const uint8_t aac_chan_configs[6][5] = {
125
 {1, TYPE_SCE},                               // 1 channel  - single channel element
126
 {1, TYPE_CPE},                               // 2 channels - channel pair
127
 {2, TYPE_SCE, TYPE_CPE},                     // 3 channels - center + stereo
128
 {3, TYPE_SCE, TYPE_CPE, TYPE_SCE},           // 4 channels - front center + stereo + back center
129
 {3, TYPE_SCE, TYPE_CPE, TYPE_CPE},           // 5 channels - front center + stereo + back stereo
130
 {4, TYPE_SCE, TYPE_CPE, TYPE_CPE, TYPE_LFE}, // 6 channels - front center + stereo + back stereo + LFE
131
};
132

    
133
/**
134
 * Make AAC audio config object.
135
 * @see 1.6.2.1 "Syntax - AudioSpecificConfig"
136
 */
137
static void put_audio_specific_config(AVCodecContext *avctx)
138
{
139
    PutBitContext pb;
140
    AACEncContext *s = avctx->priv_data;
141

    
142
    init_put_bits(&pb, avctx->extradata, avctx->extradata_size*8);
143
    put_bits(&pb, 5, 2); //object type - AAC-LC
144
    put_bits(&pb, 4, s->samplerate_index); //sample rate index
145
    put_bits(&pb, 4, avctx->channels);
146
    //GASpecificConfig
147
    put_bits(&pb, 1, 0); //frame length - 1024 samples
148
    put_bits(&pb, 1, 0); //does not depend on core coder
149
    put_bits(&pb, 1, 0); //is not extension
150
    flush_put_bits(&pb);
151
}
152

    
153
static av_cold int aac_encode_init(AVCodecContext *avctx)
154
{
155
    AACEncContext *s = avctx->priv_data;
156
    int i;
157
    const uint8_t *sizes[2];
158
    int lengths[2];
159

    
160
    avctx->frame_size = 1024;
161

    
162
    for (i = 0; i < 16; i++)
163
        if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
164
            break;
165
    if (i == 16) {
166
        av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d\n", avctx->sample_rate);
167
        return -1;
168
    }
169
    if (avctx->channels > 6) {
170
        av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n", avctx->channels);
171
        return -1;
172
    }
173
    if (avctx->profile != FF_PROFILE_UNKNOWN && avctx->profile != FF_PROFILE_AAC_LOW) {
174
        av_log(avctx, AV_LOG_ERROR, "Unsupported profile %d\n", avctx->profile);
175
        return -1;
176
    }
177
    if (1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * avctx->channels) {
178
        av_log(avctx, AV_LOG_ERROR, "Too many bits per frame requested\n");
179
        return -1;
180
    }
181
    s->samplerate_index = i;
182

    
183
    dsputil_init(&s->dsp, avctx);
184
    ff_mdct_init(&s->mdct1024, 11, 0, 1.0);
185
    ff_mdct_init(&s->mdct128,   8, 0, 1.0);
186
    // window init
187
    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
188
    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
189
    ff_init_ff_sine_windows(10);
190
    ff_init_ff_sine_windows(7);
191

    
192
    s->samples            = av_malloc(2 * 1024 * avctx->channels * sizeof(s->samples[0]));
193
    s->cpe                = av_mallocz(sizeof(ChannelElement) * aac_chan_configs[avctx->channels-1][0]);
194
    avctx->extradata      = av_malloc(2);
195
    avctx->extradata_size = 2;
196
    put_audio_specific_config(avctx);
197

    
198
    sizes[0]   = swb_size_1024[i];
199
    sizes[1]   = swb_size_128[i];
200
    lengths[0] = ff_aac_num_swb_1024[i];
201
    lengths[1] = ff_aac_num_swb_128[i];
202
    ff_psy_init(&s->psy, avctx, 2, sizes, lengths);
203
    s->psypp = ff_psy_preprocess_init(avctx);
204
    s->coder = &ff_aac_coders[2];
205

    
206
    s->lambda = avctx->global_quality ? avctx->global_quality : 120;
207

    
208
    ff_aac_tableinit();
209

    
210
    if (avctx->channels > 5)
211
        av_log(avctx, AV_LOG_ERROR, "This encoder does not yet enforce the restrictions on LFEs. "
212
               "The output will most likely be an illegal bitstream.\n");
213

    
214
    return 0;
215
}
216

    
217
static void apply_window_and_mdct(AVCodecContext *avctx, AACEncContext *s,
218
                                  SingleChannelElement *sce, short *audio, int channel)
219
{
220
    int i, j, k;
221
    const float * lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
222
    const float * swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
223
    const float * pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
224

    
225
    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
226
        memcpy(s->output, sce->saved, sizeof(float)*1024);
227
        if (sce->ics.window_sequence[0] == LONG_STOP_SEQUENCE) {
228
            memset(s->output, 0, sizeof(s->output[0]) * 448);
229
            for (i = 448; i < 576; i++)
230
                s->output[i] = sce->saved[i] * pwindow[i - 448];
231
            for (i = 576; i < 704; i++)
232
                s->output[i] = sce->saved[i];
233
        }
234
        if (sce->ics.window_sequence[0] != LONG_START_SEQUENCE) {
235
            for (i = 0, j = channel; i < 1024; i++, j += avctx->channels) {
236
                s->output[i+1024]         = audio[j] * lwindow[1024 - i - 1];
237
                sce->saved[i] = audio[j] * lwindow[i];
238
            }
239
        } else {
240
            for (i = 0, j = channel; i < 448; i++, j += avctx->channels)
241
                s->output[i+1024]         = audio[j];
242
            for (; i < 576; i++, j += avctx->channels)
243
                s->output[i+1024]         = audio[j] * swindow[576 - i - 1];
244
            memset(s->output+1024+576, 0, sizeof(s->output[0]) * 448);
245
            for (i = 0, j = channel; i < 1024; i++, j += avctx->channels)
246
                sce->saved[i] = audio[j];
247
        }
248
        ff_mdct_calc(&s->mdct1024, sce->coeffs, s->output);
249
    } else {
250
        for (k = 0; k < 1024; k += 128) {
251
            for (i = 448 + k; i < 448 + k + 256; i++)
252
                s->output[i - 448 - k] = (i < 1024)
253
                                         ? sce->saved[i]
254
                                         : audio[channel + (i-1024)*avctx->channels];
255
            s->dsp.vector_fmul        (s->output,     k ?  swindow : pwindow, 128);
256
            s->dsp.vector_fmul_reverse(s->output+128, s->output+128, swindow, 128);
257
            ff_mdct_calc(&s->mdct128, sce->coeffs + k, s->output);
258
        }
259
        for (i = 0, j = channel; i < 1024; i++, j += avctx->channels)
260
            sce->saved[i] = audio[j];
261
    }
262
}
263

    
264
/**
265
 * Encode ics_info element.
266
 * @see Table 4.6 (syntax of ics_info)
267
 */
268
static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
269
{
270
    int w;
271

    
272
    put_bits(&s->pb, 1, 0);                // ics_reserved bit
273
    put_bits(&s->pb, 2, info->window_sequence[0]);
274
    put_bits(&s->pb, 1, info->use_kb_window[0]);
275
    if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
276
        put_bits(&s->pb, 6, info->max_sfb);
277
        put_bits(&s->pb, 1, 0);            // no prediction
278
    } else {
279
        put_bits(&s->pb, 4, info->max_sfb);
280
        for (w = 1; w < 8; w++)
281
            put_bits(&s->pb, 1, !info->group_len[w]);
282
    }
283
}
284

    
285
/**
286
 * Encode MS data.
287
 * @see 4.6.8.1 "Joint Coding - M/S Stereo"
288
 */
289
static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
290
{
291
    int i, w;
292

    
293
    put_bits(pb, 2, cpe->ms_mode);
294
    if (cpe->ms_mode == 1)
295
        for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w])
296
            for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
297
                put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
298
}
299

    
300
/**
301
 * Produce integer coefficients from scalefactors provided by the model.
302
 */
303
static void adjust_frame_information(AACEncContext *apc, ChannelElement *cpe, int chans)
304
{
305
    int i, w, w2, g, ch;
306
    int start, sum, maxsfb, cmaxsfb;
307

    
308
    for (ch = 0; ch < chans; ch++) {
309
        IndividualChannelStream *ics = &cpe->ch[ch].ics;
310
        start = 0;
311
        maxsfb = 0;
312
        cpe->ch[ch].pulse.num_pulse = 0;
313
        for (w = 0; w < ics->num_windows*16; w += 16) {
314
            for (g = 0; g < ics->num_swb; g++) {
315
                sum = 0;
316
                //apply M/S
317
                if (!ch && cpe->ms_mask[w + g]) {
318
                    for (i = 0; i < ics->swb_sizes[g]; i++) {
319
                        cpe->ch[0].coeffs[start+i] = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) / 2.0;
320
                        cpe->ch[1].coeffs[start+i] =  cpe->ch[0].coeffs[start+i] - cpe->ch[1].coeffs[start+i];
321
                    }
322
                }
323
                start += ics->swb_sizes[g];
324
            }
325
            for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w+cmaxsfb-1]; cmaxsfb--)
326
                ;
327
            maxsfb = FFMAX(maxsfb, cmaxsfb);
328
        }
329
        ics->max_sfb = maxsfb;
330

    
331
        //adjust zero bands for window groups
332
        for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
333
            for (g = 0; g < ics->max_sfb; g++) {
334
                i = 1;
335
                for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
336
                    if (!cpe->ch[ch].zeroes[w2*16 + g]) {
337
                        i = 0;
338
                        break;
339
                    }
340
                }
341
                cpe->ch[ch].zeroes[w*16 + g] = i;
342
            }
343
        }
344
    }
345

    
346
    if (chans > 1 && cpe->common_window) {
347
        IndividualChannelStream *ics0 = &cpe->ch[0].ics;
348
        IndividualChannelStream *ics1 = &cpe->ch[1].ics;
349
        int msc = 0;
350
        ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
351
        ics1->max_sfb = ics0->max_sfb;
352
        for (w = 0; w < ics0->num_windows*16; w += 16)
353
            for (i = 0; i < ics0->max_sfb; i++)
354
                if (cpe->ms_mask[w+i])
355
                    msc++;
356
        if (msc == 0 || ics0->max_sfb == 0)
357
            cpe->ms_mode = 0;
358
        else
359
            cpe->ms_mode = msc < ics0->max_sfb ? 1 : 2;
360
    }
361
}
362

    
363
/**
364
 * Encode scalefactor band coding type.
365
 */
366
static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
367
{
368
    int w;
369

    
370
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
371
        s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
372
}
373

    
374
/**
375
 * Encode scalefactors.
376
 */
377
static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s,
378
                                 SingleChannelElement *sce)
379
{
380
    int off = sce->sf_idx[0], diff;
381
    int i, w;
382

    
383
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
384
        for (i = 0; i < sce->ics.max_sfb; i++) {
385
            if (!sce->zeroes[w*16 + i]) {
386
                diff = sce->sf_idx[w*16 + i] - off + SCALE_DIFF_ZERO;
387
                if (diff < 0 || diff > 120)
388
                    av_log(avctx, AV_LOG_ERROR, "Scalefactor difference is too big to be coded\n");
389
                off = sce->sf_idx[w*16 + i];
390
                put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
391
            }
392
        }
393
    }
394
}
395

    
396
/**
397
 * Encode pulse data.
398
 */
399
static void encode_pulses(AACEncContext *s, Pulse *pulse)
400
{
401
    int i;
402

    
403
    put_bits(&s->pb, 1, !!pulse->num_pulse);
404
    if (!pulse->num_pulse)
405
        return;
406

    
407
    put_bits(&s->pb, 2, pulse->num_pulse - 1);
408
    put_bits(&s->pb, 6, pulse->start);
409
    for (i = 0; i < pulse->num_pulse; i++) {
410
        put_bits(&s->pb, 5, pulse->pos[i]);
411
        put_bits(&s->pb, 4, pulse->amp[i]);
412
    }
413
}
414

    
415
/**
416
 * Encode spectral coefficients processed by psychoacoustic model.
417
 */
418
static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
419
{
420
    int start, i, w, w2;
421

    
422
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
423
        start = 0;
424
        for (i = 0; i < sce->ics.max_sfb; i++) {
425
            if (sce->zeroes[w*16 + i]) {
426
                start += sce->ics.swb_sizes[i];
427
                continue;
428
            }
429
            for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++)
430
                s->coder->quantize_and_encode_band(s, &s->pb, sce->coeffs + start + w2*128,
431
                                                   sce->ics.swb_sizes[i],
432
                                                   sce->sf_idx[w*16 + i],
433
                                                   sce->band_type[w*16 + i],
434
                                                   s->lambda);
435
            start += sce->ics.swb_sizes[i];
436
        }
437
    }
438
}
439

    
440
/**
441
 * Encode one channel of audio data.
442
 */
443
static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s,
444
                                     SingleChannelElement *sce,
445
                                     int common_window)
446
{
447
    put_bits(&s->pb, 8, sce->sf_idx[0]);
448
    if (!common_window)
449
        put_ics_info(s, &sce->ics);
450
    encode_band_info(s, sce);
451
    encode_scale_factors(avctx, s, sce);
452
    encode_pulses(s, &sce->pulse);
453
    put_bits(&s->pb, 1, 0); //tns
454
    put_bits(&s->pb, 1, 0); //ssr
455
    encode_spectral_coeffs(s, sce);
456
    return 0;
457
}
458

    
459
/**
460
 * Write some auxiliary information about the created AAC file.
461
 */
462
static void put_bitstream_info(AVCodecContext *avctx, AACEncContext *s,
463
                               const char *name)
464
{
465
    int i, namelen, padbits;
466

    
467
    namelen = strlen(name) + 2;
468
    put_bits(&s->pb, 3, TYPE_FIL);
469
    put_bits(&s->pb, 4, FFMIN(namelen, 15));
470
    if (namelen >= 15)
471
        put_bits(&s->pb, 8, namelen - 16);
472
    put_bits(&s->pb, 4, 0); //extension type - filler
473
    padbits = 8 - (put_bits_count(&s->pb) & 7);
474
    align_put_bits(&s->pb);
475
    for (i = 0; i < namelen - 2; i++)
476
        put_bits(&s->pb, 8, name[i]);
477
    put_bits(&s->pb, 12 - padbits, 0);
478
}
479

    
480
static int aac_encode_frame(AVCodecContext *avctx,
481
                            uint8_t *frame, int buf_size, void *data)
482
{
483
    AACEncContext *s = avctx->priv_data;
484
    int16_t *samples = s->samples, *samples2, *la;
485
    ChannelElement *cpe;
486
    int i, j, chans, tag, start_ch;
487
    const uint8_t *chan_map = aac_chan_configs[avctx->channels-1];
488
    int chan_el_counter[4];
489
    FFPsyWindowInfo windows[avctx->channels];
490

    
491
    if (s->last_frame)
492
        return 0;
493
    if (data) {
494
        if (!s->psypp) {
495
            memcpy(s->samples + 1024 * avctx->channels, data,
496
                   1024 * avctx->channels * sizeof(s->samples[0]));
497
        } else {
498
            start_ch = 0;
499
            samples2 = s->samples + 1024 * avctx->channels;
500
            for (i = 0; i < chan_map[0]; i++) {
501
                tag = chan_map[i+1];
502
                chans = tag == TYPE_CPE ? 2 : 1;
503
                ff_psy_preprocess(s->psypp, (uint16_t*)data + start_ch,
504
                                  samples2 + start_ch, start_ch, chans);
505
                start_ch += chans;
506
            }
507
        }
508
    }
509
    if (!avctx->frame_number) {
510
        memcpy(s->samples, s->samples + 1024 * avctx->channels,
511
               1024 * avctx->channels * sizeof(s->samples[0]));
512
        return 0;
513
    }
514

    
515
    start_ch = 0;
516
    for (i = 0; i < chan_map[0]; i++) {
517
        FFPsyWindowInfo* wi = windows + start_ch;
518
        tag      = chan_map[i+1];
519
        chans    = tag == TYPE_CPE ? 2 : 1;
520
        cpe      = &s->cpe[i];
521
        samples2 = samples + start_ch;
522
        la       = samples2 + 1024 * avctx->channels + start_ch;
523
        if (!data)
524
            la = NULL;
525
        for (j = 0; j < chans; j++) {
526
            IndividualChannelStream *ics = &cpe->ch[j].ics;
527
            int k;
528
            wi[j] = ff_psy_suggest_window(&s->psy, samples2, la, start_ch + j, ics->window_sequence[0]);
529
            ics->window_sequence[1] = ics->window_sequence[0];
530
            ics->window_sequence[0] = wi[j].window_type[0];
531
            ics->use_kb_window[1]   = ics->use_kb_window[0];
532
            ics->use_kb_window[0]   = wi[j].window_shape;
533
            ics->num_windows        = wi[j].num_windows;
534
            ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];
535
            ics->num_swb            = s->psy.num_bands[ics->num_windows == 8];
536
            for (k = 0; k < ics->num_windows; k++)
537
                ics->group_len[k] = wi[j].grouping[k];
538

    
539
            s->cur_channel = start_ch + j;
540
            apply_window_and_mdct(avctx, s, &cpe->ch[j], samples2, j);
541
        }
542
        start_ch += chans;
543
    }
544
    do {
545
        int frame_bits;
546
        init_put_bits(&s->pb, frame, buf_size*8);
547
        if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT))
548
            put_bitstream_info(avctx, s, LIBAVCODEC_IDENT);
549
        start_ch = 0;
550
        memset(chan_el_counter, 0, sizeof(chan_el_counter));
551
        for (i = 0; i < chan_map[0]; i++) {
552
            FFPsyWindowInfo* wi = windows + start_ch;
553
            tag      = chan_map[i+1];
554
            chans    = tag == TYPE_CPE ? 2 : 1;
555
            cpe      = &s->cpe[i];
556
            for (j = 0; j < chans; j++) {
557
                s->cur_channel = start_ch + j;
558
                ff_psy_set_band_info(&s->psy, s->cur_channel, cpe->ch[j].coeffs, &wi[j]);
559
                s->coder->search_for_quantizers(avctx, s, &cpe->ch[j], s->lambda);
560
            }
561
            cpe->common_window = 0;
562
            if (chans > 1
563
                && wi[0].window_type[0] == wi[1].window_type[0]
564
                && wi[0].window_shape   == wi[1].window_shape) {
565

    
566
                cpe->common_window = 1;
567
                for (j = 0; j < wi[0].num_windows; j++) {
568
                    if (wi[0].grouping[j] != wi[1].grouping[j]) {
569
                        cpe->common_window = 0;
570
                        break;
571
                    }
572
                }
573
            }
574
            s->cur_channel = start_ch;
575
            if (cpe->common_window && s->coder->search_for_ms)
576
                s->coder->search_for_ms(s, cpe, s->lambda);
577
            adjust_frame_information(s, cpe, chans);
578
            put_bits(&s->pb, 3, tag);
579
            put_bits(&s->pb, 4, chan_el_counter[tag]++);
580
            if (chans == 2) {
581
                put_bits(&s->pb, 1, cpe->common_window);
582
                if (cpe->common_window) {
583
                    put_ics_info(s, &cpe->ch[0].ics);
584
                    encode_ms_info(&s->pb, cpe);
585
                }
586
            }
587
            for (j = 0; j < chans; j++) {
588
                s->cur_channel = start_ch + j;
589
                encode_individual_channel(avctx, s, &cpe->ch[j], cpe->common_window);
590
            }
591
            start_ch += chans;
592
        }
593

    
594
        frame_bits = put_bits_count(&s->pb);
595
        if (frame_bits <= 6144 * avctx->channels - 3)
596
            break;
597

    
598
        s->lambda *= avctx->bit_rate * 1024.0f / avctx->sample_rate / frame_bits;
599

    
600
    } while (1);
601

    
602
    put_bits(&s->pb, 3, TYPE_END);
603
    flush_put_bits(&s->pb);
604
    avctx->frame_bits = put_bits_count(&s->pb);
605

    
606
    // rate control stuff
607
    if (!(avctx->flags & CODEC_FLAG_QSCALE)) {
608
        float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits;
609
        s->lambda *= ratio;
610
        s->lambda = FFMIN(s->lambda, 65536.f);
611
    }
612

    
613
    if (!data)
614
        s->last_frame = 1;
615
    memcpy(s->samples, s->samples + 1024 * avctx->channels,
616
           1024 * avctx->channels * sizeof(s->samples[0]));
617
    return put_bits_count(&s->pb)>>3;
618
}
619

    
620
static av_cold int aac_encode_end(AVCodecContext *avctx)
621
{
622
    AACEncContext *s = avctx->priv_data;
623

    
624
    ff_mdct_end(&s->mdct1024);
625
    ff_mdct_end(&s->mdct128);
626
    ff_psy_end(&s->psy);
627
    ff_psy_preprocess_end(s->psypp);
628
    av_freep(&s->samples);
629
    av_freep(&s->cpe);
630
    return 0;
631
}
632

    
633
AVCodec aac_encoder = {
634
    "aac",
635
    AVMEDIA_TYPE_AUDIO,
636
    CODEC_ID_AAC,
637
    sizeof(AACEncContext),
638
    aac_encode_init,
639
    aac_encode_frame,
640
    aac_encode_end,
641
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,
642
    .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
643
    .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
644
};