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 "encode.h"

32 #include "put_bits.h"

33 #include "golomb.h"

34 #include "internal.h"

35 #include "lpc.h"

36 #include "flac.h"

37 #include "flacdata.h"

38 #include "flacdsp.h"

40 #define FLAC_SUBFRAME_CONSTANT 0

41 #define FLAC_SUBFRAME_VERBATIM 1

42 #define FLAC_SUBFRAME_FIXED 8

43 #define FLAC_SUBFRAME_LPC 32

45 #define MAX_FIXED_ORDER 4

46 #define MAX_PARTITION_ORDER 8

47 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)

48 #define MAX_LPC_PRECISION 15

49 #define MIN_LPC_SHIFT 0

50 #define MAX_LPC_SHIFT 15

52 enum CodingMode {

53 CODING_MODE_RICE = 4,

54 CODING_MODE_RICE2 = 5,

55 };

57 typedef struct CompressionOptions {

58 int compression_level;

59 int block_time_ms;

60 enum FFLPCType lpc_type;

61 int lpc_passes;

62 int lpc_coeff_precision;

63 int min_prediction_order;

64 int max_prediction_order;

65 int prediction_order_method;

66 int min_partition_order;

67 int max_partition_order;

68 int ch_mode;

69 int exact_rice_parameters;

70 int multi_dim_quant;

71 } CompressionOptions;

73 typedef struct RiceContext {

74 enum CodingMode coding_mode;

75 int porder;

76 int params[MAX_PARTITIONS];

77 } RiceContext;

79 typedef struct FlacSubframe {

80 int type;

81 int type_code;

82 int obits;

83 int wasted;

84 int order;

85 int32_t coefs[MAX_LPC_ORDER];

86 int shift;

88 RiceContext rc;

89 uint32_t rc_udata[FLAC_MAX_BLOCKSIZE];

90 uint64_t rc_sums[32][MAX_PARTITIONS];

92 int32_t samples[FLAC_MAX_BLOCKSIZE];

93 int32_t residual[FLAC_MAX_BLOCKSIZE+11];

94 } FlacSubframe;

96 typedef struct FlacFrame {

97 FlacSubframe subframes[FLAC_MAX_CHANNELS];

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 FLACDSPContext 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 * Set blocksize based on samplerate.

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

163 */

164 static int select_blocksize(int samplerate, int block_time_ms)

165 {

166 int i;

167 int target;

168 int blocksize;

169

170 av_assert0(samplerate > 0);

171 blocksize = ff_flac_blocksize_table[1];

172 target = (samplerate * block_time_ms) / 1000;

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

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

175 ff_flac_blocksize_table[i] > blocksize) {

176 blocksize = ff_flac_blocksize_table[i];

177 }

178 }

179 return blocksize;

180 }

181

182

183 static av_cold void dprint_compression_options(FlacEncodeContext *s)

184 {

185 AVCodecContext *avctx = s->avctx;

186 CompressionOptions *opt = &s->options;

187

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

189

190 switch (opt->lpc_type) {

191 case FF_LPC_TYPE_NONE:

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

193 break;

194 case FF_LPC_TYPE_FIXED:

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

196 break;

197 case FF_LPC_TYPE_LEVINSON:

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

199 break;

200 case FF_LPC_TYPE_CHOLESKY:

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

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

203 break;

204 }

205

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

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

208

209 switch (opt->prediction_order_method) {

210 case ORDER_METHOD_EST:

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

212 break;

213 case ORDER_METHOD_2LEVEL:

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

215 break;

216 case ORDER_METHOD_4LEVEL:

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

218 break;

219 case ORDER_METHOD_8LEVEL:

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

221 break;

222 case ORDER_METHOD_SEARCH:

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

224 break;

225 case ORDER_METHOD_LOG:

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

227 break;

228 }

229

230

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

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

233

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

235

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

237 opt->lpc_coeff_precision);

238 }

239

240

241 static av_cold int flac_encode_init(AVCodecContext *avctx)

242 {

243 int freq = avctx->sample_rate;

244 int channels = avctx->channels;

245 FlacEncodeContext *s = avctx->priv_data;

246 int i, level, ret;

247 uint8_t *streaminfo;

248

249 s->avctx = avctx;

250

251 switch (avctx->sample_fmt) {

252 case AV_SAMPLE_FMT_S16:

253 avctx->bits_per_raw_sample = 16;

254 s->bps_code = 4;

255 break;

256 case AV_SAMPLE_FMT_S32:

257 if (avctx->bits_per_raw_sample != 24)

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

259 avctx->bits_per_raw_sample = 24;

260 s->bps_code = 6;

261 break;

262 }

263

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

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

266 channels, FLAC_MAX_CHANNELS);

267 return AVERROR(EINVAL);

268 }

269 s->channels = channels;

270

271 /* find samplerate in table */

272 if (freq < 1)

273 return AVERROR(EINVAL);

274 for (i = 4; i < 12; i++) {

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

276 s->samplerate = ff_flac_sample_rate_table[i];

277 s->sr_code[0] = i;

278 s->sr_code[1] = 0;

279 break;

280 }

281 }

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

283 if (i == 12) {

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

285 s->sr_code[0] = 12;

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

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

288 s->sr_code[0] = 14;

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

290 } else if (freq < 65535) {

291 s->sr_code[0] = 13;

292 s->sr_code[1] = freq;

293 } else {

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

295 return AVERROR(EINVAL);

296 }

297 s->samplerate = freq;

298 }

299

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

301 if (avctx->compression_level < 0)

302 s->options.compression_level = 5;

303 else

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

305

306 level = s->options.compression_level;

307 if (level > 12) {

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

309 s->options.compression_level);

310 return AVERROR(EINVAL);

311 }

312

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

314

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

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

317 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,

318 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,

319 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,

320 FF_LPC_TYPE_LEVINSON})[level];

321

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

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

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

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

326

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

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

329 ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,

330 ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL,

331 ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,

332 ORDER_METHOD_SEARCH})[level];

333

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

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

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

337 return AVERROR(EINVAL);

338 }

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

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

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

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

343

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

345 s->options.min_prediction_order = 0;

346 s->options.max_prediction_order = 0;

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

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

349 av_log(avctx, AV_LOG_WARNING,

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

351 s->options.min_prediction_order, MAX_FIXED_ORDER);

352 s->options.min_prediction_order = MAX_FIXED_ORDER;

353 }

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

355 av_log(avctx, AV_LOG_WARNING,

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

357 s->options.max_prediction_order, MAX_FIXED_ORDER);

358 s->options.max_prediction_order = MAX_FIXED_ORDER;

359 }

360 }

361

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

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

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

365 return AVERROR(EINVAL);

366 }

367

368 if (avctx->frame_size > 0) {

369 if (avctx->frame_size < FLAC_MIN_BLOCKSIZE ||

370 avctx->frame_size > FLAC_MAX_BLOCKSIZE) {

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

372 avctx->frame_size);

373 return AVERROR(EINVAL);

374 }

375 } else {

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

377 }

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

379

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

381 s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,

382 s->channels,

383 s->avctx->bits_per_raw_sample);

384

385 /* initialize MD5 context */

386 s->md5ctx = av_md5_alloc();

387 if (!s->md5ctx)

388 return AVERROR(ENOMEM);

389 av_md5_init(s->md5ctx);

390

391 streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);

392 if (!streaminfo)

393 return AVERROR(ENOMEM);

394 write_streaminfo(s, streaminfo);

395 avctx->extradata = streaminfo;

396 avctx->extradata_size = FLAC_STREAMINFO_SIZE;

397

398 s->frame_count = 0;

399 s->min_framesize = s->max_framesize;

400

401 if (channels == 3 &&

402 avctx->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) ||

403 channels == 4 &&

404 avctx->channel_layout != AV_CH_LAYOUT_2_2 &&

405 avctx->channel_layout != AV_CH_LAYOUT_QUAD ||

406 channels == 5 &&

407 avctx->channel_layout != AV_CH_LAYOUT_5POINT0 &&

408 avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK ||

409 channels == 6 &&

410 avctx->channel_layout != AV_CH_LAYOUT_5POINT1 &&

411 avctx->channel_layout != AV_CH_LAYOUT_5POINT1_BACK) {

412 if (avctx->channel_layout) {

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

414 "output stream will have incorrect "

415 "channel layout.\n");

416 } else {

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

418 "will use Flac channel layout for "

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

420 }

421 }

422

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

424 s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);

425

426 ff_bswapdsp_init(&s->bdsp);

427 ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt, channels,

428 avctx->bits_per_raw_sample);

429

430 dprint_compression_options(s);

431

432 return ret;

433 }

434

435

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

437 {

438 int i, ch;

439 FlacFrame *frame;

440

441 frame = &s->frame;

442

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

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

445 frame->blocksize = ff_flac_blocksize_table[i];

446 frame->bs_code[0] = i;

447 frame->bs_code[1] = 0;

448 break;

449 }

450 }

451 if (i == 16) {

452 frame->blocksize = nb_samples;

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

454 frame->bs_code[0] = 6;

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

456 } else {

457 frame->bs_code[0] = 7;

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

459 }

460 }

461

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

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

464

465 sub->wasted = 0;

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

467

468 if (sub->obits > 16)

469 sub->rc.coding_mode = CODING_MODE_RICE2;

470 else

471 sub->rc.coding_mode = CODING_MODE_RICE;

472 }

473

474 frame->verbatim_only = 0;

475 }

476

477

478 /**

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

480 */

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

482 {

483 int i, j, ch;

484 FlacFrame *frame;

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

486 s->avctx->bits_per_raw_sample;

487

488 #define COPY_SAMPLES(bits) do { \

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

490 frame = &s->frame; \

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

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

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

494 } while (0)

495

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

497 COPY_SAMPLES(16);

498 else

499 COPY_SAMPLES(32);

500 }

501

502

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

504 {

505 int i;

506 uint64_t count = 0;

507

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

509 int32_t v = -2 * res[i] - 1;

510 v ^= v >> 31;

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

512 }

513 return count;

514 }

515

516

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

518 int pred_order)

519 {

520 int p, porder, psize;

521 int i, part_end;

522 uint64_t count = 0;

523

524 /* subframe header */

525 count += 8;

526

527 if (sub->wasted)

528 count += sub->wasted;

529

530 /* subframe */

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

532 count += sub->obits;

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

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

535 } else {

536 /* warm-up samples */

537 count += pred_order * sub->obits;

538

539 /* LPC coefficients */

540 if (sub->type == FLAC_SUBFRAME_LPC)

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

542

543 /* rice-encoded block */

544 count += 2;

545

546 /* partition order */

547 porder = sub->rc.porder;

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

549 count += 4;

550

551 /* residual */

552 i = pred_order;

553 part_end = psize;

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

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

556 count += sub->rc.coding_mode;

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

558 i = part_end;

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

560 }

561 }

562

563 return count;

564 }

565

566

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

568

569 /**

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

571 */

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

573 {

574 int k;

575 uint64_t sum2;

576

577 if (sum <= n >> 1)

578 return 0;

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

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

581 return FFMIN(k, max_param);

582 }

583

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

585 {

586 int bestk = 0;

587 int64_t bestbits = INT64_MAX;

588 int k;

589

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

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

592 if (bits < bestbits) {

593 bestbits = bits;

594 bestk = k;

595 }

596 }

597

598 return bestk;

599 }

600

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

602 uint64_t sums[32][MAX_PARTITIONS],

603 int n, int pred_order, int max_param, int exact)

604 {

605 int i;

606 int k, cnt, part;

607 uint64_t all_bits;

608

609 part = (1 << porder);

610 all_bits = 4 * part;

611

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

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

614 if (exact) {

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

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

617 } else {

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

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

620 }

621 rc->params[i] = k;

622 cnt = n >> porder;

623 }

624

625 rc->porder = porder;

626

627 return all_bits;

628 }

629

630

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

632 uint64_t sums[32][MAX_PARTITIONS])

633 {

634 int i, k;

635 int parts;

636 const uint32_t *res, *res_end;

637

638 /* sums for highest level */

639 parts = (1 << pmax);

640

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

642 res = &data[pred_order];

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

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

645 if (kmax) {

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

647 while (res < res_end)

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

649 sums[k][i] = sum;

650 } else {

651 uint64_t sum = 0;

652 while (res < res_end)

653 sum += *(res++);

654 sums[k][i] = sum;

655 }

656 res_end += n >> pmax;

657 }

658 }

659 }

660

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

662 {

663 int i, k;

664 int parts = (1 << level);

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

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

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

668 }

669 }

670

671 static uint64_t calc_rice_params(RiceContext *rc,

672 uint32_t udata[FLAC_MAX_BLOCKSIZE],

673 uint64_t sums[32][MAX_PARTITIONS],

674 int pmin, int pmax,

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

676 {

677 int i;

678 uint64_t bits[MAX_PARTITION_ORDER+1];

679 int opt_porder;

680 RiceContext tmp_rc;

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

682

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

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

685 av_assert1(pmin <= pmax);

686

687 tmp_rc.coding_mode = rc->coding_mode;

688

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

690 udata[i] = (2 * data[i]) ^ (data[i] >> 31);

691

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

693

694 opt_porder = pmin;

695 bits[pmin] = UINT32_MAX;

696 for (i = pmax; ; ) {

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

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

699 opt_porder = i;

700 *rc = tmp_rc;

701 }

702 if (i == pmin)

703 break;

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

705 }

706

707 return bits[opt_porder];

708 }

709

710

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

712 {

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

714 if (order > 0)

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

716 return porder;

717 }

718

719

720 static uint64_t find_subframe_rice_params(FlacEncodeContext *s,

721 FlacSubframe *sub, int pred_order)

722 {

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

724 s->frame.blocksize, pred_order);

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

726 s->frame.blocksize, pred_order);

727

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

729 if (sub->type == FLAC_SUBFRAME_LPC)

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

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

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

733 return bits;

734 }

735

736

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

738 int order)

739 {

740 int i;

741

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

743 res[i] = smp[i];

744

745 if (order == 0) {

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

747 res[i] = smp[i];

748 } else if (order == 1) {

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

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

751 } else if (order == 2) {

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

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

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

755 res[i] = b - a;

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

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

758 }

759 } else if (order == 3) {

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

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

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

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

764 int d = b - a;

765 res[i] = d - c;

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

767 c = a - b;

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

769 }

770 } else {

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

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

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

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

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

776 int d = b - a;

777 int f = d - c;

778 res[i ] = f - e;

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

780 c = a - b;

781 e = c - d;

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

783 }

784 }

785 }

786

787

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

789 {

790 int i, n;

791 int min_order, max_order, opt_order, omethod;

792 FlacFrame *frame;

793 FlacSubframe *sub;

794 int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];

795 int shift[MAX_LPC_ORDER];

796 int32_t *res, *smp;

797

798 frame = &s->frame;

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

800 res = sub->residual;

801 smp = sub->samples;

802 n = frame->blocksize;

803

804 /* CONSTANT */

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

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

807 break;

808 if (i == n) {

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

810 res[0] = smp[0];

811 return subframe_count_exact(s, sub, 0);

812 }

813

814 /* VERBATIM */

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

816 sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;

817 memcpy(res, smp, n * sizeof(int32_t));

818 return subframe_count_exact(s, sub, 0);

819 }

820

821 min_order = s->options.min_prediction_order;

822 max_order = s->options.max_prediction_order;

823 omethod = s->options.prediction_order_method;

824

825 /* FIXED */

826 sub->type = FLAC_SUBFRAME_FIXED;

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

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

829 uint64_t bits[MAX_FIXED_ORDER+1];

830 if (max_order > MAX_FIXED_ORDER)

831 max_order = MAX_FIXED_ORDER;

832 opt_order = 0;

833 bits[0] = UINT32_MAX;

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

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

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

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

838 opt_order = i;

839 }

840 sub->order = opt_order;

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

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

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

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

845 }

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

847 }

848

849 /* LPC */

850 sub->type = FLAC_SUBFRAME_LPC;

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

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

853 s->options.lpc_passes, omethod,

854 MIN_LPC_SHIFT, MAX_LPC_SHIFT, 0);

855

856 if (omethod == ORDER_METHOD_2LEVEL ||

857 omethod == ORDER_METHOD_4LEVEL ||

858 omethod == ORDER_METHOD_8LEVEL) {

859 int levels = 1 << omethod;

860 uint64_t bits[1 << ORDER_METHOD_8LEVEL];

861 int order = -1;

862 int opt_index = levels-1;

863 opt_order = max_order-1;

864 bits[opt_index] = UINT32_MAX;

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

866 int last_order = order;

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

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

869 if (order == last_order)

870 continue;

871 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(order) <= 32) {

872 s->flac_dsp.lpc16_encode(res, smp, n, order+1, coefs[order],

873 shift[order]);

874 } else {

875 s->flac_dsp.lpc32_encode(res, smp, n, order+1, coefs[order],

876 shift[order]);

877 }

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

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

880 opt_index = i;

881 opt_order = order;

882 }

883 }

884 opt_order++;

885 } else if (omethod == ORDER_METHOD_SEARCH) {

886 // brute-force optimal order search

887 uint64_t bits[MAX_LPC_ORDER];

888 opt_order = 0;

889 bits[0] = UINT32_MAX;

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

891 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) {

892 s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]);

893 } else {

894 s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]);

895 }

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

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

898 opt_order = i;

899 }

900 opt_order++;

901 } else if (omethod == ORDER_METHOD_LOG) {

902 uint64_t bits[MAX_LPC_ORDER];

903 int step;

904

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

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

907

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

909 int last = opt_order;

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

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

912 continue;

913 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) {

914 s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]);

915 } else {

916 s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]);

917 }

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

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

920 opt_order = i;

921 }

922 }

923 opt_order++;

924 }

925

926 if (s->options.multi_dim_quant) {

927 int allsteps = 1;

928 int i, step, improved;

929 int64_t best_score = INT64_MAX;

930 int32_t qmax;

931

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

933

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

935 allsteps *= 3;

936

937 do {

938 improved = 0;

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

940 int tmp = step;

941 int32_t lpc_try[MAX_LPC_ORDER];

942 int64_t score = 0;

943 int diffsum = 0;

944

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

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

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

948 tmp /= 3;

949 diffsum += !!diff;

950 }

951 if (diffsum >8)

952 continue;

953

954 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order - 1) <= 32) {

955 s->flac_dsp.lpc16_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]);

956 } else {

957 s->flac_dsp.lpc32_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]);

958 }

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

960 if (score < best_score) {

961 best_score = score;

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

963 improved=1;

964 }

965 }

966 } while(improved);

967 }

968

969 sub->order = opt_order;

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

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

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

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

974

975 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order) <= 32) {

976 s->flac_dsp.lpc16_encode(res, smp, n, sub->order, sub->coefs, sub->shift);

977 } else {

978 s->flac_dsp.lpc32_encode(res, smp, n, sub->order, sub->coefs, sub->shift);

979 }

980

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

982

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

984 }

985

986

987 static int count_frame_header(FlacEncodeContext *s)

988 {

989 uint8_t av_unused tmp;

990 int count;

991

992 /*

993 <14> Sync code

994 <1> Reserved

995 <1> Blocking strategy

996 <4> Block size in inter-channel samples

997 <4> Sample rate

998 <4> Channel assignment

999 <3> Sample size in bits

1000 <1> Reserved

1001 */

1002 count = 32;

1003

1004 /* coded frame number */

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

1006

1007 /* explicit block size */

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

1009 count += 8;

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

1011 count += 16;

1012

1013 /* explicit sample rate */

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

1015

1016 /* frame header CRC-8 */

1017 count += 8;

1018

1019 return count;

1020 }

1021

1022

1023 static int encode_frame(FlacEncodeContext *s)

1024 {

1025 int ch;

1026 uint64_t count;

1027

1028 count = count_frame_header(s);

1029

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

1031 count += encode_residual_ch(s, ch);

1032

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

1034 count += 16; // CRC-16

1035

1036 count >>= 3;

1037 if (count > INT_MAX)

1038 return AVERROR_BUG;

1039 return count;

1040 }

1041

1042

1043 static void remove_wasted_bits(FlacEncodeContext *s)

1044 {

1045 int ch, i;

1046

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

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

1049 int32_t v = 0;

1050

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

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

1053 if (v & 1)

1054 break;

1055 }

1056

1057 if (v && !(v & 1)) {

1058 v = ff_ctz(v);

1059

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

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

1062

1063 sub->wasted = v;

1064 sub->obits -= v;

1065

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

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

1068 if (sub->obits <= 17)

1069 sub->rc.coding_mode = CODING_MODE_RICE;

1070 }

1071 }

1072 }

1073

1074

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

1076 int max_rice_param)

1077 {

1078 int i, best;

1079 int32_t lt, rt;

1080 uint64_t sum[4];

1081 uint64_t score[4];

1082 int k;

1083

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

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

1086 for (i = 2; i < n; i++) {

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

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

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

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

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

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

1093 }

1094 /* estimate bit counts */

1095 for (i = 0; i < 4; i++) {

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

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

1098 }

1099

1100 /* calculate score for each mode */

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

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

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

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

1105

1106 /* return mode with lowest score */

1107 best = 0;

1108 for (i = 1; i < 4; i++)

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

1110 best = i;

1111

1112 return best;

1113 }

1114

1115

1116 /**

1117 * Perform stereo channel decorrelation.

1118 */

1119 static void channel_decorrelation(FlacEncodeContext *s)

1120 {

1121 FlacFrame *frame;

1122 int32_t *left, *right;

1123 int i, n;

1124

1125 frame = &s->frame;

1126 n = frame->blocksize;

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

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

1129

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

1131 frame->ch_mode = FLAC_CHMODE_INDEPENDENT;

1132 return;

1133 }

1134

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

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

1137 frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param);

1138 } else

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

1140

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

1142 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)

1143 return;

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

1145 int32_t tmp;

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

1147 tmp = left[i];

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

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

1150 }

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

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

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

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

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

1156 } else {

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

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

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

1160 }

1161 }

1162

1163

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

1165 {

1166 uint8_t tmp;

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

1168 }

1169

1170

1171 static void write_frame_header(FlacEncodeContext *s)

1172 {

1173 FlacFrame *frame;

1174 int crc;

1175

1176 frame = &s->frame;

1177

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

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

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

1181

1182 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)

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

1184 else

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

1186

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

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

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

1190

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

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

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

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

1195

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

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

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

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

1200

1201 flush_put_bits(&s->pb);

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

1203 put_bytes_output(&s->pb));

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

1205 }

1206

1207

1208 static void write_subframes(FlacEncodeContext *s)

1209 {

1210 int ch;

1211

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

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

1214 int i, p, porder, psize;

1215 int32_t *part_end;

1216 int32_t *res = sub->residual;

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

1218

1219 /* subframe header */

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

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

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

1223 if (sub->wasted)

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

1225

1226 /* subframe */

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

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

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

1230 while (res < frame_end)

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

1232 } else {

1233 /* warm-up samples */

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

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

1236

1237 /* LPC coefficients */

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

1239 int cbits = s->options.lpc_coeff_precision;

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

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

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

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

1244 }

1245

1246 /* rice-encoded block */

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

1248

1249 /* partition order */

1250 porder = sub->rc.porder;

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

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

1253

1254 /* residual */

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

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

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

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

1259 while (res < part_end)

1260 set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0);

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

1262 }

1263 }

1264 }

1265 }

1266

1267

1268 static void write_frame_footer(FlacEncodeContext *s)

1269 {

1270 int crc;

1271 flush_put_bits(&s->pb);

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

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

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

1275 flush_put_bits(&s->pb);

1276 }

1277

1278

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

1280 {

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

1282 write_frame_header(s);

1283 write_subframes(s);

1284 write_frame_footer(s);

1285 return put_bytes_output(&s->pb);

1286 }

1287

1288

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

1290 {

1291 const uint8_t *buf;

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

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

1294

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

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

1297 if (!s->md5_buffer)

1298 return AVERROR(ENOMEM);

1299 }

1300

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

1302 buf = (const uint8_t *)samples;

1303 #if HAVE_BIGENDIAN

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

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

1306 buf = s->md5_buffer;

1307 #endif

1308 } else {

1309 int i;

1310 const int32_t *samples0 = samples;

1311 uint8_t *tmp = s->md5_buffer;

1312

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

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

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

1316 }

1317 buf = s->md5_buffer;

1318 }

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

1320

1321 return 0;

1322 }

1323

1324

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

1326 const AVFrame *frame, int *got_packet_ptr)

1327 {

1328 FlacEncodeContext *s;

1329 int frame_bytes, out_bytes, ret;

1330

1331 s = avctx->priv_data;

1332

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

1334 if (!frame) {

1335 s->max_framesize = s->max_encoded_framesize;

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

1337 write_streaminfo(s, avctx->extradata);

1338

1339 if (!s->flushed) {

1340 uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,

1341 avctx->extradata_size);

1342 if (!side_data)

1343 return AVERROR(ENOMEM);

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

1345

1346 avpkt->pts = s->next_pts;

1347

1348 *got_packet_ptr = 1;

1349 s->flushed = 1;

1350 }

1351

1352 return 0;

1353 }

1354

1355 /* change max_framesize for small final frame */

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

1357 s->max_framesize = ff_flac_get_max_frame_size(frame->nb_samples,

1358 s->channels,

1359 avctx->bits_per_raw_sample);

1360 }

1361

1362 init_frame(s, frame->nb_samples);

1363

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

1365

1366 channel_decorrelation(s);

1367

1368 remove_wasted_bits(s);

1369

1370 frame_bytes = encode_frame(s);

1371

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

1373 would be if encoded uncompressed. */

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

1375 s->frame.verbatim_only = 1;

1376 frame_bytes = encode_frame(s);

1377 if (frame_bytes < 0) {

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

1379 return frame_bytes;

1380 }

1381 }

1382

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

1384 return ret;

1385

1386 out_bytes = write_frame(s, avpkt);

1387

1388 s->frame_count++;

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

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

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

1392 return ret;

1393 }

1394 if (out_bytes > s->max_encoded_framesize)

1395 s->max_encoded_framesize = out_bytes;

1396 if (out_bytes < s->min_framesize)

1397 s->min_framesize = out_bytes;

1398

1399 avpkt->pts = frame->pts;

1400 avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);

1401

1402 s->next_pts = avpkt->pts + avpkt->duration;

1403

1404 av_shrink_packet(avpkt, out_bytes);

1405

1406 *got_packet_ptr = 1;

1407 return 0;

1408 }

1409

1410

1411 static av_cold int flac_encode_close(AVCodecContext *avctx)

1412 {

1413 FlacEncodeContext *s = avctx->priv_data;

1414

1415 av_freep(&s->md5ctx);

1416 av_freep(&s->md5_buffer);

1417 ff_lpc_end(&s->lpc_ctx);

1418 return 0;

1419 }

1420

1421 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM

1422 static const AVOption options[] = {

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

1424 { "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, "lpc_type" },

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

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

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

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

1429 { "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 },

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

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

1432 { "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, "predm" },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1449

1450 { NULL },

1451 };

1452

1453 static const AVClass flac_encoder_class = {

1454 .class_name = "FLAC encoder",

1455 .item_name = av_default_item_name,

1456 .option = options,

1457 .version = LIBAVUTIL_VERSION_INT,

1458 };

1459

1460 const AVCodec ff_flac_encoder = {

1461 .name = "flac",

1462 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),

1463 .type = AVMEDIA_TYPE_AUDIO,

1464 .id = AV_CODEC_ID_FLAC,

1465 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |

1466 AV_CODEC_CAP_SMALL_LAST_FRAME,

1467 .priv_data_size = sizeof(FlacEncodeContext),

1468 .init = flac_encode_init,

1469 .encode2 = flac_encode_frame,

1470 .close = flac_encode_close,

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

1472 AV_SAMPLE_FMT_S32,

1473 AV_SAMPLE_FMT_NONE },

1474 .priv_class = &flac_encoder_class,

1475 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

1476 };

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1012

AVCodec

AVCodec.

Definition: codec.h:202

bswapdsp.h

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

PUT_UTF8

#define PUT_UTF8(val, tmp, PUT_BYTE)

Definition: common.h:523

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: internal.h:42

FFLPCType

LPC analysis type.

Definition: lpc.h:43

AV_CH_LAYOUT_5POINT0_BACK

#define AV_CH_LAYOUT_5POINT0_BACK

Definition: channel_layout.h:102

level

uint8_t level

Definition: svq3.c:204

FlacSubframe::samples

int32_t samples[FLAC_MAX_BLOCKSIZE]

Definition: flacenc.c:92

av_clip

#define av_clip

Definition: common.h:96

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

flac_encode_init

static av_cold int flac_encode_init(AVCodecContext *avctx)

Definition: flacenc.c:241

AVCodecContext::channel_layout

uint64_t channel_layout

Audio channel layout.

Definition: avcodec.h:1043

ff_ctz

#define ff_ctz

Definition: intmath.h:106

put_bytes_output

static int put_bytes_output(const PutBitContext *s)

Definition: put_bits.h:88

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:992

set_sr_golomb_flac

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

write signed golomb rice code (flac).

Definition: golomb.h:738

CompressionOptions::exact_rice_parameters

int exact_rice_parameters

Definition: flacenc.c:69

MAX_PARTITION_ORDER

#define MAX_PARTITION_ORDER

Definition: flacenc.c:46

FlacEncodeContext::bdsp

BswapDSPContext bdsp

Definition: flacenc.c:126

sub

static float sub(float src0, float src1)

Definition: dnn_backend_native_layer_mathbinary.c:31

sample_fmts

static enum AVSampleFormat sample_fmts[]

Definition: adpcmenc.c:948

CompressionOptions::max_prediction_order

int max_prediction_order

Definition: flacenc.c:64

CompressionOptions::ch_mode

int ch_mode

Definition: flacenc.c:68

MAX_LPC_SHIFT

#define MAX_LPC_SHIFT

Definition: flacenc.c:50

put_sbits

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

Definition: put_bits.h:280

init_put_bits

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

Initialize the PutBitContext s.

Definition: put_bits.h:61

flac_encode_frame

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

Definition: flacenc.c:1325

FlacEncodeContext::md5sum

uint8_t md5sum[16]

Definition: flacenc.c:118

RiceContext

Definition: alacenc.c:50

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:317

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

put_bits

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

put n times val bit

Definition: j2kenc.c:220

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:67

FF_LPC_TYPE_CHOLESKY

@ FF_LPC_TYPE_CHOLESKY

Cholesky factorization.

Definition: lpc.h:48

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

ff_flacdsp_init

av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)

Definition: flacdsp.c:88

AVOption

AVOption.

Definition: opt.h:247

encode.h

FlacEncodeContext

Definition: flacenc.c:105

#define b

Definition: input.c:40

data

const char data[16]

Definition: mxf.c:143

CompressionOptions::prediction_order_method

int prediction_order_method

Definition: flacenc.c:65

FlacFrame

Definition: flacenc.c:96

select_blocksize

static int select_blocksize(int samplerate, int block_time_ms)

Set blocksize based on samplerate.

Definition: flacenc.c:164

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: packet.h:391

CODING_MODE_RICE

@ CODING_MODE_RICE

Definition: flacenc.c:53

AV_CODEC_ID_FLAC

@ AV_CODEC_ID_FLAC

Definition: codec_id.h:435

flacdsp.h

lpc.h

CompressionOptions::compression_level

int compression_level

Definition: flacenc.c:58

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

FlacEncodeContext::pb

PutBitContext pb

Definition: flacenc.c:107

init

static int init

Definition: av_tx.c:47

crc.h

golomb.h

exp golomb vlc stuff

LPCContext

Definition: lpc.h:52

find_subframe_rice_params

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

Definition: flacenc.c:720

ORDER_METHOD_4LEVEL

#define ORDER_METHOD_4LEVEL

Definition: lpc.h:32

FlacSubframe::wasted

int wasted

Definition: flacenc.c:83

av_shrink_packet

void av_shrink_packet(AVPacket *pkt, int size)

Reduce packet size, correctly zeroing padding.

Definition: avpacket.c:114

FlacEncodeContext::frame_count

uint32_t frame_count

Definition: flacenc.c:116

CompressionOptions::lpc_coeff_precision

int lpc_coeff_precision

Definition: flacenc.c:62

val

static double val(void *priv, double ch)

Definition: aeval.c:76

AVMD5

Definition: md5.c:40

AV_CH_LAYOUT_STEREO

#define AV_CH_LAYOUT_STEREO

Definition: channel_layout.h:91

AV_CH_LAYOUT_QUAD

#define AV_CH_LAYOUT_QUAD

Definition: channel_layout.h:99

FF_LPC_TYPE_DEFAULT

@ FF_LPC_TYPE_DEFAULT

use the codec default LPC type

Definition: lpc.h:44

ff_flac_blocksize_table

const int32_t ff_flac_blocksize_table[16]

Definition: flacdata.c:30

FLAC_CHMODE_RIGHT_SIDE

@ FLAC_CHMODE_RIGHT_SIDE

Definition: flac.h:43

avassert.h

FlacFrame::ch_mode

int ch_mode

Definition: flacenc.c:101

ff_samples_to_time_base

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

Rescale from sample rate to AVCodecContext.time_base.

Definition: internal.h:242

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:1208

av_cold

#define av_cold

Definition: attributes.h:90

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:485

#define s(width, name)

Definition: cbs_vp9.c:257

FlacSubframe::type_code

int type_code

Definition: flacenc.c:81

ff_flac_get_max_frame_size

int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)

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

Definition: flac.c:148

FlacSubframe::obits

int obits

Definition: flacenc.c:82

FlacEncodeContext::max_framesize

int max_framesize

Definition: flacenc.c:114

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

CompressionOptions::multi_dim_quant

int multi_dim_quant

Definition: flacenc.c:70

bits

uint8_t bits

Definition: vp3data.h:141

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

FlacSubframe::order

int order

Definition: flacenc.c:84

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

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

Definition: avcodec.h:1425

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:1043

channels

Definition: aptx.h:33

FlacSubframe::rc

RiceContext rc

Definition: flacenc.c:88

FLAC_SUBFRAME_LPC

#define FLAC_SUBFRAME_LPC

Definition: flacenc.c:43

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:601

CompressionOptions

Definition: dcaenc.c:58

FLAC_SUBFRAME_VERBATIM

#define FLAC_SUBFRAME_VERBATIM

Definition: flacenc.c:41

#define f(width, name)

Definition: cbs_vp9.c:255

PutBitContext

Definition: put_bits.h:49

RiceContext::porder

int porder

Definition: flacenc.c:75

FFABS

#define FFABS(a)

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

Definition: common.h:65

FLAC_SUBFRAME_CONSTANT

#define FLAC_SUBFRAME_CONSTANT

Definition: flacenc.c:40

if(ret)

Definition: filter_design.txt:179

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:97

ff_bswapdsp_init

av_cold void ff_bswapdsp_init(BswapDSPContext *c)

Definition: bswapdsp.c:49

NULL

#define NULL

Definition: coverity.c:32

FLAC_SUBFRAME_FIXED

#define FLAC_SUBFRAME_FIXED

Definition: flacenc.c:42

FlacEncodeContext::lpc_ctx

LPCContext lpc_ctx

Definition: flacenc.c:122

MIN_LPC_SHIFT

#define MIN_LPC_SHIFT

Definition: flacenc.c:49

FlacEncodeContext::max_blocksize

int max_blocksize

Definition: flacenc.c:112

AV_WL24

#define AV_WL24(p, d)

Definition: intreadwrite.h:464

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:235

FLAGS

#define FLAGS

Definition: flacenc.c:1421

FlacEncodeContext::next_pts

int64_t next_pts

Definition: flacenc.c:130

AV_CH_LAYOUT_5POINT1

#define AV_CH_LAYOUT_5POINT1

Definition: channel_layout.h:101

FLAC_STREAMINFO_SIZE

#define FLAC_STREAMINFO_SIZE

Definition: flac.h:34

FlacEncodeContext::md5_buffer

uint8_t * md5_buffer

Definition: flacenc.c:124

ORDER_METHOD_SEARCH

#define ORDER_METHOD_SEARCH

Definition: lpc.h:34

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:201

AV_CH_FRONT_CENTER

#define AV_CH_FRONT_CENTER

Definition: channel_layout.h:51

CompressionOptions::lpc_passes

int lpc_passes

Definition: flacenc.c:61

FlacEncodeContext::channels

int channels

Definition: flacenc.c:108

FlacEncodeContext::flac_dsp

FLACDSPContext flac_dsp

Definition: flacenc.c:127

FLAC_CHMODE_MID_SIDE

@ FLAC_CHMODE_MID_SIDE

Definition: flac.h:44

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:503

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:788

get_max_p_order

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

Definition: flacenc.c:711

ORDER_METHOD_8LEVEL

#define ORDER_METHOD_8LEVEL

Definition: lpc.h:33

find_optimal_param_exact

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

Definition: flacenc.c:584

FlacEncodeContext::flushed

int flushed

Definition: flacenc.c:129

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:374

FlacEncodeContext::md5_buffer_size

unsigned int md5_buffer_size

Definition: flacenc.c:125

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

av_clipl_int32

#define av_clipl_int32

Definition: common.h:114

channel_decorrelation

static void channel_decorrelation(FlacEncodeContext *s)

Perform stereo channel decorrelation.

Definition: flacenc.c:1119

FF_LPC_TYPE_NB

@ FF_LPC_TYPE_NB

Not part of ABI.

Definition: lpc.h:49

FLAC_CHMODE_LEFT_SIDE

@ FLAC_CHMODE_LEFT_SIDE

Definition: flac.h:42

MAX_LPC_ORDER

#define MAX_LPC_ORDER

Definition: lpc.h:38

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1000

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:59

flacdata.h

encode_frame

static int encode_frame(FlacEncodeContext *s)

Definition: flacenc.c:1023

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:631

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

FlacSubframe::residual

int32_t residual[FLAC_MAX_BLOCKSIZE+11]

Definition: flacenc.c:93

FlacEncodeContext::options

CompressionOptions options

Definition: flacenc.c:120

header

static const uint8_t header[24]

Definition: sdr2.c:67

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

AV_CH_LAYOUT_5POINT1_BACK

#define AV_CH_LAYOUT_5POINT1_BACK

Definition: channel_layout.h:103

write_frame

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

Definition: flacenc.c:1279

av_bswap16

#define av_bswap16

Definition: bswap.h:31

FlacSubframe::type

int type

Definition: flacenc.c:80

ORDER_METHOD_EST

#define ORDER_METHOD_EST

Definition: lpc.h:30

options

static const AVOption options[]

Definition: flacenc.c:1422

FlacSubframe

Definition: flacenc.c:79

FlacSubframe::coefs

int32_t coefs[MAX_LPC_ORDER]

Definition: flacenc.c:85

ff_lpc_end

av_cold void ff_lpc_end(LPCContext *s)

Uninitialize LPCContext.

Definition: lpc.c:323

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:993

AV_CH_LAYOUT_5POINT0

#define AV_CH_LAYOUT_5POINT0

Definition: channel_layout.h:100

calc_sum_next

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

Definition: flacenc.c:661

av_md5_init

void av_md5_init(AVMD5 *ctx)

Initialize MD5 hashing.

Definition: md5.c:141

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

Definition: cbs_h2645.c:271

AVPacket::pts

int64_t pts

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

Definition: packet.h:366

av_get_bytes_per_sample

int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)

Return number of bytes per sample.

Definition: samplefmt.c:106

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:484

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: internal.h:50

write_utf8

static void write_utf8(PutBitContext *pb, uint32_t val)

Definition: flacenc.c:1164

CompressionOptions::min_partition_order

int min_partition_order

Definition: flacenc.c:66

count_frame_header

static int count_frame_header(FlacEncodeContext *s)

Definition: flacenc.c:987

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:53

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:58

write_frame_header

static void write_frame_header(FlacEncodeContext *s)

Definition: flacenc.c:1171

md5.h

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

write_frame_footer

static void write_frame_footer(FlacEncodeContext *s)

Definition: flacenc.c:1268

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:61

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

copy_samples

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

Copy channel-interleaved input samples into separate subframes.

Definition: flacenc.c:481

av_md5_final

void av_md5_final(AVMD5 *ctx, uint8_t *dst)

Finish hashing and output digest value.

Definition: md5.c:186

MAX_PARTITIONS

#define MAX_PARTITIONS

Definition: flacenc.c:47

avcodec.h

CompressionOptions::lpc_type

enum FFLPCType lpc_type

Definition: flacenc.c:60

estimate_stereo_mode

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

Definition: flacenc.c:1075

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:671

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

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

ff_flac_encoder

const AVCodec ff_flac_encoder

Definition: flacenc.c:1460

encode_residual_fixed

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

Definition: flacenc.c:737

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:35

MAX_LPC_PRECISION

#define MAX_LPC_PRECISION

Definition: flacenc.c:48

AVCodecContext

main external API structure.

Definition: avcodec.h:383

FlacEncodeContext::bps_code

int bps_code

Definition: flacenc.c:111

FlacSubframe::rc_sums

uint64_t rc_sums[32][MAX_PARTITIONS]

Definition: flacenc.c:90

channel_layout.h

FlacSubframe::rc_udata

uint32_t rc_udata[FLAC_MAX_BLOCKSIZE]

Definition: flacenc.c:89

ORDER_METHOD_LOG

#define ORDER_METHOD_LOG

Definition: lpc.h:35

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:232

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:78

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:48

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:55

subframe_count_exact

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

Definition: flacenc.c:517

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:224

frame_end

static void frame_end(MpegEncContext *s)

Definition: mpegvideo_enc.c:1583

FlacEncodeContext::sr_code

int sr_code[2]

Definition: flacenc.c:110

CompressionOptions::min_prediction_order

int min_prediction_order

Definition: flacenc.c:63

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:82

samples

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

Definition: filter_design.txt:8

FlacSubframe::shift

int shift

Definition: flacenc.c:86

av_md5_update

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

Update hash value.

Definition: md5.c:151

init_frame

static void init_frame(FlacEncodeContext *s, int nb_samples)

Definition: flacenc.c:436

RiceContext::params

int params[MAX_PARTITIONS]

Definition: flacenc.c:76

shift

static int shift(int a, int b)

Definition: sonic.c:83

FLAC_MAX_BLOCKSIZE

#define FLAC_MAX_BLOCKSIZE

Definition: flac.h:37

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:142

diff

static av_always_inline int diff(const uint32_t a, const uint32_t b)

Definition: vf_palettegen.c:139

AVPacket

This structure stores compressed data.

Definition: packet.h:350

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:410

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Definition: opt.h:241

RiceContext::coding_mode

enum CodingMode coding_mode

Definition: flacenc.c:74

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

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:560

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:572

dprint_compression_options

static av_cold void dprint_compression_options(FlacEncodeContext *s)

Definition: flacenc.c:183

update_md5_sum

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

Definition: flacenc.c:1289

flac_encode_close

static av_cold int flac_encode_close(AVCodecContext *avctx)

Definition: flacenc.c:1411

Definition: ffmpeg_filter.c:153

CODING_MODE_RICE2

@ CODING_MODE_RICE2

Definition: flacenc.c:54

int32_t

Definition: audioconvert.c:56

CompressionOptions::block_time_ms

int block_time_ms

Definition: flacenc.c:59

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:28

flac_encoder_class

static const AVClass flac_encoder_class

Definition: flacenc.c:1453

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

MAX_FIXED_ORDER

#define MAX_FIXED_ORDER

Definition: flacenc.c:45

ORDER_METHOD_2LEVEL

#define ORDER_METHOD_2LEVEL

Definition: lpc.h:31

FLAC_MIN_BLOCKSIZE

#define FLAC_MIN_BLOCKSIZE

Definition: flac.h:36

flac.h

FF_LPC_TYPE_NONE

@ FF_LPC_TYPE_NONE

do not use LPC prediction or use all zero coefficients

Definition: lpc.h:45

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:87

FlacFrame::verbatim_only

int verbatim_only

Definition: flacenc.c:102

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:62

AV_OPT_TYPE_CONST

@ AV_OPT_TYPE_CONST

Definition: opt.h:233

FLACDSPContext

Definition: flacdsp.h:26

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:47

AV_CH_LAYOUT_2_2

#define AV_CH_LAYOUT_2_2

Definition: channel_layout.h:98

FLAC_CHMODE_INDEPENDENT

@ FLAC_CHMODE_INDEPENDENT

Definition: flac.h:41

FlacFrame::blocksize

int blocksize

Definition: flacenc.c:98

CodingMode

Definition: flacenc.c:52

rice_encode_count

#define rice_encode_count(sum, n, k)

Definition: flacenc.c:567

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:301

AVCodecContext::compression_level

int compression_level

Definition: avcodec.h:455

FF_LPC_TYPE_FIXED

@ FF_LPC_TYPE_FIXED

fixed LPC coefficients

Definition: lpc.h:46

intmath.h

Generated on Wed Aug 24 2022 21:37:34 for FFmpeg by doxygen 1.8.17