Mercurial > libavcodec.hg
comparison vorbis_enc.c @ 3917:62849ae93c2b libavcodec
slightly saner indention
author | michael |
---|---|
date | Mon, 02 Oct 2006 11:31:52 +0000 |
parents | a4f6e6981930 |
children | 56c8e3ab7fe0 |
comparison
equal
deleted
inserted
replaced
3916:77cb5bdaf963 | 3917:62849ae93c2b |
---|---|
170 assert(cb->lens[entry]); | 170 assert(cb->lens[entry]); |
171 put_bits(pb, cb->lens[entry], cb->codewords[entry]); | 171 put_bits(pb, cb->lens[entry], cb->codewords[entry]); |
172 } | 172 } |
173 | 173 |
174 static int cb_lookup_vals(int lookup, int dimentions, int entries) { | 174 static int cb_lookup_vals(int lookup, int dimentions, int entries) { |
175 if (lookup == 1) return ff_vorbis_nth_root(entries, dimentions); | 175 if (lookup == 1) return ff_vorbis_nth_root(entries, dimentions); |
176 else if (lookup == 2) return dimentions * entries; | 176 else if (lookup == 2) return dimentions * entries; |
177 return 0; | 177 return 0; |
178 } | 178 } |
179 | 179 |
180 static void ready_codebook(codebook_t * cb) { | 180 static void ready_codebook(codebook_t * cb) { |
181 int i; | 181 int i; |
182 | 182 |
183 ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries); | 183 ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries); |
184 | 184 |
185 if (!cb->lookup) cb->pow2 = cb->dimentions = NULL; | 185 if (!cb->lookup) |
186 cb->pow2 = cb->dimentions = NULL; | |
186 else { | 187 else { |
187 int vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries); | 188 int vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries); |
188 cb->dimentions = av_malloc(sizeof(float) * cb->nentries * cb->ndimentions); | 189 cb->dimentions = av_malloc(sizeof(float) * cb->nentries * cb->ndimentions); |
189 cb->pow2 = av_mallocz(sizeof(float) * cb->nentries); | 190 cb->pow2 = av_mallocz(sizeof(float) * cb->nentries); |
190 for (i = 0; i < cb->nentries; i++) { | 191 for (i = 0; i < cb->nentries; i++) { |
191 float last = 0; | 192 float last = 0; |
192 int j; | 193 int j; |
193 int div = 1; | 194 int div = 1; |
194 for (j = 0; j < cb->ndimentions; j++) { | 195 for (j = 0; j < cb->ndimentions; j++) { |
195 int off; | 196 int off; |
196 if (cb->lookup == 1) off = (i / div) % vals; // lookup type 1 | 197 if (cb->lookup == 1) |
197 else off = i * cb->ndimentions + j; // lookup type 2 | 198 off = (i / div) % vals; // lookup type 1 |
199 else | |
200 off = i * cb->ndimentions + j; // lookup type 2 | |
198 | 201 |
199 cb->dimentions[i * cb->ndimentions + j] = last + cb->min + cb->quantlist[off] * cb->delta; | 202 cb->dimentions[i * cb->ndimentions + j] = last + cb->min + cb->quantlist[off] * cb->delta; |
200 if (cb->seq_p) last = cb->dimentions[i * cb->ndimentions + j]; | 203 if (cb->seq_p) |
204 last = cb->dimentions[i * cb->ndimentions + j]; | |
201 cb->pow2[i] += cb->dimentions[i * cb->ndimentions + j]*cb->dimentions[i * cb->ndimentions + j]; | 205 cb->pow2[i] += cb->dimentions[i * cb->ndimentions + j]*cb->dimentions[i * cb->ndimentions + j]; |
202 div *= vals; | 206 div *= vals; |
203 } | 207 } |
204 cb->pow2[i] /= 2.; | 208 cb->pow2[i] /= 2.; |
205 } | 209 } |
206 } | 210 } |
207 | |
208 } | 211 } |
209 | 212 |
210 static void ready_residue(residue_t * rc, venc_context_t * venc) { | 213 static void ready_residue(residue_t * rc, venc_context_t * venc) { |
211 int i; | 214 int i; |
212 assert(rc->type == 2); | 215 assert(rc->type == 2); |
213 rc->maxes = av_mallocz(sizeof(float[2]) * rc->classifications); | 216 rc->maxes = av_mallocz(sizeof(float[2]) * rc->classifications); |
214 for (i = 0; i < rc->classifications; i++) { | 217 for (i = 0; i < rc->classifications; i++) { |
215 int j; | 218 int j; |
216 codebook_t * cb; | 219 codebook_t * cb; |
217 for (j = 0; j < 8; j++) if (rc->books[i][j] != -1) break; | 220 for (j = 0; j < 8; j++) |
221 if (rc->books[i][j] != -1) break; | |
218 if (j == 8) continue; // zero | 222 if (j == 8) continue; // zero |
219 cb = &venc->codebooks[rc->books[i][j]]; | 223 cb = &venc->codebooks[rc->books[i][j]]; |
220 assert(cb->ndimentions >= 2); | 224 assert(cb->ndimentions >= 2); |
221 assert(cb->lookup); | 225 assert(cb->lookup); |
222 | 226 |
223 for (j = 0; j < cb->nentries; j++) { | 227 for (j = 0; j < cb->nentries; j++) { |
224 float a; | 228 float a; |
225 if (!cb->lens[j]) continue; | 229 if (!cb->lens[j]) continue; |
226 a = fabs(cb->dimentions[j * cb->ndimentions]); | 230 a = fabs(cb->dimentions[j * cb->ndimentions]); |
227 if (a > rc->maxes[i][0]) rc->maxes[i][0] = a; | 231 if (a > rc->maxes[i][0]) |
232 rc->maxes[i][0] = a; | |
228 a = fabs(cb->dimentions[j * cb->ndimentions + 1]); | 233 a = fabs(cb->dimentions[j * cb->ndimentions + 1]); |
229 if (a > rc->maxes[i][1]) rc->maxes[i][1] = a; | 234 if (a > rc->maxes[i][1]) |
235 rc->maxes[i][1] = a; | |
230 } | 236 } |
231 } | 237 } |
232 // small bias | 238 // small bias |
233 for (i = 0; i < rc->classifications; i++) { | 239 for (i = 0; i < rc->classifications; i++) { |
234 rc->maxes[i][0] += 0.8; | 240 rc->maxes[i][0] += 0.8; |
268 memset(cb->lens + cvectors[book].len, 0, cb->nentries - cvectors[book].len); | 274 memset(cb->lens + cvectors[book].len, 0, cb->nentries - cvectors[book].len); |
269 | 275 |
270 if (cb->lookup) { | 276 if (cb->lookup) { |
271 vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries); | 277 vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries); |
272 cb->quantlist = av_malloc(sizeof(int) * vals); | 278 cb->quantlist = av_malloc(sizeof(int) * vals); |
273 for (i = 0; i < vals; i++) cb->quantlist[i] = cvectors[book].quant[i]; | 279 for (i = 0; i < vals; i++) |
280 cb->quantlist[i] = cvectors[book].quant[i]; | |
274 } else { | 281 } else { |
275 cb->quantlist = NULL; | 282 cb->quantlist = NULL; |
276 } | 283 } |
277 ready_codebook(cb); | 284 ready_codebook(cb); |
278 } | 285 } |
298 c->dim = floor_classes[i].dim; | 305 c->dim = floor_classes[i].dim; |
299 c->subclass = floor_classes[i].subclass; | 306 c->subclass = floor_classes[i].subclass; |
300 c->masterbook = floor_classes[i].masterbook; | 307 c->masterbook = floor_classes[i].masterbook; |
301 books = (1 << c->subclass); | 308 books = (1 << c->subclass); |
302 c->books = av_malloc(sizeof(int) * books); | 309 c->books = av_malloc(sizeof(int) * books); |
303 for (j = 0; j < books; j++) c->books[j] = floor_classes[i].nbooks[j]; | 310 for (j = 0; j < books; j++) |
311 c->books[j] = floor_classes[i].nbooks[j]; | |
304 } | 312 } |
305 fc->multiplier = 2; | 313 fc->multiplier = 2; |
306 fc->rangebits = venc->log2_blocksize[0] - 1; | 314 fc->rangebits = venc->log2_blocksize[0] - 1; |
307 | 315 |
308 fc->values = 2; | 316 fc->values = 2; |
356 | 364 |
357 // single mapping | 365 // single mapping |
358 mc = &venc->mappings[0]; | 366 mc = &venc->mappings[0]; |
359 mc->submaps = 1; | 367 mc->submaps = 1; |
360 mc->mux = av_malloc(sizeof(int) * venc->channels); | 368 mc->mux = av_malloc(sizeof(int) * venc->channels); |
361 for (i = 0; i < venc->channels; i++) mc->mux[i] = 0; | 369 for (i = 0; i < venc->channels; i++) |
370 mc->mux[i] = 0; | |
362 mc->floor = av_malloc(sizeof(int) * mc->submaps); | 371 mc->floor = av_malloc(sizeof(int) * mc->submaps); |
363 mc->residue = av_malloc(sizeof(int) * mc->submaps); | 372 mc->residue = av_malloc(sizeof(int) * mc->submaps); |
364 for (i = 0; i < mc->submaps; i++) { | 373 for (i = 0; i < mc->submaps; i++) { |
365 mc->floor[i] = 0; | 374 mc->floor[i] = 0; |
366 mc->residue[i] = 0; | 375 mc->residue[i] = 0; |
409 | 418 |
410 put_bits(pb, 24, 0x564342); //magic | 419 put_bits(pb, 24, 0x564342); //magic |
411 put_bits(pb, 16, cb->ndimentions); | 420 put_bits(pb, 16, cb->ndimentions); |
412 put_bits(pb, 24, cb->nentries); | 421 put_bits(pb, 24, cb->nentries); |
413 | 422 |
414 for (i = 1; i < cb->nentries; i++) if (cb->lens[i] < cb->lens[i-1]) break; | 423 for (i = 1; i < cb->nentries; i++) |
415 if (i == cb->nentries) ordered = 1; | 424 if (cb->lens[i] < cb->lens[i-1]) break; |
425 if (i == cb->nentries) | |
426 ordered = 1; | |
416 | 427 |
417 put_bits(pb, 1, ordered); | 428 put_bits(pb, 1, ordered); |
418 if (ordered) { | 429 if (ordered) { |
419 int len = cb->lens[0]; | 430 int len = cb->lens[0]; |
420 put_bits(pb, 5, len - 1); | 431 put_bits(pb, 5, len - 1); |
421 i = 0; | 432 i = 0; |
422 while (i < cb->nentries) { | 433 while (i < cb->nentries) { |
423 int j; | 434 int j; |
424 for (j = 0; j+i < cb->nentries; j++) if (cb->lens[j+i] != len) break; | 435 for (j = 0; j+i < cb->nentries; j++) |
436 if (cb->lens[j+i] != len) break; | |
425 put_bits(pb, ilog(cb->nentries - i), j); | 437 put_bits(pb, ilog(cb->nentries - i), j); |
426 i += j; | 438 i += j; |
427 len++; | 439 len++; |
428 } | 440 } |
429 } else { | 441 } else { |
430 int sparse = 0; | 442 int sparse = 0; |
431 for (i = 0; i < cb->nentries; i++) if (!cb->lens[i]) break; | 443 for (i = 0; i < cb->nentries; i++) |
432 if (i != cb->nentries) sparse = 1; | 444 if (!cb->lens[i]) break; |
445 if (i != cb->nentries) | |
446 sparse = 1; | |
433 put_bits(pb, 1, sparse); | 447 put_bits(pb, 1, sparse); |
434 | 448 |
435 for (i = 0; i < cb->nentries; i++) { | 449 for (i = 0; i < cb->nentries; i++) { |
436 if (sparse) put_bits(pb, 1, !!cb->lens[i]); | 450 if (sparse) put_bits(pb, 1, !!cb->lens[i]); |
437 if (cb->lens[i]) put_bits(pb, 5, cb->lens[i] - 1); | 451 if (cb->lens[i]) put_bits(pb, 5, cb->lens[i] - 1); |
441 put_bits(pb, 4, cb->lookup); | 455 put_bits(pb, 4, cb->lookup); |
442 if (cb->lookup) { | 456 if (cb->lookup) { |
443 int tmp = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries); | 457 int tmp = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries); |
444 int bits = ilog(cb->quantlist[0]); | 458 int bits = ilog(cb->quantlist[0]); |
445 | 459 |
446 for (i = 1; i < tmp; i++) bits = FFMAX(bits, ilog(cb->quantlist[i])); | 460 for (i = 1; i < tmp; i++) |
461 bits = FFMAX(bits, ilog(cb->quantlist[i])); | |
447 | 462 |
448 put_float(pb, cb->min); | 463 put_float(pb, cb->min); |
449 put_float(pb, cb->delta); | 464 put_float(pb, cb->delta); |
450 | 465 |
451 put_bits(pb, 4, bits - 1); | 466 put_bits(pb, 4, bits - 1); |
452 put_bits(pb, 1, cb->seq_p); | 467 put_bits(pb, 1, cb->seq_p); |
453 | 468 |
454 for (i = 0; i < tmp; i++) put_bits(pb, bits, cb->quantlist[i]); | 469 for (i = 0; i < tmp; i++) |
470 put_bits(pb, bits, cb->quantlist[i]); | |
455 } | 471 } |
456 } | 472 } |
457 | 473 |
458 static void put_floor_header(PutBitContext * pb, floor_t * fc) { | 474 static void put_floor_header(PutBitContext * pb, floor_t * fc) { |
459 int i; | 475 int i; |
460 | 476 |
461 put_bits(pb, 16, 1); // type, only floor1 is supported | 477 put_bits(pb, 16, 1); // type, only floor1 is supported |
462 | 478 |
463 put_bits(pb, 5, fc->partitions); | 479 put_bits(pb, 5, fc->partitions); |
464 | 480 |
465 for (i = 0; i < fc->partitions; i++) put_bits(pb, 4, fc->partition_to_class[i]); | 481 for (i = 0; i < fc->partitions; i++) |
482 put_bits(pb, 4, fc->partition_to_class[i]); | |
466 | 483 |
467 for (i = 0; i < fc->nclasses; i++) { | 484 for (i = 0; i < fc->nclasses; i++) { |
468 int j, books; | 485 int j, books; |
469 | 486 |
470 put_bits(pb, 3, fc->classes[i].dim - 1); | 487 put_bits(pb, 3, fc->classes[i].dim - 1); |
471 put_bits(pb, 2, fc->classes[i].subclass); | 488 put_bits(pb, 2, fc->classes[i].subclass); |
472 | 489 |
473 if (fc->classes[i].subclass) put_bits(pb, 8, fc->classes[i].masterbook); | 490 if (fc->classes[i].subclass) |
491 put_bits(pb, 8, fc->classes[i].masterbook); | |
474 | 492 |
475 books = (1 << fc->classes[i].subclass); | 493 books = (1 << fc->classes[i].subclass); |
476 | 494 |
477 for (j = 0; j < books; j++) put_bits(pb, 8, fc->classes[i].books[j] + 1); | 495 for (j = 0; j < books; j++) |
496 put_bits(pb, 8, fc->classes[i].books[j] + 1); | |
478 } | 497 } |
479 | 498 |
480 put_bits(pb, 2, fc->multiplier - 1); | 499 put_bits(pb, 2, fc->multiplier - 1); |
481 put_bits(pb, 4, fc->rangebits); | 500 put_bits(pb, 4, fc->rangebits); |
482 | 501 |
483 for (i = 2; i < fc->values; i++) put_bits(pb, fc->rangebits, fc->list[i].x); | 502 for (i = 2; i < fc->values; i++) |
503 put_bits(pb, fc->rangebits, fc->list[i].x); | |
484 } | 504 } |
485 | 505 |
486 static void put_residue_header(PutBitContext * pb, residue_t * rc) { | 506 static void put_residue_header(PutBitContext * pb, residue_t * rc) { |
487 int i; | 507 int i; |
488 | 508 |
494 put_bits(pb, 6, rc->classifications - 1); | 514 put_bits(pb, 6, rc->classifications - 1); |
495 put_bits(pb, 8, rc->classbook); | 515 put_bits(pb, 8, rc->classbook); |
496 | 516 |
497 for (i = 0; i < rc->classifications; i++) { | 517 for (i = 0; i < rc->classifications; i++) { |
498 int j, tmp = 0; | 518 int j, tmp = 0; |
499 for (j = 0; j < 8; j++) tmp |= (rc->books[i][j] != -1) << j; | 519 for (j = 0; j < 8; j++) |
520 tmp |= (rc->books[i][j] != -1) << j; | |
500 | 521 |
501 put_bits(pb, 3, tmp & 7); | 522 put_bits(pb, 3, tmp & 7); |
502 put_bits(pb, 1, tmp > 7); | 523 put_bits(pb, 1, tmp > 7); |
503 | 524 |
504 if (tmp > 7) put_bits(pb, 5, tmp >> 3); | 525 if (tmp > 7) |
526 put_bits(pb, 5, tmp >> 3); | |
505 } | 527 } |
506 | 528 |
507 for (i = 0; i < rc->classifications; i++) { | 529 for (i = 0; i < rc->classifications; i++) { |
508 int j; | 530 int j; |
509 for (j = 0; j < 8; j++) | 531 for (j = 0; j < 8; j++) |
520 int len, hlens[3]; | 542 int len, hlens[3]; |
521 | 543 |
522 // identification header | 544 // identification header |
523 init_put_bits(&pb, p, buffer_len); | 545 init_put_bits(&pb, p, buffer_len); |
524 put_bits(&pb, 8, 1); //magic | 546 put_bits(&pb, 8, 1); //magic |
525 for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]); | 547 for (i = 0; "vorbis"[i]; i++) |
548 put_bits(&pb, 8, "vorbis"[i]); | |
526 put_bits(&pb, 32, 0); // version | 549 put_bits(&pb, 32, 0); // version |
527 put_bits(&pb, 8, venc->channels); | 550 put_bits(&pb, 8, venc->channels); |
528 put_bits(&pb, 32, venc->sample_rate); | 551 put_bits(&pb, 32, venc->sample_rate); |
529 put_bits(&pb, 32, 0); // bitrate | 552 put_bits(&pb, 32, 0); // bitrate |
530 put_bits(&pb, 32, 0); // bitrate | 553 put_bits(&pb, 32, 0); // bitrate |
539 p += hlens[0]; | 562 p += hlens[0]; |
540 | 563 |
541 // comment header | 564 // comment header |
542 init_put_bits(&pb, p, buffer_len); | 565 init_put_bits(&pb, p, buffer_len); |
543 put_bits(&pb, 8, 3); //magic | 566 put_bits(&pb, 8, 3); //magic |
544 for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]); | 567 for (i = 0; "vorbis"[i]; i++) |
568 put_bits(&pb, 8, "vorbis"[i]); | |
545 put_bits(&pb, 32, 0); // vendor length TODO | 569 put_bits(&pb, 32, 0); // vendor length TODO |
546 put_bits(&pb, 32, 0); // amount of comments | 570 put_bits(&pb, 32, 0); // amount of comments |
547 put_bits(&pb, 1, 1); // framing | 571 put_bits(&pb, 1, 1); // framing |
548 | 572 |
549 flush_put_bits(&pb); | 573 flush_put_bits(&pb); |
552 p += hlens[1]; | 576 p += hlens[1]; |
553 | 577 |
554 // setup header | 578 // setup header |
555 init_put_bits(&pb, p, buffer_len); | 579 init_put_bits(&pb, p, buffer_len); |
556 put_bits(&pb, 8, 5); //magic | 580 put_bits(&pb, 8, 5); //magic |
557 for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]); | 581 for (i = 0; "vorbis"[i]; i++) |
582 put_bits(&pb, 8, "vorbis"[i]); | |
558 | 583 |
559 // codebooks | 584 // codebooks |
560 put_bits(&pb, 8, venc->ncodebooks - 1); | 585 put_bits(&pb, 8, venc->ncodebooks - 1); |
561 for (i = 0; i < venc->ncodebooks; i++) put_codebook_header(&pb, &venc->codebooks[i]); | 586 for (i = 0; i < venc->ncodebooks; i++) |
587 put_codebook_header(&pb, &venc->codebooks[i]); | |
562 | 588 |
563 // time domain, reserved, zero | 589 // time domain, reserved, zero |
564 put_bits(&pb, 6, 0); | 590 put_bits(&pb, 6, 0); |
565 put_bits(&pb, 16, 0); | 591 put_bits(&pb, 16, 0); |
566 | 592 |
567 // floors | 593 // floors |
568 put_bits(&pb, 6, venc->nfloors - 1); | 594 put_bits(&pb, 6, venc->nfloors - 1); |
569 for (i = 0; i < venc->nfloors; i++) put_floor_header(&pb, &venc->floors[i]); | 595 for (i = 0; i < venc->nfloors; i++) |
596 put_floor_header(&pb, &venc->floors[i]); | |
570 | 597 |
571 // residues | 598 // residues |
572 put_bits(&pb, 6, venc->nresidues - 1); | 599 put_bits(&pb, 6, venc->nresidues - 1); |
573 for (i = 0; i < venc->nresidues; i++) put_residue_header(&pb, &venc->residues[i]); | 600 for (i = 0; i < venc->nresidues; i++) |
601 put_residue_header(&pb, &venc->residues[i]); | |
574 | 602 |
575 // mappings | 603 // mappings |
576 put_bits(&pb, 6, venc->nmappings - 1); | 604 put_bits(&pb, 6, venc->nmappings - 1); |
577 for (i = 0; i < venc->nmappings; i++) { | 605 for (i = 0; i < venc->nmappings; i++) { |
578 mapping_t * mc = &venc->mappings[i]; | 606 mapping_t * mc = &venc->mappings[i]; |
579 int j; | 607 int j; |
580 put_bits(&pb, 16, 0); // mapping type | 608 put_bits(&pb, 16, 0); // mapping type |
581 | 609 |
582 put_bits(&pb, 1, mc->submaps > 1); | 610 put_bits(&pb, 1, mc->submaps > 1); |
583 if (mc->submaps > 1) put_bits(&pb, 4, mc->submaps - 1); | 611 if (mc->submaps > 1) |
612 put_bits(&pb, 4, mc->submaps - 1); | |
584 | 613 |
585 put_bits(&pb, 1, !!mc->coupling_steps); | 614 put_bits(&pb, 1, !!mc->coupling_steps); |
586 if (mc->coupling_steps) { | 615 if (mc->coupling_steps) { |
587 put_bits(&pb, 8, mc->coupling_steps - 1); | 616 put_bits(&pb, 8, mc->coupling_steps - 1); |
588 for (j = 0; j < mc->coupling_steps; j++) { | 617 for (j = 0; j < mc->coupling_steps; j++) { |
591 } | 620 } |
592 } | 621 } |
593 | 622 |
594 put_bits(&pb, 2, 0); // reserved | 623 put_bits(&pb, 2, 0); // reserved |
595 | 624 |
596 if (mc->submaps > 1) for (j = 0; j < venc->channels; j++) put_bits(&pb, 4, mc->mux[j]); | 625 if (mc->submaps > 1) |
626 for (j = 0; j < venc->channels; j++) | |
627 put_bits(&pb, 4, mc->mux[j]); | |
597 | 628 |
598 for (j = 0; j < mc->submaps; j++) { | 629 for (j = 0; j < mc->submaps; j++) { |
599 put_bits(&pb, 8, 0); // reserved time configuration | 630 put_bits(&pb, 8, 0); // reserved time configuration |
600 put_bits(&pb, 8, mc->floor[j]); | 631 put_bits(&pb, 8, mc->floor[j]); |
601 put_bits(&pb, 8, mc->residue[j]); | 632 put_bits(&pb, 8, mc->residue[j]); |
636 int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x; | 667 int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x; |
637 int end = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x; | 668 int end = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x; |
638 int j; | 669 int j; |
639 float average = 0; | 670 float average = 0; |
640 | 671 |
641 for (j = begin; j < end; j++) average += fabs(coeffs[j]); | 672 for (j = begin; j < end; j++) |
673 average += fabs(coeffs[j]); | |
642 return average / (end - begin); | 674 return average / (end - begin); |
643 } | 675 } |
644 | 676 |
645 static void floor_fit(venc_context_t * venc, floor_t * fc, float * coeffs, uint_fast16_t * posts, int samples) { | 677 static void floor_fit(venc_context_t * venc, floor_t * fc, float * coeffs, uint_fast16_t * posts, int samples) { |
646 int range = 255 / fc->multiplier + 1; | 678 int range = 255 / fc->multiplier + 1; |
647 int i; | 679 int i; |
648 float tot_average = 0.; | 680 float tot_average = 0.; |
649 float averages[fc->values]; | 681 float averages[fc->values]; |
650 for (i = 0; i < fc->values; i++) tot_average += averages[i] = get_floor_average(fc, coeffs, i); | 682 for (i = 0; i < fc->values; i++){ |
683 averages[i] = get_floor_average(fc, coeffs, i); | |
684 tot_average += averages[i]; | |
685 } | |
651 tot_average /= fc->values; | 686 tot_average /= fc->values; |
652 tot_average /= venc->quality; | 687 tot_average /= venc->quality; |
653 | 688 |
654 for (i = 0; i < fc->values; i++) { | 689 for (i = 0; i < fc->values; i++) { |
655 int position = fc->list[fc->list[i].sort].x; | 690 int position = fc->list[fc->list[i].sort].x; |
656 float average = averages[i]; | 691 float average = averages[i]; |
657 int j; | 692 int j; |
658 | 693 |
659 average *= pow(tot_average / average, 0.5) * pow(1.25, position/200.); // MAGIC! | 694 average *= pow(tot_average / average, 0.5) * pow(1.25, position/200.); // MAGIC! |
660 for (j = 0; j < range - 1; j++) if (ff_vorbis_floor1_inverse_db_table[j * fc->multiplier] > average) break; | 695 for (j = 0; j < range - 1; j++) |
696 if (ff_vorbis_floor1_inverse_db_table[j * fc->multiplier] > average) break; | |
661 posts[fc->list[i].sort] = j; | 697 posts[fc->list[i].sort] = j; |
662 } | 698 } |
663 } | 699 } |
664 | 700 |
665 static int render_point(int x0, int y0, int x1, int y1, int x) { | 701 static int render_point(int x0, int y0, int x1, int y1, int x) { |
687 int room = FFMIN(highroom, lowroom); | 723 int room = FFMIN(highroom, lowroom); |
688 if (predicted == posts[i]) { | 724 if (predicted == posts[i]) { |
689 coded[i] = 0; // must be used later as flag! | 725 coded[i] = 0; // must be used later as flag! |
690 continue; | 726 continue; |
691 } else { | 727 } else { |
692 if (!coded[fc->list[i].low]) coded[fc->list[i].low] = -1; | 728 if (!coded[fc->list[i].low ]) coded[fc->list[i].low ] = -1; |
693 if (!coded[fc->list[i].high]) coded[fc->list[i].high] = -1; | 729 if (!coded[fc->list[i].high]) coded[fc->list[i].high] = -1; |
694 } | 730 } |
695 if (posts[i] > predicted) { | 731 if (posts[i] > predicted) { |
696 if (posts[i] - predicted > room) coded[i] = posts[i] - predicted + lowroom; | 732 if (posts[i] - predicted > room) |
697 else coded[i] = (posts[i] - predicted) << 1; | 733 coded[i] = posts[i] - predicted + lowroom; |
734 else | |
735 coded[i] = (posts[i] - predicted) << 1; | |
698 } else { | 736 } else { |
699 if (predicted - posts[i] > room) coded[i] = predicted - posts[i] + highroom - 1; | 737 if (predicted - posts[i] > room) |
700 else coded[i] = ((predicted - posts[i]) << 1) - 1; | 738 coded[i] = predicted - posts[i] + highroom - 1; |
739 else | |
740 coded[i] = ((predicted - posts[i]) << 1) - 1; | |
701 } | 741 } |
702 } | 742 } |
703 | 743 |
704 counter = 2; | 744 counter = 2; |
705 for (i = 0; i < fc->partitions; i++) { | 745 for (i = 0; i < fc->partitions; i++) { |
710 int cshift = 0; | 750 int cshift = 0; |
711 for (k = 0; k < c->dim; k++) { | 751 for (k = 0; k < c->dim; k++) { |
712 int l; | 752 int l; |
713 for (l = 0; l < csub; l++) { | 753 for (l = 0; l < csub; l++) { |
714 int maxval = 1; | 754 int maxval = 1; |
715 if (c->books[l] != -1) maxval = venc->codebooks[c->books[l]].nentries; | 755 if (c->books[l] != -1) |
756 maxval = venc->codebooks[c->books[l]].nentries; | |
716 // coded could be -1, but this still works, cause thats 0 | 757 // coded could be -1, but this still works, cause thats 0 |
717 if (coded[counter + k] < maxval) break; | 758 if (coded[counter + k] < maxval) break; |
718 } | 759 } |
719 assert(l != csub); | 760 assert(l != csub); |
720 cval |= l << cshift; | 761 cval |= l << cshift; |
741 assert(book->dimentions); | 782 assert(book->dimentions); |
742 for (i = 0; i < book->nentries; i++) { | 783 for (i = 0; i < book->nentries; i++) { |
743 float * vec = book->dimentions + i * book->ndimentions, d = book->pow2[i]; | 784 float * vec = book->dimentions + i * book->ndimentions, d = book->pow2[i]; |
744 int j; | 785 int j; |
745 if (!book->lens[i]) continue; | 786 if (!book->lens[i]) continue; |
746 for (j = 0; j < book->ndimentions; j++) d -= vec[j] * num[j]; | 787 for (j = 0; j < book->ndimentions; j++) |
788 d -= vec[j] * num[j]; | |
747 if (distance > d) { | 789 if (distance > d) { |
748 entry = i; | 790 entry = i; |
749 distance = d; | 791 distance = d; |
750 } | 792 } |
751 } | 793 } |
778 } | 820 } |
779 | 821 |
780 for (pass = 0; pass < 8; pass++) { | 822 for (pass = 0; pass < 8; pass++) { |
781 p = 0; | 823 p = 0; |
782 while (p < partitions) { | 824 while (p < partitions) { |
783 if (pass == 0) for (j = 0; j < channels; j++) { | 825 if (pass == 0) |
784 codebook_t * book = &venc->codebooks[rc->classbook]; | 826 for (j = 0; j < channels; j++) { |
785 int entry = 0; | 827 codebook_t * book = &venc->codebooks[rc->classbook]; |
786 for (i = 0; i < classwords; i++) { | 828 int entry = 0; |
787 entry *= rc->classifications; | 829 for (i = 0; i < classwords; i++) { |
788 entry += classes[j][p + i]; | 830 entry *= rc->classifications; |
831 entry += classes[j][p + i]; | |
832 } | |
833 put_codeword(pb, book, entry); | |
789 } | 834 } |
790 put_codeword(pb, book, entry); | |
791 } | |
792 for (i = 0; i < classwords && p < partitions; i++, p++) { | 835 for (i = 0; i < classwords && p < partitions; i++, p++) { |
793 for (j = 0; j < channels; j++) { | 836 for (j = 0; j < channels; j++) { |
794 int nbook = rc->books[classes[j][p]][pass]; | 837 int nbook = rc->books[classes[j][p]][pass]; |
795 codebook_t * book = &venc->codebooks[nbook]; | 838 codebook_t * book = &venc->codebooks[nbook]; |
796 float * buf = coeffs + samples*j + rc->begin + p*psize; | 839 float * buf = coeffs + samples*j + rc->begin + p*psize; |
801 | 844 |
802 if (rc->type == 0) { | 845 if (rc->type == 0) { |
803 for (k = 0; k < psize; k += book->ndimentions) { | 846 for (k = 0; k < psize; k += book->ndimentions) { |
804 float * a = put_vector(book, pb, &buf[k]); | 847 float * a = put_vector(book, pb, &buf[k]); |
805 int l; | 848 int l; |
806 for (l = 0; l < book->ndimentions; l++) buf[k + l] -= a[l]; | 849 for (l = 0; l < book->ndimentions; l++) |
850 buf[k + l] -= a[l]; | |
807 } | 851 } |
808 } else { | 852 } else { |
809 int s = rc->begin + p * psize, a1, b1; | 853 int s = rc->begin + p * psize, a1, b1; |
810 a1 = (s % real_ch) * samples; | 854 a1 = (s % real_ch) * samples; |
811 b1 = s / real_ch; | 855 b1 = s / real_ch; |
813 for (k = 0; k < psize; k += book->ndimentions) { | 857 for (k = 0; k < psize; k += book->ndimentions) { |
814 int dim, a2 = a1, b2 = b1; | 858 int dim, a2 = a1, b2 = b1; |
815 float vec[book->ndimentions], * pv = vec; | 859 float vec[book->ndimentions], * pv = vec; |
816 for (dim = book->ndimentions; dim--; ) { | 860 for (dim = book->ndimentions; dim--; ) { |
817 *pv++ = coeffs[a2 + b2]; | 861 *pv++ = coeffs[a2 + b2]; |
818 if ((a2 += samples) == s) { a2=0; b2++; } | 862 if ((a2 += samples) == s) { |
863 a2=0; | |
864 b2++; | |
865 } | |
819 } | 866 } |
820 pv = put_vector(book, pb, vec); | 867 pv = put_vector(book, pb, vec); |
821 for (dim = book->ndimentions; dim--; ) { | 868 for (dim = book->ndimentions; dim--; ) { |
822 coeffs[a1 + b1] -= *pv++; | 869 coeffs[a1 + b1] -= *pv++; |
823 if ((a1 += samples) == s) { a1=0; b1++; } | 870 if ((a1 += samples) == s) { |
871 a1=0; | |
872 b1++; | |
873 } | |
824 } | 874 } |
825 } | 875 } |
826 } | 876 } |
827 } | 877 } |
828 } | 878 } |
889 return -1; | 939 return -1; |
890 } | 940 } |
891 | 941 |
892 create_vorbis_context(venc, avccontext); | 942 create_vorbis_context(venc, avccontext); |
893 | 943 |
894 if (avccontext->flags & CODEC_FLAG_QSCALE) venc->quality = avccontext->global_quality / (float)FF_QP2LAMBDA / 10.; | 944 if (avccontext->flags & CODEC_FLAG_QSCALE) |
895 else venc->quality = 1.; | 945 venc->quality = avccontext->global_quality / (float)FF_QP2LAMBDA / 10.; |
946 else | |
947 venc->quality = 1.; | |
896 venc->quality *= venc->quality; | 948 venc->quality *= venc->quality; |
897 | 949 |
898 avccontext->extradata_size = put_main_header(venc, (uint8_t**)&avccontext->extradata); | 950 avccontext->extradata_size = put_main_header(venc, (uint8_t**)&avccontext->extradata); |
899 | 951 |
900 avccontext->frame_size = 1 << (venc->log2_blocksize[0] - 1); | 952 avccontext->frame_size = 1 << (venc->log2_blocksize[0] - 1); |
964 static int vorbis_encode_close(AVCodecContext * avccontext) | 1016 static int vorbis_encode_close(AVCodecContext * avccontext) |
965 { | 1017 { |
966 venc_context_t * venc = avccontext->priv_data; | 1018 venc_context_t * venc = avccontext->priv_data; |
967 int i; | 1019 int i; |
968 | 1020 |
969 if (venc->codebooks) for (i = 0; i < venc->ncodebooks; i++) { | 1021 if (venc->codebooks) |
970 av_freep(&venc->codebooks[i].lens); | 1022 for (i = 0; i < venc->ncodebooks; i++) { |
971 av_freep(&venc->codebooks[i].codewords); | 1023 av_freep(&venc->codebooks[i].lens); |
972 av_freep(&venc->codebooks[i].quantlist); | 1024 av_freep(&venc->codebooks[i].codewords); |
973 av_freep(&venc->codebooks[i].dimentions); | 1025 av_freep(&venc->codebooks[i].quantlist); |
974 av_freep(&venc->codebooks[i].pow2); | 1026 av_freep(&venc->codebooks[i].dimentions); |
975 } | 1027 av_freep(&venc->codebooks[i].pow2); |
1028 } | |
976 av_freep(&venc->codebooks); | 1029 av_freep(&venc->codebooks); |
977 | 1030 |
978 if (venc->floors) for (i = 0; i < venc->nfloors; i++) { | 1031 if (venc->floors) |
979 int j; | 1032 for (i = 0; i < venc->nfloors; i++) { |
980 av_freep(&venc->floors[i].classes); | 1033 int j; |
981 if (venc->floors[i].classes) | 1034 av_freep(&venc->floors[i].classes); |
982 for (j = 0; j < venc->floors[i].nclasses; j++) | 1035 if (venc->floors[i].classes) |
983 av_freep(&venc->floors[i].classes[j].books); | 1036 for (j = 0; j < venc->floors[i].nclasses; j++) |
984 av_freep(&venc->floors[i].partition_to_class); | 1037 av_freep(&venc->floors[i].classes[j].books); |
985 av_freep(&venc->floors[i].list); | 1038 av_freep(&venc->floors[i].partition_to_class); |
986 } | 1039 av_freep(&venc->floors[i].list); |
1040 } | |
987 av_freep(&venc->floors); | 1041 av_freep(&venc->floors); |
988 | 1042 |
989 if (venc->residues) for (i = 0; i < venc->nresidues; i++) { | 1043 if (venc->residues) |
990 av_freep(&venc->residues[i].books); | 1044 for (i = 0; i < venc->nresidues; i++) { |
991 av_freep(&venc->residues[i].maxes); | 1045 av_freep(&venc->residues[i].books); |
992 } | 1046 av_freep(&venc->residues[i].maxes); |
1047 } | |
993 av_freep(&venc->residues); | 1048 av_freep(&venc->residues); |
994 | 1049 |
995 if (venc->mappings) for (i = 0; i < venc->nmappings; i++) { | 1050 if (venc->mappings) |
996 av_freep(&venc->mappings[i].mux); | 1051 for (i = 0; i < venc->nmappings; i++) { |
997 av_freep(&venc->mappings[i].floor); | 1052 av_freep(&venc->mappings[i].mux); |
998 av_freep(&venc->mappings[i].residue); | 1053 av_freep(&venc->mappings[i].floor); |
999 } | 1054 av_freep(&venc->mappings[i].residue); |
1055 } | |
1000 av_freep(&venc->mappings); | 1056 av_freep(&venc->mappings); |
1001 | 1057 |
1002 av_freep(&venc->modes); | 1058 av_freep(&venc->modes); |
1003 | 1059 |
1004 av_freep(&venc->saved); | 1060 av_freep(&venc->saved); |