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);
389 put_bits(pb
, 32, res
);
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 for (i
= 0; "vorbis"[i
]; i
++)
534 put_bits(&pb
, 8, "vorbis"[i
]);
535 put_bits(&pb
, 32, 0); // version
536 put_bits(&pb
, 8, venc
->channels
);
537 put_bits(&pb
, 32, venc
->sample_rate
);
538 put_bits(&pb
, 32, 0); // bitrate
539 put_bits(&pb
, 32, 0); // bitrate
540 put_bits(&pb
, 32, 0); // bitrate
541 put_bits(&pb
, 4, venc
->log2_blocksize
[0]);
542 put_bits(&pb
, 4, venc
->log2_blocksize
[1]);
543 put_bits(&pb
, 1, 1); // framing
546 hlens
[0] = (put_bits_count(&pb
) + 7) / 8;
547 buffer_len
-= hlens
[0];
551 init_put_bits(&pb
, p
, buffer_len
);
552 put_bits(&pb
, 8, 3); //magic
553 for (i
= 0; "vorbis"[i
]; i
++)
554 put_bits(&pb
, 8, "vorbis"[i
]);
555 put_bits(&pb
, 32, 0); // vendor length TODO
556 put_bits(&pb
, 32, 0); // amount of comments
557 put_bits(&pb
, 1, 1); // framing
560 hlens
[1] = (put_bits_count(&pb
) + 7) / 8;
561 buffer_len
-= hlens
[1];
565 init_put_bits(&pb
, p
, buffer_len
);
566 put_bits(&pb
, 8, 5); //magic
567 for (i
= 0; "vorbis"[i
]; i
++)
568 put_bits(&pb
, 8, "vorbis"[i
]);
571 put_bits(&pb
, 8, venc
->ncodebooks
- 1);
572 for (i
= 0; i
< venc
->ncodebooks
; i
++)
573 put_codebook_header(&pb
, &venc
->codebooks
[i
]);
575 // time domain, reserved, zero
577 put_bits(&pb
, 16, 0);
580 put_bits(&pb
, 6, venc
->nfloors
- 1);
581 for (i
= 0; i
< venc
->nfloors
; i
++)
582 put_floor_header(&pb
, &venc
->floors
[i
]);
585 put_bits(&pb
, 6, venc
->nresidues
- 1);
586 for (i
= 0; i
< venc
->nresidues
; i
++)
587 put_residue_header(&pb
, &venc
->residues
[i
]);
590 put_bits(&pb
, 6, venc
->nmappings
- 1);
591 for (i
= 0; i
< venc
->nmappings
; i
++) {
592 vorbis_enc_mapping
*mc
= &venc
->mappings
[i
];
594 put_bits(&pb
, 16, 0); // mapping type
596 put_bits(&pb
, 1, mc
->submaps
> 1);
598 put_bits(&pb
, 4, mc
->submaps
- 1);
600 put_bits(&pb
, 1, !!mc
->coupling_steps
);
601 if (mc
->coupling_steps
) {
602 put_bits(&pb
, 8, mc
->coupling_steps
- 1);
603 for (j
= 0; j
< mc
->coupling_steps
; j
++) {
604 put_bits(&pb
, ilog(venc
->channels
- 1), mc
->magnitude
[j
]);
605 put_bits(&pb
, ilog(venc
->channels
- 1), mc
->angle
[j
]);
609 put_bits(&pb
, 2, 0); // reserved
612 for (j
= 0; j
< venc
->channels
; j
++)
613 put_bits(&pb
, 4, mc
->mux
[j
]);
615 for (j
= 0; j
< mc
->submaps
; j
++) {
616 put_bits(&pb
, 8, 0); // reserved time configuration
617 put_bits(&pb
, 8, mc
->floor
[j
]);
618 put_bits(&pb
, 8, mc
->residue
[j
]);
623 put_bits(&pb
, 6, venc
->nmodes
- 1);
624 for (i
= 0; i
< venc
->nmodes
; i
++) {
625 put_bits(&pb
, 1, venc
->modes
[i
].blockflag
);
626 put_bits(&pb
, 16, 0); // reserved window type
627 put_bits(&pb
, 16, 0); // reserved transform type
628 put_bits(&pb
, 8, venc
->modes
[i
].mapping
);
631 put_bits(&pb
, 1, 1); // framing
634 hlens
[2] = (put_bits_count(&pb
) + 7) / 8;
636 len
= hlens
[0] + hlens
[1] + hlens
[2];
637 p
= *out
= av_mallocz(64 + len
+ len
/255);
640 p
+= av_xiphlacing(p
, hlens
[0]);
641 p
+= av_xiphlacing(p
, hlens
[1]);
643 for (i
= 0; i
< 3; i
++) {
644 memcpy(p
, buffer
+ buffer_len
, hlens
[i
]);
646 buffer_len
+= hlens
[i
];
652 static float get_floor_average(vorbis_enc_floor
* fc
, float *coeffs
, int i
)
654 int begin
= fc
->list
[fc
->list
[FFMAX(i
-1, 0)].sort
].x
;
655 int end
= fc
->list
[fc
->list
[FFMIN(i
+1, fc
->values
- 1)].sort
].x
;
659 for (j
= begin
; j
< end
; j
++)
660 average
+= fabs(coeffs
[j
]);
661 return average
/ (end
- begin
);
664 static void floor_fit(vorbis_enc_context
*venc
, vorbis_enc_floor
*fc
,
665 float *coeffs
, uint_fast16_t *posts
, int samples
)
667 int range
= 255 / fc
->multiplier
+ 1;
669 float tot_average
= 0.;
670 float averages
[fc
->values
];
671 for (i
= 0; i
< fc
->values
; i
++) {
672 averages
[i
] = get_floor_average(fc
, coeffs
, i
);
673 tot_average
+= averages
[i
];
675 tot_average
/= fc
->values
;
676 tot_average
/= venc
->quality
;
678 for (i
= 0; i
< fc
->values
; i
++) {
679 int position
= fc
->list
[fc
->list
[i
].sort
].x
;
680 float average
= averages
[i
];
683 average
*= pow(tot_average
/ average
, 0.5) * pow(1.25, position
/200.); // MAGIC!
684 for (j
= 0; j
< range
- 1; j
++)
685 if (ff_vorbis_floor1_inverse_db_table
[j
* fc
->multiplier
] > average
)
687 posts
[fc
->list
[i
].sort
] = j
;
691 static int render_point(int x0
, int y0
, int x1
, int y1
, int x
)
693 return y0
+ (x
- x0
) * (y1
- y0
) / (x1
- x0
);
696 static void floor_encode(vorbis_enc_context
*venc
, vorbis_enc_floor
*fc
,
697 PutBitContext
*pb
, uint_fast16_t *posts
,
698 float *floor
, int samples
)
700 int range
= 255 / fc
->multiplier
+ 1;
701 int coded
[fc
->values
]; // first 2 values are unused
704 put_bits(pb
, 1, 1); // non zero
705 put_bits(pb
, ilog(range
- 1), posts
[0]);
706 put_bits(pb
, ilog(range
- 1), posts
[1]);
707 coded
[0] = coded
[1] = 1;
709 for (i
= 2; i
< fc
->values
; i
++) {
710 int predicted
= render_point(fc
->list
[fc
->list
[i
].low
].x
,
711 posts
[fc
->list
[i
].low
],
712 fc
->list
[fc
->list
[i
].high
].x
,
713 posts
[fc
->list
[i
].high
],
715 int highroom
= range
- predicted
;
716 int lowroom
= predicted
;
717 int room
= FFMIN(highroom
, lowroom
);
718 if (predicted
== posts
[i
]) {
719 coded
[i
] = 0; // must be used later as flag!
722 if (!coded
[fc
->list
[i
].low
])
723 coded
[fc
->list
[i
].low
] = -1;
724 if (!coded
[fc
->list
[i
].high
])
725 coded
[fc
->list
[i
].high
] = -1;
727 if (posts
[i
] > predicted
) {
728 if (posts
[i
] - predicted
> room
)
729 coded
[i
] = posts
[i
] - predicted
+ lowroom
;
731 coded
[i
] = (posts
[i
] - predicted
) << 1;
733 if (predicted
- posts
[i
] > room
)
734 coded
[i
] = predicted
- posts
[i
] + highroom
- 1;
736 coded
[i
] = ((predicted
- posts
[i
]) << 1) - 1;
741 for (i
= 0; i
< fc
->partitions
; i
++) {
742 vorbis_enc_floor_class
* c
= &fc
->classes
[fc
->partition_to_class
[i
]];
743 int k
, cval
= 0, csub
= 1<<c
->subclass
;
745 vorbis_enc_codebook
* book
= &venc
->codebooks
[c
->masterbook
];
747 for (k
= 0; k
< c
->dim
; k
++) {
749 for (l
= 0; l
< csub
; l
++) {
751 if (c
->books
[l
] != -1)
752 maxval
= venc
->codebooks
[c
->books
[l
]].nentries
;
753 // coded could be -1, but this still works, cause that is 0
754 if (coded
[counter
+ k
] < maxval
)
759 cshift
+= c
->subclass
;
761 put_codeword(pb
, book
, cval
);
763 for (k
= 0; k
< c
->dim
; k
++) {
764 int book
= c
->books
[cval
& (csub
-1)];
765 int entry
= coded
[counter
++];
766 cval
>>= c
->subclass
;
771 put_codeword(pb
, &venc
->codebooks
[book
], entry
);
775 ff_vorbis_floor1_render_list(fc
->list
, fc
->values
, posts
, coded
,
776 fc
->multiplier
, floor
, samples
);
779 static float *put_vector(vorbis_enc_codebook
*book
, PutBitContext
*pb
,
783 float distance
= FLT_MAX
;
784 assert(book
->dimentions
);
785 for (i
= 0; i
< book
->nentries
; i
++) {
786 float * vec
= book
->dimentions
+ i
* book
->ndimentions
, d
= book
->pow2
[i
];
790 for (j
= 0; j
< book
->ndimentions
; j
++)
791 d
-= vec
[j
] * num
[j
];
797 put_codeword(pb
, book
, entry
);
798 return &book
->dimentions
[entry
* book
->ndimentions
];
801 static void residue_encode(vorbis_enc_context
*venc
, vorbis_enc_residue
*rc
,
802 PutBitContext
*pb
, float *coeffs
, int samples
,
805 int pass
, i
, j
, p
, k
;
806 int psize
= rc
->partition_size
;
807 int partitions
= (rc
->end
- rc
->begin
) / psize
;
808 int channels
= (rc
->type
== 2) ? 1 : real_ch
;
809 int classes
[channels
][partitions
];
810 int classwords
= venc
->codebooks
[rc
->classbook
].ndimentions
;
812 assert(rc
->type
== 2);
813 assert(real_ch
== 2);
814 for (p
= 0; p
< partitions
; p
++) {
815 float max1
= 0., max2
= 0.;
816 int s
= rc
->begin
+ p
* psize
;
817 for (k
= s
; k
< s
+ psize
; k
+= 2) {
818 max1
= FFMAX(max1
, fabs(coeffs
[ k
/ real_ch
]));
819 max2
= FFMAX(max2
, fabs(coeffs
[samples
+ k
/ real_ch
]));
822 for (i
= 0; i
< rc
->classifications
- 1; i
++)
823 if (max1
< rc
->maxes
[i
][0] && max2
< rc
->maxes
[i
][1])
828 for (pass
= 0; pass
< 8; pass
++) {
830 while (p
< partitions
) {
832 for (j
= 0; j
< channels
; j
++) {
833 vorbis_enc_codebook
* book
= &venc
->codebooks
[rc
->classbook
];
835 for (i
= 0; i
< classwords
; i
++) {
836 entry
*= rc
->classifications
;
837 entry
+= classes
[j
][p
+ i
];
839 put_codeword(pb
, book
, entry
);
841 for (i
= 0; i
< classwords
&& p
< partitions
; i
++, p
++) {
842 for (j
= 0; j
< channels
; j
++) {
843 int nbook
= rc
->books
[classes
[j
][p
]][pass
];
844 vorbis_enc_codebook
* book
= &venc
->codebooks
[nbook
];
845 float *buf
= coeffs
+ samples
*j
+ rc
->begin
+ p
*psize
;
849 assert(rc
->type
== 0 || rc
->type
== 2);
850 assert(!(psize
% book
->ndimentions
));
853 for (k
= 0; k
< psize
; k
+= book
->ndimentions
) {
854 float *a
= put_vector(book
, pb
, &buf
[k
]);
856 for (l
= 0; l
< book
->ndimentions
; l
++)
860 int s
= rc
->begin
+ p
* psize
, a1
, b1
;
861 a1
= (s
% real_ch
) * samples
;
863 s
= real_ch
* samples
;
864 for (k
= 0; k
< psize
; k
+= book
->ndimentions
) {
865 int dim
, a2
= a1
, b2
= b1
;
866 float vec
[book
->ndimentions
], *pv
= vec
;
867 for (dim
= book
->ndimentions
; dim
--; ) {
868 *pv
++ = coeffs
[a2
+ b2
];
869 if ((a2
+= samples
) == s
) {
874 pv
= put_vector(book
, pb
, vec
);
875 for (dim
= book
->ndimentions
; dim
--; ) {
876 coeffs
[a1
+ b1
] -= *pv
++;
877 if ((a1
+= samples
) == s
) {
890 static int apply_window_and_mdct(vorbis_enc_context
*venc
, signed short *audio
,
894 const float * win
= venc
->win
[0];
895 int window_len
= 1 << (venc
->log2_blocksize
[0] - 1);
896 float n
= (float)(1 << venc
->log2_blocksize
[0]) / 4.;
899 if (!venc
->have_saved
&& !samples
)
902 if (venc
->have_saved
) {
903 for (channel
= 0; channel
< venc
->channels
; channel
++)
904 memcpy(venc
->samples
+ channel
* window_len
* 2,
905 venc
->saved
+ channel
* window_len
, sizeof(float) * window_len
);
907 for (channel
= 0; channel
< venc
->channels
; channel
++)
908 memset(venc
->samples
+ channel
* window_len
* 2, 0,
909 sizeof(float) * window_len
);
913 for (channel
= 0; channel
< venc
->channels
; channel
++) {
914 float * offset
= venc
->samples
+ channel
*window_len
*2 + window_len
;
916 for (i
= 0; i
< samples
; i
++, j
+= venc
->channels
)
917 offset
[i
] = -audio
[j
] / 32768. / n
* win
[window_len
- i
- 1]; //FIXME find out why the sign has to be fliped
920 for (channel
= 0; channel
< venc
->channels
; channel
++)
921 memset(venc
->samples
+ channel
* window_len
* 2 + window_len
,
922 0, sizeof(float) * window_len
);
925 for (channel
= 0; channel
< venc
->channels
; channel
++)
926 ff_mdct_calc(&venc
->mdct
[0], venc
->coeffs
+ channel
* window_len
,
927 venc
->samples
+ channel
* window_len
* 2);
930 for (channel
= 0; channel
< venc
->channels
; channel
++) {
931 float *offset
= venc
->saved
+ channel
* window_len
;
933 for (i
= 0; i
< samples
; i
++, j
+= venc
->channels
)
934 offset
[i
] = -audio
[j
] / 32768. / n
* win
[i
]; //FIXME find out why the sign has to be fliped
936 venc
->have_saved
= 1;
938 venc
->have_saved
= 0;
943 static av_cold
int vorbis_encode_init(AVCodecContext
*avccontext
)
945 vorbis_enc_context
*venc
= avccontext
->priv_data
;
947 if (avccontext
->channels
!= 2) {
948 av_log(avccontext
, AV_LOG_ERROR
, "Current FFmpeg Vorbis encoder only supports 2 channels.\n");
952 create_vorbis_context(venc
, avccontext
);
954 if (avccontext
->flags
& CODEC_FLAG_QSCALE
)
955 venc
->quality
= avccontext
->global_quality
/ (float)FF_QP2LAMBDA
/ 10.;
958 venc
->quality
*= venc
->quality
;
960 avccontext
->extradata_size
= put_main_header(venc
, (uint8_t**)&avccontext
->extradata
);
962 avccontext
->frame_size
= 1 << (venc
->log2_blocksize
[0] - 1);
964 avccontext
->coded_frame
= avcodec_alloc_frame();
965 avccontext
->coded_frame
->key_frame
= 1;
970 static int vorbis_encode_frame(AVCodecContext
*avccontext
,
971 unsigned char *packets
,
972 int buf_size
, void *data
)
974 vorbis_enc_context
*venc
= avccontext
->priv_data
;
975 signed short *audio
= data
;
976 int samples
= data
? avccontext
->frame_size
: 0;
977 vorbis_enc_mode
*mode
;
978 vorbis_enc_mapping
*mapping
;
982 if (!apply_window_and_mdct(venc
, audio
, samples
))
984 samples
= 1 << (venc
->log2_blocksize
[0] - 1);
986 init_put_bits(&pb
, packets
, buf_size
);
988 put_bits(&pb
, 1, 0); // magic bit
990 put_bits(&pb
, ilog(venc
->nmodes
- 1), 0); // 0 bits, the mode
992 mode
= &venc
->modes
[0];
993 mapping
= &venc
->mappings
[mode
->mapping
];
994 if (mode
->blockflag
) {
999 for (i
= 0; i
< venc
->channels
; i
++) {
1000 vorbis_enc_floor
*fc
= &venc
->floors
[mapping
->floor
[mapping
->mux
[i
]]];
1001 uint_fast16_t posts
[fc
->values
];
1002 floor_fit(venc
, fc
, &venc
->coeffs
[i
* samples
], posts
, samples
);
1003 floor_encode(venc
, fc
, &pb
, posts
, &venc
->floor
[i
* samples
], samples
);
1006 for (i
= 0; i
< venc
->channels
* samples
; i
++)
1007 venc
->coeffs
[i
] /= venc
->floor
[i
];
1009 for (i
= 0; i
< mapping
->coupling_steps
; i
++) {
1010 float *mag
= venc
->coeffs
+ mapping
->magnitude
[i
] * samples
;
1011 float *ang
= venc
->coeffs
+ mapping
->angle
[i
] * samples
;
1013 for (j
= 0; j
< samples
; j
++) {
1023 residue_encode(venc
, &venc
->residues
[mapping
->residue
[mapping
->mux
[0]]],
1024 &pb
, venc
->coeffs
, samples
, venc
->channels
);
1026 avccontext
->coded_frame
->pts
= venc
->sample_count
;
1027 venc
->sample_count
+= avccontext
->frame_size
;
1028 flush_put_bits(&pb
);
1029 return (put_bits_count(&pb
) + 7) / 8;
1033 static av_cold
int vorbis_encode_close(AVCodecContext
*avccontext
)
1035 vorbis_enc_context
*venc
= avccontext
->priv_data
;
1038 if (venc
->codebooks
)
1039 for (i
= 0; i
< venc
->ncodebooks
; i
++) {
1040 av_freep(&venc
->codebooks
[i
].lens
);
1041 av_freep(&venc
->codebooks
[i
].codewords
);
1042 av_freep(&venc
->codebooks
[i
].quantlist
);
1043 av_freep(&venc
->codebooks
[i
].dimentions
);
1044 av_freep(&venc
->codebooks
[i
].pow2
);
1046 av_freep(&venc
->codebooks
);
1049 for (i
= 0; i
< venc
->nfloors
; i
++) {
1051 if (venc
->floors
[i
].classes
)
1052 for (j
= 0; j
< venc
->floors
[i
].nclasses
; j
++)
1053 av_freep(&venc
->floors
[i
].classes
[j
].books
);
1054 av_freep(&venc
->floors
[i
].classes
);
1055 av_freep(&venc
->floors
[i
].partition_to_class
);
1056 av_freep(&venc
->floors
[i
].list
);
1058 av_freep(&venc
->floors
);
1061 for (i
= 0; i
< venc
->nresidues
; i
++) {
1062 av_freep(&venc
->residues
[i
].books
);
1063 av_freep(&venc
->residues
[i
].maxes
);
1065 av_freep(&venc
->residues
);
1068 for (i
= 0; i
< venc
->nmappings
; i
++) {
1069 av_freep(&venc
->mappings
[i
].mux
);
1070 av_freep(&venc
->mappings
[i
].floor
);
1071 av_freep(&venc
->mappings
[i
].residue
);
1072 av_freep(&venc
->mappings
[i
].magnitude
);
1073 av_freep(&venc
->mappings
[i
].angle
);
1075 av_freep(&venc
->mappings
);
1077 av_freep(&venc
->modes
);
1079 av_freep(&venc
->saved
);
1080 av_freep(&venc
->samples
);
1081 av_freep(&venc
->floor
);
1082 av_freep(&venc
->coeffs
);
1084 ff_mdct_end(&venc
->mdct
[0]);
1085 ff_mdct_end(&venc
->mdct
[1]);
1087 av_freep(&avccontext
->coded_frame
);
1088 av_freep(&avccontext
->extradata
);
1093 AVCodec vorbis_encoder
= {
1097 sizeof(vorbis_enc_context
),
1099 vorbis_encode_frame
,
1100 vorbis_encode_close
,
1101 .capabilities
= CODEC_CAP_DELAY
,
1102 .sample_fmts
= (const enum SampleFormat
[]){SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
},
1103 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),