FFmpeg: libavcodec/flacenc.c Source File

FFmpeg

[フレーム]

libavcodec

flacenc.c

Go to the documentation of this file.

1 /*

2 * FLAC audio encoder

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include "libavutil/avassert.h"

23 #include "libavutil/channel_layout.h"

24 #include "libavutil/crc.h"

25 #include "libavutil/intmath.h"

26 #include "libavutil/md5.h"

27 #include "libavutil/opt.h"

29 #include "avcodec.h"

30 #include "bswapdsp.h"

31 #include "codec_internal.h"

32 #include "encode.h"

33 #include "put_bits.h"

34 #include "lpc.h"

35 #include "flac.h"

36 #include "flacdata.h"

37 #include "flacencdsp.h"

39 #define FLAC_SUBFRAME_CONSTANT 0

40 #define FLAC_SUBFRAME_VERBATIM 1

41 #define FLAC_SUBFRAME_FIXED 8

42 #define FLAC_SUBFRAME_LPC 32

44 #define MAX_FIXED_ORDER 4

45 #define MAX_PARTITION_ORDER 8

46 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)

47 #define MAX_LPC_PRECISION 15

48 #define MIN_LPC_SHIFT 0

49 #define MAX_LPC_SHIFT 15

51 enum CodingMode {

52 CODING_MODE_RICE = 4,

53 CODING_MODE_RICE2 = 5,

54 };

56 typedef struct CompressionOptions {

57 int compression_level;

58 int block_time_ms;

59 enum FFLPCType lpc_type;

60 int lpc_passes;

61 int lpc_coeff_precision;

62 int min_prediction_order;

63 int max_prediction_order;

64 int prediction_order_method;

65 int min_partition_order;

66 int max_partition_order;

67 int ch_mode;

68 int exact_rice_parameters;

69 int multi_dim_quant;

70 } CompressionOptions;

72 typedef struct RiceContext {

73 enum CodingMode coding_mode;

74 int porder;

75 int params[MAX_PARTITIONS];

76 } RiceContext;

78 typedef struct FlacSubframe {

79 int type;

80 int type_code;

81 int obits;

82 int wasted;

83 int order;

84 int32_t coefs[MAX_LPC_ORDER];

85 int shift;

87 RiceContext rc;

88 uint32_t rc_udata[FLAC_MAX_BLOCKSIZE];

89 uint64_t rc_sums[32][MAX_PARTITIONS];

91 int32_t samples[FLAC_MAX_BLOCKSIZE];

92 int32_t residual[FLAC_MAX_BLOCKSIZE+11];

93 } FlacSubframe;

95 typedef struct FlacFrame {

96 FlacSubframe subframes[FLAC_MAX_CHANNELS];

97 int64_t samples_33bps[FLAC_MAX_BLOCKSIZE];

98 int blocksize;

99 int bs_code[2];

100 uint8_t crc8;

101 int ch_mode;

102 int verbatim_only;

103 } FlacFrame;

104

105 typedef struct FlacEncodeContext {

106 AVClass *class;

107 PutBitContext pb;

108 int channels;

109 int samplerate;

110 int sr_code[2];

111 int bps_code;

112 int max_blocksize;

113 int min_framesize;

114 int max_framesize;

115 int max_encoded_framesize;

116 uint32_t frame_count;

117 uint64_t sample_count;

118 uint8_t md5sum[16];

119 FlacFrame frame;

120 CompressionOptions options;

121 AVCodecContext *avctx;

122 LPCContext lpc_ctx;

123 struct AVMD5 *md5ctx;

124 uint8_t *md5_buffer;

125 unsigned int md5_buffer_size;

126 BswapDSPContext bdsp;

127 FLACEncDSPContext flac_dsp;

128

129 int flushed;

130 int64_t next_pts;

131 } FlacEncodeContext;

132

133

134 /**

135 * Write streaminfo metadata block to byte array.

136 */

137 static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)

138 {

139 PutBitContext pb;

140

141 memset(header, 0, FLAC_STREAMINFO_SIZE);

142 init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);

143

144 /* streaminfo metadata block */

145 put_bits(&pb, 16, s->max_blocksize);

146 put_bits(&pb, 16, s->max_blocksize);

147 put_bits(&pb, 24, s->min_framesize);

148 put_bits(&pb, 24, s->max_framesize);

149 put_bits(&pb, 20, s->samplerate);

150 put_bits(&pb, 3, s->channels-1);

151 put_bits(&pb, 5, s->avctx->bits_per_raw_sample - 1);

152 /* write 36-bit sample count in 2 put_bits() calls */

153 put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);

154 put_bits(&pb, 12, s->sample_count & 0x000000FFFLL);

155 flush_put_bits(&pb);

156 memcpy(&header[18], s->md5sum, 16);

157 }

158

159

160 /**

161 * Calculate an estimate for the maximum frame size based on verbatim mode.

162 * @param blocksize block size, in samples

163 * @param ch number of channels

164 * @param bps bits-per-sample

165 */

166 static int flac_get_max_frame_size(int blocksize, int ch, int bps)

167 {

168 /* Technically, there is no limit to FLAC frame size, but an encoder

169 should not write a frame that is larger than if verbatim encoding mode

170 were to be used. */

171

172 int count;

173

174 count = 16; /* frame header */

175 count += ch * ((7+bps+7)/8); /* subframe headers */

176 if (ch == 2) {

177 /* for stereo, need to account for using decorrelation */

178 count += (( 2*bps+1) * blocksize + 7) / 8;

179 } else {

180 count += ( ch*bps * blocksize + 7) / 8;

181 }

182 count += 2; /* frame footer */

183

184 return count;

185 }

186

187

188 /**

189 * Set blocksize based on samplerate.

190 * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.

191 */

192 static int select_blocksize(int samplerate, int block_time_ms)

193 {

194 int i;

195 int target;

196 int blocksize;

197

198 av_assert0(samplerate > 0);

199 blocksize = ff_flac_blocksize_table[1];

200 target = (samplerate * block_time_ms) / 1000;

201 for (i = 0; i < 16; i++) {

202 if (target >= ff_flac_blocksize_table[i] &&

203 ff_flac_blocksize_table[i] > blocksize) {

204 blocksize = ff_flac_blocksize_table[i];

205 }

206 }

207 return blocksize;

208 }

209

210

211 static av_cold void dprint_compression_options(FlacEncodeContext *s)

212 {

213 AVCodecContext *avctx = s->avctx;

214 CompressionOptions *opt = &s->options;

215

216 av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt->compression_level);

217

218 switch (opt->lpc_type) {

219 case FF_LPC_TYPE_NONE:

220 av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n");

221 break;

222 case FF_LPC_TYPE_FIXED:

223 av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n");

224 break;

225 case FF_LPC_TYPE_LEVINSON:

226 av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n");

227 break;

228 case FF_LPC_TYPE_CHOLESKY:

229 av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n",

230 opt->lpc_passes, opt->lpc_passes == 1 ? "" : "es");

231 break;

232 }

233

234 av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",

235 opt->min_prediction_order, opt->max_prediction_order);

236

237 switch (opt->prediction_order_method) {

238 case ORDER_METHOD_EST:

239 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate");

240 break;

241 case ORDER_METHOD_2LEVEL:

242 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2-level");

243 break;

244 case ORDER_METHOD_4LEVEL:

245 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4-level");

246 break;

247 case ORDER_METHOD_8LEVEL:

248 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8-level");

249 break;

250 case ORDER_METHOD_SEARCH:

251 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search");

252 break;

253 case ORDER_METHOD_LOG:

254 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search");

255 break;

256 }

257

258

259 av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",

260 opt->min_partition_order, opt->max_partition_order);

261

262 av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx->frame_size);

263

264 av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",

265 opt->lpc_coeff_precision);

266 }

267

268

269 static av_cold int flac_encode_init(AVCodecContext *avctx)

270 {

271 int freq = avctx->sample_rate;

272 int channels = avctx->ch_layout.nb_channels;

273 FlacEncodeContext *s = avctx->priv_data;

274 int i, level, ret;

275 uint8_t *streaminfo;

276

277 s->avctx = avctx;

278

279 switch (avctx->sample_fmt) {

280 case AV_SAMPLE_FMT_S16:

281 avctx->bits_per_raw_sample = 16;

282 s->bps_code = 4;

283 break;

284 case AV_SAMPLE_FMT_S32:

285 if (avctx->bits_per_raw_sample <= 24) {

286 if (avctx->bits_per_raw_sample < 24)

287 av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");

288 avctx->bits_per_raw_sample = 24;

289 s->bps_code = 6;

290 } else if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

291 av_log(avctx, AV_LOG_WARNING,

292 "encoding as 24 bits-per-sample, more is considered "

293 "experimental. Add -strict experimental if you want "

294 "to encode more than 24 bits-per-sample\n");

295 avctx->bits_per_raw_sample = 24;

296 s->bps_code = 6;

297 } else {

298 avctx->bits_per_raw_sample = 32;

299 s->bps_code = 7;

300 }

301 break;

302 }

303

304 if (channels < 1 || channels > FLAC_MAX_CHANNELS) {

305 av_log(avctx, AV_LOG_ERROR, "%d channels not supported (max %d)\n",

306 channels, FLAC_MAX_CHANNELS);

307 return AVERROR(EINVAL);

308 }

309 s->channels = channels;

310

311 /* find samplerate in table */

312 if (freq < 1)

313 return AVERROR(EINVAL);

314 for (i = 1; i < 12; i++) {

315 if (freq == ff_flac_sample_rate_table[i]) {

316 s->samplerate = ff_flac_sample_rate_table[i];

317 s->sr_code[0] = i;

318 s->sr_code[1] = 0;

319 break;

320 }

321 }

322 /* if not in table, samplerate is non-standard */

323 if (i == 12) {

324 if (freq % 1000 == 0 && freq < 255000) {

325 s->sr_code[0] = 12;

326 s->sr_code[1] = freq / 1000;

327 } else if (freq % 10 == 0 && freq < 655350) {

328 s->sr_code[0] = 14;

329 s->sr_code[1] = freq / 10;

330 } else if (freq < 65535) {

331 s->sr_code[0] = 13;

332 s->sr_code[1] = freq;

333 } else if (freq < 1048576) {

334 s->sr_code[0] = 0;

335 s->sr_code[1] = 0;

336 } else {

337 av_log(avctx, AV_LOG_ERROR, "%d Hz not supported\n", freq);

338 return AVERROR(EINVAL);

339 }

340 s->samplerate = freq;

341 }

342

343 /* set compression option defaults based on avctx->compression_level */

344 if (avctx->compression_level < 0)

345 s->options.compression_level = 5;

346 else

347 s->options.compression_level = avctx->compression_level;

348

349 level = s->options.compression_level;

350 if (level > 12) {

351 av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",

352 s->options.compression_level);

353 return AVERROR(EINVAL);

354 }

355

356 s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];

357

358 if (s->options.lpc_type == FF_LPC_TYPE_DEFAULT)

359 s->options.lpc_type = ((int[]){ FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED,

360 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,

361 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,

362 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,

363 FF_LPC_TYPE_LEVINSON})[level];

364

365 if (s->options.min_prediction_order < 0)

366 s->options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];

367 if (s->options.max_prediction_order < 0)

368 s->options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];

369

370 if (s->options.prediction_order_method < 0)

371 s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,

372 ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,

373 ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL,

374 ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,

375 ORDER_METHOD_SEARCH})[level];

376

377 if (s->options.min_partition_order > s->options.max_partition_order) {

378 av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",

379 s->options.min_partition_order, s->options.max_partition_order);

380 return AVERROR(EINVAL);

381 }

382 if (s->options.min_partition_order < 0)

383 s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];

384 if (s->options.max_partition_order < 0)

385 s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];

386

387 if (s->options.lpc_type == FF_LPC_TYPE_NONE) {

388 s->options.min_prediction_order = 0;

389 s->options.max_prediction_order = 0;

390 } else if (s->options.lpc_type == FF_LPC_TYPE_FIXED) {

391 if (s->options.min_prediction_order > MAX_FIXED_ORDER) {

392 av_log(avctx, AV_LOG_WARNING,

393 "invalid min prediction order %d, clamped to %d\n",

394 s->options.min_prediction_order, MAX_FIXED_ORDER);

395 s->options.min_prediction_order = MAX_FIXED_ORDER;

396 }

397 if (s->options.max_prediction_order > MAX_FIXED_ORDER) {

398 av_log(avctx, AV_LOG_WARNING,

399 "invalid max prediction order %d, clamped to %d\n",

400 s->options.max_prediction_order, MAX_FIXED_ORDER);

401 s->options.max_prediction_order = MAX_FIXED_ORDER;

402 }

403 }

404

405 if (s->options.max_prediction_order < s->options.min_prediction_order) {

406 av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",

407 s->options.min_prediction_order, s->options.max_prediction_order);

408 return AVERROR(EINVAL);

409 }

410

411 if (avctx->frame_size > 0) {

412 if (avctx->frame_size < FLAC_MIN_BLOCKSIZE ||

413 avctx->frame_size > FLAC_MAX_BLOCKSIZE) {

414 av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",

415 avctx->frame_size);

416 return AVERROR(EINVAL);

417 }

418 } else {

419 s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);

420 }

421 s->max_blocksize = s->avctx->frame_size;

422

423 /* set maximum encoded frame size in verbatim mode */

424 s->max_framesize = flac_get_max_frame_size(s->avctx->frame_size,

425 s->channels,

426 s->avctx->bits_per_raw_sample);

427

428 /* initialize MD5 context */

429 s->md5ctx = av_md5_alloc();

430 if (!s->md5ctx)

431 return AVERROR(ENOMEM);

432 av_md5_init(s->md5ctx);

433

434 streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);

435 if (!streaminfo)

436 return AVERROR(ENOMEM);

437 write_streaminfo(s, streaminfo);

438 avctx->extradata = streaminfo;

439 avctx->extradata_size = FLAC_STREAMINFO_SIZE;

440

441 s->frame_count = 0;

442 s->min_framesize = s->max_framesize;

443

444 if ((channels == 3 &&

445 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_SURROUND)) ||

446 (channels == 4 &&

447 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_2_2) &&

448 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_QUAD)) ||

449 (channels == 5 &&

450 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0) &&

451 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0_BACK)) ||

452 (channels == 6 &&

453 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1) &&

454 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1_BACK))) {

455 if (avctx->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {

456 av_log(avctx, AV_LOG_ERROR, "Channel layout not supported by Flac, "

457 "output stream will have incorrect "

458 "channel layout.\n");

459 } else {

460 av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "

461 "will use Flac channel layout for "

462 "%d channels.\n", channels);

463 }

464 }

465

466 ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,

467 s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);

468

469 ff_bswapdsp_init(&s->bdsp);

470 ff_flacencdsp_init(&s->flac_dsp);

471

472 dprint_compression_options(s);

473

474 return ret;

475 }

476

477

478 static void init_frame(FlacEncodeContext *s, int nb_samples)

479 {

480 int i, ch;

481 FlacFrame *frame;

482

483 frame = &s->frame;

484

485 for (i = 0; i < 16; i++) {

486 if (nb_samples == ff_flac_blocksize_table[i]) {

487 frame->blocksize = ff_flac_blocksize_table[i];

488 frame->bs_code[0] = i;

489 frame->bs_code[1] = 0;

490 break;

491 }

492 }

493 if (i == 16) {

494 frame->blocksize = nb_samples;

495 if (frame->blocksize <= 256) {

496 frame->bs_code[0] = 6;

497 frame->bs_code[1] = frame->blocksize-1;

498 } else {

499 frame->bs_code[0] = 7;

500 frame->bs_code[1] = frame->blocksize-1;

501 }

502 }

503

504 for (ch = 0; ch < s->channels; ch++) {

505 FlacSubframe *sub = &frame->subframes[ch];

506

507 sub->wasted = 0;

508 sub->obits = s->avctx->bits_per_raw_sample;

509

510 if (sub->obits > 16)

511 sub->rc.coding_mode = CODING_MODE_RICE2;

512 else

513 sub->rc.coding_mode = CODING_MODE_RICE;

514 }

515

516 frame->verbatim_only = 0;

517 }

518

519

520 /**

521 * Copy channel-interleaved input samples into separate subframes.

522 */

523 static void copy_samples(FlacEncodeContext *s, const void *samples)

524 {

525 int i, j, ch;

526 FlacFrame *frame;

527 int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -

528 s->avctx->bits_per_raw_sample;

529

530 #define COPY_SAMPLES(bits) do { \

531 const int ## bits ## _t *samples0 = samples; \

532 frame = &s->frame; \

533 for (i = 0, j = 0; i < frame->blocksize; i++) \

534 for (ch = 0; ch < s->channels; ch++, j++) \

535 frame->subframes[ch].samples[i] = samples0[j] >> shift; \

536 } while (0)

537

538 if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16)

539 COPY_SAMPLES(16);

540 else

541 COPY_SAMPLES(32);

542 }

543

544

545 static uint64_t rice_count_exact(const int32_t *res, int n, int k)

546 {

547 int i;

548 uint64_t count = 0;

549

550 for (i = 0; i < n; i++) {

551 unsigned v = ((unsigned)(res[i]) << 1) ^ (res[i] >> 31);

552 count += (v >> k) + 1 + k;

553 }

554 return count;

555 }

556

557

558 static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub,

559 int pred_order)

560 {

561 int p, porder, psize;

562 int i, part_end;

563 uint64_t count = 0;

564

565 /* subframe header */

566 count += 8;

567

568 if (sub->wasted)

569 count += sub->wasted;

570

571 /* subframe */

572 if (sub->type == FLAC_SUBFRAME_CONSTANT) {

573 count += sub->obits;

574 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {

575 count += s->frame.blocksize * sub->obits;

576 } else {

577 /* warm-up samples */

578 count += pred_order * sub->obits;

579

580 /* LPC coefficients */

581 if (sub->type == FLAC_SUBFRAME_LPC)

582 count += 4 + 5 + pred_order * s->options.lpc_coeff_precision;

583

584 /* rice-encoded block */

585 count += 2;

586

587 /* partition order */

588 porder = sub->rc.porder;

589 psize = s->frame.blocksize >> porder;

590 count += 4;

591

592 /* residual */

593 i = pred_order;

594 part_end = psize;

595 for (p = 0; p < 1 << porder; p++) {

596 int k = sub->rc.params[p];

597 count += sub->rc.coding_mode;

598 count += rice_count_exact(&sub->residual[i], part_end - i, k);

599 i = part_end;

600 part_end = FFMIN(s->frame.blocksize, part_end + psize);

601 }

602 }

603

604 return count;

605 }

606

607

608 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))

609

610 /**

611 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.

612 */

613 static int find_optimal_param(uint64_t sum, int n, int max_param)

614 {

615 int k;

616 uint64_t sum2;

617

618 if (sum <= n >> 1)

619 return 0;

620 sum2 = sum - (n >> 1);

621 k = av_log2(av_clipl_int32(sum2 / n));

622 return FFMIN(k, max_param);

623 }

624

625 static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)

626 {

627 int bestk = 0;

628 int64_t bestbits = INT64_MAX;

629 int k;

630

631 for (k = 0; k <= max_param; k++) {

632 int64_t bits = sums[k][i];

633 if (bits < bestbits) {

634 bestbits = bits;

635 bestk = k;

636 }

637 }

638

639 return bestk;

640 }

641

642 static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder,

643 uint64_t sums[32][MAX_PARTITIONS],

644 int n, int pred_order, int max_param, int exact)

645 {

646 int i;

647 int k, cnt, part;

648 uint64_t all_bits;

649

650 part = (1 << porder);

651 all_bits = 4 * part;

652

653 cnt = (n >> porder) - pred_order;

654 for (i = 0; i < part; i++) {

655 if (exact) {

656 k = find_optimal_param_exact(sums, i, max_param);

657 all_bits += sums[k][i];

658 } else {

659 k = find_optimal_param(sums[0][i], cnt, max_param);

660 all_bits += rice_encode_count(sums[0][i], cnt, k);

661 }

662 rc->params[i] = k;

663 cnt = n >> porder;

664 }

665

666 rc->porder = porder;

667

668 return all_bits;

669 }

670

671

672 static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order,

673 uint64_t sums[32][MAX_PARTITIONS])

674 {

675 int i, k;

676 int parts;

677 const uint32_t *res, *res_end;

678

679 /* sums for highest level */

680 parts = (1 << pmax);

681

682 for (k = 0; k <= kmax; k++) {

683 res = &data[pred_order];

684 res_end = &data[n >> pmax];

685 for (i = 0; i < parts; i++) {

686 if (kmax) {

687 uint64_t sum = (1LL + k) * (res_end - res);

688 while (res < res_end)

689 sum += *(res++) >> k;

690 sums[k][i] = sum;

691 } else {

692 uint64_t sum = 0;

693 while (res < res_end)

694 sum += *(res++);

695 sums[k][i] = sum;

696 }

697 res_end += n >> pmax;

698 }

699 }

700 }

701

702 static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)

703 {

704 int i, k;

705 int parts = (1 << level);

706 for (i = 0; i < parts; i++) {

707 for (k=0; k<=kmax; k++)

708 sums[k][i] = sums[k][2*i] + sums[k][2*i+1];

709 }

710 }

711

712 static uint64_t calc_rice_params(RiceContext *rc,

713 uint32_t udata[FLAC_MAX_BLOCKSIZE],

714 uint64_t sums[32][MAX_PARTITIONS],

715 int pmin, int pmax,

716 const int32_t *data, int n, int pred_order, int exact)

717 {

718 int i;

719 uint64_t bits[MAX_PARTITION_ORDER+1];

720 int opt_porder;

721 RiceContext tmp_rc;

722 int kmax = (1 << rc->coding_mode) - 2;

723

724 av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);

725 av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);

726 av_assert1(pmin <= pmax);

727

728 tmp_rc.coding_mode = rc->coding_mode;

729

730 for (i = pred_order; i < n; i++)

731 udata[i] = ((unsigned)(data[i]) << 1) ^ (data[i] >> 31);

732

733 calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums);

734

735 opt_porder = pmin;

736 bits[pmin] = UINT32_MAX;

737 for (i = pmax; ; ) {

738 bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums, n, pred_order, kmax, exact);

739 if (bits[i] < bits[opt_porder] || pmax == pmin) {

740 opt_porder = i;

741 *rc = tmp_rc;

742 }

743 if (i == pmin)

744 break;

745 calc_sum_next(--i, sums, exact ? kmax : 0);

746 }

747

748 return bits[opt_porder];

749 }

750

751

752 static int get_max_p_order(int max_porder, int n, int order)

753 {

754 int porder = FFMIN(max_porder, av_log2(n^(n-1)));

755 if (order > 0)

756 porder = FFMIN(porder, av_log2(n/order));

757 return porder;

758 }

759

760

761 static uint64_t find_subframe_rice_params(FlacEncodeContext *s,

762 FlacSubframe *sub, int pred_order)

763 {

764 int pmin = get_max_p_order(s->options.min_partition_order,

765 s->frame.blocksize, pred_order);

766 int pmax = get_max_p_order(s->options.max_partition_order,

767 s->frame.blocksize, pred_order);

768

769 uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode;

770 if (sub->type == FLAC_SUBFRAME_LPC)

771 bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision;

772 bits += calc_rice_params(&sub->rc, sub->rc_udata, sub->rc_sums, pmin, pmax, sub->residual,

773 s->frame.blocksize, pred_order, s->options.exact_rice_parameters);

774 return bits;

775 }

776

777

778 static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,

779 int order)

780 {

781 int i;

782

783 for (i = 0; i < order; i++)

784 res[i] = smp[i];

785

786 if (order == 0) {

787 for (i = order; i < n; i++)

788 res[i] = smp[i];

789 } else if (order == 1) {

790 for (i = order; i < n; i++)

791 res[i] = smp[i] - smp[i-1];

792 } else if (order == 2) {

793 int a = smp[order-1] - smp[order-2];

794 for (i = order; i < n; i += 2) {

795 int b = smp[i ] - smp[i-1];

796 res[i] = b - a;

797 a = smp[i+1] - smp[i ];

798 res[i+1] = a - b;

799 }

800 } else if (order == 3) {

801 int a = smp[order-1] - smp[order-2];

802 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];

803 for (i = order; i < n; i += 2) {

804 int b = smp[i ] - smp[i-1];

805 int d = b - a;

806 res[i] = d - c;

807 a = smp[i+1] - smp[i ];

808 c = a - b;

809 res[i+1] = c - d;

810 }

811 } else {

812 int a = smp[order-1] - smp[order-2];

813 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];

814 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];

815 for (i = order; i < n; i += 2) {

816 int b = smp[i ] - smp[i-1];

817 int d = b - a;

818 int f = d - c;

819 res[i ] = f - e;

820 a = smp[i+1] - smp[i ];

821 c = a - b;

822 e = c - d;

823 res[i+1] = e - f;

824 }

825 }

826 }

827

828

829 /* These four functions check for every residual whether it can be

830 * contained in <INT32_MIN,INT32_MAX]. In case it doesn't, the

831 * function that called this function has to try something else.

832 * Each function is duplicated, once for int32_t input, once for

833 * int64_t input */

834 #define ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT() \

835 { \

836 for (int i = 0; i < order; i++) \

837 res[i] = smp[i]; \

838 if (order == 0) { \

839 for (int i = order; i < n; i++) { \

840 if (smp[i] == INT32_MIN) \

841 return 1; \

842 res[i] = smp[i]; \

843 } \

844 } else if (order == 1) { \

845 for (int i = order; i < n; i++) { \

846 int64_t res64 = (int64_t)smp[i] - smp[i-1]; \

847 if (res64 <= INT32_MIN || res64 > INT32_MAX) \

848 return 1; \

849 res[i] = res64; \

850 } \

851 } else if (order == 2) { \

852 for (int i = order; i < n; i++) { \

853 int64_t res64 = (int64_t)smp[i] - 2*(int64_t)smp[i-1] + smp[i-2]; \

854 if (res64 <= INT32_MIN || res64 > INT32_MAX) \

855 return 1; \

856 res[i] = res64; \

857 } \

858 } else if (order == 3) { \

859 for (int i = order; i < n; i++) { \

860 int64_t res64 = (int64_t)smp[i] - 3*(int64_t)smp[i-1] + 3*(int64_t)smp[i-2] - smp[i-3]; \

861 if (res64 <= INT32_MIN || res64 > INT32_MAX) \

862 return 1; \

863 res[i] = res64; \

864 } \

865 } else { \

866 for (int i = order; i < n; i++) { \

867 int64_t res64 = (int64_t)smp[i] - 4*(int64_t)smp[i-1] + 6*(int64_t)smp[i-2] - 4*(int64_t)smp[i-3] + smp[i-4]; \

868 if (res64 <= INT32_MIN || res64 > INT32_MAX) \

869 return 1; \

870 res[i] = res64; \

871 } \

872 } \

873 return 0; \

874 }

875

876 static int encode_residual_fixed_with_residual_limit(int32_t *res, const int32_t *smp,

877 int n, int order)

878 {

879 ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT();

880 }

881

882

883 static int encode_residual_fixed_with_residual_limit_33bps(int32_t *res, const int64_t *smp,

884 int n, int order)

885 {

886 ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT();

887 }

888

889 #define LPC_ENCODE_WITH_RESIDUAL_LIMIT() \

890 { \

891 for (int i = 0; i < order; i++) \

892 res[i] = smp[i]; \

893 for (int i = order; i < len; i++) { \

894 int64_t p = 0, tmp; \

895 for (int j = 0; j < order; j++) \

896 p += (int64_t)coefs[j]*smp[(i-1)-j]; \

897 p >>= shift; \

898 tmp = smp[i] - p; \

899 if (tmp <= INT32_MIN || tmp > INT32_MAX) \

900 return 1; \

901 res[i] = tmp; \

902 } \

903 return 0; \

904 }

905

906 static int lpc_encode_with_residual_limit(int32_t *res, const int32_t *smp, int len,

907 int order, int32_t *coefs, int shift)

908 {

909 LPC_ENCODE_WITH_RESIDUAL_LIMIT();

910 }

911

912 static int lpc_encode_with_residual_limit_33bps(int32_t *res, const int64_t *smp, int len,

913 int order, int32_t *coefs, int shift)

914 {

915 LPC_ENCODE_WITH_RESIDUAL_LIMIT();

916 }

917

918 static int lpc_encode_choose_datapath(FlacEncodeContext *s, int32_t bps,

919 int32_t *res, const int32_t *smp,

920 const int64_t *smp_33bps, int len,

921 int order, int32_t *coefs, int shift)

922 {

923 uint64_t max_residual_value = 0;

924 int64_t max_sample_value = ((int64_t)(1) << (bps-1));

925 /* This calculates the max size of any residual with the current

926 * predictor, so we know whether we need to check the residual */

927 for (int i = 0; i < order; i++)

928 max_residual_value += FFABS(max_sample_value * coefs[i]);

929 max_residual_value >>= shift;

930 max_residual_value += max_sample_value;

931 if (bps > 32) {

932 if (lpc_encode_with_residual_limit_33bps(res, smp_33bps, len, order, coefs, shift))

933 return 1;

934 } else if (max_residual_value > INT32_MAX) {

935 if (lpc_encode_with_residual_limit(res, smp, len, order, coefs, shift))

936 return 1;

937 } else if (bps + s->options.lpc_coeff_precision + av_log2(order) <= 32) {

938 s->flac_dsp.lpc16_encode(res, smp, len, order, coefs, shift);

939 } else {

940 s->flac_dsp.lpc32_encode(res, smp, len, order, coefs, shift);

941 }

942 return 0;

943 }

944

945 #define DEFAULT_TO_VERBATIM() \

946 { \

947 sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM; \

948 if (sub->obits <= 32) \

949 memcpy(res, smp, n * sizeof(int32_t)); \

950 return subframe_count_exact(s, sub, 0); \

951 }

952

953 static int encode_residual_ch(FlacEncodeContext *s, int ch)

954 {

955 int i, n;

956 int min_order, max_order, opt_order, omethod;

957 FlacFrame *frame;

958 FlacSubframe *sub;

959 int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];

960 int shift[MAX_LPC_ORDER];

961 int32_t *res, *smp;

962 int64_t *smp_33bps;

963

964 frame = &s->frame;

965 sub = &frame->subframes[ch];

966 res = sub->residual;

967 smp = sub->samples;

968 smp_33bps = frame->samples_33bps;

969 n = frame->blocksize;

970

971 /* CONSTANT */

972 if (sub->obits > 32) {

973 for (i = 1; i < n; i++)

974 if(smp_33bps[i] != smp_33bps[0])

975 break;

976 if (i == n) {

977 sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;

978 return subframe_count_exact(s, sub, 0);

979 }

980 } else {

981 for (i = 1; i < n; i++)

982 if(smp[i] != smp[0])

983 break;

984 if (i == n) {

985 sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;

986 res[0] = smp[0];

987 return subframe_count_exact(s, sub, 0);

988 }

989 }

990

991 /* VERBATIM */

992 if (frame->verbatim_only || n < 5) {

993 DEFAULT_TO_VERBATIM();

994 }

995

996 min_order = s->options.min_prediction_order;

997 max_order = s->options.max_prediction_order;

998 omethod = s->options.prediction_order_method;

999

1000 /* FIXED */

1001 sub->type = FLAC_SUBFRAME_FIXED;

1002 if (s->options.lpc_type == FF_LPC_TYPE_NONE ||

1003 s->options.lpc_type == FF_LPC_TYPE_FIXED || n <= max_order) {

1004 uint64_t bits[MAX_FIXED_ORDER+1];

1005 if (max_order > MAX_FIXED_ORDER)

1006 max_order = MAX_FIXED_ORDER;

1007 opt_order = 0;

1008 bits[0] = UINT32_MAX;

1009 for (i = min_order; i <= max_order; i++) {

1010 if (sub->obits == 33) {

1011 if (encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, i))

1012 continue;

1013 } else if (sub->obits + i >= 32) {

1014 if (encode_residual_fixed_with_residual_limit(res, smp, n, i))

1015 continue;

1016 } else

1017 encode_residual_fixed(res, smp, n, i);

1018 bits[i] = find_subframe_rice_params(s, sub, i);

1019 if (bits[i] < bits[opt_order])

1020 opt_order = i;

1021 }

1022 if (opt_order == 0 && bits[0] == UINT32_MAX) {

1023 /* No predictor found with residuals within <INT32_MIN,INT32_MAX],

1024 * so encode a verbatim subframe instead */

1025 DEFAULT_TO_VERBATIM();

1026 }

1027 sub->order = opt_order;

1028 sub->type_code = sub->type | sub->order;

1029 if (sub->order != max_order) {

1030 if (sub->obits == 33)

1031 encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, sub->order);

1032 else if (sub->obits + i >= 32)

1033 encode_residual_fixed_with_residual_limit(res, smp, n, sub->order);

1034 else

1035 encode_residual_fixed(res, smp, n, sub->order);

1036 find_subframe_rice_params(s, sub, sub->order);

1037 }

1038 return subframe_count_exact(s, sub, sub->order);

1039 }

1040

1041 /* LPC */

1042 sub->type = FLAC_SUBFRAME_LPC;

1043 if (sub->obits == 33)

1044 /* As ff_lpc_calc_coefs is shared with other codecs and the LSB

1045 * probably isn't predictable anyway, throw away LSB for analysis

1046 * so it fits 32 bit int and existing function can be used

1047 * unmodified */

1048 for (i = 0; i < n; i++)

1049 smp[i] = smp_33bps[i] >> 1;

1050

1051 opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, smp, n, min_order, max_order,

1052 s->options.lpc_coeff_precision, coefs, shift, s->options.lpc_type,

1053 s->options.lpc_passes, omethod,

1054 MIN_LPC_SHIFT, MAX_LPC_SHIFT, 0);

1055

1056 if (omethod == ORDER_METHOD_2LEVEL ||

1057 omethod == ORDER_METHOD_4LEVEL ||

1058 omethod == ORDER_METHOD_8LEVEL) {

1059 int levels = 1 << omethod;

1060 uint64_t bits[1 << ORDER_METHOD_8LEVEL];

1061 int order = -1;

1062 int opt_index = levels-1;

1063 opt_order = max_order-1;

1064 bits[opt_index] = UINT32_MAX;

1065 for (i = levels-1; i >= 0; i--) {

1066 int last_order = order;

1067 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;

1068 order = av_clip(order, min_order - 1, max_order - 1);

1069 if (order == last_order)

1070 continue;

1071 if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, order+1, coefs[order], shift[order]))

1072 continue;

1073 bits[i] = find_subframe_rice_params(s, sub, order+1);

1074 if (bits[i] < bits[opt_index]) {

1075 opt_index = i;

1076 opt_order = order;

1077 }

1078 }

1079 opt_order++;

1080 } else if (omethod == ORDER_METHOD_SEARCH) {

1081 // brute-force optimal order search

1082 uint64_t bits[MAX_LPC_ORDER];

1083 opt_order = 0;

1084 bits[0] = UINT32_MAX;

1085 for (i = min_order-1; i < max_order; i++) {

1086 if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, i+1, coefs[i], shift[i]))

1087 continue;

1088 bits[i] = find_subframe_rice_params(s, sub, i+1);

1089 if (bits[i] < bits[opt_order])

1090 opt_order = i;

1091 }

1092 opt_order++;

1093 } else if (omethod == ORDER_METHOD_LOG) {

1094 uint64_t bits[MAX_LPC_ORDER];

1095 int step;

1096

1097 opt_order = min_order - 1 + (max_order-min_order)/3;

1098 memset(bits, -1, sizeof(bits));

1099

1100 for (step = 16; step; step >>= 1) {

1101 int last = opt_order;

1102 for (i = last-step; i <= last+step; i += step) {

1103 if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX)

1104 continue;

1105 if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, i+1, coefs[i], shift[i]))

1106 continue;

1107 bits[i] = find_subframe_rice_params(s, sub, i+1);

1108 if (bits[i] < bits[opt_order])

1109 opt_order = i;

1110 }

1111 }

1112 opt_order++;

1113 }

1114

1115 if (s->options.multi_dim_quant) {

1116 int allsteps = 1;

1117 int i, step, improved;

1118 int64_t best_score = INT64_MAX;

1119 int32_t qmax;

1120

1121 qmax = (1 << (s->options.lpc_coeff_precision - 1)) - 1;

1122

1123 for (i=0; i<opt_order; i++)

1124 allsteps *= 3;

1125

1126 do {

1127 improved = 0;

1128 for (step = 0; step < allsteps; step++) {

1129 int tmp = step;

1130 int32_t lpc_try[MAX_LPC_ORDER];

1131 int64_t score = 0;

1132 int diffsum = 0;

1133

1134 for (i=0; i<opt_order; i++) {

1135 int diff = ((tmp + 1) % 3) - 1;

1136 lpc_try[i] = av_clip(coefs[opt_order - 1][i] + diff, -qmax, qmax);

1137 tmp /= 3;

1138 diffsum += !!diff;

1139 }

1140 if (diffsum >8)

1141 continue;

1142

1143 if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, opt_order, lpc_try, shift[opt_order-1]))

1144 continue;

1145 score = find_subframe_rice_params(s, sub, opt_order);

1146 if (score < best_score) {

1147 best_score = score;

1148 memcpy(coefs[opt_order-1], lpc_try, sizeof(*coefs));

1149 improved=1;

1150 }

1151 }

1152 } while(improved);

1153 }

1154

1155 sub->order = opt_order;

1156 sub->type_code = sub->type | (sub->order-1);

1157 sub->shift = shift[sub->order-1];

1158 for (i = 0; i < sub->order; i++)

1159 sub->coefs[i] = coefs[sub->order-1][i];

1160

1161 if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, sub->order, sub->coefs, sub->shift)) {

1162 /* No predictor found with residuals within <INT32_MIN,INT32_MAX],

1163 * so encode a verbatim subframe instead */

1164 DEFAULT_TO_VERBATIM();

1165 }

1166

1167 find_subframe_rice_params(s, sub, sub->order);

1168

1169 return subframe_count_exact(s, sub, sub->order);

1170 }

1171

1172

1173 static int count_frame_header(FlacEncodeContext *s)

1174 {

1175 uint8_t av_unused tmp;

1176 int count;

1177

1178 /*

1179 <14> Sync code

1180 <1> Reserved

1181 <1> Blocking strategy

1182 <4> Block size in inter-channel samples

1183 <4> Sample rate

1184 <4> Channel assignment

1185 <3> Sample size in bits

1186 <1> Reserved

1187 */

1188 count = 32;

1189

1190 /* coded frame number */

1191 PUT_UTF8(s->frame_count, tmp, count += 8;)

1192

1193 /* explicit block size */

1194 if (s->frame.bs_code[0] == 6)

1195 count += 8;

1196 else if (s->frame.bs_code[0] == 7)

1197 count += 16;

1198

1199 /* explicit sample rate */

1200 count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12) * 2) * 8;

1201

1202 /* frame header CRC-8 */

1203 count += 8;

1204

1205 return count;

1206 }

1207

1208

1209 static int encode_frame(FlacEncodeContext *s)

1210 {

1211 int ch;

1212 uint64_t count;

1213

1214 count = count_frame_header(s);

1215

1216 for (ch = 0; ch < s->channels; ch++)

1217 count += encode_residual_ch(s, ch);

1218

1219 count += (8 - (count & 7)) & 7; // byte alignment

1220 count += 16; // CRC-16

1221

1222 count >>= 3;

1223 if (count > INT_MAX)

1224 return AVERROR_BUG;

1225 return count;

1226 }

1227

1228

1229 static void remove_wasted_bits(FlacEncodeContext *s)

1230 {

1231 int ch, i, wasted_bits;

1232

1233 for (ch = 0; ch < s->channels; ch++) {

1234 FlacSubframe *sub = &s->frame.subframes[ch];

1235

1236 if (sub->obits > 32) {

1237 int64_t v = 0;

1238 for (i = 0; i < s->frame.blocksize; i++) {

1239 v |= s->frame.samples_33bps[i];

1240 if (v & 1)

1241 break;

1242 }

1243

1244 if (!v || (v & 1))

1245 return;

1246

1247 v = ff_ctzll(v);

1248

1249 /* If any wasted bits are found, samples are moved

1250 * from frame.samples_33bps to frame.subframes[ch] */

1251 for (i = 0; i < s->frame.blocksize; i++)

1252 sub->samples[i] = s->frame.samples_33bps[i] >> v;

1253 wasted_bits = v;

1254 } else {

1255 int32_t v = 0;

1256 for (i = 0; i < s->frame.blocksize; i++) {

1257 v |= sub->samples[i];

1258 if (v & 1)

1259 break;

1260 }

1261

1262 if (!v || (v & 1))

1263 return;

1264

1265 v = ff_ctz(v);

1266

1267 for (i = 0; i < s->frame.blocksize; i++)

1268 sub->samples[i] >>= v;

1269 wasted_bits = v;

1270 }

1271

1272 sub->wasted = wasted_bits;

1273 sub->obits -= wasted_bits;

1274

1275 /* for 24-bit, check if removing wasted bits makes the range better

1276 * suited for using RICE instead of RICE2 for entropy coding */

1277 if (sub->obits <= 17)

1278 sub->rc.coding_mode = CODING_MODE_RICE;

1279 }

1280 }

1281

1282

1283 static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n,

1284 int max_rice_param, int bps)

1285 {

1286 int best;

1287 uint64_t sum[4];

1288 uint64_t score[4];

1289 int k;

1290

1291 /* calculate sum of 2nd order residual for each channel */

1292 sum[0] = sum[1] = sum[2] = sum[3] = 0;

1293 if(bps < 30) {

1294 int32_t lt, rt;

1295 for (int i = 2; i < n; i++) {

1296 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];

1297 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];

1298 sum[2] += FFABS((lt + rt) >> 1);

1299 sum[3] += FFABS(lt - rt);

1300 sum[0] += FFABS(lt);

1301 sum[1] += FFABS(rt);

1302 }

1303 } else {

1304 int64_t lt, rt;

1305 for (int i = 2; i < n; i++) {

1306 lt = (int64_t)left_ch[i] - 2*(int64_t)left_ch[i-1] + left_ch[i-2];

1307 rt = (int64_t)right_ch[i] - 2*(int64_t)right_ch[i-1] + right_ch[i-2];

1308 sum[2] += FFABS((lt + rt) >> 1);

1309 sum[3] += FFABS(lt - rt);

1310 sum[0] += FFABS(lt);

1311 sum[1] += FFABS(rt);

1312 }

1313 }

1314 /* estimate bit counts */

1315 for (int i = 0; i < 4; i++) {

1316 k = find_optimal_param(2 * sum[i], n, max_rice_param);

1317 sum[i] = rice_encode_count( 2 * sum[i], n, k);

1318 }

1319

1320 /* calculate score for each mode */

1321 score[0] = sum[0] + sum[1];

1322 score[1] = sum[0] + sum[3];

1323 score[2] = sum[1] + sum[3];

1324 score[3] = sum[2] + sum[3];

1325

1326 /* return mode with lowest score */

1327 best = 0;

1328 for (int i = 1; i < 4; i++)

1329 if (score[i] < score[best])

1330 best = i;

1331

1332 return best;

1333 }

1334

1335

1336 /**

1337 * Perform stereo channel decorrelation.

1338 */

1339 static void channel_decorrelation(FlacEncodeContext *s)

1340 {

1341 FlacFrame *frame;

1342 int32_t *left, *right;

1343 int64_t *side_33bps;

1344 int n;

1345

1346 frame = &s->frame;

1347 n = frame->blocksize;

1348 left = frame->subframes[0].samples;

1349 right = frame->subframes[1].samples;

1350 side_33bps = frame->samples_33bps;

1351

1352 if (s->channels != 2) {

1353 frame->ch_mode = FLAC_CHMODE_INDEPENDENT;

1354 return;

1355 }

1356

1357 if (s->options.ch_mode < 0) {

1358 int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2;

1359 frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param, s->avctx->bits_per_raw_sample);

1360 } else

1361 frame->ch_mode = s->options.ch_mode;

1362

1363 /* perform decorrelation and adjust bits-per-sample */

1364 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)

1365 return;

1366 if(s->avctx->bits_per_raw_sample == 32) {

1367 if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {

1368 int64_t tmp;

1369 for (int i = 0; i < n; i++) {

1370 tmp = left[i];

1371 left[i] = (tmp + right[i]) >> 1;

1372 side_33bps[i] = tmp - right[i];

1373 }

1374 frame->subframes[1].obits++;

1375 } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {

1376 for (int i = 0; i < n; i++)

1377 side_33bps[i] = (int64_t)left[i] - right[i];

1378 frame->subframes[1].obits++;

1379 } else {

1380 for (int i = 0; i < n; i++)

1381 side_33bps[i] = (int64_t)left[i] - right[i];

1382 frame->subframes[0].obits++;

1383 }

1384 } else {

1385 if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {

1386 int32_t tmp;

1387 for (int i = 0; i < n; i++) {

1388 tmp = left[i];

1389 left[i] = (tmp + right[i]) >> 1;

1390 right[i] = tmp - right[i];

1391 }

1392 frame->subframes[1].obits++;

1393 } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {

1394 for (int i = 0; i < n; i++)

1395 right[i] = left[i] - right[i];

1396 frame->subframes[1].obits++;

1397 } else {

1398 for (int i = 0; i < n; i++)

1399 left[i] -= right[i];

1400 frame->subframes[0].obits++;

1401 }

1402 }

1403 }

1404

1405

1406 static void write_utf8(PutBitContext *pb, uint32_t val)

1407 {

1408 uint8_t tmp;

1409 PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)

1410 }

1411

1412

1413 static void write_frame_header(FlacEncodeContext *s)

1414 {

1415 FlacFrame *frame;

1416 int crc;

1417

1418 frame = &s->frame;

1419

1420 put_bits(&s->pb, 16, 0xFFF8);

1421 put_bits(&s->pb, 4, frame->bs_code[0]);

1422 put_bits(&s->pb, 4, s->sr_code[0]);

1423

1424 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)

1425 put_bits(&s->pb, 4, s->channels-1);

1426 else

1427 put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1);

1428

1429 put_bits(&s->pb, 3, s->bps_code);

1430 put_bits(&s->pb, 1, 0);

1431 write_utf8(&s->pb, s->frame_count);

1432

1433 if (frame->bs_code[0] == 6)

1434 put_bits(&s->pb, 8, frame->bs_code[1]);

1435 else if (frame->bs_code[0] == 7)

1436 put_bits(&s->pb, 16, frame->bs_code[1]);

1437

1438 if (s->sr_code[0] == 12)

1439 put_bits(&s->pb, 8, s->sr_code[1]);

1440 else if (s->sr_code[0] > 12)

1441 put_bits(&s->pb, 16, s->sr_code[1]);

1442

1443 flush_put_bits(&s->pb);

1444 crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf,

1445 put_bytes_output(&s->pb));

1446 put_bits(&s->pb, 8, crc);

1447 }

1448

1449

1450 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k)

1451 {

1452 unsigned v, e;

1453

1454 v = ((unsigned)(i) << 1) ^ (i >> 31);

1455

1456 e = (v >> k) + 1;

1457 while (e > 31) {

1458 put_bits(pb, 31, 0);

1459 e -= 31;

1460 }

1461 put_bits(pb, e, 1);

1462 if (k) {

1463 unsigned mask = UINT32_MAX >> (32-k);

1464 put_bits(pb, k, v & mask);

1465 }

1466 }

1467

1468

1469 static void write_subframes(FlacEncodeContext *s)

1470 {

1471 int ch;

1472

1473 for (ch = 0; ch < s->channels; ch++) {

1474 FlacSubframe *sub = &s->frame.subframes[ch];

1475 int p, porder, psize;

1476 int32_t *part_end;

1477 int32_t *res = sub->residual;

1478 int32_t *frame_end = &sub->residual[s->frame.blocksize];

1479

1480 /* subframe header */

1481 put_bits(&s->pb, 1, 0);

1482 put_bits(&s->pb, 6, sub->type_code);

1483 put_bits(&s->pb, 1, !!sub->wasted);

1484 if (sub->wasted)

1485 put_bits(&s->pb, sub->wasted, 1);

1486

1487 /* subframe */

1488 if (sub->type == FLAC_SUBFRAME_CONSTANT) {

1489 if(sub->obits == 33)

1490 put_sbits63(&s->pb, 33, s->frame.samples_33bps[0]);

1491 else if(sub->obits == 32)

1492 put_bits32(&s->pb, res[0]);

1493 else

1494 put_sbits(&s->pb, sub->obits, res[0]);

1495 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {

1496 if (sub->obits == 33) {

1497 int64_t *res64 = s->frame.samples_33bps;

1498 int64_t *frame_end64 = &s->frame.samples_33bps[s->frame.blocksize];

1499 while (res64 < frame_end64)

1500 put_sbits63(&s->pb, 33, (*res64++));

1501 } else if (sub->obits == 32) {

1502 while (res < frame_end)

1503 put_bits32(&s->pb, *res++);

1504 } else {

1505 while (res < frame_end)

1506 put_sbits(&s->pb, sub->obits, *res++);

1507 }

1508 } else {

1509 /* warm-up samples */

1510 if (sub->obits == 33) {

1511 for (int i = 0; i < sub->order; i++)

1512 put_sbits63(&s->pb, 33, s->frame.samples_33bps[i]);

1513 res += sub->order;

1514 } else if (sub->obits == 32) {

1515 for (int i = 0; i < sub->order; i++)

1516 put_bits32(&s->pb, *res++);

1517 } else {

1518 for (int i = 0; i < sub->order; i++)

1519 put_sbits(&s->pb, sub->obits, *res++);

1520 }

1521

1522 /* LPC coefficients */

1523 if (sub->type == FLAC_SUBFRAME_LPC) {

1524 int cbits = s->options.lpc_coeff_precision;

1525 put_bits( &s->pb, 4, cbits-1);

1526 put_sbits(&s->pb, 5, sub->shift);

1527 for (int i = 0; i < sub->order; i++)

1528 put_sbits(&s->pb, cbits, sub->coefs[i]);

1529 }

1530

1531 /* rice-encoded block */

1532 put_bits(&s->pb, 2, sub->rc.coding_mode - 4);

1533

1534 /* partition order */

1535 porder = sub->rc.porder;

1536 psize = s->frame.blocksize >> porder;

1537 put_bits(&s->pb, 4, porder);

1538

1539 /* residual */

1540 part_end = &sub->residual[psize];

1541 for (p = 0; p < 1 << porder; p++) {

1542 int k = sub->rc.params[p];

1543 put_bits(&s->pb, sub->rc.coding_mode, k);

1544 while (res < part_end)

1545 set_sr_golomb_flac(&s->pb, *res++, k);

1546 part_end = FFMIN(frame_end, part_end + psize);

1547 }

1548 }

1549 }

1550 }

1551

1552

1553 static void write_frame_footer(FlacEncodeContext *s)

1554 {

1555 int crc;

1556 flush_put_bits(&s->pb);

1557 crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf,

1558 put_bytes_output(&s->pb)));

1559 put_bits(&s->pb, 16, crc);

1560 flush_put_bits(&s->pb);

1561 }

1562

1563

1564 static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)

1565 {

1566 init_put_bits(&s->pb, avpkt->data, avpkt->size);

1567 write_frame_header(s);

1568 write_subframes(s);

1569 write_frame_footer(s);

1570 return put_bytes_output(&s->pb);

1571 }

1572

1573

1574 static int update_md5_sum(FlacEncodeContext *s, const void *samples)

1575 {

1576 const uint8_t *buf;

1577 int buf_size = s->frame.blocksize * s->channels *

1578 ((s->avctx->bits_per_raw_sample + 7) / 8);

1579

1580 if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {

1581 av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size);

1582 if (!s->md5_buffer)

1583 return AVERROR(ENOMEM);

1584 }

1585

1586 if (s->avctx->bits_per_raw_sample <= 16) {

1587 buf = (const uint8_t *)samples;

1588 #if HAVE_BIGENDIAN

1589 s->bdsp.bswap16_buf((uint16_t *) s->md5_buffer,

1590 (const uint16_t *) samples, buf_size / 2);

1591 buf = s->md5_buffer;

1592 #endif

1593 } else if (s->avctx->bits_per_raw_sample <= 24) {

1594 int i;

1595 const int32_t *samples0 = samples;

1596 uint8_t *tmp = s->md5_buffer;

1597

1598 for (i = 0; i < s->frame.blocksize * s->channels; i++) {

1599 int32_t v = samples0[i] >> 8;

1600 AV_WL24(tmp + 3*i, v);

1601 }

1602 buf = s->md5_buffer;

1603 } else {

1604 /* s->avctx->bits_per_raw_sample <= 32 */

1605 int i;

1606 const int32_t *samples0 = samples;

1607 uint8_t *tmp = s->md5_buffer;

1608

1609 for (i = 0; i < s->frame.blocksize * s->channels; i++)

1610 AV_WL32(tmp + 4*i, samples0[i]);

1611 buf = s->md5_buffer;

1612 }

1613 av_md5_update(s->md5ctx, buf, buf_size);

1614

1615 return 0;

1616 }

1617

1618

1619 static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

1620 const AVFrame *frame, int *got_packet_ptr)

1621 {

1622 FlacEncodeContext *s;

1623 int frame_bytes, out_bytes, ret;

1624

1625 s = avctx->priv_data;

1626

1627 /* when the last block is reached, update the header in extradata */

1628 if (!frame) {

1629 s->max_framesize = s->max_encoded_framesize;

1630 av_md5_final(s->md5ctx, s->md5sum);

1631 write_streaminfo(s, avctx->extradata);

1632

1633 if (!s->flushed) {

1634 uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,

1635 avctx->extradata_size);

1636 if (!side_data)

1637 return AVERROR(ENOMEM);

1638 memcpy(side_data, avctx->extradata, avctx->extradata_size);

1639

1640 avpkt->pts = s->next_pts;

1641

1642 *got_packet_ptr = 1;

1643 s->flushed = 1;

1644 }

1645

1646 return 0;

1647 }

1648

1649 /* change max_framesize for small final frame */

1650 if (frame->nb_samples < s->frame.blocksize) {

1651 s->max_framesize = flac_get_max_frame_size(frame->nb_samples,

1652 s->channels,

1653 avctx->bits_per_raw_sample);

1654 }

1655

1656 init_frame(s, frame->nb_samples);

1657

1658 copy_samples(s, frame->data[0]);

1659

1660 channel_decorrelation(s);

1661

1662 remove_wasted_bits(s);

1663

1664 frame_bytes = encode_frame(s);

1665

1666 /* Fall back on verbatim mode if the compressed frame is larger than it

1667 would be if encoded uncompressed. */

1668 if (frame_bytes < 0 || frame_bytes > s->max_framesize) {

1669 s->frame.verbatim_only = 1;

1670 frame_bytes = encode_frame(s);

1671 if (frame_bytes < 0) {

1672 av_log(avctx, AV_LOG_ERROR, "Bad frame count\n");

1673 return frame_bytes;

1674 }

1675 }

1676

1677 if ((ret = ff_get_encode_buffer(avctx, avpkt, frame_bytes, 0)) < 0)

1678 return ret;

1679

1680 out_bytes = write_frame(s, avpkt);

1681

1682 s->frame_count++;

1683 s->sample_count += frame->nb_samples;

1684 if ((ret = update_md5_sum(s, frame->data[0])) < 0) {

1685 av_log(avctx, AV_LOG_ERROR, "Error updating MD5 checksum\n");

1686 return ret;

1687 }

1688 if (out_bytes > s->max_encoded_framesize)

1689 s->max_encoded_framesize = out_bytes;

1690 if (out_bytes < s->min_framesize)

1691 s->min_framesize = out_bytes;

1692

1693 s->next_pts = frame->pts + ff_samples_to_time_base(avctx, frame->nb_samples);

1694

1695 av_shrink_packet(avpkt, out_bytes);

1696

1697 *got_packet_ptr = 1;

1698 return 0;

1699 }

1700

1701

1702 static av_cold int flac_encode_close(AVCodecContext *avctx)

1703 {

1704 FlacEncodeContext *s = avctx->priv_data;

1705

1706 av_freep(&s->md5ctx);

1707 av_freep(&s->md5_buffer);

1708 ff_lpc_end(&s->lpc_ctx);

1709 return 0;

1710 }

1711

1712 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM

1713 static const AVOption options[] = {

1714 { "lpc_coeff_precision", "LPC coefficient precision", offsetof(FlacEncodeContext, options.lpc_coeff_precision), AV_OPT_TYPE_INT, {.i64 = 15 }, 0, MAX_LPC_PRECISION, FLAGS },

1715 { "lpc_type", "LPC algorithm", offsetof(FlacEncodeContext, options.lpc_type), AV_OPT_TYPE_INT, {.i64 = FF_LPC_TYPE_DEFAULT }, FF_LPC_TYPE_DEFAULT, FF_LPC_TYPE_NB-1, FLAGS, .unit = "lpc_type" },

1716 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_NONE }, INT_MIN, INT_MAX, FLAGS, .unit = "lpc_type" },

1717 { "fixed", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_FIXED }, INT_MIN, INT_MAX, FLAGS, .unit = "lpc_type" },

1718 { "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, INT_MIN, INT_MAX, FLAGS, .unit = "lpc_type" },

1719 { "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, INT_MIN, INT_MAX, FLAGS, .unit = "lpc_type" },

1720 { "lpc_passes", "Number of passes to use for Cholesky factorization during LPC analysis", offsetof(FlacEncodeContext, options.lpc_passes), AV_OPT_TYPE_INT, {.i64 = 2 }, 1, INT_MAX, FLAGS },

1721 { "min_partition_order", NULL, offsetof(FlacEncodeContext, options.min_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS },

1722 { "max_partition_order", NULL, offsetof(FlacEncodeContext, options.max_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS },

1723 { "prediction_order_method", "Search method for selecting prediction order", offsetof(FlacEncodeContext, options.prediction_order_method), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, ORDER_METHOD_LOG, FLAGS, .unit = "predm" },

1724 { "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },

1725 { "2level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_2LEVEL }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },

1726 { "4level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_4LEVEL }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },

1727 { "8level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_8LEVEL }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },

1728 { "search", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },

1729 { "log", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_LOG }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },

1730 { "ch_mode", "Stereo decorrelation mode", offsetof(FlacEncodeContext, options.ch_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, FLAC_CHMODE_MID_SIDE, FLAGS, .unit = "ch_mode" },

1731 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },

1732 { "indep", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_INDEPENDENT }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },

1733 { "left_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_LEFT_SIDE }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },

1734 { "right_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_RIGHT_SIDE }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },

1735 { "mid_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_MID_SIDE }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },

1736 { "exact_rice_parameters", "Calculate rice parameters exactly", offsetof(FlacEncodeContext, options.exact_rice_parameters), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },

1737 { "multi_dim_quant", "Multi-dimensional quantization", offsetof(FlacEncodeContext, options.multi_dim_quant), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },

1738 { "min_prediction_order", NULL, offsetof(FlacEncodeContext, options.min_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },

1739 { "max_prediction_order", NULL, offsetof(FlacEncodeContext, options.max_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },

1740

1741 { NULL },

1742 };

1743

1744 static const AVClass flac_encoder_class = {

1745 .class_name = "FLAC encoder",

1746 .item_name = av_default_item_name,

1747 .option = options,

1748 .version = LIBAVUTIL_VERSION_INT,

1749 };

1750

1751 const FFCodec ff_flac_encoder = {

1752 .p.name = "flac",

1753 CODEC_LONG_NAME("FLAC (Free Lossless Audio Codec)"),

1754 .p.type = AVMEDIA_TYPE_AUDIO,

1755 .p.id = AV_CODEC_ID_FLAC,

1756 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |

1757 AV_CODEC_CAP_SMALL_LAST_FRAME |

1758 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

1759 .priv_data_size = sizeof(FlacEncodeContext),

1760 .init = flac_encode_init,

1761 FF_CODEC_ENCODE_CB(flac_encode_frame),

1762 .close = flac_encode_close,

1763 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,

1764 AV_SAMPLE_FMT_S32,

1765 AV_SAMPLE_FMT_NONE },

1766 .p.priv_class = &flac_encoder_class,

1767 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,

1768 };

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1077

bswapdsp.h

FLAC_CHMODE_MID_SIDE

@ FLAC_CHMODE_MID_SIDE

Definition: flac.h:42

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

LPC_ENCODE_WITH_RESIDUAL_LIMIT

#define LPC_ENCODE_WITH_RESIDUAL_LIMIT()

Definition: flacenc.c:889

PUT_UTF8

#define PUT_UTF8(val, tmp, PUT_BYTE)

Definition: common.h:525

FFLPCType

LPC analysis type.

Definition: lpc.h:42

level

uint8_t level

Definition: svq3.c:204

FlacSubframe::samples

int32_t samples[FLAC_MAX_BLOCKSIZE]

Definition: flacenc.c:91

av_clip

#define av_clip

Definition: common.h:98

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

put_bits32

static void av_unused put_bits32(PutBitContext *s, uint32_t value)

Write exactly 32 bits into a bitstream.

Definition: put_bits.h:291

flac_encode_init

static av_cold int flac_encode_init(AVCodecContext *avctx)

Definition: flacenc.c:269

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:424

ff_ctz

#define ff_ctz

Definition: intmath.h:107

put_bytes_output

static int put_bytes_output(const PutBitContext *s)

Definition: put_bits.h:89

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1050

CompressionOptions::exact_rice_parameters

int exact_rice_parameters

Definition: flacenc.c:68

MAX_PARTITION_ORDER

#define MAX_PARTITION_ORDER

Definition: flacenc.c:45

FlacEncodeContext::bdsp

BswapDSPContext bdsp

Definition: flacenc.c:126

AV_PKT_DATA_NEW_EXTRADATA

@ AV_PKT_DATA_NEW_EXTRADATA

The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...

Definition: packet.h:56

encode_residual_fixed_with_residual_limit_33bps

static int encode_residual_fixed_with_residual_limit_33bps(int32_t *res, const int64_t *smp, int n, int order)

Definition: flacenc.c:883

CompressionOptions::max_prediction_order

int max_prediction_order

Definition: flacenc.c:63

CompressionOptions::ch_mode

int ch_mode

Definition: flacenc.c:67

MAX_LPC_SHIFT

#define MAX_LPC_SHIFT

Definition: flacenc.c:49

FF_CODEC_CAP_EOF_FLUSH

#define FF_CODEC_CAP_EOF_FLUSH

The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...

Definition: codec_internal.h:90

ff_lpc_calc_coefs

int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)

Calculate LPC coefficients for multiple orders.

Definition: lpc.c:238

int64_t

long long int64_t

Definition: coverity.c:34

put_sbits

static void put_sbits(PutBitContext *pb, int n, int32_t value)

Definition: put_bits.h:281

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:62

flac_encode_frame

static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)

Definition: flacenc.c:1619

FLACEncDSPContext

Definition: flacencdsp.h:24

FlacEncodeContext::md5sum

uint8_t md5sum[16]

Definition: flacenc.c:118

ff_lpc_init

av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)

Initialize LPCContext.

Definition: lpc.c:340

RiceContext

Definition: alacenc.c:50

AV_CHANNEL_LAYOUT_2_2

#define AV_CHANNEL_LAYOUT_2_2

Definition: channel_layout.h:386

av_unused

#define av_unused

Definition: attributes.h:131

FlacEncodeContext::avctx

AVCodecContext * avctx

Definition: flacenc.c:121

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:344

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:222

AVFrame::pts

int64_t pts

Presentation timestamp in time_base units (time when frame should be shown to user).

Definition: frame.h:456

step

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step

Definition: rate_distortion.txt:58

CompressionOptions::max_partition_order

int max_partition_order

Definition: flacenc.c:66

FF_LPC_TYPE_CHOLESKY

@ FF_LPC_TYPE_CHOLESKY

Cholesky factorization.

Definition: lpc.h:47

AVPacket::data

uint8_t * data

Definition: packet.h:522

AVOption

AVOption.

Definition: opt.h:346

encode.h

FlacEncodeContext

Definition: flacenc.c:105

#define b

Definition: input.c:41

data

const char data[16]

Definition: mxf.c:148

FFCodec

Definition: codec_internal.h:127

CompressionOptions::prediction_order_method

int prediction_order_method

Definition: flacenc.c:64

FlacFrame

Definition: flacenc.c:95

select_blocksize

static int select_blocksize(int samplerate, int block_time_ms)

Set blocksize based on samplerate.

Definition: flacenc.c:192

CODING_MODE_RICE

@ CODING_MODE_RICE

Definition: flacenc.c:52

FF_COMPLIANCE_EXPERIMENTAL

#define FF_COMPLIANCE_EXPERIMENTAL

Allow nonstandardized experimental things.

Definition: defs.h:62

AV_CODEC_ID_FLAC

@ AV_CODEC_ID_FLAC

Definition: codec_id.h:452

AVChannelLayout::order

enum AVChannelOrder order

Channel order used in this layout.

Definition: channel_layout.h:308

lpc.h

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:313

CompressionOptions::compression_level

int compression_level

Definition: flacenc.c:57

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:365

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

FlacEncodeContext::pb

PutBitContext pb

Definition: flacenc.c:107

crc.h

LPCContext

Definition: lpc.h:51

find_subframe_rice_params

static uint64_t find_subframe_rice_params(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)

Definition: flacenc.c:761

ORDER_METHOD_4LEVEL

#define ORDER_METHOD_4LEVEL

Definition: lpc.h:31

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

FlacSubframe::wasted

int wasted

Definition: flacenc.c:82

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1065

av_shrink_packet

void av_shrink_packet(AVPacket *pkt, int size)

Reduce packet size, correctly zeroing padding.

Definition: avpacket.c:113

FlacEncodeContext::frame_count

uint32_t frame_count

Definition: flacenc.c:116

DEFAULT_TO_VERBATIM

#define DEFAULT_TO_VERBATIM()

Definition: flacenc.c:945

CompressionOptions::lpc_coeff_precision

int lpc_coeff_precision

Definition: flacenc.c:61

val

static double val(void *priv, double ch)

Definition: aeval.c:78

FlacEncodeContext::flac_dsp

FLACEncDSPContext flac_dsp

Definition: flacenc.c:127

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:296

AVMD5

Definition: md5.c:42

frame_end

static int64_t frame_end(const SyncQueue *sq, SyncQueueFrame frame, int nb_samples)

Compute the end timestamp of a frame.

Definition: sync_queue.c:128

AV_CHANNEL_LAYOUT_SURROUND

#define AV_CHANNEL_LAYOUT_SURROUND

Definition: channel_layout.h:382

FF_LPC_TYPE_DEFAULT

@ FF_LPC_TYPE_DEFAULT

use the codec default LPC type

Definition: lpc.h:43

ff_flac_blocksize_table

const int32_t ff_flac_blocksize_table[16]

Definition: flacdata.c:30

lpc_encode_choose_datapath

static int lpc_encode_choose_datapath(FlacEncodeContext *s, int32_t bps, int32_t *res, const int32_t *smp, const int64_t *smp_33bps, int len, int order, int32_t *coefs, int shift)

Definition: flacenc.c:918

avassert.h

FlacFrame::ch_mode

int ch_mode

Definition: flacenc.c:101

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

write_subframes

static void write_subframes(FlacEncodeContext *s)

Definition: flacenc.c:1469

av_cold

#define av_cold

Definition: attributes.h:90

mask

static const uint16_t mask[17]

Definition: lzw.c:38

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:524

#define s(width, name)

Definition: cbs_vp9.c:198

FlacSubframe::type_code

int type_code

Definition: flacenc.c:80

FlacSubframe::obits

int obits

Definition: flacenc.c:81

FlacEncodeContext::max_framesize

int max_framesize

Definition: flacenc.c:114

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CHANNEL_ORDER_UNSPEC

@ AV_CHANNEL_ORDER_UNSPEC

Only the channel count is specified, without any further information about the channel order.

Definition: channel_layout.h:112

AV_CHANNEL_LAYOUT_5POINT0_BACK

#define AV_CHANNEL_LAYOUT_5POINT0_BACK

Definition: channel_layout.h:390

flac_get_max_frame_size

static int flac_get_max_frame_size(int blocksize, int ch, int bps)

Calculate an estimate for the maximum frame size based on verbatim mode.

Definition: flacenc.c:166

AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...

Definition: codec.h:159

CompressionOptions::multi_dim_quant

int multi_dim_quant

Definition: flacenc.c:69

bits

uint8_t bits

Definition: vp3data.h:128

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

FlacSubframe::order

int order

Definition: flacenc.c:83

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1574

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

remove_wasted_bits

static void remove_wasted_bits(FlacEncodeContext *s)

Definition: flacenc.c:1229

channels

Definition: aptx.h:31

FlacSubframe::rc

RiceContext rc

Definition: flacenc.c:87

FLAC_SUBFRAME_LPC

#define FLAC_SUBFRAME_LPC

Definition: flacenc.c:42

COPY_SAMPLES

#define COPY_SAMPLES(bits)

calc_optimal_rice_params

static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder, uint64_t sums[32][MAX_PARTITIONS], int n, int pred_order, int max_param, int exact)

Definition: flacenc.c:642

CompressionOptions

Definition: dcaenc.c:56

FLAC_SUBFRAME_VERBATIM

#define FLAC_SUBFRAME_VERBATIM

Definition: flacenc.c:40

PutBitContext

Definition: put_bits.h:50

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

frame

static AVFrame * frame

Definition: demux_decode.c:54

RiceContext::porder

int porder

Definition: flacenc.c:74

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:72

FLAC_SUBFRAME_CONSTANT

#define FLAC_SUBFRAME_CONSTANT

Definition: flacenc.c:39

ff_flac_sample_rate_table

const int ff_flac_sample_rate_table[16]

Definition: flacdata.c:24

AV_CRC_16_ANSI

@ AV_CRC_16_ANSI

Definition: crc.h:50

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

FlacFrame::subframes

FlacSubframe subframes[FLAC_MAX_CHANNELS]

Definition: flacenc.c:96

ff_bswapdsp_init

av_cold void ff_bswapdsp_init(BswapDSPContext *c)

Definition: bswapdsp.c:49

NULL

#define NULL

Definition: coverity.c:32

FlacFrame::samples_33bps

int64_t samples_33bps[FLAC_MAX_BLOCKSIZE]

Definition: flacenc.c:97

FLAC_SUBFRAME_FIXED

#define FLAC_SUBFRAME_FIXED

Definition: flacenc.c:41

FlacEncodeContext::lpc_ctx

LPCContext lpc_ctx

Definition: flacenc.c:122

MIN_LPC_SHIFT

#define MIN_LPC_SHIFT

Definition: flacenc.c:48

ff_samples_to_time_base

static av_always_inline int64_t ff_samples_to_time_base(const AVCodecContext *avctx, int64_t samples)

Rescale from sample rate to AVCodecContext.time_base.

Definition: encode.h:90

ff_ctzll

#define ff_ctzll

Definition: intmath.h:127

FlacEncodeContext::max_blocksize

int max_blocksize

Definition: flacenc.c:112

AV_WL24

#define AV_WL24(p, d)

Definition: intreadwrite.h:462

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

FLAGS

#define FLAGS

Definition: flacenc.c:1712

FlacEncodeContext::next_pts

int64_t next_pts

Definition: flacenc.c:130

ff_lpc_end

av_cold void ff_lpc_end(LPCContext *s)

Uninitialize LPCContext.

Definition: lpc.c:365

FLAC_STREAMINFO_SIZE

#define FLAC_STREAMINFO_SIZE

Definition: flac.h:32

FLAC_CHMODE_RIGHT_SIDE

@ FLAC_CHMODE_RIGHT_SIDE

Definition: flac.h:41

FlacEncodeContext::md5_buffer

uint8_t * md5_buffer

Definition: flacenc.c:124

ORDER_METHOD_SEARCH

#define ORDER_METHOD_SEARCH

Definition: lpc.h:33

put_sbits63

static void put_sbits63(PutBitContext *pb, int n, int64_t value)

Definition: put_bits.h:366

CompressionOptions::lpc_passes

int lpc_passes

Definition: flacenc.c:60

FlacEncodeContext::channels

int channels

Definition: flacenc.c:108

estimate_stereo_mode

static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n, int max_rice_param, int bps)

Definition: flacenc.c:1283

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

rice_count_exact

static uint64_t rice_count_exact(const int32_t *res, int n, int k)

Definition: flacenc.c:545

FlacEncodeContext::max_encoded_framesize

int max_encoded_framesize

Definition: flacenc.c:115

encode_residual_ch

static int encode_residual_ch(FlacEncodeContext *s, int ch)

Definition: flacenc.c:953

get_max_p_order

static int get_max_p_order(int max_porder, int n, int order)

Definition: flacenc.c:752

ORDER_METHOD_8LEVEL

#define ORDER_METHOD_8LEVEL

Definition: lpc.h:32

find_optimal_param_exact

static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)

Definition: flacenc.c:625

FlacEncodeContext::flushed

int flushed

Definition: flacenc.c:129

Definition: af_crystalizer.c:121

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:365

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:523

FlacEncodeContext::md5_buffer_size

unsigned int md5_buffer_size

Definition: flacenc.c:125

encode_residual_fixed_with_residual_limit

static int encode_residual_fixed_with_residual_limit(int32_t *res, const int32_t *smp, int n, int order)

Definition: flacenc.c:876

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:303

codec_internal.h

av_clipl_int32

#define av_clipl_int32

Definition: common.h:116

shift

static int shift(int a, int b)

Definition: bonk.c:262

channel_decorrelation

static void channel_decorrelation(FlacEncodeContext *s)

Perform stereo channel decorrelation.

Definition: flacenc.c:1339

FF_LPC_TYPE_NB

@ FF_LPC_TYPE_NB

Not part of ABI.

Definition: lpc.h:48

MAX_LPC_ORDER

#define MAX_LPC_ORDER

Definition: lpc.h:37

bps

unsigned bps

Definition: movenc.c:1792

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1057

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

flacdata.h

encode_frame

static int encode_frame(FlacEncodeContext *s)

Definition: flacenc.c:1209

calc_sum_top

static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order, uint64_t sums[32][MAX_PARTITIONS])

Definition: flacenc.c:672

FlacFrame::crc8

uint8_t crc8

Definition: flacenc.c:100

FlacEncodeContext::frame

FlacFrame frame

Definition: flacenc.c:119

FlacFrame::bs_code

int bs_code[2]

Definition: flacenc.c:99

flacencdsp.h

FlacSubframe::residual

int32_t residual[FLAC_MAX_BLOCKSIZE+11]

Definition: flacenc.c:92

FlacEncodeContext::options

CompressionOptions options

Definition: flacenc.c:120

header

static const uint8_t header[24]

Definition: sdr2.c:68

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:164

FlacEncodeContext::samplerate

int samplerate

Definition: flacenc.c:109

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

FlacEncodeContext::min_framesize

int min_framesize

Definition: flacenc.c:113

av_crc_get_table

const AVCRC * av_crc_get_table(AVCRCId crc_id)

Get an initialized standard CRC table.

Definition: crc.c:374

write_frame

static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)

Definition: flacenc.c:1564

FlacSubframe::type

int type

Definition: flacenc.c:79

ORDER_METHOD_EST

#define ORDER_METHOD_EST

Definition: lpc.h:29

options

static const AVOption options[]

Definition: flacenc.c:1713

FlacSubframe

Definition: flacenc.c:78

av_channel_layout_compare

int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)

Check whether two channel layouts are semantically the same, i.e.

Definition: channel_layout.c:800

FlacSubframe::coefs

int32_t coefs[MAX_LPC_ORDER]

Definition: flacenc.c:84

calc_sum_next

static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)

Definition: flacenc.c:702

av_md5_init

void av_md5_init(AVMD5 *ctx)

Initialize MD5 hashing.

Definition: md5.c:143

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:424

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:515

av_get_bytes_per_sample

int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)

Return number of bytes per sample.

Definition: samplefmt.c:108

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:523

write_utf8

static void write_utf8(PutBitContext *pb, uint32_t val)

Definition: flacenc.c:1406

AV_CHANNEL_LAYOUT_QUAD

#define AV_CHANNEL_LAYOUT_QUAD

Definition: channel_layout.h:387

CompressionOptions::min_partition_order

int min_partition_order

Definition: flacenc.c:65

count_frame_header

static int count_frame_header(FlacEncodeContext *s)

Definition: flacenc.c:1173

ff_flac_encoder

const FFCodec ff_flac_encoder

Definition: flacenc.c:1751

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:56

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

write_frame_header

static void write_frame_header(FlacEncodeContext *s)

Definition: flacenc.c:1413

md5.h

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

ff_flacencdsp_init

av_cold void ff_flacencdsp_init(FLACEncDSPContext *c)

Definition: flacencdsp.c:32

write_frame_footer

static void write_frame_footer(FlacEncodeContext *s)

Definition: flacenc.c:1553

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

copy_samples

static void copy_samples(FlacEncodeContext *s, const void *samples)

Copy channel-interleaved input samples into separate subframes.

Definition: flacenc.c:523

len

int len

Definition: vorbis_enc_data.h:426

av_md5_final

void av_md5_final(AVMD5 *ctx, uint8_t *dst)

Finish hashing and output digest value.

Definition: md5.c:188

MAX_PARTITIONS

#define MAX_PARTITIONS

Definition: flacenc.c:46

lpc_encode_with_residual_limit_33bps

static int lpc_encode_with_residual_limit_33bps(int32_t *res, const int64_t *smp, int len, int order, int32_t *coefs, int shift)

Definition: flacenc.c:912

avcodec.h

CompressionOptions::lpc_type

enum FFLPCType lpc_type

Definition: flacenc.c:59

FlacEncodeContext::sample_count

uint64_t sample_count

Definition: flacenc.c:117

calc_rice_params

static uint64_t calc_rice_params(RiceContext *rc, uint32_t udata[FLAC_MAX_BLOCKSIZE], uint64_t sums[32][MAX_PARTITIONS], int pmin, int pmax, const int32_t *data, int n, int pred_order, int exact)

Definition: flacenc.c:712

ret

Definition: filter_design.txt:187

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

AVCodecContext::strict_std_compliance

int strict_std_compliance

strictly follow the standard (MPEG-4, ...).

Definition: avcodec.h:1379

encode_residual_fixed

static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, int order)

Definition: flacenc.c:778

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

FLAC_MAX_CHANNELS

#define FLAC_MAX_CHANNELS

Definition: flac.h:33

MAX_LPC_PRECISION

#define MAX_LPC_PRECISION

Definition: flacenc.c:47

AVCodecContext

main external API structure.

Definition: avcodec.h:445

ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT

#define ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT()

Definition: flacenc.c:834

FlacEncodeContext::bps_code

int bps_code

Definition: flacenc.c:111

FlacSubframe::rc_sums

uint64_t rc_sums[32][MAX_PARTITIONS]

Definition: flacenc.c:89

channel_layout.h

FlacSubframe::rc_udata

uint32_t rc_udata[FLAC_MAX_BLOCKSIZE]

Definition: flacenc.c:88

ORDER_METHOD_LOG

#define ORDER_METHOD_LOG

Definition: lpc.h:34

av_packet_new_side_data

uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)

Allocate new information of a packet.

Definition: avpacket.c:231

ff_get_encode_buffer

int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)

Get a buffer for a packet.

Definition: encode.c:105

av_crc

uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)

Calculate the CRC of a block.

Definition: crc.c:392

av_md5_alloc

struct AVMD5 * av_md5_alloc(void)

Allocate an AVMD5 context.

Definition: md5.c:50

subframe_count_exact

static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)

Definition: flacenc.c:558

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:235

FlacEncodeContext::sr_code

int sr_code[2]

Definition: flacenc.c:110

CompressionOptions::min_prediction_order

int min_prediction_order

Definition: flacenc.c:62

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: codec.h:76

samples

Filter the word "frame" indicates either a video frame or a group of audio samples

Definition: filter_design.txt:8

lpc_encode_with_residual_limit

static int lpc_encode_with_residual_limit(int32_t *res, const int32_t *smp, int len, int order, int32_t *coefs, int shift)

Definition: flacenc.c:906

FlacSubframe::shift

int shift

Definition: flacenc.c:85

av_md5_update

void av_md5_update(AVMD5 *ctx, const uint8_t *src, size_t len)

Update hash value.

Definition: md5.c:153

init_frame

static void init_frame(FlacEncodeContext *s, int nb_samples)

Definition: flacenc.c:478

RiceContext::params

int params[MAX_PARTITIONS]

Definition: flacenc.c:75

FLAC_MAX_BLOCKSIZE

#define FLAC_MAX_BLOCKSIZE

Definition: flac.h:35

AV_CRC_8_ATM

@ AV_CRC_8_ATM

Definition: crc.h:49

flush_put_bits

static void flush_put_bits(PutBitContext *s)

Pad the end of the output stream with zeros.

Definition: put_bits.h:143

AVPacket

This structure stores compressed data.

Definition: packet.h:499

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:472

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Definition: opt.h:251

RiceContext::coding_mode

enum CodingMode coding_mode

Definition: flacenc.c:73

FLAC_CHMODE_LEFT_SIDE

@ FLAC_CHMODE_LEFT_SIDE

Definition: flac.h:40

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

av_fast_malloc

void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)

Allocate a buffer, reusing the given one if large enough.

Definition: mem.c:555

find_optimal_param

static int find_optimal_param(uint64_t sum, int n, int max_param)

Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.

Definition: flacenc.c:613

dprint_compression_options

static av_cold void dprint_compression_options(FlacEncodeContext *s)

Definition: flacenc.c:211

update_md5_sum

static int update_md5_sum(FlacEncodeContext *s, const void *samples)

Definition: flacenc.c:1574

flac_encode_close

static av_cold int flac_encode_close(AVCodecContext *avctx)

Definition: flacenc.c:1702

Definition: ffmpeg_filter.c:409

CODING_MODE_RICE2

@ CODING_MODE_RICE2

Definition: flacenc.c:53

int32_t

Definition: audioconvert.c:56

CompressionOptions::block_time_ms

int block_time_ms

Definition: flacenc.c:58

AV_CHANNEL_LAYOUT_5POINT1_BACK

#define AV_CHANNEL_LAYOUT_5POINT1_BACK

Definition: channel_layout.h:391

AVERROR_BUG

#define AVERROR_BUG

Internal bug, also see AVERROR_BUG2.

Definition: error.h:52

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

flac_encoder_class

static const AVClass flac_encoder_class

Definition: flacenc.c:1744

BswapDSPContext

Definition: bswapdsp.h:24

write_streaminfo

static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)

Write streaminfo metadata block to byte array.

Definition: flacenc.c:137

AV_CHANNEL_LAYOUT_5POINT0

#define AV_CHANNEL_LAYOUT_5POINT0

Definition: channel_layout.h:388

MAX_FIXED_ORDER

#define MAX_FIXED_ORDER

Definition: flacenc.c:44

ORDER_METHOD_2LEVEL

#define ORDER_METHOD_2LEVEL

Definition: lpc.h:30

FLAC_MIN_BLOCKSIZE

#define FLAC_MIN_BLOCKSIZE

Definition: flac.h:34

set_sr_golomb_flac

static void set_sr_golomb_flac(PutBitContext *pb, int i, int k)

Definition: flacenc.c:1450

flac.h

FF_LPC_TYPE_NONE

@ FF_LPC_TYPE_NONE

do not use LPC prediction or use all zero coefficients

Definition: lpc.h:44

AV_CODEC_CAP_SMALL_LAST_FRAME

#define AV_CODEC_CAP_SMALL_LAST_FRAME

Codec can be fed a final frame with a smaller size.

Definition: codec.h:81

av_bswap16

#define av_bswap16

Definition: bswap.h:27

FlacFrame::verbatim_only

int verbatim_only

Definition: flacenc.c:102

AV_CHANNEL_LAYOUT_5POINT1

#define AV_CHANNEL_LAYOUT_5POINT1

Definition: channel_layout.h:389

put_bits.h

FlacEncodeContext::md5ctx

struct AVMD5 * md5ctx

Definition: flacenc.c:123

AV_SAMPLE_FMT_S32

@ AV_SAMPLE_FMT_S32

signed 32 bits

Definition: samplefmt.h:59

AV_OPT_TYPE_CONST

@ AV_OPT_TYPE_CONST

Definition: opt.h:244

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

FF_LPC_TYPE_LEVINSON

@ FF_LPC_TYPE_LEVINSON

Levinson-Durbin recursion.

Definition: lpc.h:46

FlacFrame::blocksize

int blocksize

Definition: flacenc.c:98

CodingMode

Definition: flacenc.c:51

rice_encode_count

#define rice_encode_count(sum, n, k)

Definition: flacenc.c:608

FLAC_CHMODE_INDEPENDENT

@ FLAC_CHMODE_INDEPENDENT

Definition: flac.h:39

AVCodecContext::compression_level

int compression_level

Definition: avcodec.h:1245

FF_LPC_TYPE_FIXED

@ FF_LPC_TYPE_FIXED

fixed LPC coefficients

Definition: lpc.h:45

intmath.h

Generated on Thu Sep 26 2024 23:14:56 for FFmpeg by doxygen 1.8.17