1/* 2 * copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org> 3 * 4 * This file is part of FFmpeg. 5 * 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. 10 * 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. 15 * 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 19 */ 20 21/** 22 * @file 23 * Native Vorbis encoder. 24 * @author Oded Shimon <ods15@ods15.dyndns.org> 25 */ 26 27#include <float.h> 28#include "libavutil/float_dsp.h" 29 30#include "avcodec.h" 31#include "codec_internal.h" 32#include "encode.h" 33#include "fft.h" 34#include "mathops.h" 35#include "vorbis.h" 36#include "vorbis_enc_data.h" 37 38#include "audio_frame_queue.h" 39#include "libavfilter/bufferqueue.h" 40 41#define BITSTREAM_WRITER_LE 42#include "put_bits.h" 43 44#undef NDEBUG 45#include <assert.h> 46 47typedef struct vorbis_enc_codebook { 48 int nentries; 49 uint8_t *lens; 50 uint32_t *codewords; 51 int ndimensions; 52 float min; 53 float delta; 54 int seq_p; 55 int lookup; 56 int *quantlist; 57 float *dimensions; 58 float *pow2; 59} vorbis_enc_codebook; 60 61typedef struct vorbis_enc_floor_class { 62 int dim; 63 int subclass; 64 int masterbook; 65 int *books; 66} vorbis_enc_floor_class; 67 68typedef struct vorbis_enc_floor { 69 int partitions; 70 int *partition_to_class; 71 int nclasses; 72 vorbis_enc_floor_class *classes; 73 int multiplier; 74 int rangebits; 75 int values; 76 vorbis_floor1_entry *list; 77} vorbis_enc_floor; 78 79typedef struct vorbis_enc_residue { 80 int type; 81 int begin; 82 int end; 83 int partition_size; 84 int classifications; 85 int classbook; 86 int8_t (*books)[8]; 87 float (*maxes)[2]; 88} vorbis_enc_residue; 89 90typedef struct vorbis_enc_mapping { 91 int submaps; 92 int *mux; 93 int *floor; 94 int *residue; 95 int coupling_steps; 96 int *magnitude; 97 int *angle; 98} vorbis_enc_mapping; 99 100typedef struct vorbis_enc_mode { 101 int blockflag; 102 int mapping; 103} vorbis_enc_mode; 104 105typedef struct vorbis_enc_context { 106 int channels; 107 int sample_rate; 108 int log2_blocksize[2]; 109 FFTContext mdct[2]; 110 const float *win[2]; 111 int have_saved; 112 float *saved; 113 float *samples; 114 float *floor; // also used for tmp values for mdct 115 float *coeffs; // also used for residue after floor 116 float *scratch; // used for tmp values for psy model 117 float quality; 118 119 AudioFrameQueue afq; 120 struct FFBufQueue bufqueue; 121 122 int ncodebooks; 123 vorbis_enc_codebook *codebooks; 124 125 int nfloors; 126 vorbis_enc_floor *floors; 127 128 int nresidues; 129 vorbis_enc_residue *residues; 130 131 int nmappings; 132 vorbis_enc_mapping *mappings; 133 134 int nmodes; 135 vorbis_enc_mode *modes; 136 137 int64_t next_pts; 138 139 AVFloatDSPContext *fdsp; 140} vorbis_enc_context; 141 142#define MAX_CHANNELS 2 143#define MAX_CODEBOOK_DIM 8 144 145#define MAX_FLOOR_CLASS_DIM 4 146#define NUM_FLOOR_PARTITIONS 8 147#define MAX_FLOOR_VALUES (MAX_FLOOR_CLASS_DIM*NUM_FLOOR_PARTITIONS+2) 148 149#define RESIDUE_SIZE 1600 150#define RESIDUE_PART_SIZE 32 151#define NUM_RESIDUE_PARTITIONS (RESIDUE_SIZE/RESIDUE_PART_SIZE) 152 153static inline int put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb, 154 int entry) 155{ 156 av_assert2(entry >= 0); 157 av_assert2(entry < cb->nentries); 158 av_assert2(cb->lens[entry]); 159 if (put_bits_left(pb) < cb->lens[entry]) 160 return AVERROR(EINVAL); 161 put_bits(pb, cb->lens[entry], cb->codewords[entry]); 162 return 0; 163} 164 165static int cb_lookup_vals(int lookup, int dimensions, int entries) 166{ 167 if (lookup == 1) 168 return ff_vorbis_nth_root(entries, dimensions); 169 else if (lookup == 2) 170 return dimensions *entries; 171 return 0; 172} 173 174static int ready_codebook(vorbis_enc_codebook *cb) 175{ 176 int i; 177 178 ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries); 179 180 if (!cb->lookup) { 181 cb->pow2 = cb->dimensions = NULL; 182 } else { 183 int vals = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries); 184 cb->dimensions = av_malloc_array(cb->nentries, sizeof(float) * cb->ndimensions); 185 cb->pow2 = av_calloc(cb->nentries, sizeof(*cb->pow2)); 186 if (!cb->dimensions || !cb->pow2) 187 return AVERROR(ENOMEM); 188 for (i = 0; i < cb->nentries; i++) { 189 float last = 0; 190 int j; 191 int div = 1; 192 for (j = 0; j < cb->ndimensions; j++) { 193 int off; 194 if (cb->lookup == 1) 195 off = (i / div) % vals; // lookup type 1 196 else 197 off = i * cb->ndimensions + j; // lookup type 2 198 199 cb->dimensions[i * cb->ndimensions + j] = last + cb->min + cb->quantlist[off] * cb->delta; 200 if (cb->seq_p) 201 last = cb->dimensions[i * cb->ndimensions + j]; 202 cb->pow2[i] += cb->dimensions[i * cb->ndimensions + j] * cb->dimensions[i * cb->ndimensions + j]; 203 div *= vals; 204 } 205 cb->pow2[i] /= 2.0; 206 } 207 } 208 return 0; 209} 210 211static int ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc) 212{ 213 int i; 214 av_assert0(rc->type == 2); 215 rc->maxes = av_calloc(rc->classifications, sizeof(*rc->maxes)); 216 if (!rc->maxes) 217 return AVERROR(ENOMEM); 218 for (i = 0; i < rc->classifications; i++) { 219 int j; 220 vorbis_enc_codebook * cb; 221 for (j = 0; j < 8; j++) 222 if (rc->books[i][j] != -1) 223 break; 224 if (j == 8) // zero 225 continue; 226 cb = &venc->codebooks[rc->books[i][j]]; 227 assert(cb->ndimensions >= 2); 228 assert(cb->lookup); 229 230 for (j = 0; j < cb->nentries; j++) { 231 float a; 232 if (!cb->lens[j]) 233 continue; 234 a = fabs(cb->dimensions[j * cb->ndimensions]); 235 if (a > rc->maxes[i][0]) 236 rc->maxes[i][0] = a; 237 a = fabs(cb->dimensions[j * cb->ndimensions + 1]); 238 if (a > rc->maxes[i][1]) 239 rc->maxes[i][1] = a; 240 } 241 } 242 // small bias 243 for (i = 0; i < rc->classifications; i++) { 244 rc->maxes[i][0] += 0.8; 245 rc->maxes[i][1] += 0.8; 246 } 247 return 0; 248} 249 250static av_cold int dsp_init(AVCodecContext *avctx, vorbis_enc_context *venc) 251{ 252 int ret = 0; 253 254 venc->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT); 255 if (!venc->fdsp) 256 return AVERROR(ENOMEM); 257 258 // init windows 259 venc->win[0] = ff_vorbis_vwin[venc->log2_blocksize[0] - 6]; 260 venc->win[1] = ff_vorbis_vwin[venc->log2_blocksize[1] - 6]; 261 262 if ((ret = ff_mdct_init(&venc->mdct[0], venc->log2_blocksize[0], 0, 1.0)) < 0) 263 return ret; 264 if ((ret = ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0, 1.0)) < 0) 265 return ret; 266 267 return 0; 268} 269 270static int create_vorbis_context(vorbis_enc_context *venc, 271 AVCodecContext *avctx) 272{ 273 vorbis_enc_floor *fc; 274 vorbis_enc_residue *rc; 275 vorbis_enc_mapping *mc; 276 const uint8_t *clens, *quant; 277 int i, book, ret; 278 279 venc->channels = avctx->ch_layout.nb_channels; 280 venc->sample_rate = avctx->sample_rate; 281 venc->log2_blocksize[0] = venc->log2_blocksize[1] = 11; 282 283 venc->ncodebooks = FF_ARRAY_ELEMS(cvectors); 284 venc->codebooks = av_mallocz(sizeof(vorbis_enc_codebook) * venc->ncodebooks); 285 if (!venc->codebooks) 286 return AVERROR(ENOMEM); 287 288 // codebook 0..14 - floor1 book, values 0..255 289 // codebook 15 residue masterbook 290 // codebook 16..29 residue 291 clens = codebooks; 292 quant = quant_tables; 293 for (book = 0; book < venc->ncodebooks; book++) { 294 vorbis_enc_codebook *cb = &venc->codebooks[book]; 295 int vals; 296 cb->ndimensions = cvectors[book].dim; 297 cb->nentries = cvectors[book].real_len; 298 cb->min = cvectors[book].min; 299 cb->delta = cvectors[book].delta; 300 cb->lookup = cvectors[book].lookup; 301 cb->seq_p = 0; 302 303 cb->lens = av_malloc_array(cb->nentries, sizeof(uint8_t)); 304 cb->codewords = av_malloc_array(cb->nentries, sizeof(uint32_t)); 305 if (!cb->lens || !cb->codewords) 306 return AVERROR(ENOMEM); 307 memcpy(cb->lens, clens, cvectors[book].len); 308 memset(cb->lens + cvectors[book].len, 0, cb->nentries - cvectors[book].len); 309 clens += cvectors[book].len; 310 311 if (cb->lookup) { 312 vals = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries); 313 cb->quantlist = av_malloc_array(vals, sizeof(int)); 314 if (!cb->quantlist) 315 return AVERROR(ENOMEM); 316 for (i = 0; i < vals; i++) 317 cb->quantlist[i] = *quant++; 318 } else { 319 cb->quantlist = NULL; 320 } 321 if ((ret = ready_codebook(cb)) < 0) 322 return ret; 323 } 324 325 venc->nfloors = 1; 326 venc->floors = av_mallocz(sizeof(vorbis_enc_floor) * venc->nfloors); 327 if (!venc->floors) 328 return AVERROR(ENOMEM); 329 330 // just 1 floor 331 fc = &venc->floors[0]; 332 fc->partitions = NUM_FLOOR_PARTITIONS; 333 fc->partition_to_class = av_malloc(sizeof(int) * fc->partitions); 334 if (!fc->partition_to_class) 335 return AVERROR(ENOMEM); 336 fc->nclasses = 0; 337 for (i = 0; i < fc->partitions; i++) { 338 static const int a[] = {0, 1, 2, 2, 3, 3, 4, 4}; 339 fc->partition_to_class[i] = a[i]; 340 fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]); 341 } 342 fc->nclasses++; 343 fc->classes = av_calloc(fc->nclasses, sizeof(vorbis_enc_floor_class)); 344 if (!fc->classes) 345 return AVERROR(ENOMEM); 346 for (i = 0; i < fc->nclasses; i++) { 347 vorbis_enc_floor_class * c = &fc->classes[i]; 348 int j, books; 349 c->dim = floor_classes[i].dim; 350 c->subclass = floor_classes[i].subclass; 351 c->masterbook = floor_classes[i].masterbook; 352 books = (1 << c->subclass); 353 c->books = av_malloc_array(books, sizeof(int)); 354 if (!c->books) 355 return AVERROR(ENOMEM); 356 for (j = 0; j < books; j++) 357 c->books[j] = floor_classes[i].nbooks[j]; 358 } 359 fc->multiplier = 2; 360 fc->rangebits = venc->log2_blocksize[1] - 1; 361 362 fc->values = 2; 363 for (i = 0; i < fc->partitions; i++) 364 fc->values += fc->classes[fc->partition_to_class[i]].dim; 365 366 fc->list = av_malloc_array(fc->values, sizeof(vorbis_floor1_entry)); 367 if (!fc->list) 368 return AVERROR(ENOMEM); 369 fc->list[0].x = 0; 370 fc->list[1].x = 1 << fc->rangebits; 371 for (i = 2; i < fc->values; i++) { 372 static const int a[] = { 373 93, 23,372, 6, 46,186,750, 14, 33, 65, 374 130,260,556, 3, 10, 18, 28, 39, 55, 79, 375 111,158,220,312,464,650,850 376 }; 377 fc->list[i].x = a[i - 2]; 378 } 379 if (ff_vorbis_ready_floor1_list(avctx, fc->list, fc->values)) 380 return AVERROR_BUG; 381 382 venc->nresidues = 1; 383 venc->residues = av_mallocz(sizeof(vorbis_enc_residue) * venc->nresidues); 384 if (!venc->residues) 385 return AVERROR(ENOMEM); 386 387 // single residue 388 rc = &venc->residues[0]; 389 rc->type = 2; 390 rc->begin = 0; 391 rc->end = 1600; 392 rc->partition_size = 32; 393 rc->classifications = 10; 394 rc->classbook = 15; 395 rc->books = av_malloc(sizeof(*rc->books) * rc->classifications); 396 if (!rc->books) 397 return AVERROR(ENOMEM); 398 { 399 static const int8_t a[10][8] = { 400 { -1, -1, -1, -1, -1, -1, -1, -1, }, 401 { -1, -1, 16, -1, -1, -1, -1, -1, }, 402 { -1, -1, 17, -1, -1, -1, -1, -1, }, 403 { -1, -1, 18, -1, -1, -1, -1, -1, }, 404 { -1, -1, 19, -1, -1, -1, -1, -1, }, 405 { -1, -1, 20, -1, -1, -1, -1, -1, }, 406 { -1, -1, 21, -1, -1, -1, -1, -1, }, 407 { 22, 23, -1, -1, -1, -1, -1, -1, }, 408 { 24, 25, -1, -1, -1, -1, -1, -1, }, 409 { 26, 27, 28, -1, -1, -1, -1, -1, }, 410 }; 411 memcpy(rc->books, a, sizeof a); 412 } 413 if ((ret = ready_residue(rc, venc)) < 0) 414 return ret; 415 416 venc->nmappings = 1; 417 venc->mappings = av_mallocz(sizeof(vorbis_enc_mapping) * venc->nmappings); 418 if (!venc->mappings) 419 return AVERROR(ENOMEM); 420 421 // single mapping 422 mc = &venc->mappings[0]; 423 mc->submaps = 1; 424 mc->mux = av_malloc(sizeof(int) * venc->channels); 425 if (!mc->mux) 426 return AVERROR(ENOMEM); 427 for (i = 0; i < venc->channels; i++) 428 mc->mux[i] = 0; 429 mc->floor = av_malloc(sizeof(int) * mc->submaps); 430 mc->residue = av_malloc(sizeof(int) * mc->submaps); 431 if (!mc->floor || !mc->residue) 432 return AVERROR(ENOMEM); 433 for (i = 0; i < mc->submaps; i++) { 434 mc->floor[i] = 0; 435 mc->residue[i] = 0; 436 } 437 mc->coupling_steps = venc->channels == 2 ? 1 : 0; 438 mc->magnitude = av_malloc(sizeof(int) * mc->coupling_steps); 439 mc->angle = av_malloc(sizeof(int) * mc->coupling_steps); 440 if (!mc->magnitude || !mc->angle) 441 return AVERROR(ENOMEM); 442 if (mc->coupling_steps) { 443 mc->magnitude[0] = 0; 444 mc->angle[0] = 1; 445 } 446 447 venc->nmodes = 2; 448 venc->modes = av_malloc(sizeof(vorbis_enc_mode) * venc->nmodes); 449 if (!venc->modes) 450 return AVERROR(ENOMEM); 451 452 // Short block 453 venc->modes[0].blockflag = 0; 454 venc->modes[0].mapping = 0; 455 // Long block 456 venc->modes[1].blockflag = 1; 457 venc->modes[1].mapping = 0; 458 459 venc->have_saved = 0; 460 venc->saved = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2); 461 venc->samples = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1])); 462 venc->floor = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2); 463 venc->coeffs = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2); 464 venc->scratch = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1])); 465 466 if (!venc->saved || !venc->samples || !venc->floor || !venc->coeffs || !venc->scratch) 467 return AVERROR(ENOMEM); 468 469 if ((ret = dsp_init(avctx, venc)) < 0) 470 return ret; 471 472 return 0; 473} 474 475static void put_float(PutBitContext *pb, float f) 476{ 477 int exp, mant; 478 uint32_t res = 0; 479 mant = (int)ldexp(frexp(f, &exp), 20); 480 exp += 788 - 20; 481 if (mant < 0) { 482 res |= (1U << 31); 483 mant = -mant; 484 } 485 res |= mant | (exp << 21); 486 put_bits32(pb, res); 487} 488 489static void put_codebook_header(PutBitContext *pb, vorbis_enc_codebook *cb) 490{ 491 int i; 492 int ordered = 0; 493 494 put_bits(pb, 24, 0x564342); //magic 495 put_bits(pb, 16, cb->ndimensions); 496 put_bits(pb, 24, cb->nentries); 497 498 for (i = 1; i < cb->nentries; i++) 499 if (cb->lens[i] < cb->lens[i-1]) 500 break; 501 if (i == cb->nentries) 502 ordered = 1; 503 504 put_bits(pb, 1, ordered); 505 if (ordered) { 506 int len = cb->lens[0]; 507 put_bits(pb, 5, len - 1); 508 i = 0; 509 while (i < cb->nentries) { 510 int j; 511 for (j = 0; j+i < cb->nentries; j++) 512 if (cb->lens[j+i] != len) 513 break; 514 put_bits(pb, ilog(cb->nentries - i), j); 515 i += j; 516 len++; 517 } 518 } else { 519 int sparse = 0; 520 for (i = 0; i < cb->nentries; i++) 521 if (!cb->lens[i]) 522 break; 523 if (i != cb->nentries) 524 sparse = 1; 525 put_bits(pb, 1, sparse); 526 527 for (i = 0; i < cb->nentries; i++) { 528 if (sparse) 529 put_bits(pb, 1, !!cb->lens[i]); 530 if (cb->lens[i]) 531 put_bits(pb, 5, cb->lens[i] - 1); 532 } 533 } 534 535 put_bits(pb, 4, cb->lookup); 536 if (cb->lookup) { 537 int tmp = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries); 538 int bits = ilog(cb->quantlist[0]); 539 540 for (i = 1; i < tmp; i++) 541 bits = FFMAX(bits, ilog(cb->quantlist[i])); 542 543 put_float(pb, cb->min); 544 put_float(pb, cb->delta); 545 546 put_bits(pb, 4, bits - 1); 547 put_bits(pb, 1, cb->seq_p); 548 549 for (i = 0; i < tmp; i++) 550 put_bits(pb, bits, cb->quantlist[i]); 551 } 552} 553 554static void put_floor_header(PutBitContext *pb, vorbis_enc_floor *fc) 555{ 556 int i; 557 558 put_bits(pb, 16, 1); // type, only floor1 is supported 559 560 put_bits(pb, 5, fc->partitions); 561 562 for (i = 0; i < fc->partitions; i++) 563 put_bits(pb, 4, fc->partition_to_class[i]); 564 565 for (i = 0; i < fc->nclasses; i++) { 566 int j, books; 567 568 put_bits(pb, 3, fc->classes[i].dim - 1); 569 put_bits(pb, 2, fc->classes[i].subclass); 570 571 if (fc->classes[i].subclass) 572 put_bits(pb, 8, fc->classes[i].masterbook); 573 574 books = (1 << fc->classes[i].subclass); 575 576 for (j = 0; j < books; j++) 577 put_bits(pb, 8, fc->classes[i].books[j] + 1); 578 } 579 580 put_bits(pb, 2, fc->multiplier - 1); 581 put_bits(pb, 4, fc->rangebits); 582 583 for (i = 2; i < fc->values; i++) 584 put_bits(pb, fc->rangebits, fc->list[i].x); 585} 586 587static void put_residue_header(PutBitContext *pb, vorbis_enc_residue *rc) 588{ 589 int i; 590 591 put_bits(pb, 16, rc->type); 592 593 put_bits(pb, 24, rc->begin); 594 put_bits(pb, 24, rc->end); 595 put_bits(pb, 24, rc->partition_size - 1); 596 put_bits(pb, 6, rc->classifications - 1); 597 put_bits(pb, 8, rc->classbook); 598 599 for (i = 0; i < rc->classifications; i++) { 600 int j, tmp = 0; 601 for (j = 0; j < 8; j++) 602 tmp |= (rc->books[i][j] != -1) << j; 603 604 put_bits(pb, 3, tmp & 7); 605 put_bits(pb, 1, tmp > 7); 606 607 if (tmp > 7) 608 put_bits(pb, 5, tmp >> 3); 609 } 610 611 for (i = 0; i < rc->classifications; i++) { 612 int j; 613 for (j = 0; j < 8; j++) 614 if (rc->books[i][j] != -1) 615 put_bits(pb, 8, rc->books[i][j]); 616 } 617} 618 619static int put_main_header(vorbis_enc_context *venc, uint8_t **out) 620{ 621 int i; 622 PutBitContext pb; 623 int len, hlens[3]; 624 int buffer_len = 50000; 625 uint8_t *buffer = av_mallocz(buffer_len), *p = buffer; 626 if (!buffer) 627 return AVERROR(ENOMEM); 628 629 // identification header 630 init_put_bits(&pb, p, buffer_len); 631 put_bits(&pb, 8, 1); //magic 632 for (i = 0; "vorbis"[i]; i++) 633 put_bits(&pb, 8, "vorbis"[i]); 634 put_bits32(&pb, 0); // version 635 put_bits(&pb, 8, venc->channels); 636 put_bits32(&pb, venc->sample_rate); 637 put_bits32(&pb, 0); // bitrate 638 put_bits32(&pb, 0); // bitrate 639 put_bits32(&pb, 0); // bitrate 640 put_bits(&pb, 4, venc->log2_blocksize[0]); 641 put_bits(&pb, 4, venc->log2_blocksize[1]); 642 put_bits(&pb, 1, 1); // framing 643 644 flush_put_bits(&pb); 645 hlens[0] = put_bytes_output(&pb); 646 buffer_len -= hlens[0]; 647 p += hlens[0]; 648 649 // comment header 650 init_put_bits(&pb, p, buffer_len); 651 put_bits(&pb, 8, 3); //magic 652 for (i = 0; "vorbis"[i]; i++) 653 put_bits(&pb, 8, "vorbis"[i]); 654 put_bits32(&pb, 0); // vendor length TODO 655 put_bits32(&pb, 0); // amount of comments 656 put_bits(&pb, 1, 1); // framing 657 658 flush_put_bits(&pb); 659 hlens[1] = put_bytes_output(&pb); 660 buffer_len -= hlens[1]; 661 p += hlens[1]; 662 663 // setup header 664 init_put_bits(&pb, p, buffer_len); 665 put_bits(&pb, 8, 5); //magic 666 for (i = 0; "vorbis"[i]; i++) 667 put_bits(&pb, 8, "vorbis"[i]); 668 669 // codebooks 670 put_bits(&pb, 8, venc->ncodebooks - 1); 671 for (i = 0; i < venc->ncodebooks; i++) 672 put_codebook_header(&pb, &venc->codebooks[i]); 673 674 // time domain, reserved, zero 675 put_bits(&pb, 6, 0); 676 put_bits(&pb, 16, 0); 677 678 // floors 679 put_bits(&pb, 6, venc->nfloors - 1); 680 for (i = 0; i < venc->nfloors; i++) 681 put_floor_header(&pb, &venc->floors[i]); 682 683 // residues 684 put_bits(&pb, 6, venc->nresidues - 1); 685 for (i = 0; i < venc->nresidues; i++) 686 put_residue_header(&pb, &venc->residues[i]); 687 688 // mappings 689 put_bits(&pb, 6, venc->nmappings - 1); 690 for (i = 0; i < venc->nmappings; i++) { 691 vorbis_enc_mapping *mc = &venc->mappings[i]; 692 int j; 693 put_bits(&pb, 16, 0); // mapping type 694 695 put_bits(&pb, 1, mc->submaps > 1); 696 if (mc->submaps > 1) 697 put_bits(&pb, 4, mc->submaps - 1); 698 699 put_bits(&pb, 1, !!mc->coupling_steps); 700 if (mc->coupling_steps) { 701 put_bits(&pb, 8, mc->coupling_steps - 1); 702 for (j = 0; j < mc->coupling_steps; j++) { 703 put_bits(&pb, ilog(venc->channels - 1), mc->magnitude[j]); 704 put_bits(&pb, ilog(venc->channels - 1), mc->angle[j]); 705 } 706 } 707 708 put_bits(&pb, 2, 0); // reserved 709 710 if (mc->submaps > 1) 711 for (j = 0; j < venc->channels; j++) 712 put_bits(&pb, 4, mc->mux[j]); 713 714 for (j = 0; j < mc->submaps; j++) { 715 put_bits(&pb, 8, 0); // reserved time configuration 716 put_bits(&pb, 8, mc->floor[j]); 717 put_bits(&pb, 8, mc->residue[j]); 718 } 719 } 720 721 // modes 722 put_bits(&pb, 6, venc->nmodes - 1); 723 for (i = 0; i < venc->nmodes; i++) { 724 put_bits(&pb, 1, venc->modes[i].blockflag); 725 put_bits(&pb, 16, 0); // reserved window type 726 put_bits(&pb, 16, 0); // reserved transform type 727 put_bits(&pb, 8, venc->modes[i].mapping); 728 } 729 730 put_bits(&pb, 1, 1); // framing 731 732 flush_put_bits(&pb); 733 hlens[2] = put_bytes_output(&pb); 734 735 len = hlens[0] + hlens[1] + hlens[2]; 736 p = *out = av_mallocz(64 + len + len/255); 737 if (!p) 738 return AVERROR(ENOMEM); 739 740 *p++ = 2; 741 p += av_xiphlacing(p, hlens[0]); 742 p += av_xiphlacing(p, hlens[1]); 743 buffer_len = 0; 744 for (i = 0; i < 3; i++) { 745 memcpy(p, buffer + buffer_len, hlens[i]); 746 p += hlens[i]; 747 buffer_len += hlens[i]; 748 } 749 750 av_freep(&buffer); 751 return p - *out; 752} 753 754static float get_floor_average(vorbis_enc_floor * fc, float *coeffs, int i) 755{ 756 int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x; 757 int end = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x; 758 int j; 759 float average = 0; 760 761 for (j = begin; j < end; j++) 762 average += fabs(coeffs[j]); 763 return average / (end - begin); 764} 765 766static void floor_fit(vorbis_enc_context *venc, vorbis_enc_floor *fc, 767 float *coeffs, uint16_t *posts, int samples) 768{ 769 int range = 255 / fc->multiplier + 1; 770 int i; 771 float tot_average = 0.0; 772 float averages[MAX_FLOOR_VALUES]; 773 for (i = 0; i < fc->values; i++) { 774 averages[i] = get_floor_average(fc, coeffs, i); 775 tot_average += averages[i]; 776 } 777 tot_average /= fc->values; 778 tot_average /= venc->quality; 779 780 for (i = 0; i < fc->values; i++) { 781 int position = fc->list[fc->list[i].sort].x; 782 float average = averages[i]; 783 int j; 784 785 average = sqrt(tot_average * average) * pow(1.25f, position*0.005f); // MAGIC! 786 for (j = 0; j < range - 1; j++) 787 if (ff_vorbis_floor1_inverse_db_table[j * fc->multiplier] > average) 788 break; 789 posts[fc->list[i].sort] = j; 790 } 791} 792 793static int render_point(int x0, int y0, int x1, int y1, int x) 794{ 795 return y0 + (x - x0) * (y1 - y0) / (x1 - x0); 796} 797 798static int floor_encode(vorbis_enc_context *venc, vorbis_enc_floor *fc, 799 PutBitContext *pb, uint16_t *posts, 800 float *floor, int samples) 801{ 802 int range = 255 / fc->multiplier + 1; 803 int coded[MAX_FLOOR_VALUES]; // first 2 values are unused 804 int i, counter; 805 806 if (put_bits_left(pb) < 1 + 2 * ilog(range - 1)) 807 return AVERROR(EINVAL); 808 put_bits(pb, 1, 1); // non zero 809 put_bits(pb, ilog(range - 1), posts[0]); 810 put_bits(pb, ilog(range - 1), posts[1]); 811 coded[0] = coded[1] = 1; 812 813 for (i = 2; i < fc->values; i++) { 814 int predicted = render_point(fc->list[fc->list[i].low].x, 815 posts[fc->list[i].low], 816 fc->list[fc->list[i].high].x, 817 posts[fc->list[i].high], 818 fc->list[i].x); 819 int highroom = range - predicted; 820 int lowroom = predicted; 821 int room = FFMIN(highroom, lowroom); 822 if (predicted == posts[i]) { 823 coded[i] = 0; // must be used later as flag! 824 continue; 825 } else { 826 if (!coded[fc->list[i].low ]) 827 coded[fc->list[i].low ] = -1; 828 if (!coded[fc->list[i].high]) 829 coded[fc->list[i].high] = -1; 830 } 831 if (posts[i] > predicted) { 832 if (posts[i] - predicted > room) 833 coded[i] = posts[i] - predicted + lowroom; 834 else 835 coded[i] = (posts[i] - predicted) << 1; 836 } else { 837 if (predicted - posts[i] > room) 838 coded[i] = predicted - posts[i] + highroom - 1; 839 else 840 coded[i] = ((predicted - posts[i]) << 1) - 1; 841 } 842 } 843 844 counter = 2; 845 for (i = 0; i < fc->partitions; i++) { 846 vorbis_enc_floor_class * c = &fc->classes[fc->partition_to_class[i]]; 847 int k, cval = 0, csub = 1<<c->subclass; 848 if (c->subclass) { 849 vorbis_enc_codebook * book = &venc->codebooks[c->masterbook]; 850 int cshift = 0; 851 for (k = 0; k < c->dim; k++) { 852 int l; 853 for (l = 0; l < csub; l++) { 854 int maxval = 1; 855 if (c->books[l] != -1) 856 maxval = venc->codebooks[c->books[l]].nentries; 857 // coded could be -1, but this still works, cause that is 0 858 if (coded[counter + k] < maxval) 859 break; 860 } 861 assert(l != csub); 862 cval |= l << cshift; 863 cshift += c->subclass; 864 } 865 if (put_codeword(pb, book, cval)) 866 return AVERROR(EINVAL); 867 } 868 for (k = 0; k < c->dim; k++) { 869 int book = c->books[cval & (csub-1)]; 870 int entry = coded[counter++]; 871 cval >>= c->subclass; 872 if (book == -1) 873 continue; 874 if (entry == -1) 875 entry = 0; 876 if (put_codeword(pb, &venc->codebooks[book], entry)) 877 return AVERROR(EINVAL); 878 } 879 } 880 881 ff_vorbis_floor1_render_list(fc->list, fc->values, posts, coded, 882 fc->multiplier, floor, samples); 883 884 return 0; 885} 886 887static float *put_vector(vorbis_enc_codebook *book, PutBitContext *pb, 888 float *num) 889{ 890 int i, entry = -1; 891 float distance = FLT_MAX; 892 assert(book->dimensions); 893 for (i = 0; i < book->nentries; i++) { 894 float * vec = book->dimensions + i * book->ndimensions, d = book->pow2[i]; 895 int j; 896 if (!book->lens[i]) 897 continue; 898 for (j = 0; j < book->ndimensions; j++) 899 d -= vec[j] * num[j]; 900 if (distance > d) { 901 entry = i; 902 distance = d; 903 } 904 } 905 if (put_codeword(pb, book, entry)) 906 return NULL; 907 return &book->dimensions[entry * book->ndimensions]; 908} 909 910static int residue_encode(vorbis_enc_context *venc, vorbis_enc_residue *rc, 911 PutBitContext *pb, float *coeffs, int samples, 912 int real_ch) 913{ 914 int pass, i, j, p, k; 915 int psize = rc->partition_size; 916 int partitions = (rc->end - rc->begin) / psize; 917 int channels = (rc->type == 2) ? 1 : real_ch; 918 int classes[MAX_CHANNELS][NUM_RESIDUE_PARTITIONS]; 919 int classwords = venc->codebooks[rc->classbook].ndimensions; 920 921 av_assert0(rc->type == 2); 922 av_assert0(real_ch == 2); 923 for (p = 0; p < partitions; p++) { 924 float max1 = 0.0, max2 = 0.0; 925 int s = rc->begin + p * psize; 926 for (k = s; k < s + psize; k += 2) { 927 max1 = FFMAX(max1, fabs(coeffs[ k / real_ch])); 928 max2 = FFMAX(max2, fabs(coeffs[samples + k / real_ch])); 929 } 930 931 for (i = 0; i < rc->classifications - 1; i++) 932 if (max1 < rc->maxes[i][0] && max2 < rc->maxes[i][1]) 933 break; 934 classes[0][p] = i; 935 } 936 937 for (pass = 0; pass < 8; pass++) { 938 p = 0; 939 while (p < partitions) { 940 if (pass == 0) 941 for (j = 0; j < channels; j++) { 942 vorbis_enc_codebook * book = &venc->codebooks[rc->classbook]; 943 int entry = 0; 944 for (i = 0; i < classwords; i++) { 945 entry *= rc->classifications; 946 entry += classes[j][p + i]; 947 } 948 if (put_codeword(pb, book, entry)) 949 return AVERROR(EINVAL); 950 } 951 for (i = 0; i < classwords && p < partitions; i++, p++) { 952 for (j = 0; j < channels; j++) { 953 int nbook = rc->books[classes[j][p]][pass]; 954 vorbis_enc_codebook * book = &venc->codebooks[nbook]; 955 float *buf = coeffs + samples*j + rc->begin + p*psize; 956 if (nbook == -1) 957 continue; 958 959 assert(rc->type == 0 || rc->type == 2); 960 assert(!(psize % book->ndimensions)); 961 962 if (rc->type == 0) { 963 for (k = 0; k < psize; k += book->ndimensions) { 964 int l; 965 float *a = put_vector(book, pb, &buf[k]); 966 if (!a) 967 return AVERROR(EINVAL); 968 for (l = 0; l < book->ndimensions; l++) 969 buf[k + l] -= a[l]; 970 } 971 } else { 972 int s = rc->begin + p * psize, a1, b1; 973 a1 = (s % real_ch) * samples; 974 b1 = s / real_ch; 975 s = real_ch * samples; 976 for (k = 0; k < psize; k += book->ndimensions) { 977 int dim, a2 = a1, b2 = b1; 978 float vec[MAX_CODEBOOK_DIM], *pv = vec; 979 for (dim = book->ndimensions; dim--; ) { 980 *pv++ = coeffs[a2 + b2]; 981 if ((a2 += samples) == s) { 982 a2 = 0; 983 b2++; 984 } 985 } 986 pv = put_vector(book, pb, vec); 987 if (!pv) 988 return AVERROR(EINVAL); 989 for (dim = book->ndimensions; dim--; ) { 990 coeffs[a1 + b1] -= *pv++; 991 if ((a1 += samples) == s) { 992 a1 = 0; 993 b1++; 994 } 995 } 996 } 997 } 998 } 999 } 1000 } 1001 } 1002 return 0; 1003} 1004 1005static int apply_window_and_mdct(vorbis_enc_context *venc) 1006{ 1007 int channel; 1008 const float * win = venc->win[1]; 1009 int window_len = 1 << (venc->log2_blocksize[1] - 1); 1010 float n = (float)(1 << venc->log2_blocksize[1]) / 4.0; 1011 AVFloatDSPContext *fdsp = venc->fdsp; 1012 1013 for (channel = 0; channel < venc->channels; channel++) { 1014 float *offset = venc->samples + channel * window_len * 2; 1015 1016 fdsp->vector_fmul(offset, offset, win, window_len); 1017 fdsp->vector_fmul_scalar(offset, offset, 1/n, window_len); 1018 1019 offset += window_len; 1020 1021 fdsp->vector_fmul_reverse(offset, offset, win, window_len); 1022 fdsp->vector_fmul_scalar(offset, offset, 1/n, window_len); 1023 1024 venc->mdct[1].mdct_calc(&venc->mdct[1], venc->coeffs + channel * window_len, 1025 venc->samples + channel * window_len * 2); 1026 } 1027 return 1; 1028} 1029 1030/* Used for padding the last encoded packet */ 1031static AVFrame *spawn_empty_frame(AVCodecContext *avctx, int channels) 1032{ 1033 AVFrame *f = av_frame_alloc(); 1034 int ch; 1035 1036 if (!f) 1037 return NULL; 1038 1039 f->format = avctx->sample_fmt; 1040 f->nb_samples = avctx->frame_size; 1041 f->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC; 1042 f->ch_layout.nb_channels = channels; 1043 1044 if (av_frame_get_buffer(f, 4)) { 1045 av_frame_free(&f); 1046 return NULL; 1047 } 1048 1049 for (ch = 0; ch < channels; ch++) { 1050 size_t bps = av_get_bytes_per_sample(f->format); 1051 memset(f->extended_data[ch], 0, bps * f->nb_samples); 1052 } 1053 return f; 1054} 1055 1056/* Set up audio samples for psy analysis and window/mdct */ 1057static void move_audio(vorbis_enc_context *venc, int sf_size) 1058{ 1059 AVFrame *cur = NULL; 1060 int frame_size = 1 << (venc->log2_blocksize[1] - 1); 1061 int subframes = frame_size / sf_size; 1062 int sf, ch; 1063 1064 /* Copy samples from last frame into current frame */ 1065 if (venc->have_saved) 1066 for (ch = 0; ch < venc->channels; ch++) 1067 memcpy(venc->samples + 2 * ch * frame_size, 1068 venc->saved + ch * frame_size, sizeof(float) * frame_size); 1069 else 1070 for (ch = 0; ch < venc->channels; ch++) 1071 memset(venc->samples + 2 * ch * frame_size, 0, sizeof(float) * frame_size); 1072 1073 for (sf = 0; sf < subframes; sf++) { 1074 cur = ff_bufqueue_get(&venc->bufqueue); 1075 1076 for (ch = 0; ch < venc->channels; ch++) { 1077 float *offset = venc->samples + 2 * ch * frame_size + frame_size; 1078 float *save = venc->saved + ch * frame_size; 1079 const float *input = (float *) cur->extended_data[ch]; 1080 const size_t len = cur->nb_samples * sizeof(float); 1081 1082 memcpy(offset + sf*sf_size, input, len); 1083 memcpy(save + sf*sf_size, input, len); // Move samples for next frame 1084 } 1085 av_frame_free(&cur); 1086 } 1087 venc->have_saved = 1; 1088 memcpy(venc->scratch, venc->samples, 2 * venc->channels * frame_size); 1089} 1090 1091static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, 1092 const AVFrame *frame, int *got_packet_ptr) 1093{ 1094 vorbis_enc_context *venc = avctx->priv_data; 1095 int i, ret, need_more; 1096 int frame_size = 1 << (venc->log2_blocksize[1] - 1); 1097 vorbis_enc_mode *mode; 1098 vorbis_enc_mapping *mapping; 1099 PutBitContext pb; 1100 1101 if (frame) { 1102 AVFrame *clone; 1103 if ((ret = ff_af_queue_add(&venc->afq, frame)) < 0) 1104 return ret; 1105 clone = av_frame_clone(frame); 1106 if (!clone) 1107 return AVERROR(ENOMEM); 1108 ff_bufqueue_add(avctx, &venc->bufqueue, clone); 1109 } else 1110 if (!venc->afq.remaining_samples) 1111 return 0; 1112 1113 need_more = venc->bufqueue.available * avctx->frame_size < frame_size; 1114 need_more = frame && need_more; 1115 if (need_more) 1116 return 0; 1117 1118 /* Pad the bufqueue with empty frames for encoding the last packet. */ 1119 if (!frame) { 1120 if (venc->bufqueue.available * avctx->frame_size < frame_size) { 1121 int frames_needed = (frame_size/avctx->frame_size) - venc->bufqueue.available; 1122 int i; 1123 1124 for (i = 0; i < frames_needed; i++) { 1125 AVFrame *empty = spawn_empty_frame(avctx, venc->channels); 1126 if (!empty) 1127 return AVERROR(ENOMEM); 1128 1129 ff_bufqueue_add(avctx, &venc->bufqueue, empty); 1130 } 1131 } 1132 } 1133 1134 move_audio(venc, avctx->frame_size); 1135 1136 if (!apply_window_and_mdct(venc)) 1137 return 0; 1138 1139 if ((ret = ff_alloc_packet(avctx, avpkt, 8192)) < 0) 1140 return ret; 1141 1142 init_put_bits(&pb, avpkt->data, avpkt->size); 1143 1144 put_bits(&pb, 1, 0); // magic bit 1145 1146 put_bits(&pb, ilog(venc->nmodes - 1), 1); // Mode for current frame 1147 1148 mode = &venc->modes[1]; 1149 mapping = &venc->mappings[mode->mapping]; 1150 if (mode->blockflag) { 1151 put_bits(&pb, 1, 1); // Previous windowflag 1152 put_bits(&pb, 1, 1); // Next windowflag 1153 } 1154 1155 for (i = 0; i < venc->channels; i++) { 1156 vorbis_enc_floor *fc = &venc->floors[mapping->floor[mapping->mux[i]]]; 1157 uint16_t posts[MAX_FLOOR_VALUES]; 1158 floor_fit(venc, fc, &venc->coeffs[i * frame_size], posts, frame_size); 1159 if (floor_encode(venc, fc, &pb, posts, &venc->floor[i * frame_size], frame_size)) { 1160 av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); 1161 return AVERROR(EINVAL); 1162 } 1163 } 1164 1165 for (i = 0; i < venc->channels * frame_size; i++) 1166 venc->coeffs[i] /= venc->floor[i]; 1167 1168 for (i = 0; i < mapping->coupling_steps; i++) { 1169 float *mag = venc->coeffs + mapping->magnitude[i] * frame_size; 1170 float *ang = venc->coeffs + mapping->angle[i] * frame_size; 1171 int j; 1172 for (j = 0; j < frame_size; j++) { 1173 float a = ang[j]; 1174 ang[j] -= mag[j]; 1175 if (mag[j] > 0) 1176 ang[j] = -ang[j]; 1177 if (ang[j] < 0) 1178 mag[j] = a; 1179 } 1180 } 1181 1182 if (residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]], 1183 &pb, venc->coeffs, frame_size, venc->channels)) { 1184 av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n"); 1185 return AVERROR(EINVAL); 1186 } 1187 1188 flush_put_bits(&pb); 1189 avpkt->size = put_bytes_output(&pb); 1190 1191 ff_af_queue_remove(&venc->afq, frame_size, &avpkt->pts, &avpkt->duration); 1192 1193 if (frame_size > avpkt->duration) { 1194 uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10); 1195 if (!side) 1196 return AVERROR(ENOMEM); 1197 AV_WL32(&side[4], frame_size - avpkt->duration); 1198 } 1199 1200 *got_packet_ptr = 1; 1201 return 0; 1202} 1203 1204 1205static av_cold int vorbis_encode_close(AVCodecContext *avctx) 1206{ 1207 vorbis_enc_context *venc = avctx->priv_data; 1208 int i; 1209 1210 if (venc->codebooks) 1211 for (i = 0; i < venc->ncodebooks; i++) { 1212 av_freep(&venc->codebooks[i].lens); 1213 av_freep(&venc->codebooks[i].codewords); 1214 av_freep(&venc->codebooks[i].quantlist); 1215 av_freep(&venc->codebooks[i].dimensions); 1216 av_freep(&venc->codebooks[i].pow2); 1217 } 1218 av_freep(&venc->codebooks); 1219 1220 if (venc->floors) 1221 for (i = 0; i < venc->nfloors; i++) { 1222 int j; 1223 if (venc->floors[i].classes) 1224 for (j = 0; j < venc->floors[i].nclasses; j++) 1225 av_freep(&venc->floors[i].classes[j].books); 1226 av_freep(&venc->floors[i].classes); 1227 av_freep(&venc->floors[i].partition_to_class); 1228 av_freep(&venc->floors[i].list); 1229 } 1230 av_freep(&venc->floors); 1231 1232 if (venc->residues) 1233 for (i = 0; i < venc->nresidues; i++) { 1234 av_freep(&venc->residues[i].books); 1235 av_freep(&venc->residues[i].maxes); 1236 } 1237 av_freep(&venc->residues); 1238 1239 if (venc->mappings) 1240 for (i = 0; i < venc->nmappings; i++) { 1241 av_freep(&venc->mappings[i].mux); 1242 av_freep(&venc->mappings[i].floor); 1243 av_freep(&venc->mappings[i].residue); 1244 av_freep(&venc->mappings[i].magnitude); 1245 av_freep(&venc->mappings[i].angle); 1246 } 1247 av_freep(&venc->mappings); 1248 1249 av_freep(&venc->modes); 1250 1251 av_freep(&venc->saved); 1252 av_freep(&venc->samples); 1253 av_freep(&venc->floor); 1254 av_freep(&venc->coeffs); 1255 av_freep(&venc->scratch); 1256 av_freep(&venc->fdsp); 1257 1258 ff_mdct_end(&venc->mdct[0]); 1259 ff_mdct_end(&venc->mdct[1]); 1260 ff_af_queue_close(&venc->afq); 1261 ff_bufqueue_discard_all(&venc->bufqueue); 1262 1263 return 0 ; 1264} 1265 1266static av_cold int vorbis_encode_init(AVCodecContext *avctx) 1267{ 1268 vorbis_enc_context *venc = avctx->priv_data; 1269 int ret; 1270 1271 if (avctx->ch_layout.nb_channels != 2) { 1272 av_log(avctx, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n"); 1273 return -1; 1274 } 1275 1276 if ((ret = create_vorbis_context(venc, avctx)) < 0) 1277 return ret; 1278 1279 avctx->bit_rate = 0; 1280 if (avctx->flags & AV_CODEC_FLAG_QSCALE) 1281 venc->quality = avctx->global_quality / (float)FF_QP2LAMBDA; 1282 else 1283 venc->quality = 8; 1284 venc->quality *= venc->quality; 1285 1286 if ((ret = put_main_header(venc, (uint8_t**)&avctx->extradata)) < 0) 1287 return ret; 1288 avctx->extradata_size = ret; 1289 1290 avctx->frame_size = 64; 1291 avctx->initial_padding = 1 << (venc->log2_blocksize[1] - 1); 1292 1293 ff_af_queue_init(avctx, &venc->afq); 1294 1295 return 0; 1296} 1297 1298const FFCodec ff_vorbis_encoder = { 1299 .p.name = "vorbis", 1300 .p.long_name = NULL_IF_CONFIG_SMALL("Vorbis"), 1301 .p.type = AVMEDIA_TYPE_AUDIO, 1302 .p.id = AV_CODEC_ID_VORBIS, 1303 .priv_data_size = sizeof(vorbis_enc_context), 1304 .init = vorbis_encode_init, 1305 FF_CODEC_ENCODE_CB(vorbis_encode_frame), 1306 .close = vorbis_encode_close, 1307 .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL, 1308 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, 1309 AV_SAMPLE_FMT_NONE }, 1310 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 1311}; 1312