2 * copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * @file libavcodec/vorbis_enc.c
23 * Native Vorbis encoder.
24 * @author Oded Shimon <ods15@ods15.dyndns.org>
31 #include "vorbis_enc_data.h"
33 #define BITSTREAM_WRITER_LE
51 } vorbis_enc_codebook
;
58 } vorbis_enc_floor_class
;
62 int *partition_to_class
;
64 vorbis_enc_floor_class
*classes
;
68 vorbis_floor1_entry
*list
;
100 int log2_blocksize
[2];
106 float *floor
; // also used for tmp values for mdct
107 float *coeffs
; // also used for residue after floor
111 vorbis_enc_codebook
*codebooks
;
114 vorbis_enc_floor
*floors
;
117 vorbis_enc_residue
*residues
;
120 vorbis_enc_mapping
*mappings
;
123 vorbis_enc_mode
*modes
;
125 int64_t sample_count
;
126 } vorbis_enc_context
;
128 static inline void put_codeword(PutBitContext
*pb
, vorbis_enc_codebook
*cb
,
132 assert(entry
< cb
->nentries
);
133 assert(cb
->lens
[entry
]);
134 put_bits(pb
, cb
->lens
[entry
], cb
->codewords
[entry
]);
137 static int cb_lookup_vals(int lookup
, int dimentions
, int entries
)
140 return ff_vorbis_nth_root(entries
, dimentions
);
141 else if (lookup
== 2)
142 return dimentions
*entries
;
146 static void ready_codebook(vorbis_enc_codebook
*cb
)
150 ff_vorbis_len2vlc(cb
->lens
, cb
->codewords
, cb
->nentries
);
153 cb
->pow2
= cb
->dimentions
= NULL
;
155 int vals
= cb_lookup_vals(cb
->lookup
, cb
->ndimentions
, cb
->nentries
);
156 cb
->dimentions
= av_malloc(sizeof(float) * cb
->nentries
* cb
->ndimentions
);
157 cb
->pow2
= av_mallocz(sizeof(float) * cb
->nentries
);
158 for (i
= 0; i
< cb
->nentries
; i
++) {
162 for (j
= 0; j
< cb
->ndimentions
; j
++) {
165 off
= (i
/ div
) % vals
; // lookup type 1
167 off
= i
* cb
->ndimentions
+ j
; // lookup type 2
169 cb
->dimentions
[i
* cb
->ndimentions
+ j
] = last
+ cb
->min
+ cb
->quantlist
[off
] * cb
->delta
;
171 last
= cb
->dimentions
[i
* cb
->ndimentions
+ j
];
172 cb
->pow2
[i
] += cb
->dimentions
[i
* cb
->ndimentions
+ j
] * cb
->dimentions
[i
* cb
->ndimentions
+ j
];
180 static void ready_residue(vorbis_enc_residue
*rc
, vorbis_enc_context
*venc
)
183 assert(rc
->type
== 2);
184 rc
->maxes
= av_mallocz(sizeof(float[2]) * rc
->classifications
);
185 for (i
= 0; i
< rc
->classifications
; i
++) {
187 vorbis_enc_codebook
* cb
;
188 for (j
= 0; j
< 8; j
++)
189 if (rc
->books
[i
][j
] != -1)
193 cb
= &venc
->codebooks
[rc
->books
[i
][j
]];
194 assert(cb
->ndimentions
>= 2);
197 for (j
= 0; j
< cb
->nentries
; j
++) {
201 a
= fabs(cb
->dimentions
[j
* cb
->ndimentions
]);
202 if (a
> rc
->maxes
[i
][0])
204 a
= fabs(cb
->dimentions
[j
* cb
->ndimentions
+ 1]);
205 if (a
> rc
->maxes
[i
][1])
210 for (i
= 0; i
< rc
->classifications
; i
++) {
211 rc
->maxes
[i
][0] += 0.8;
212 rc
->maxes
[i
][1] += 0.8;
216 static void create_vorbis_context(vorbis_enc_context
*venc
,
217 AVCodecContext
*avccontext
)
219 vorbis_enc_floor
*fc
;
220 vorbis_enc_residue
*rc
;
221 vorbis_enc_mapping
*mc
;
224 venc
->channels
= avccontext
->channels
;
225 venc
->sample_rate
= avccontext
->sample_rate
;
226 venc
->log2_blocksize
[0] = venc
->log2_blocksize
[1] = 11;
228 venc
->ncodebooks
= FF_ARRAY_ELEMS(cvectors
);
229 venc
->codebooks
= av_malloc(sizeof(vorbis_enc_codebook
) * venc
->ncodebooks
);
231 // codebook 0..14 - floor1 book, values 0..255
232 // codebook 15 residue masterbook
233 // codebook 16..29 residue
234 for (book
= 0; book
< venc
->ncodebooks
; book
++) {
235 vorbis_enc_codebook
*cb
= &venc
->codebooks
[book
];
237 cb
->ndimentions
= cvectors
[book
].dim
;
238 cb
->nentries
= cvectors
[book
].real_len
;
239 cb
->min
= cvectors
[book
].min
;
240 cb
->delta
= cvectors
[book
].delta
;
241 cb
->lookup
= cvectors
[book
].lookup
;
244 cb
->lens
= av_malloc(sizeof(uint8_t) * cb
->nentries
);
245 cb
->codewords
= av_malloc(sizeof(uint32_t) * cb
->nentries
);
246 memcpy(cb
->lens
, cvectors
[book
].clens
, cvectors
[book
].len
);
247 memset(cb
->lens
+ cvectors
[book
].len
, 0, cb
->nentries
- cvectors
[book
].len
);
250 vals
= cb_lookup_vals(cb
->lookup
, cb
->ndimentions
, cb
->nentries
);
251 cb
->quantlist
= av_malloc(sizeof(int) * vals
);
252 for (i
= 0; i
< vals
; i
++)
253 cb
->quantlist
[i
] = cvectors
[book
].quant
[i
];
255 cb
->quantlist
= NULL
;
261 venc
->floors
= av_malloc(sizeof(vorbis_enc_floor
) * venc
->nfloors
);
264 fc
= &venc
->floors
[0];
266 fc
->partition_to_class
= av_malloc(sizeof(int) * fc
->partitions
);
268 for (i
= 0; i
< fc
->partitions
; i
++) {
269 static const int a
[] = {0, 1, 2, 2, 3, 3, 4, 4};
270 fc
->partition_to_class
[i
] = a
[i
];
271 fc
->nclasses
= FFMAX(fc
->nclasses
, fc
->partition_to_class
[i
]);
274 fc
->classes
= av_malloc(sizeof(vorbis_enc_floor_class
) * fc
->nclasses
);
275 for (i
= 0; i
< fc
->nclasses
; i
++) {
276 vorbis_enc_floor_class
* c
= &fc
->classes
[i
];
278 c
->dim
= floor_classes
[i
].dim
;
279 c
->subclass
= floor_classes
[i
].subclass
;
280 c
->masterbook
= floor_classes
[i
].masterbook
;
281 books
= (1 << c
->subclass
);
282 c
->books
= av_malloc(sizeof(int) * books
);
283 for (j
= 0; j
< books
; j
++)
284 c
->books
[j
] = floor_classes
[i
].nbooks
[j
];
287 fc
->rangebits
= venc
->log2_blocksize
[0] - 1;
290 for (i
= 0; i
< fc
->partitions
; i
++)
291 fc
->values
+= fc
->classes
[fc
->partition_to_class
[i
]].dim
;
293 fc
->list
= av_malloc(sizeof(vorbis_floor1_entry
) * fc
->values
);
295 fc
->list
[1].x
= 1 << fc
->rangebits
;
296 for (i
= 2; i
< fc
->values
; i
++) {
297 static const int a
[] = {
298 93, 23,372, 6, 46,186,750, 14, 33, 65,
299 130,260,556, 3, 10, 18, 28, 39, 55, 79,
300 111,158,220,312,464,650,850
302 fc
->list
[i
].x
= a
[i
- 2];
304 ff_vorbis_ready_floor1_list(fc
->list
, fc
->values
);
307 venc
->residues
= av_malloc(sizeof(vorbis_enc_residue
) * venc
->nresidues
);
310 rc
= &venc
->residues
[0];
314 rc
->partition_size
= 32;
315 rc
->classifications
= 10;
317 rc
->books
= av_malloc(sizeof(*rc
->books
) * rc
->classifications
);
319 static const int8_t a
[10][8] = {
320 { -1, -1, -1, -1, -1, -1, -1, -1, },
321 { -1, -1, 16, -1, -1, -1, -1, -1, },
322 { -1, -1, 17, -1, -1, -1, -1, -1, },
323 { -1, -1, 18, -1, -1, -1, -1, -1, },
324 { -1, -1, 19, -1, -1, -1, -1, -1, },
325 { -1, -1, 20, -1, -1, -1, -1, -1, },
326 { -1, -1, 21, -1, -1, -1, -1, -1, },
327 { 22, 23, -1, -1, -1, -1, -1, -1, },
328 { 24, 25, -1, -1, -1, -1, -1, -1, },
329 { 26, 27, 28, -1, -1, -1, -1, -1, },
331 memcpy(rc
->books
, a
, sizeof a
);
333 ready_residue(rc
, venc
);
336 venc
->mappings
= av_malloc(sizeof(vorbis_enc_mapping
) * venc
->nmappings
);
339 mc
= &venc
->mappings
[0];
341 mc
->mux
= av_malloc(sizeof(int) * venc
->channels
);
342 for (i
= 0; i
< venc
->channels
; i
++)
344 mc
->floor
= av_malloc(sizeof(int) * mc
->submaps
);
345 mc
->residue
= av_malloc(sizeof(int) * mc
->submaps
);
346 for (i
= 0; i
< mc
->submaps
; i
++) {
350 mc
->coupling_steps
= venc
->channels
== 2 ? 1 : 0;
351 mc
->magnitude
= av_malloc(sizeof(int) * mc
->coupling_steps
);
352 mc
->angle
= av_malloc(sizeof(int) * mc
->coupling_steps
);
353 if (mc
->coupling_steps
) {
354 mc
->magnitude
[0] = 0;
359 venc
->modes
= av_malloc(sizeof(vorbis_enc_mode
) * venc
->nmodes
);
362 venc
->modes
[0].blockflag
= 0;
363 venc
->modes
[0].mapping
= 0;
365 venc
->have_saved
= 0;
366 venc
->saved
= av_malloc(sizeof(float) * venc
->channels
* (1 << venc
->log2_blocksize
[1]) / 2);
367 venc
->samples
= av_malloc(sizeof(float) * venc
->channels
* (1 << venc
->log2_blocksize
[1]));
368 venc
->floor
= av_malloc(sizeof(float) * venc
->channels
* (1 << venc
->log2_blocksize
[1]) / 2);
369 venc
->coeffs
= av_malloc(sizeof(float) * venc
->channels
* (1 << venc
->log2_blocksize
[1]) / 2);
371 venc
->win
[0] = ff_vorbis_vwin
[venc
->log2_blocksize
[0] - 6];
372 venc
->win
[1] = ff_vorbis_vwin
[venc
->log2_blocksize
[1] - 6];
374 ff_mdct_init(&venc
->mdct
[0], venc
->log2_blocksize
[0], 0, 1.0);
375 ff_mdct_init(&venc
->mdct
[1], venc
->log2_blocksize
[1], 0, 1.0);
378 static void put_float(PutBitContext
*pb
, float f
)
382 mant
= (int)ldexp(frexp(f
, &exp
), 20);
388 res
|= mant
| (exp
<< 21);
392 static void put_codebook_header(PutBitContext
*pb
, vorbis_enc_codebook
*cb
)
397 put_bits(pb
, 24, 0x564342); //magic
398 put_bits(pb
, 16, cb
->ndimentions
);
399 put_bits(pb
, 24, cb
->nentries
);
401 for (i
= 1; i
< cb
->nentries
; i
++)
402 if (cb
->lens
[i
] < cb
->lens
[i
-1])
404 if (i
== cb
->nentries
)
407 put_bits(pb
, 1, ordered
);
409 int len
= cb
->lens
[0];
410 put_bits(pb
, 5, len
- 1);
412 while (i
< cb
->nentries
) {
414 for (j
= 0; j
+i
< cb
->nentries
; j
++)
415 if (cb
->lens
[j
+i
] != len
)
417 put_bits(pb
, ilog(cb
->nentries
- i
), j
);
423 for (i
= 0; i
< cb
->nentries
; i
++)
426 if (i
!= cb
->nentries
)
428 put_bits(pb
, 1, sparse
);
430 for (i
= 0; i
< cb
->nentries
; i
++) {
432 put_bits(pb
, 1, !!cb
->lens
[i
]);
434 put_bits(pb
, 5, cb
->lens
[i
] - 1);
438 put_bits(pb
, 4, cb
->lookup
);
440 int tmp
= cb_lookup_vals(cb
->lookup
, cb
->ndimentions
, cb
->nentries
);
441 int bits
= ilog(cb
->quantlist
[0]);
443 for (i
= 1; i
< tmp
; i
++)
444 bits
= FFMAX(bits
, ilog(cb
->quantlist
[i
]));
446 put_float(pb
, cb
->min
);
447 put_float(pb
, cb
->delta
);
449 put_bits(pb
, 4, bits
- 1);
450 put_bits(pb
, 1, cb
->seq_p
);
452 for (i
= 0; i
< tmp
; i
++)
453 put_bits(pb
, bits
, cb
->quantlist
[i
]);
457 static void put_floor_header(PutBitContext
*pb
, vorbis_enc_floor
*fc
)
461 put_bits(pb
, 16, 1); // type, only floor1 is supported
463 put_bits(pb
, 5, fc
->partitions
);
465 for (i
= 0; i
< fc
->partitions
; i
++)
466 put_bits(pb
, 4, fc
->partition_to_class
[i
]);
468 for (i
= 0; i
< fc
->nclasses
; i
++) {
471 put_bits(pb
, 3, fc
->classes
[i
].dim
- 1);
472 put_bits(pb
, 2, fc
->classes
[i
].subclass
);
474 if (fc
->classes
[i
].subclass
)
475 put_bits(pb
, 8, fc
->classes
[i
].masterbook
);
477 books
= (1 << fc
->classes
[i
].subclass
);
479 for (j
= 0; j
< books
; j
++)
480 put_bits(pb
, 8, fc
->classes
[i
].books
[j
] + 1);
483 put_bits(pb
, 2, fc
->multiplier
- 1);
484 put_bits(pb
, 4, fc
->rangebits
);
486 for (i
= 2; i
< fc
->values
; i
++)
487 put_bits(pb
, fc
->rangebits
, fc
->list
[i
].x
);
490 static void put_residue_header(PutBitContext
*pb
, vorbis_enc_residue
*rc
)
494 put_bits(pb
, 16, rc
->type
);
496 put_bits(pb
, 24, rc
->begin
);
497 put_bits(pb
, 24, rc
->end
);
498 put_bits(pb
, 24, rc
->partition_size
- 1);
499 put_bits(pb
, 6, rc
->classifications
- 1);
500 put_bits(pb
, 8, rc
->classbook
);
502 for (i
= 0; i
< rc
->classifications
; i
++) {
504 for (j
= 0; j
< 8; j
++)
505 tmp
|= (rc
->books
[i
][j
] != -1) << j
;
507 put_bits(pb
, 3, tmp
& 7);
508 put_bits(pb
, 1, tmp
> 7);
511 put_bits(pb
, 5, tmp
>> 3);
514 for (i
= 0; i
< rc
->classifications
; i
++) {
516 for (j
= 0; j
< 8; j
++)
517 if (rc
->books
[i
][j
] != -1)
518 put_bits(pb
, 8, rc
->books
[i
][j
]);
522 static int put_main_header(vorbis_enc_context
*venc
, uint8_t **out
)
526 uint8_t buffer
[50000] = {0}, *p
= buffer
;
527 int buffer_len
= sizeof buffer
;
530 // identification header
531 init_put_bits(&pb
, p
, buffer_len
);
532 put_bits(&pb
, 8, 1); //magic
533 ff_put_string(&pb
, "vorbis", 0);
534 put_bits32(&pb
, 0); // version
535 put_bits(&pb
, 8, venc
->channels
);
536 put_bits32(&pb
, venc
->sample_rate
);
537 put_bits32(&pb
, 0); // bitrate
538 put_bits32(&pb
, 0); // bitrate
539 put_bits32(&pb
, 0); // bitrate
540 put_bits(&pb
, 4, venc
->log2_blocksize
[0]);
541 put_bits(&pb
, 4, venc
->log2_blocksize
[1]);
542 put_bits(&pb
, 1, 1); // framing
545 hlens
[0] = put_bits_count(&pb
) >> 3;
546 buffer_len
-= hlens
[0];
550 init_put_bits(&pb
, p
, buffer_len
);
551 put_bits(&pb
, 8, 3); //magic
552 ff_put_string(&pb
, "vorbis", 0);
553 put_bits32(&pb
, 0); // vendor length TODO
554 put_bits32(&pb
, 0); // amount of comments
555 put_bits(&pb
, 1, 1); // framing
558 hlens
[1] = put_bits_count(&pb
) >> 3;
559 buffer_len
-= hlens
[1];
563 init_put_bits(&pb
, p
, buffer_len
);
564 put_bits(&pb
, 8, 5); //magic
565 ff_put_string(&pb
, "vorbis", 0);
568 put_bits(&pb
, 8, venc
->ncodebooks
- 1);
569 for (i
= 0; i
< venc
->ncodebooks
; i
++)
570 put_codebook_header(&pb
, &venc
->codebooks
[i
]);
572 // time domain, reserved, zero
574 put_bits(&pb
, 16, 0);
577 put_bits(&pb
, 6, venc
->nfloors
- 1);
578 for (i
= 0; i
< venc
->nfloors
; i
++)
579 put_floor_header(&pb
, &venc
->floors
[i
]);
582 put_bits(&pb
, 6, venc
->nresidues
- 1);
583 for (i
= 0; i
< venc
->nresidues
; i
++)
584 put_residue_header(&pb
, &venc
->residues
[i
]);
587 put_bits(&pb
, 6, venc
->nmappings
- 1);
588 for (i
= 0; i
< venc
->nmappings
; i
++) {
589 vorbis_enc_mapping
*mc
= &venc
->mappings
[i
];
591 put_bits(&pb
, 16, 0); // mapping type
593 put_bits(&pb
, 1, mc
->submaps
> 1);
595 put_bits(&pb
, 4, mc
->submaps
- 1);
597 put_bits(&pb
, 1, !!mc
->coupling_steps
);
598 if (mc
->coupling_steps
) {
599 put_bits(&pb
, 8, mc
->coupling_steps
- 1);
600 for (j
= 0; j
< mc
->coupling_steps
; j
++) {
601 put_bits(&pb
, ilog(venc
->channels
- 1), mc
->magnitude
[j
]);
602 put_bits(&pb
, ilog(venc
->channels
- 1), mc
->angle
[j
]);
606 put_bits(&pb
, 2, 0); // reserved
609 for (j
= 0; j
< venc
->channels
; j
++)
610 put_bits(&pb
, 4, mc
->mux
[j
]);
612 for (j
= 0; j
< mc
->submaps
; j
++) {
613 put_bits(&pb
, 8, 0); // reserved time configuration
614 put_bits(&pb
, 8, mc
->floor
[j
]);
615 put_bits(&pb
, 8, mc
->residue
[j
]);
620 put_bits(&pb
, 6, venc
->nmodes
- 1);
621 for (i
= 0; i
< venc
->nmodes
; i
++) {
622 put_bits(&pb
, 1, venc
->modes
[i
].blockflag
);
623 put_bits(&pb
, 16, 0); // reserved window type
624 put_bits(&pb
, 16, 0); // reserved transform type
625 put_bits(&pb
, 8, venc
->modes
[i
].mapping
);
628 put_bits(&pb
, 1, 1); // framing
631 hlens
[2] = put_bits_count(&pb
) >> 3;
633 len
= hlens
[0] + hlens
[1] + hlens
[2];
634 p
= *out
= av_mallocz(64 + len
+ len
/255);
637 p
+= av_xiphlacing(p
, hlens
[0]);
638 p
+= av_xiphlacing(p
, hlens
[1]);
640 for (i
= 0; i
< 3; i
++) {
641 memcpy(p
, buffer
+ buffer_len
, hlens
[i
]);
643 buffer_len
+= hlens
[i
];
649 static float get_floor_average(vorbis_enc_floor
* fc
, float *coeffs
, int i
)
651 int begin
= fc
->list
[fc
->list
[FFMAX(i
-1, 0)].sort
].x
;
652 int end
= fc
->list
[fc
->list
[FFMIN(i
+1, fc
->values
- 1)].sort
].x
;
656 for (j
= begin
; j
< end
; j
++)
657 average
+= fabs(coeffs
[j
]);
658 return average
/ (end
- begin
);
661 static void floor_fit(vorbis_enc_context
*venc
, vorbis_enc_floor
*fc
,
662 float *coeffs
, uint_fast16_t *posts
, int samples
)
664 int range
= 255 / fc
->multiplier
+ 1;
666 float tot_average
= 0.;
667 float averages
[fc
->values
];
668 for (i
= 0; i
< fc
->values
; i
++) {
669 averages
[i
] = get_floor_average(fc
, coeffs
, i
);
670 tot_average
+= averages
[i
];
672 tot_average
/= fc
->values
;
673 tot_average
/= venc
->quality
;
675 for (i
= 0; i
< fc
->values
; i
++) {
676 int position
= fc
->list
[fc
->list
[i
].sort
].x
;
677 float average
= averages
[i
];
680 average
*= pow(tot_average
/ average
, 0.5) * pow(1.25, position
/200.); // MAGIC!
681 for (j
= 0; j
< range
- 1; j
++)
682 if (ff_vorbis_floor1_inverse_db_table
[j
* fc
->multiplier
] > average
)
684 posts
[fc
->list
[i
].sort
] = j
;
688 static int render_point(int x0
, int y0
, int x1
, int y1
, int x
)
690 return y0
+ (x
- x0
) * (y1
- y0
) / (x1
- x0
);
693 static void floor_encode(vorbis_enc_context
*venc
, vorbis_enc_floor
*fc
,
694 PutBitContext
*pb
, uint_fast16_t *posts
,
695 float *floor
, int samples
)
697 int range
= 255 / fc
->multiplier
+ 1;
698 int coded
[fc
->values
]; // first 2 values are unused
701 put_bits(pb
, 1, 1); // non zero
702 put_bits(pb
, ilog(range
- 1), posts
[0]);
703 put_bits(pb
, ilog(range
- 1), posts
[1]);
704 coded
[0] = coded
[1] = 1;
706 for (i
= 2; i
< fc
->values
; i
++) {
707 int predicted
= render_point(fc
->list
[fc
->list
[i
].low
].x
,
708 posts
[fc
->list
[i
].low
],
709 fc
->list
[fc
->list
[i
].high
].x
,
710 posts
[fc
->list
[i
].high
],
712 int highroom
= range
- predicted
;
713 int lowroom
= predicted
;
714 int room
= FFMIN(highroom
, lowroom
);
715 if (predicted
== posts
[i
]) {
716 coded
[i
] = 0; // must be used later as flag!
719 if (!coded
[fc
->list
[i
].low
])
720 coded
[fc
->list
[i
].low
] = -1;
721 if (!coded
[fc
->list
[i
].high
])
722 coded
[fc
->list
[i
].high
] = -1;
724 if (posts
[i
] > predicted
) {
725 if (posts
[i
] - predicted
> room
)
726 coded
[i
] = posts
[i
] - predicted
+ lowroom
;
728 coded
[i
] = (posts
[i
] - predicted
) << 1;
730 if (predicted
- posts
[i
] > room
)
731 coded
[i
] = predicted
- posts
[i
] + highroom
- 1;
733 coded
[i
] = ((predicted
- posts
[i
]) << 1) - 1;
738 for (i
= 0; i
< fc
->partitions
; i
++) {
739 vorbis_enc_floor_class
* c
= &fc
->classes
[fc
->partition_to_class
[i
]];
740 int k
, cval
= 0, csub
= 1<<c
->subclass
;
742 vorbis_enc_codebook
* book
= &venc
->codebooks
[c
->masterbook
];
744 for (k
= 0; k
< c
->dim
; k
++) {
746 for (l
= 0; l
< csub
; l
++) {
748 if (c
->books
[l
] != -1)
749 maxval
= venc
->codebooks
[c
->books
[l
]].nentries
;
750 // coded could be -1, but this still works, cause that is 0
751 if (coded
[counter
+ k
] < maxval
)
756 cshift
+= c
->subclass
;
758 put_codeword(pb
, book
, cval
);
760 for (k
= 0; k
< c
->dim
; k
++) {
761 int book
= c
->books
[cval
& (csub
-1)];
762 int entry
= coded
[counter
++];
763 cval
>>= c
->subclass
;
768 put_codeword(pb
, &venc
->codebooks
[book
], entry
);
772 ff_vorbis_floor1_render_list(fc
->list
, fc
->values
, posts
, coded
,
773 fc
->multiplier
, floor
, samples
);
776 static float *put_vector(vorbis_enc_codebook
*book
, PutBitContext
*pb
,
780 float distance
= FLT_MAX
;
781 assert(book
->dimentions
);
782 for (i
= 0; i
< book
->nentries
; i
++) {
783 float * vec
= book
->dimentions
+ i
* book
->ndimentions
, d
= book
->pow2
[i
];
787 for (j
= 0; j
< book
->ndimentions
; j
++)
788 d
-= vec
[j
] * num
[j
];
794 put_codeword(pb
, book
, entry
);
795 return &book
->dimentions
[entry
* book
->ndimentions
];
798 static void residue_encode(vorbis_enc_context
*venc
, vorbis_enc_residue
*rc
,
799 PutBitContext
*pb
, float *coeffs
, int samples
,
802 int pass
, i
, j
, p
, k
;
803 int psize
= rc
->partition_size
;
804 int partitions
= (rc
->end
- rc
->begin
) / psize
;
805 int channels
= (rc
->type
== 2) ? 1 : real_ch
;
806 int classes
[channels
][partitions
];
807 int classwords
= venc
->codebooks
[rc
->classbook
].ndimentions
;
809 assert(rc
->type
== 2);
810 assert(real_ch
== 2);
811 for (p
= 0; p
< partitions
; p
++) {
812 float max1
= 0., max2
= 0.;
813 int s
= rc
->begin
+ p
* psize
;
814 for (k
= s
; k
< s
+ psize
; k
+= 2) {
815 max1
= FFMAX(max1
, fabs(coeffs
[ k
/ real_ch
]));
816 max2
= FFMAX(max2
, fabs(coeffs
[samples
+ k
/ real_ch
]));
819 for (i
= 0; i
< rc
->classifications
- 1; i
++)
820 if (max1
< rc
->maxes
[i
][0] && max2
< rc
->maxes
[i
][1])
825 for (pass
= 0; pass
< 8; pass
++) {
827 while (p
< partitions
) {
829 for (j
= 0; j
< channels
; j
++) {
830 vorbis_enc_codebook
* book
= &venc
->codebooks
[rc
->classbook
];
832 for (i
= 0; i
< classwords
; i
++) {
833 entry
*= rc
->classifications
;
834 entry
+= classes
[j
][p
+ i
];
836 put_codeword(pb
, book
, entry
);
838 for (i
= 0; i
< classwords
&& p
< partitions
; i
++, p
++) {
839 for (j
= 0; j
< channels
; j
++) {
840 int nbook
= rc
->books
[classes
[j
][p
]][pass
];
841 vorbis_enc_codebook
* book
= &venc
->codebooks
[nbook
];
842 float *buf
= coeffs
+ samples
*j
+ rc
->begin
+ p
*psize
;
846 assert(rc
->type
== 0 || rc
->type
== 2);
847 assert(!(psize
% book
->ndimentions
));
850 for (k
= 0; k
< psize
; k
+= book
->ndimentions
) {
851 float *a
= put_vector(book
, pb
, &buf
[k
]);
853 for (l
= 0; l
< book
->ndimentions
; l
++)
857 int s
= rc
->begin
+ p
* psize
, a1
, b1
;
858 a1
= (s
% real_ch
) * samples
;
860 s
= real_ch
* samples
;
861 for (k
= 0; k
< psize
; k
+= book
->ndimentions
) {
862 int dim
, a2
= a1
, b2
= b1
;
863 float vec
[book
->ndimentions
], *pv
= vec
;
864 for (dim
= book
->ndimentions
; dim
--; ) {
865 *pv
++ = coeffs
[a2
+ b2
];
866 if ((a2
+= samples
) == s
) {
871 pv
= put_vector(book
, pb
, vec
);
872 for (dim
= book
->ndimentions
; dim
--; ) {
873 coeffs
[a1
+ b1
] -= *pv
++;
874 if ((a1
+= samples
) == s
) {
887 static int apply_window_and_mdct(vorbis_enc_context
*venc
, signed short *audio
,
891 const float * win
= venc
->win
[0];
892 int window_len
= 1 << (venc
->log2_blocksize
[0] - 1);
893 float n
= (float)(1 << venc
->log2_blocksize
[0]) / 4.;
896 if (!venc
->have_saved
&& !samples
)
899 if (venc
->have_saved
) {
900 for (channel
= 0; channel
< venc
->channels
; channel
++)
901 memcpy(venc
->samples
+ channel
* window_len
* 2,
902 venc
->saved
+ channel
* window_len
, sizeof(float) * window_len
);
904 for (channel
= 0; channel
< venc
->channels
; channel
++)
905 memset(venc
->samples
+ channel
* window_len
* 2, 0,
906 sizeof(float) * window_len
);
910 for (channel
= 0; channel
< venc
->channels
; channel
++) {
911 float * offset
= venc
->samples
+ channel
*window_len
*2 + window_len
;
913 for (i
= 0; i
< samples
; i
++, j
+= venc
->channels
)
914 offset
[i
] = -audio
[j
] / 32768. / n
* win
[window_len
- i
- 1]; //FIXME find out why the sign has to be fliped
917 for (channel
= 0; channel
< venc
->channels
; channel
++)
918 memset(venc
->samples
+ channel
* window_len
* 2 + window_len
,
919 0, sizeof(float) * window_len
);
922 for (channel
= 0; channel
< venc
->channels
; channel
++)
923 ff_mdct_calc(&venc
->mdct
[0], venc
->coeffs
+ channel
* window_len
,
924 venc
->samples
+ channel
* window_len
* 2);
927 for (channel
= 0; channel
< venc
->channels
; channel
++) {
928 float *offset
= venc
->saved
+ channel
* window_len
;
930 for (i
= 0; i
< samples
; i
++, j
+= venc
->channels
)
931 offset
[i
] = -audio
[j
] / 32768. / n
* win
[i
]; //FIXME find out why the sign has to be fliped
933 venc
->have_saved
= 1;
935 venc
->have_saved
= 0;
940 static av_cold
int vorbis_encode_init(AVCodecContext
*avccontext
)
942 vorbis_enc_context
*venc
= avccontext
->priv_data
;
944 if (avccontext
->channels
!= 2) {
945 av_log(avccontext
, AV_LOG_ERROR
, "Current FFmpeg Vorbis encoder only supports 2 channels.\n");
949 create_vorbis_context(venc
, avccontext
);
951 if (avccontext
->flags
& CODEC_FLAG_QSCALE
)
952 venc
->quality
= avccontext
->global_quality
/ (float)FF_QP2LAMBDA
/ 10.;
955 venc
->quality
*= venc
->quality
;
957 avccontext
->extradata_size
= put_main_header(venc
, (uint8_t**)&avccontext
->extradata
);
959 avccontext
->frame_size
= 1 << (venc
->log2_blocksize
[0] - 1);
961 avccontext
->coded_frame
= avcodec_alloc_frame();
962 avccontext
->coded_frame
->key_frame
= 1;
967 static int vorbis_encode_frame(AVCodecContext
*avccontext
,
968 unsigned char *packets
,
969 int buf_size
, void *data
)
971 vorbis_enc_context
*venc
= avccontext
->priv_data
;
972 signed short *audio
= data
;
973 int samples
= data
? avccontext
->frame_size
: 0;
974 vorbis_enc_mode
*mode
;
975 vorbis_enc_mapping
*mapping
;
979 if (!apply_window_and_mdct(venc
, audio
, samples
))
981 samples
= 1 << (venc
->log2_blocksize
[0] - 1);
983 init_put_bits(&pb
, packets
, buf_size
);
985 put_bits(&pb
, 1, 0); // magic bit
987 put_bits(&pb
, ilog(venc
->nmodes
- 1), 0); // 0 bits, the mode
989 mode
= &venc
->modes
[0];
990 mapping
= &venc
->mappings
[mode
->mapping
];
991 if (mode
->blockflag
) {
996 for (i
= 0; i
< venc
->channels
; i
++) {
997 vorbis_enc_floor
*fc
= &venc
->floors
[mapping
->floor
[mapping
->mux
[i
]]];
998 uint_fast16_t posts
[fc
->values
];
999 floor_fit(venc
, fc
, &venc
->coeffs
[i
* samples
], posts
, samples
);
1000 floor_encode(venc
, fc
, &pb
, posts
, &venc
->floor
[i
* samples
], samples
);
1003 for (i
= 0; i
< venc
->channels
* samples
; i
++)
1004 venc
->coeffs
[i
] /= venc
->floor
[i
];
1006 for (i
= 0; i
< mapping
->coupling_steps
; i
++) {
1007 float *mag
= venc
->coeffs
+ mapping
->magnitude
[i
] * samples
;
1008 float *ang
= venc
->coeffs
+ mapping
->angle
[i
] * samples
;
1010 for (j
= 0; j
< samples
; j
++) {
1020 residue_encode(venc
, &venc
->residues
[mapping
->residue
[mapping
->mux
[0]]],
1021 &pb
, venc
->coeffs
, samples
, venc
->channels
);
1023 avccontext
->coded_frame
->pts
= venc
->sample_count
;
1024 venc
->sample_count
+= avccontext
->frame_size
;
1025 flush_put_bits(&pb
);
1026 return put_bits_count(&pb
) >> 3;
1030 static av_cold
int vorbis_encode_close(AVCodecContext
*avccontext
)
1032 vorbis_enc_context
*venc
= avccontext
->priv_data
;
1035 if (venc
->codebooks
)
1036 for (i
= 0; i
< venc
->ncodebooks
; i
++) {
1037 av_freep(&venc
->codebooks
[i
].lens
);
1038 av_freep(&venc
->codebooks
[i
].codewords
);
1039 av_freep(&venc
->codebooks
[i
].quantlist
);
1040 av_freep(&venc
->codebooks
[i
].dimentions
);
1041 av_freep(&venc
->codebooks
[i
].pow2
);
1043 av_freep(&venc
->codebooks
);
1046 for (i
= 0; i
< venc
->nfloors
; i
++) {
1048 if (venc
->floors
[i
].classes
)
1049 for (j
= 0; j
< venc
->floors
[i
].nclasses
; j
++)
1050 av_freep(&venc
->floors
[i
].classes
[j
].books
);
1051 av_freep(&venc
->floors
[i
].classes
);
1052 av_freep(&venc
->floors
[i
].partition_to_class
);
1053 av_freep(&venc
->floors
[i
].list
);
1055 av_freep(&venc
->floors
);
1058 for (i
= 0; i
< venc
->nresidues
; i
++) {
1059 av_freep(&venc
->residues
[i
].books
);
1060 av_freep(&venc
->residues
[i
].maxes
);
1062 av_freep(&venc
->residues
);
1065 for (i
= 0; i
< venc
->nmappings
; i
++) {
1066 av_freep(&venc
->mappings
[i
].mux
);
1067 av_freep(&venc
->mappings
[i
].floor
);
1068 av_freep(&venc
->mappings
[i
].residue
);
1069 av_freep(&venc
->mappings
[i
].magnitude
);
1070 av_freep(&venc
->mappings
[i
].angle
);
1072 av_freep(&venc
->mappings
);
1074 av_freep(&venc
->modes
);
1076 av_freep(&venc
->saved
);
1077 av_freep(&venc
->samples
);
1078 av_freep(&venc
->floor
);
1079 av_freep(&venc
->coeffs
);
1081 ff_mdct_end(&venc
->mdct
[0]);
1082 ff_mdct_end(&venc
->mdct
[1]);
1084 av_freep(&avccontext
->coded_frame
);
1085 av_freep(&avccontext
->extradata
);
1090 AVCodec vorbis_encoder
= {
1094 sizeof(vorbis_enc_context
),
1096 vorbis_encode_frame
,
1097 vorbis_encode_close
,
1098 .capabilities
= CODEC_CAP_DELAY
,
1099 .sample_fmts
= (const enum SampleFormat
[]){SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
},
1100 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),