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
23 * Native Vorbis encoder.
24 * @author Oded Shimon <ods15@ods15.dyndns.org>
34 #include "vorbis_enc_data.h"
36 #define BITSTREAM_WRITER_LE
54 } vorbis_enc_codebook
;
61 } vorbis_enc_floor_class
;
65 int *partition_to_class
;
67 vorbis_enc_floor_class
*classes
;
71 vorbis_floor1_entry
*list
;
103 int log2_blocksize
[2];
109 float *floor
; // also used for tmp values for mdct
110 float *coeffs
; // also used for residue after floor
114 vorbis_enc_codebook
*codebooks
;
117 vorbis_enc_floor
*floors
;
120 vorbis_enc_residue
*residues
;
123 vorbis_enc_mapping
*mappings
;
126 vorbis_enc_mode
*modes
;
129 } vorbis_enc_context
;
131 #define MAX_CHANNELS 2
132 #define MAX_CODEBOOK_DIM 8
134 #define MAX_FLOOR_CLASS_DIM 4
135 #define NUM_FLOOR_PARTITIONS 8
136 #define MAX_FLOOR_VALUES (MAX_FLOOR_CLASS_DIM*NUM_FLOOR_PARTITIONS+2)
138 #define RESIDUE_SIZE 1600
139 #define RESIDUE_PART_SIZE 32
140 #define NUM_RESIDUE_PARTITIONS (RESIDUE_SIZE/RESIDUE_PART_SIZE)
142 static inline int put_codeword(PutBitContext
*pb
, vorbis_enc_codebook
*cb
,
145 av_assert2(entry
>= 0);
146 av_assert2(entry
< cb
->nentries
);
147 av_assert2(cb
->lens
[entry
]);
148 if (pb
->size_in_bits
- put_bits_count(pb
) < cb
->lens
[entry
])
149 return AVERROR(EINVAL
);
150 put_bits(pb
, cb
->lens
[entry
], cb
->codewords
[entry
]);
154 static int cb_lookup_vals(int lookup
, int dimensions
, int entries
)
157 return ff_vorbis_nth_root(entries
, dimensions
);
158 else if (lookup
== 2)
159 return dimensions
*entries
;
163 static int ready_codebook(vorbis_enc_codebook
*cb
)
167 ff_vorbis_len2vlc(cb
->lens
, cb
->codewords
, cb
->nentries
);
170 cb
->pow2
= cb
->dimensions
= NULL
;
172 int vals
= cb_lookup_vals(cb
->lookup
, cb
->ndimensions
, cb
->nentries
);
173 cb
->dimensions
= av_malloc_array(cb
->nentries
, sizeof(float) * cb
->ndimensions
);
174 cb
->pow2
= av_mallocz_array(cb
->nentries
, sizeof(float));
175 if (!cb
->dimensions
|| !cb
->pow2
)
176 return AVERROR(ENOMEM
);
177 for (i
= 0; i
< cb
->nentries
; i
++) {
181 for (j
= 0; j
< cb
->ndimensions
; j
++) {
184 off
= (i
/ div
) % vals
; // lookup type 1
186 off
= i
* cb
->ndimensions
+ j
; // lookup type 2
188 cb
->dimensions
[i
* cb
->ndimensions
+ j
] = last
+ cb
->min
+ cb
->quantlist
[off
] * cb
->delta
;
190 last
= cb
->dimensions
[i
* cb
->ndimensions
+ j
];
191 cb
->pow2
[i
] += cb
->dimensions
[i
* cb
->ndimensions
+ j
] * cb
->dimensions
[i
* cb
->ndimensions
+ j
];
200 static int ready_residue(vorbis_enc_residue
*rc
, vorbis_enc_context
*venc
)
203 av_assert0(rc
->type
== 2);
204 rc
->maxes
= av_mallocz_array(rc
->classifications
, sizeof(float[2]));
206 return AVERROR(ENOMEM
);
207 for (i
= 0; i
< rc
->classifications
; i
++) {
209 vorbis_enc_codebook
* cb
;
210 for (j
= 0; j
< 8; j
++)
211 if (rc
->books
[i
][j
] != -1)
215 cb
= &venc
->codebooks
[rc
->books
[i
][j
]];
216 assert(cb
->ndimensions
>= 2);
219 for (j
= 0; j
< cb
->nentries
; j
++) {
223 a
= fabs(cb
->dimensions
[j
* cb
->ndimensions
]);
224 if (a
> rc
->maxes
[i
][0])
226 a
= fabs(cb
->dimensions
[j
* cb
->ndimensions
+ 1]);
227 if (a
> rc
->maxes
[i
][1])
232 for (i
= 0; i
< rc
->classifications
; i
++) {
233 rc
->maxes
[i
][0] += 0.8;
234 rc
->maxes
[i
][1] += 0.8;
239 static int create_vorbis_context(vorbis_enc_context
*venc
,
240 AVCodecContext
*avctx
)
242 vorbis_enc_floor
*fc
;
243 vorbis_enc_residue
*rc
;
244 vorbis_enc_mapping
*mc
;
247 venc
->channels
= avctx
->channels
;
248 venc
->sample_rate
= avctx
->sample_rate
;
249 venc
->log2_blocksize
[0] = venc
->log2_blocksize
[1] = 11;
251 venc
->ncodebooks
= FF_ARRAY_ELEMS(cvectors
);
252 venc
->codebooks
= av_malloc(sizeof(vorbis_enc_codebook
) * venc
->ncodebooks
);
253 if (!venc
->codebooks
)
254 return AVERROR(ENOMEM
);
256 // codebook 0..14 - floor1 book, values 0..255
257 // codebook 15 residue masterbook
258 // codebook 16..29 residue
259 for (book
= 0; book
< venc
->ncodebooks
; book
++) {
260 vorbis_enc_codebook
*cb
= &venc
->codebooks
[book
];
262 cb
->ndimensions
= cvectors
[book
].dim
;
263 cb
->nentries
= cvectors
[book
].real_len
;
264 cb
->min
= cvectors
[book
].min
;
265 cb
->delta
= cvectors
[book
].delta
;
266 cb
->lookup
= cvectors
[book
].lookup
;
269 cb
->lens
= av_malloc_array(cb
->nentries
, sizeof(uint8_t));
270 cb
->codewords
= av_malloc_array(cb
->nentries
, sizeof(uint32_t));
271 if (!cb
->lens
|| !cb
->codewords
)
272 return AVERROR(ENOMEM
);
273 memcpy(cb
->lens
, cvectors
[book
].clens
, cvectors
[book
].len
);
274 memset(cb
->lens
+ cvectors
[book
].len
, 0, cb
->nentries
- cvectors
[book
].len
);
277 vals
= cb_lookup_vals(cb
->lookup
, cb
->ndimensions
, cb
->nentries
);
278 cb
->quantlist
= av_malloc_array(vals
, sizeof(int));
280 return AVERROR(ENOMEM
);
281 for (i
= 0; i
< vals
; i
++)
282 cb
->quantlist
[i
] = cvectors
[book
].quant
[i
];
284 cb
->quantlist
= NULL
;
286 if ((ret
= ready_codebook(cb
)) < 0)
291 venc
->floors
= av_malloc(sizeof(vorbis_enc_floor
) * venc
->nfloors
);
293 return AVERROR(ENOMEM
);
296 fc
= &venc
->floors
[0];
297 fc
->partitions
= NUM_FLOOR_PARTITIONS
;
298 fc
->partition_to_class
= av_malloc(sizeof(int) * fc
->partitions
);
299 if (!fc
->partition_to_class
)
300 return AVERROR(ENOMEM
);
302 for (i
= 0; i
< fc
->partitions
; i
++) {
303 static const int a
[] = {0, 1, 2, 2, 3, 3, 4, 4};
304 fc
->partition_to_class
[i
] = a
[i
];
305 fc
->nclasses
= FFMAX(fc
->nclasses
, fc
->partition_to_class
[i
]);
308 fc
->classes
= av_malloc_array(fc
->nclasses
, sizeof(vorbis_enc_floor_class
));
310 return AVERROR(ENOMEM
);
311 for (i
= 0; i
< fc
->nclasses
; i
++) {
312 vorbis_enc_floor_class
* c
= &fc
->classes
[i
];
314 c
->dim
= floor_classes
[i
].dim
;
315 c
->subclass
= floor_classes
[i
].subclass
;
316 c
->masterbook
= floor_classes
[i
].masterbook
;
317 books
= (1 << c
->subclass
);
318 c
->books
= av_malloc_array(books
, sizeof(int));
320 return AVERROR(ENOMEM
);
321 for (j
= 0; j
< books
; j
++)
322 c
->books
[j
] = floor_classes
[i
].nbooks
[j
];
325 fc
->rangebits
= venc
->log2_blocksize
[0] - 1;
328 for (i
= 0; i
< fc
->partitions
; i
++)
329 fc
->values
+= fc
->classes
[fc
->partition_to_class
[i
]].dim
;
331 fc
->list
= av_malloc_array(fc
->values
, sizeof(vorbis_floor1_entry
));
333 return AVERROR(ENOMEM
);
335 fc
->list
[1].x
= 1 << fc
->rangebits
;
336 for (i
= 2; i
< fc
->values
; i
++) {
337 static const int a
[] = {
338 93, 23,372, 6, 46,186,750, 14, 33, 65,
339 130,260,556, 3, 10, 18, 28, 39, 55, 79,
340 111,158,220,312,464,650,850
342 fc
->list
[i
].x
= a
[i
- 2];
344 if (ff_vorbis_ready_floor1_list(avctx
, fc
->list
, fc
->values
))
348 venc
->residues
= av_malloc(sizeof(vorbis_enc_residue
) * venc
->nresidues
);
350 return AVERROR(ENOMEM
);
353 rc
= &venc
->residues
[0];
357 rc
->partition_size
= 32;
358 rc
->classifications
= 10;
360 rc
->books
= av_malloc(sizeof(*rc
->books
) * rc
->classifications
);
362 return AVERROR(ENOMEM
);
364 static const int8_t a
[10][8] = {
365 { -1, -1, -1, -1, -1, -1, -1, -1, },
366 { -1, -1, 16, -1, -1, -1, -1, -1, },
367 { -1, -1, 17, -1, -1, -1, -1, -1, },
368 { -1, -1, 18, -1, -1, -1, -1, -1, },
369 { -1, -1, 19, -1, -1, -1, -1, -1, },
370 { -1, -1, 20, -1, -1, -1, -1, -1, },
371 { -1, -1, 21, -1, -1, -1, -1, -1, },
372 { 22, 23, -1, -1, -1, -1, -1, -1, },
373 { 24, 25, -1, -1, -1, -1, -1, -1, },
374 { 26, 27, 28, -1, -1, -1, -1, -1, },
376 memcpy(rc
->books
, a
, sizeof a
);
378 if ((ret
= ready_residue(rc
, venc
)) < 0)
382 venc
->mappings
= av_malloc(sizeof(vorbis_enc_mapping
) * venc
->nmappings
);
384 return AVERROR(ENOMEM
);
387 mc
= &venc
->mappings
[0];
389 mc
->mux
= av_malloc(sizeof(int) * venc
->channels
);
391 return AVERROR(ENOMEM
);
392 for (i
= 0; i
< venc
->channels
; i
++)
394 mc
->floor
= av_malloc(sizeof(int) * mc
->submaps
);
395 mc
->residue
= av_malloc(sizeof(int) * mc
->submaps
);
396 if (!mc
->floor
|| !mc
->residue
)
397 return AVERROR(ENOMEM
);
398 for (i
= 0; i
< mc
->submaps
; i
++) {
402 mc
->coupling_steps
= venc
->channels
== 2 ? 1 : 0;
403 mc
->magnitude
= av_malloc(sizeof(int) * mc
->coupling_steps
);
404 mc
->angle
= av_malloc(sizeof(int) * mc
->coupling_steps
);
405 if (!mc
->magnitude
|| !mc
->angle
)
406 return AVERROR(ENOMEM
);
407 if (mc
->coupling_steps
) {
408 mc
->magnitude
[0] = 0;
413 venc
->modes
= av_malloc(sizeof(vorbis_enc_mode
) * venc
->nmodes
);
415 return AVERROR(ENOMEM
);
418 venc
->modes
[0].blockflag
= 0;
419 venc
->modes
[0].mapping
= 0;
421 venc
->have_saved
= 0;
422 venc
->saved
= av_malloc_array(sizeof(float) * venc
->channels
, (1 << venc
->log2_blocksize
[1]) / 2);
423 venc
->samples
= av_malloc_array(sizeof(float) * venc
->channels
, (1 << venc
->log2_blocksize
[1]));
424 venc
->floor
= av_malloc_array(sizeof(float) * venc
->channels
, (1 << venc
->log2_blocksize
[1]) / 2);
425 venc
->coeffs
= av_malloc_array(sizeof(float) * venc
->channels
, (1 << venc
->log2_blocksize
[1]) / 2);
426 if (!venc
->saved
|| !venc
->samples
|| !venc
->floor
|| !venc
->coeffs
)
427 return AVERROR(ENOMEM
);
429 venc
->win
[0] = ff_vorbis_vwin
[venc
->log2_blocksize
[0] - 6];
430 venc
->win
[1] = ff_vorbis_vwin
[venc
->log2_blocksize
[1] - 6];
432 if ((ret
= ff_mdct_init(&venc
->mdct
[0], venc
->log2_blocksize
[0], 0, 1.0)) < 0)
434 if ((ret
= ff_mdct_init(&venc
->mdct
[1], venc
->log2_blocksize
[1], 0, 1.0)) < 0)
440 static void put_float(PutBitContext
*pb
, float f
)
444 mant
= (int)ldexp(frexp(f
, &exp
), 20);
450 res
|= mant
| (exp
<< 21);
454 static void put_codebook_header(PutBitContext
*pb
, vorbis_enc_codebook
*cb
)
459 put_bits(pb
, 24, 0x564342); //magic
460 put_bits(pb
, 16, cb
->ndimensions
);
461 put_bits(pb
, 24, cb
->nentries
);
463 for (i
= 1; i
< cb
->nentries
; i
++)
464 if (cb
->lens
[i
] < cb
->lens
[i
-1])
466 if (i
== cb
->nentries
)
469 put_bits(pb
, 1, ordered
);
471 int len
= cb
->lens
[0];
472 put_bits(pb
, 5, len
- 1);
474 while (i
< cb
->nentries
) {
476 for (j
= 0; j
+i
< cb
->nentries
; j
++)
477 if (cb
->lens
[j
+i
] != len
)
479 put_bits(pb
, ilog(cb
->nentries
- i
), j
);
485 for (i
= 0; i
< cb
->nentries
; i
++)
488 if (i
!= cb
->nentries
)
490 put_bits(pb
, 1, sparse
);
492 for (i
= 0; i
< cb
->nentries
; i
++) {
494 put_bits(pb
, 1, !!cb
->lens
[i
]);
496 put_bits(pb
, 5, cb
->lens
[i
] - 1);
500 put_bits(pb
, 4, cb
->lookup
);
502 int tmp
= cb_lookup_vals(cb
->lookup
, cb
->ndimensions
, cb
->nentries
);
503 int bits
= ilog(cb
->quantlist
[0]);
505 for (i
= 1; i
< tmp
; i
++)
506 bits
= FFMAX(bits
, ilog(cb
->quantlist
[i
]));
508 put_float(pb
, cb
->min
);
509 put_float(pb
, cb
->delta
);
511 put_bits(pb
, 4, bits
- 1);
512 put_bits(pb
, 1, cb
->seq_p
);
514 for (i
= 0; i
< tmp
; i
++)
515 put_bits(pb
, bits
, cb
->quantlist
[i
]);
519 static void put_floor_header(PutBitContext
*pb
, vorbis_enc_floor
*fc
)
523 put_bits(pb
, 16, 1); // type, only floor1 is supported
525 put_bits(pb
, 5, fc
->partitions
);
527 for (i
= 0; i
< fc
->partitions
; i
++)
528 put_bits(pb
, 4, fc
->partition_to_class
[i
]);
530 for (i
= 0; i
< fc
->nclasses
; i
++) {
533 put_bits(pb
, 3, fc
->classes
[i
].dim
- 1);
534 put_bits(pb
, 2, fc
->classes
[i
].subclass
);
536 if (fc
->classes
[i
].subclass
)
537 put_bits(pb
, 8, fc
->classes
[i
].masterbook
);
539 books
= (1 << fc
->classes
[i
].subclass
);
541 for (j
= 0; j
< books
; j
++)
542 put_bits(pb
, 8, fc
->classes
[i
].books
[j
] + 1);
545 put_bits(pb
, 2, fc
->multiplier
- 1);
546 put_bits(pb
, 4, fc
->rangebits
);
548 for (i
= 2; i
< fc
->values
; i
++)
549 put_bits(pb
, fc
->rangebits
, fc
->list
[i
].x
);
552 static void put_residue_header(PutBitContext
*pb
, vorbis_enc_residue
*rc
)
556 put_bits(pb
, 16, rc
->type
);
558 put_bits(pb
, 24, rc
->begin
);
559 put_bits(pb
, 24, rc
->end
);
560 put_bits(pb
, 24, rc
->partition_size
- 1);
561 put_bits(pb
, 6, rc
->classifications
- 1);
562 put_bits(pb
, 8, rc
->classbook
);
564 for (i
= 0; i
< rc
->classifications
; i
++) {
566 for (j
= 0; j
< 8; j
++)
567 tmp
|= (rc
->books
[i
][j
] != -1) << j
;
569 put_bits(pb
, 3, tmp
& 7);
570 put_bits(pb
, 1, tmp
> 7);
573 put_bits(pb
, 5, tmp
>> 3);
576 for (i
= 0; i
< rc
->classifications
; i
++) {
578 for (j
= 0; j
< 8; j
++)
579 if (rc
->books
[i
][j
] != -1)
580 put_bits(pb
, 8, rc
->books
[i
][j
]);
584 static int put_main_header(vorbis_enc_context
*venc
, uint8_t **out
)
589 int buffer_len
= 50000;
590 uint8_t *buffer
= av_mallocz(buffer_len
), *p
= buffer
;
592 return AVERROR(ENOMEM
);
594 // identification header
595 init_put_bits(&pb
, p
, buffer_len
);
596 put_bits(&pb
, 8, 1); //magic
597 for (i
= 0; "vorbis"[i
]; i
++)
598 put_bits(&pb
, 8, "vorbis"[i
]);
599 put_bits32(&pb
, 0); // version
600 put_bits(&pb
, 8, venc
->channels
);
601 put_bits32(&pb
, venc
->sample_rate
);
602 put_bits32(&pb
, 0); // bitrate
603 put_bits32(&pb
, 0); // bitrate
604 put_bits32(&pb
, 0); // bitrate
605 put_bits(&pb
, 4, venc
->log2_blocksize
[0]);
606 put_bits(&pb
, 4, venc
->log2_blocksize
[1]);
607 put_bits(&pb
, 1, 1); // framing
610 hlens
[0] = put_bits_count(&pb
) >> 3;
611 buffer_len
-= hlens
[0];
615 init_put_bits(&pb
, p
, buffer_len
);
616 put_bits(&pb
, 8, 3); //magic
617 for (i
= 0; "vorbis"[i
]; i
++)
618 put_bits(&pb
, 8, "vorbis"[i
]);
619 put_bits32(&pb
, 0); // vendor length TODO
620 put_bits32(&pb
, 0); // amount of comments
621 put_bits(&pb
, 1, 1); // framing
624 hlens
[1] = put_bits_count(&pb
) >> 3;
625 buffer_len
-= hlens
[1];
629 init_put_bits(&pb
, p
, buffer_len
);
630 put_bits(&pb
, 8, 5); //magic
631 for (i
= 0; "vorbis"[i
]; i
++)
632 put_bits(&pb
, 8, "vorbis"[i
]);
635 put_bits(&pb
, 8, venc
->ncodebooks
- 1);
636 for (i
= 0; i
< venc
->ncodebooks
; i
++)
637 put_codebook_header(&pb
, &venc
->codebooks
[i
]);
639 // time domain, reserved, zero
641 put_bits(&pb
, 16, 0);
644 put_bits(&pb
, 6, venc
->nfloors
- 1);
645 for (i
= 0; i
< venc
->nfloors
; i
++)
646 put_floor_header(&pb
, &venc
->floors
[i
]);
649 put_bits(&pb
, 6, venc
->nresidues
- 1);
650 for (i
= 0; i
< venc
->nresidues
; i
++)
651 put_residue_header(&pb
, &venc
->residues
[i
]);
654 put_bits(&pb
, 6, venc
->nmappings
- 1);
655 for (i
= 0; i
< venc
->nmappings
; i
++) {
656 vorbis_enc_mapping
*mc
= &venc
->mappings
[i
];
658 put_bits(&pb
, 16, 0); // mapping type
660 put_bits(&pb
, 1, mc
->submaps
> 1);
662 put_bits(&pb
, 4, mc
->submaps
- 1);
664 put_bits(&pb
, 1, !!mc
->coupling_steps
);
665 if (mc
->coupling_steps
) {
666 put_bits(&pb
, 8, mc
->coupling_steps
- 1);
667 for (j
= 0; j
< mc
->coupling_steps
; j
++) {
668 put_bits(&pb
, ilog(venc
->channels
- 1), mc
->magnitude
[j
]);
669 put_bits(&pb
, ilog(venc
->channels
- 1), mc
->angle
[j
]);
673 put_bits(&pb
, 2, 0); // reserved
676 for (j
= 0; j
< venc
->channels
; j
++)
677 put_bits(&pb
, 4, mc
->mux
[j
]);
679 for (j
= 0; j
< mc
->submaps
; j
++) {
680 put_bits(&pb
, 8, 0); // reserved time configuration
681 put_bits(&pb
, 8, mc
->floor
[j
]);
682 put_bits(&pb
, 8, mc
->residue
[j
]);
687 put_bits(&pb
, 6, venc
->nmodes
- 1);
688 for (i
= 0; i
< venc
->nmodes
; i
++) {
689 put_bits(&pb
, 1, venc
->modes
[i
].blockflag
);
690 put_bits(&pb
, 16, 0); // reserved window type
691 put_bits(&pb
, 16, 0); // reserved transform type
692 put_bits(&pb
, 8, venc
->modes
[i
].mapping
);
695 put_bits(&pb
, 1, 1); // framing
698 hlens
[2] = put_bits_count(&pb
) >> 3;
700 len
= hlens
[0] + hlens
[1] + hlens
[2];
701 p
= *out
= av_mallocz(64 + len
+ len
/255);
703 return AVERROR(ENOMEM
);
706 p
+= av_xiphlacing(p
, hlens
[0]);
707 p
+= av_xiphlacing(p
, hlens
[1]);
709 for (i
= 0; i
< 3; i
++) {
710 memcpy(p
, buffer
+ buffer_len
, hlens
[i
]);
712 buffer_len
+= hlens
[i
];
719 static float get_floor_average(vorbis_enc_floor
* fc
, float *coeffs
, int i
)
721 int begin
= fc
->list
[fc
->list
[FFMAX(i
-1, 0)].sort
].x
;
722 int end
= fc
->list
[fc
->list
[FFMIN(i
+1, fc
->values
- 1)].sort
].x
;
726 for (j
= begin
; j
< end
; j
++)
727 average
+= fabs(coeffs
[j
]);
728 return average
/ (end
- begin
);
731 static void floor_fit(vorbis_enc_context
*venc
, vorbis_enc_floor
*fc
,
732 float *coeffs
, uint16_t *posts
, int samples
)
734 int range
= 255 / fc
->multiplier
+ 1;
736 float tot_average
= 0.0;
737 float averages
[MAX_FLOOR_VALUES
];
738 for (i
= 0; i
< fc
->values
; i
++) {
739 averages
[i
] = get_floor_average(fc
, coeffs
, i
);
740 tot_average
+= averages
[i
];
742 tot_average
/= fc
->values
;
743 tot_average
/= venc
->quality
;
745 for (i
= 0; i
< fc
->values
; i
++) {
746 int position
= fc
->list
[fc
->list
[i
].sort
].x
;
747 float average
= averages
[i
];
750 average
= sqrt(tot_average
* average
) * pow(1.25f
, position
*0.005f
); // MAGIC!
751 for (j
= 0; j
< range
- 1; j
++)
752 if (ff_vorbis_floor1_inverse_db_table
[j
* fc
->multiplier
] > average
)
754 posts
[fc
->list
[i
].sort
] = j
;
758 static int render_point(int x0
, int y0
, int x1
, int y1
, int x
)
760 return y0
+ (x
- x0
) * (y1
- y0
) / (x1
- x0
);
763 static int floor_encode(vorbis_enc_context
*venc
, vorbis_enc_floor
*fc
,
764 PutBitContext
*pb
, uint16_t *posts
,
765 float *floor
, int samples
)
767 int range
= 255 / fc
->multiplier
+ 1;
768 int coded
[MAX_FLOOR_VALUES
]; // first 2 values are unused
771 if (pb
->size_in_bits
- put_bits_count(pb
) < 1 + 2 * ilog(range
- 1))
772 return AVERROR(EINVAL
);
773 put_bits(pb
, 1, 1); // non zero
774 put_bits(pb
, ilog(range
- 1), posts
[0]);
775 put_bits(pb
, ilog(range
- 1), posts
[1]);
776 coded
[0] = coded
[1] = 1;
778 for (i
= 2; i
< fc
->values
; i
++) {
779 int predicted
= render_point(fc
->list
[fc
->list
[i
].low
].x
,
780 posts
[fc
->list
[i
].low
],
781 fc
->list
[fc
->list
[i
].high
].x
,
782 posts
[fc
->list
[i
].high
],
784 int highroom
= range
- predicted
;
785 int lowroom
= predicted
;
786 int room
= FFMIN(highroom
, lowroom
);
787 if (predicted
== posts
[i
]) {
788 coded
[i
] = 0; // must be used later as flag!
791 if (!coded
[fc
->list
[i
].low
])
792 coded
[fc
->list
[i
].low
] = -1;
793 if (!coded
[fc
->list
[i
].high
])
794 coded
[fc
->list
[i
].high
] = -1;
796 if (posts
[i
] > predicted
) {
797 if (posts
[i
] - predicted
> room
)
798 coded
[i
] = posts
[i
] - predicted
+ lowroom
;
800 coded
[i
] = (posts
[i
] - predicted
) << 1;
802 if (predicted
- posts
[i
] > room
)
803 coded
[i
] = predicted
- posts
[i
] + highroom
- 1;
805 coded
[i
] = ((predicted
- posts
[i
]) << 1) - 1;
810 for (i
= 0; i
< fc
->partitions
; i
++) {
811 vorbis_enc_floor_class
* c
= &fc
->classes
[fc
->partition_to_class
[i
]];
812 int k
, cval
= 0, csub
= 1<<c
->subclass
;
814 vorbis_enc_codebook
* book
= &venc
->codebooks
[c
->masterbook
];
816 for (k
= 0; k
< c
->dim
; k
++) {
818 for (l
= 0; l
< csub
; l
++) {
820 if (c
->books
[l
] != -1)
821 maxval
= venc
->codebooks
[c
->books
[l
]].nentries
;
822 // coded could be -1, but this still works, cause that is 0
823 if (coded
[counter
+ k
] < maxval
)
828 cshift
+= c
->subclass
;
830 if (put_codeword(pb
, book
, cval
))
831 return AVERROR(EINVAL
);
833 for (k
= 0; k
< c
->dim
; k
++) {
834 int book
= c
->books
[cval
& (csub
-1)];
835 int entry
= coded
[counter
++];
836 cval
>>= c
->subclass
;
841 if (put_codeword(pb
, &venc
->codebooks
[book
], entry
))
842 return AVERROR(EINVAL
);
846 ff_vorbis_floor1_render_list(fc
->list
, fc
->values
, posts
, coded
,
847 fc
->multiplier
, floor
, samples
);
852 static float *put_vector(vorbis_enc_codebook
*book
, PutBitContext
*pb
,
856 float distance
= FLT_MAX
;
857 assert(book
->dimensions
);
858 for (i
= 0; i
< book
->nentries
; i
++) {
859 float * vec
= book
->dimensions
+ i
* book
->ndimensions
, d
= book
->pow2
[i
];
863 for (j
= 0; j
< book
->ndimensions
; j
++)
864 d
-= vec
[j
] * num
[j
];
870 if (put_codeword(pb
, book
, entry
))
872 return &book
->dimensions
[entry
* book
->ndimensions
];
875 static int residue_encode(vorbis_enc_context
*venc
, vorbis_enc_residue
*rc
,
876 PutBitContext
*pb
, float *coeffs
, int samples
,
879 int pass
, i
, j
, p
, k
;
880 int psize
= rc
->partition_size
;
881 int partitions
= (rc
->end
- rc
->begin
) / psize
;
882 int channels
= (rc
->type
== 2) ? 1 : real_ch
;
883 int classes
[MAX_CHANNELS
][NUM_RESIDUE_PARTITIONS
];
884 int classwords
= venc
->codebooks
[rc
->classbook
].ndimensions
;
886 av_assert0(rc
->type
== 2);
887 av_assert0(real_ch
== 2);
888 for (p
= 0; p
< partitions
; p
++) {
889 float max1
= 0.0, max2
= 0.0;
890 int s
= rc
->begin
+ p
* psize
;
891 for (k
= s
; k
< s
+ psize
; k
+= 2) {
892 max1
= FFMAX(max1
, fabs(coeffs
[ k
/ real_ch
]));
893 max2
= FFMAX(max2
, fabs(coeffs
[samples
+ k
/ real_ch
]));
896 for (i
= 0; i
< rc
->classifications
- 1; i
++)
897 if (max1
< rc
->maxes
[i
][0] && max2
< rc
->maxes
[i
][1])
902 for (pass
= 0; pass
< 8; pass
++) {
904 while (p
< partitions
) {
906 for (j
= 0; j
< channels
; j
++) {
907 vorbis_enc_codebook
* book
= &venc
->codebooks
[rc
->classbook
];
909 for (i
= 0; i
< classwords
; i
++) {
910 entry
*= rc
->classifications
;
911 entry
+= classes
[j
][p
+ i
];
913 if (put_codeword(pb
, book
, entry
))
914 return AVERROR(EINVAL
);
916 for (i
= 0; i
< classwords
&& p
< partitions
; i
++, p
++) {
917 for (j
= 0; j
< channels
; j
++) {
918 int nbook
= rc
->books
[classes
[j
][p
]][pass
];
919 vorbis_enc_codebook
* book
= &venc
->codebooks
[nbook
];
920 float *buf
= coeffs
+ samples
*j
+ rc
->begin
+ p
*psize
;
924 assert(rc
->type
== 0 || rc
->type
== 2);
925 assert(!(psize
% book
->ndimensions
));
928 for (k
= 0; k
< psize
; k
+= book
->ndimensions
) {
930 float *a
= put_vector(book
, pb
, &buf
[k
]);
932 return AVERROR(EINVAL
);
933 for (l
= 0; l
< book
->ndimensions
; l
++)
937 int s
= rc
->begin
+ p
* psize
, a1
, b1
;
938 a1
= (s
% real_ch
) * samples
;
940 s
= real_ch
* samples
;
941 for (k
= 0; k
< psize
; k
+= book
->ndimensions
) {
942 int dim
, a2
= a1
, b2
= b1
;
943 float vec
[MAX_CODEBOOK_DIM
], *pv
= vec
;
944 for (dim
= book
->ndimensions
; dim
--; ) {
945 *pv
++ = coeffs
[a2
+ b2
];
946 if ((a2
+= samples
) == s
) {
951 pv
= put_vector(book
, pb
, vec
);
953 return AVERROR(EINVAL
);
954 for (dim
= book
->ndimensions
; dim
--; ) {
955 coeffs
[a1
+ b1
] -= *pv
++;
956 if ((a1
+= samples
) == s
) {
970 static int apply_window_and_mdct(vorbis_enc_context
*venc
,
971 float **audio
, int samples
)
974 const float * win
= venc
->win
[0];
975 int window_len
= 1 << (venc
->log2_blocksize
[0] - 1);
976 float n
= (float)(1 << venc
->log2_blocksize
[0]) / 4.0;
979 if (!venc
->have_saved
&& !samples
)
982 if (venc
->have_saved
) {
983 for (channel
= 0; channel
< venc
->channels
; channel
++)
984 memcpy(venc
->samples
+ channel
* window_len
* 2,
985 venc
->saved
+ channel
* window_len
, sizeof(float) * window_len
);
987 for (channel
= 0; channel
< venc
->channels
; channel
++)
988 memset(venc
->samples
+ channel
* window_len
* 2, 0,
989 sizeof(float) * window_len
);
993 for (channel
= 0; channel
< venc
->channels
; channel
++) {
994 float * offset
= venc
->samples
+ channel
*window_len
*2 + window_len
;
995 for (i
= 0; i
< samples
; i
++)
996 offset
[i
] = audio
[channel
][i
] / n
* win
[window_len
- i
- 1];
999 for (channel
= 0; channel
< venc
->channels
; channel
++)
1000 memset(venc
->samples
+ channel
* window_len
* 2 + window_len
,
1001 0, sizeof(float) * window_len
);
1004 for (channel
= 0; channel
< venc
->channels
; channel
++)
1005 venc
->mdct
[0].mdct_calc(&venc
->mdct
[0], venc
->coeffs
+ channel
* window_len
,
1006 venc
->samples
+ channel
* window_len
* 2);
1009 for (channel
= 0; channel
< venc
->channels
; channel
++) {
1010 float *offset
= venc
->saved
+ channel
* window_len
;
1011 for (i
= 0; i
< samples
; i
++)
1012 offset
[i
] = audio
[channel
][i
] / n
* win
[i
];
1014 venc
->have_saved
= 1;
1016 venc
->have_saved
= 0;
1021 static int vorbis_encode_frame(AVCodecContext
*avctx
, AVPacket
*avpkt
,
1022 const AVFrame
*frame
, int *got_packet_ptr
)
1024 vorbis_enc_context
*venc
= avctx
->priv_data
;
1025 float **audio
= frame
? (float **)frame
->extended_data
: NULL
;
1026 int samples
= frame
? frame
->nb_samples
: 0;
1027 vorbis_enc_mode
*mode
;
1028 vorbis_enc_mapping
*mapping
;
1032 if (!apply_window_and_mdct(venc
, audio
, samples
))
1034 samples
= 1 << (venc
->log2_blocksize
[0] - 1);
1036 if ((ret
= ff_alloc_packet2(avctx
, avpkt
, 8192)) < 0)
1039 init_put_bits(&pb
, avpkt
->data
, avpkt
->size
);
1041 if (pb
.size_in_bits
- put_bits_count(&pb
) < 1 + ilog(venc
->nmodes
- 1)) {
1042 av_log(avctx
, AV_LOG_ERROR
, "output buffer is too small\n");
1043 return AVERROR(EINVAL
);
1046 put_bits(&pb
, 1, 0); // magic bit
1048 put_bits(&pb
, ilog(venc
->nmodes
- 1), 0); // 0 bits, the mode
1050 mode
= &venc
->modes
[0];
1051 mapping
= &venc
->mappings
[mode
->mapping
];
1052 if (mode
->blockflag
) {
1053 put_bits(&pb
, 1, 0);
1054 put_bits(&pb
, 1, 0);
1057 for (i
= 0; i
< venc
->channels
; i
++) {
1058 vorbis_enc_floor
*fc
= &venc
->floors
[mapping
->floor
[mapping
->mux
[i
]]];
1059 uint16_t posts
[MAX_FLOOR_VALUES
];
1060 floor_fit(venc
, fc
, &venc
->coeffs
[i
* samples
], posts
, samples
);
1061 if (floor_encode(venc
, fc
, &pb
, posts
, &venc
->floor
[i
* samples
], samples
)) {
1062 av_log(avctx
, AV_LOG_ERROR
, "output buffer is too small\n");
1063 return AVERROR(EINVAL
);
1067 for (i
= 0; i
< venc
->channels
* samples
; i
++)
1068 venc
->coeffs
[i
] /= venc
->floor
[i
];
1070 for (i
= 0; i
< mapping
->coupling_steps
; i
++) {
1071 float *mag
= venc
->coeffs
+ mapping
->magnitude
[i
] * samples
;
1072 float *ang
= venc
->coeffs
+ mapping
->angle
[i
] * samples
;
1074 for (j
= 0; j
< samples
; j
++) {
1084 if (residue_encode(venc
, &venc
->residues
[mapping
->residue
[mapping
->mux
[0]]],
1085 &pb
, venc
->coeffs
, samples
, venc
->channels
)) {
1086 av_log(avctx
, AV_LOG_ERROR
, "output buffer is too small\n");
1087 return AVERROR(EINVAL
);
1090 flush_put_bits(&pb
);
1091 avpkt
->size
= put_bits_count(&pb
) >> 3;
1093 avpkt
->duration
= ff_samples_to_time_base(avctx
, avctx
->frame_size
);
1095 if (frame
->pts
!= AV_NOPTS_VALUE
)
1096 avpkt
->pts
= ff_samples_to_time_base(avctx
, frame
->pts
);
1098 avpkt
->pts
= venc
->next_pts
;
1100 if (avpkt
->pts
!= AV_NOPTS_VALUE
)
1101 venc
->next_pts
= avpkt
->pts
+ avpkt
->duration
;
1103 *got_packet_ptr
= 1;
1108 static av_cold
int vorbis_encode_close(AVCodecContext
*avctx
)
1110 vorbis_enc_context
*venc
= avctx
->priv_data
;
1113 if (venc
->codebooks
)
1114 for (i
= 0; i
< venc
->ncodebooks
; i
++) {
1115 av_freep(&venc
->codebooks
[i
].lens
);
1116 av_freep(&venc
->codebooks
[i
].codewords
);
1117 av_freep(&venc
->codebooks
[i
].quantlist
);
1118 av_freep(&venc
->codebooks
[i
].dimensions
);
1119 av_freep(&venc
->codebooks
[i
].pow2
);
1121 av_freep(&venc
->codebooks
);
1124 for (i
= 0; i
< venc
->nfloors
; i
++) {
1126 if (venc
->floors
[i
].classes
)
1127 for (j
= 0; j
< venc
->floors
[i
].nclasses
; j
++)
1128 av_freep(&venc
->floors
[i
].classes
[j
].books
);
1129 av_freep(&venc
->floors
[i
].classes
);
1130 av_freep(&venc
->floors
[i
].partition_to_class
);
1131 av_freep(&venc
->floors
[i
].list
);
1133 av_freep(&venc
->floors
);
1136 for (i
= 0; i
< venc
->nresidues
; i
++) {
1137 av_freep(&venc
->residues
[i
].books
);
1138 av_freep(&venc
->residues
[i
].maxes
);
1140 av_freep(&venc
->residues
);
1143 for (i
= 0; i
< venc
->nmappings
; i
++) {
1144 av_freep(&venc
->mappings
[i
].mux
);
1145 av_freep(&venc
->mappings
[i
].floor
);
1146 av_freep(&venc
->mappings
[i
].residue
);
1147 av_freep(&venc
->mappings
[i
].magnitude
);
1148 av_freep(&venc
->mappings
[i
].angle
);
1150 av_freep(&venc
->mappings
);
1152 av_freep(&venc
->modes
);
1154 av_freep(&venc
->saved
);
1155 av_freep(&venc
->samples
);
1156 av_freep(&venc
->floor
);
1157 av_freep(&venc
->coeffs
);
1159 ff_mdct_end(&venc
->mdct
[0]);
1160 ff_mdct_end(&venc
->mdct
[1]);
1162 av_freep(&avctx
->extradata
);
1167 static av_cold
int vorbis_encode_init(AVCodecContext
*avctx
)
1169 vorbis_enc_context
*venc
= avctx
->priv_data
;
1172 if (avctx
->channels
!= 2) {
1173 av_log(avctx
, AV_LOG_ERROR
, "Current FFmpeg Vorbis encoder only supports 2 channels.\n");
1177 if ((ret
= create_vorbis_context(venc
, avctx
)) < 0)
1180 avctx
->bit_rate
= 0;
1181 if (avctx
->flags
& CODEC_FLAG_QSCALE
)
1182 venc
->quality
= avctx
->global_quality
/ (float)FF_QP2LAMBDA
;
1185 venc
->quality
*= venc
->quality
;
1187 if ((ret
= put_main_header(venc
, (uint8_t**)&avctx
->extradata
)) < 0)
1189 avctx
->extradata_size
= ret
;
1191 avctx
->frame_size
= 1 << (venc
->log2_blocksize
[0] - 1);
1195 vorbis_encode_close(avctx
);
1199 AVCodec ff_vorbis_encoder
= {
1201 .long_name
= NULL_IF_CONFIG_SMALL("Vorbis"),
1202 .type
= AVMEDIA_TYPE_AUDIO
,
1203 .id
= AV_CODEC_ID_VORBIS
,
1204 .priv_data_size
= sizeof(vorbis_enc_context
),
1205 .init
= vorbis_encode_init
,
1206 .encode2
= vorbis_encode_frame
,
1207 .close
= vorbis_encode_close
,
1208 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_EXPERIMENTAL
,
1209 .sample_fmts
= (const enum AVSampleFormat
[]){ AV_SAMPLE_FMT_FLTP
,
1210 AV_SAMPLE_FMT_NONE
},