libavcodec.hg: flacenc.c comparison

comparison flacenc.c @ 12139:e59926e2c50c libavcodec

Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields. Add AVLPCType enum. Deprecate AVCodecContext.use_lpc.

author	jbr
date	Sun, 11 Jul 2010 16:56:20 +0000
parents	8b28e74de2c0
children	dde20597f15e

comparison

equal deleted inserted replaced

-:41f078d6869d
+:e59926e2c50c
 #define MAX_RICE_PARAM     14
 typedef struct CompressionOptions {
 int compression_level;
 int block_time_ms;
-int use_lpc;
+enum AVLPCType lpc_type;
+int lpc_passes;
 int lpc_coeff_precision;
 int min_prediction_order;
 int max_prediction_order;
 int prediction_order_method;
 int min_partition_order;
 s->options.compression_level);
 return -1;
 }
 s->options.block_time_ms       = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
-s->options.use_lpc             = ((int[]){  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
+s->options.lpc_type            = ((int[]){ AV_LPC_TYPE_FIXED,    AV_LPC_TYPE_FIXED,    AV_LPC_TYPE_FIXED,
+AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON,
+AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON,
+AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON,
+AV_LPC_TYPE_LEVINSON})[level];
 s->options.min_prediction_order= ((int[]){  2,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
 s->options.max_prediction_order= ((int[]){  3,  4,  4,  6,  8,  8,  8,  8, 12, 12, 12, 32, 32})[level];
 s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
 ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
 ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
 ORDER_METHOD_SEARCH})[level];
 s->options.min_partition_order = ((int[]){  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0})[level];
 s->options.max_partition_order = ((int[]){  2,  2,  3,  3,  3,  8,  8,  8,  8,  8,  8,  8,  8})[level];
 /* set compression option overrides from AVCodecContext */
-if(avctx->use_lpc >= 0) {
+#if LIBAVCODEC_VERSION_MAJOR < 53
-s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
+/* for compatibility with deprecated AVCodecContext.use_lpc */
-}
+if (avctx->use_lpc == 0) {
-if(s->options.use_lpc == 1)
+s->options.lpc_type = AV_LPC_TYPE_FIXED;
-av_log(avctx, AV_LOG_DEBUG, " use lpc: Levinson-Durbin recursion with Welch window\n");
+} else if (avctx->use_lpc == 1) {
-else if(s->options.use_lpc > 1)
+s->options.lpc_type = AV_LPC_TYPE_LEVINSON;
-av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");
+} else if (avctx->use_lpc > 1) {
+s->options.lpc_type   = AV_LPC_TYPE_CHOLESKY;
-if(avctx->min_prediction_order >= 0) {
+s->options.lpc_passes = avctx->use_lpc - 1;
-if(s->options.use_lpc) {
+}
-if(avctx->min_prediction_order < MIN_LPC_ORDER ||
+#endif
-avctx->min_prediction_order > MAX_LPC_ORDER) {
+if (avctx->lpc_type > AV_LPC_TYPE_DEFAULT) {
-av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
+if (avctx->lpc_type > AV_LPC_TYPE_CHOLESKY) {
-avctx->min_prediction_order);
+av_log(avctx, AV_LOG_ERROR, "unknown lpc type: %d\n", avctx->lpc_type);
+return -1;
+}
+s->options.lpc_type = avctx->lpc_type;
+if (s->options.lpc_type == AV_LPC_TYPE_CHOLESKY) {
+if (avctx->lpc_passes < 0) {
+// default number of passes for Cholesky
+s->options.lpc_passes = 2;
+} else if (avctx->lpc_passes == 0) {
+av_log(avctx, AV_LOG_ERROR, "invalid number of lpc passes: %d\n",
+avctx->lpc_passes);
 return -1;
+} else {
+s->options.lpc_passes = avctx->lpc_passes;
 }
-} else {
+}
+}
+switch (s->options.lpc_type) {
+case AV_LPC_TYPE_NONE:
+av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n");
+break;
+case AV_LPC_TYPE_FIXED:
+av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n");
+break;
+case AV_LPC_TYPE_LEVINSON:
+av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n");
+break;
+case AV_LPC_TYPE_CHOLESKY:
+av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n",
+s->options.lpc_passes, s->options.lpc_passes==1?"":"es");
+break;
+}
+if (s->options.lpc_type == AV_LPC_TYPE_NONE) {
+s->options.min_prediction_order = 0;
+} else if (avctx->min_prediction_order >= 0) {
+if (s->options.lpc_type == AV_LPC_TYPE_FIXED) {
 if(avctx->min_prediction_order > MAX_FIXED_ORDER) {
 av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
 avctx->min_prediction_order);
 return -1;
 }
+} else if(avctx->min_prediction_order < MIN_LPC_ORDER ||
+avctx->min_prediction_order > MAX_LPC_ORDER) {
+av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
+avctx->min_prediction_order);
+return -1;
 }
 s->options.min_prediction_order = avctx->min_prediction_order;
 }
-if(avctx->max_prediction_order >= 0) {
+if (s->options.lpc_type == AV_LPC_TYPE_NONE) {
-if(s->options.use_lpc) {
+s->options.max_prediction_order = 0;
-if(avctx->max_prediction_order < MIN_LPC_ORDER ||
+} else if (avctx->max_prediction_order >= 0) {
-avctx->max_prediction_order > MAX_LPC_ORDER) {
+if (s->options.lpc_type == AV_LPC_TYPE_FIXED) {
-av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
-avctx->max_prediction_order);
-return -1;
-}
-} else {
 if(avctx->max_prediction_order > MAX_FIXED_ORDER) {
 av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
 avctx->max_prediction_order);
 return -1;
 }
+} else if (avctx->max_prediction_order < MIN_LPC_ORDER ||
+avctx->max_prediction_order > MAX_LPC_ORDER) {
+av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
+avctx->max_prediction_order);
+return -1;
 }
 s->options.max_prediction_order = avctx->max_prediction_order;
 }
 if(s->options.max_prediction_order < s->options.min_prediction_order) {
 av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
 max_porder = ctx->options.max_partition_order;
 precision = ctx->options.lpc_coeff_precision;
 omethod = ctx->options.prediction_order_method;
 /* FIXED */
-if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
+if (ctx->options.lpc_type == AV_LPC_TYPE_NONE  ||
+ctx->options.lpc_type == AV_LPC_TYPE_FIXED || n <= max_order) {
 uint32_t bits[MAX_FIXED_ORDER+1];
 if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
 opt_order = 0;
 bits[0] = UINT32_MAX;
 for(i=min_order; i<=max_order; i++) {
 return bits[sub->order];
 }
 /* LPC */
 opt_order = ff_lpc_calc_coefs(&ctx->dsp, smp, n, min_order, max_order,
-precision, coefs, shift, ctx->options.use_lpc,
+precision, coefs, shift, ctx->options.lpc_type,
-omethod, MAX_LPC_SHIFT, 0);
+ctx->options.lpc_passes, omethod,
+MAX_LPC_SHIFT, 0);
 if(omethod == ORDER_METHOD_2LEVEL ||
 omethod == ORDER_METHOD_4LEVEL ||
 omethod == ORDER_METHOD_8LEVEL) {
 int levels = 1 << omethod;

Mercurial > libavcodec.hg

comparison flacenc.c @ 12139:e59926e2c50c libavcodec