LCOV - code coverage report
Current view: top level - libavcodec - flacenc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 603 746 80.8 %
Date: 2017-12-16 13:57:32 Functions: 31 31 100.0 %

          Line data    Source code
       1             : /*
       2             :  * FLAC audio encoder
       3             :  * Copyright (c) 2006  Justin Ruggles <justin.ruggles@gmail.com>
       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             :  */
      21             : 
      22             : #include "libavutil/avassert.h"
      23             : #include "libavutil/crc.h"
      24             : #include "libavutil/intmath.h"
      25             : #include "libavutil/md5.h"
      26             : #include "libavutil/opt.h"
      27             : 
      28             : #include "avcodec.h"
      29             : #include "bswapdsp.h"
      30             : #include "put_bits.h"
      31             : #include "golomb.h"
      32             : #include "internal.h"
      33             : #include "lpc.h"
      34             : #include "flac.h"
      35             : #include "flacdata.h"
      36             : #include "flacdsp.h"
      37             : 
      38             : #define FLAC_SUBFRAME_CONSTANT  0
      39             : #define FLAC_SUBFRAME_VERBATIM  1
      40             : #define FLAC_SUBFRAME_FIXED     8
      41             : #define FLAC_SUBFRAME_LPC      32
      42             : 
      43             : #define MAX_FIXED_ORDER     4
      44             : #define MAX_PARTITION_ORDER 8
      45             : #define MAX_PARTITIONS     (1 << MAX_PARTITION_ORDER)
      46             : #define MAX_LPC_PRECISION  15
      47             : #define MIN_LPC_SHIFT       0
      48             : #define MAX_LPC_SHIFT      15
      49             : 
      50             : enum CodingMode {
      51             :     CODING_MODE_RICE  = 4,
      52             :     CODING_MODE_RICE2 = 5,
      53             : };
      54             : 
      55             : typedef struct CompressionOptions {
      56             :     int compression_level;
      57             :     int block_time_ms;
      58             :     enum FFLPCType lpc_type;
      59             :     int lpc_passes;
      60             :     int lpc_coeff_precision;
      61             :     int min_prediction_order;
      62             :     int max_prediction_order;
      63             :     int prediction_order_method;
      64             :     int min_partition_order;
      65             :     int max_partition_order;
      66             :     int ch_mode;
      67             :     int exact_rice_parameters;
      68             :     int multi_dim_quant;
      69             : } CompressionOptions;
      70             : 
      71             : typedef struct RiceContext {
      72             :     enum CodingMode coding_mode;
      73             :     int porder;
      74             :     int params[MAX_PARTITIONS];
      75             : } RiceContext;
      76             : 
      77             : typedef struct FlacSubframe {
      78             :     int type;
      79             :     int type_code;
      80             :     int obits;
      81             :     int wasted;
      82             :     int order;
      83             :     int32_t coefs[MAX_LPC_ORDER];
      84             :     int shift;
      85             : 
      86             :     RiceContext rc;
      87             :     uint32_t rc_udata[FLAC_MAX_BLOCKSIZE];
      88             :     uint64_t rc_sums[32][MAX_PARTITIONS];
      89             : 
      90             :     int32_t samples[FLAC_MAX_BLOCKSIZE];
      91             :     int32_t residual[FLAC_MAX_BLOCKSIZE+11];
      92             : } FlacSubframe;
      93             : 
      94             : typedef struct FlacFrame {
      95             :     FlacSubframe subframes[FLAC_MAX_CHANNELS];
      96             :     int blocksize;
      97             :     int bs_code[2];
      98             :     uint8_t crc8;
      99             :     int ch_mode;
     100             :     int verbatim_only;
     101             : } FlacFrame;
     102             : 
     103             : typedef struct FlacEncodeContext {
     104             :     AVClass *class;
     105             :     PutBitContext pb;
     106             :     int channels;
     107             :     int samplerate;
     108             :     int sr_code[2];
     109             :     int bps_code;
     110             :     int max_blocksize;
     111             :     int min_framesize;
     112             :     int max_framesize;
     113             :     int max_encoded_framesize;
     114             :     uint32_t frame_count;
     115             :     uint64_t sample_count;
     116             :     uint8_t md5sum[16];
     117             :     FlacFrame frame;
     118             :     CompressionOptions options;
     119             :     AVCodecContext *avctx;
     120             :     LPCContext lpc_ctx;
     121             :     struct AVMD5 *md5ctx;
     122             :     uint8_t *md5_buffer;
     123             :     unsigned int md5_buffer_size;
     124             :     BswapDSPContext bdsp;
     125             :     FLACDSPContext flac_dsp;
     126             : 
     127             :     int flushed;
     128             :     int64_t next_pts;
     129             : } FlacEncodeContext;
     130             : 
     131             : 
     132             : /**
     133             :  * Write streaminfo metadata block to byte array.
     134             :  */
     135          52 : static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
     136             : {
     137             :     PutBitContext pb;
     138             : 
     139          52 :     memset(header, 0, FLAC_STREAMINFO_SIZE);
     140          52 :     init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
     141             : 
     142             :     /* streaminfo metadata block */
     143          52 :     put_bits(&pb, 16, s->max_blocksize);
     144          52 :     put_bits(&pb, 16, s->max_blocksize);
     145          52 :     put_bits(&pb, 24, s->min_framesize);
     146          52 :     put_bits(&pb, 24, s->max_framesize);
     147          52 :     put_bits(&pb, 20, s->samplerate);
     148          52 :     put_bits(&pb, 3, s->channels-1);
     149          52 :     put_bits(&pb,  5, s->avctx->bits_per_raw_sample - 1);
     150             :     /* write 36-bit sample count in 2 put_bits() calls */
     151          52 :     put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
     152          52 :     put_bits(&pb, 12,  s->sample_count & 0x000000FFFLL);
     153          52 :     flush_put_bits(&pb);
     154          52 :     memcpy(&header[18], s->md5sum, 16);
     155          52 : }
     156             : 
     157             : 
     158             : /**
     159             :  * Set blocksize based on samplerate.
     160             :  * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.
     161             :  */
     162          28 : static int select_blocksize(int samplerate, int block_time_ms)
     163             : {
     164             :     int i;
     165             :     int target;
     166             :     int blocksize;
     167             : 
     168          28 :     av_assert0(samplerate > 0);
     169          28 :     blocksize = ff_flac_blocksize_table[1];
     170          28 :     target    = (samplerate * block_time_ms) / 1000;
     171         476 :     for (i = 0; i < 16; i++) {
     172         790 :         if (target >= ff_flac_blocksize_table[i] &&
     173         342 :             ff_flac_blocksize_table[i] > blocksize) {
     174         106 :             blocksize = ff_flac_blocksize_table[i];
     175             :         }
     176             :     }
     177          28 :     return blocksize;
     178             : }
     179             : 
     180             : 
     181          28 : static av_cold void dprint_compression_options(FlacEncodeContext *s)
     182             : {
     183          28 :     AVCodecContext     *avctx = s->avctx;
     184          28 :     CompressionOptions *opt   = &s->options;
     185             : 
     186          28 :     av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt->compression_level);
     187             : 
     188          28 :     switch (opt->lpc_type) {
     189           0 :     case FF_LPC_TYPE_NONE:
     190           0 :         av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n");
     191           0 :         break;
     192           3 :     case FF_LPC_TYPE_FIXED:
     193           3 :         av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n");
     194           3 :         break;
     195          24 :     case FF_LPC_TYPE_LEVINSON:
     196          24 :         av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n");
     197          24 :         break;
     198           1 :     case FF_LPC_TYPE_CHOLESKY:
     199           1 :         av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n",
     200           1 :                opt->lpc_passes, opt->lpc_passes == 1 ? "" : "es");
     201           1 :         break;
     202             :     }
     203             : 
     204          28 :     av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
     205             :            opt->min_prediction_order, opt->max_prediction_order);
     206             : 
     207          28 :     switch (opt->prediction_order_method) {
     208          27 :     case ORDER_METHOD_EST:
     209          27 :         av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate");
     210          27 :         break;
     211           0 :     case ORDER_METHOD_2LEVEL:
     212           0 :         av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2-level");
     213           0 :         break;
     214           1 :     case ORDER_METHOD_4LEVEL:
     215           1 :         av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4-level");
     216           1 :         break;
     217           0 :     case ORDER_METHOD_8LEVEL:
     218           0 :         av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8-level");
     219           0 :         break;
     220           0 :     case ORDER_METHOD_SEARCH:
     221           0 :         av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search");
     222           0 :         break;
     223           0 :     case ORDER_METHOD_LOG:
     224           0 :         av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search");
     225           0 :         break;
     226             :     }
     227             : 
     228             : 
     229          28 :     av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
     230             :            opt->min_partition_order, opt->max_partition_order);
     231             : 
     232          28 :     av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx->frame_size);
     233             : 
     234          28 :     av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
     235             :            opt->lpc_coeff_precision);
     236          28 : }
     237             : 
     238             : 
     239          28 : static av_cold int flac_encode_init(AVCodecContext *avctx)
     240             : {
     241          28 :     int freq = avctx->sample_rate;
     242          28 :     int channels = avctx->channels;
     243          28 :     FlacEncodeContext *s = avctx->priv_data;
     244             :     int i, level, ret;
     245             :     uint8_t *streaminfo;
     246             : 
     247          28 :     s->avctx = avctx;
     248             : 
     249          28 :     switch (avctx->sample_fmt) {
     250          27 :     case AV_SAMPLE_FMT_S16:
     251          27 :         avctx->bits_per_raw_sample = 16;
     252          27 :         s->bps_code                = 4;
     253          27 :         break;
     254           1 :     case AV_SAMPLE_FMT_S32:
     255           1 :         if (avctx->bits_per_raw_sample != 24)
     256           0 :             av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");
     257           1 :         avctx->bits_per_raw_sample = 24;
     258           1 :         s->bps_code                = 6;
     259           1 :         break;
     260             :     }
     261             : 
     262          28 :     if (channels < 1 || channels > FLAC_MAX_CHANNELS) {
     263           0 :         av_log(avctx, AV_LOG_ERROR, "%d channels not supported (max %d)\n",
     264             :                channels, FLAC_MAX_CHANNELS);
     265           0 :         return AVERROR(EINVAL);
     266             :     }
     267          28 :     s->channels = channels;
     268             : 
     269             :     /* find samplerate in table */
     270          28 :     if (freq < 1)
     271           0 :         return AVERROR(EINVAL);
     272         167 :     for (i = 4; i < 12; i++) {
     273         162 :         if (freq == ff_flac_sample_rate_table[i]) {
     274          23 :             s->samplerate = ff_flac_sample_rate_table[i];
     275          23 :             s->sr_code[0] = i;
     276          23 :             s->sr_code[1] = 0;
     277          23 :             break;
     278             :         }
     279             :     }
     280             :     /* if not in table, samplerate is non-standard */
     281          28 :     if (i == 12) {
     282           5 :         if (freq % 1000 == 0 && freq < 255000) {
     283           5 :             s->sr_code[0] = 12;
     284           5 :             s->sr_code[1] = freq / 1000;
     285           0 :         } else if (freq % 10 == 0 && freq < 655350) {
     286           0 :             s->sr_code[0] = 14;
     287           0 :             s->sr_code[1] = freq / 10;
     288           0 :         } else if (freq < 65535) {
     289           0 :             s->sr_code[0] = 13;
     290           0 :             s->sr_code[1] = freq;
     291             :         } else {
     292           0 :             av_log(avctx, AV_LOG_ERROR, "%d Hz not supported\n", freq);
     293           0 :             return AVERROR(EINVAL);
     294             :         }
     295           5 :         s->samplerate = freq;
     296             :     }
     297             : 
     298             :     /* set compression option defaults based on avctx->compression_level */
     299          28 :     if (avctx->compression_level < 0)
     300          25 :         s->options.compression_level = 5;
     301             :     else
     302           3 :         s->options.compression_level = avctx->compression_level;
     303             : 
     304          28 :     level = s->options.compression_level;
     305          28 :     if (level > 12) {
     306           0 :         av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
     307             :                s->options.compression_level);
     308           0 :         return AVERROR(EINVAL);
     309             :     }
     310             : 
     311          28 :     s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
     312             : 
     313          28 :     if (s->options.lpc_type == FF_LPC_TYPE_DEFAULT)
     314          50 :         s->options.lpc_type  = ((int[]){ FF_LPC_TYPE_FIXED,    FF_LPC_TYPE_FIXED,    FF_LPC_TYPE_FIXED,
     315             :                                          FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,
     316             :                                          FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,
     317             :                                          FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,
     318          25 :                                          FF_LPC_TYPE_LEVINSON})[level];
     319             : 
     320          28 :     if (s->options.min_prediction_order < 0)
     321          28 :         s->options.min_prediction_order = ((int[]){  2,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
     322          28 :     if (s->options.max_prediction_order < 0)
     323          28 :         s->options.max_prediction_order = ((int[]){  3,  4,  4,  6,  8,  8,  8,  8, 12, 12, 12, 32, 32})[level];
     324             : 
     325          28 :     if (s->options.prediction_order_method < 0)
     326          56 :         s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
     327             :                                                        ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
     328             :                                                        ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
     329             :                                                        ORDER_METHOD_LOG,    ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
     330          28 :                                                        ORDER_METHOD_SEARCH})[level];
     331             : 
     332          28 :     if (s->options.min_partition_order > s->options.max_partition_order) {
     333           0 :         av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
     334             :                s->options.min_partition_order, s->options.max_partition_order);
     335           0 :         return AVERROR(EINVAL);
     336             :     }
     337          28 :     if (s->options.min_partition_order < 0)
     338          28 :         s->options.min_partition_order = ((int[]){  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0})[level];
     339          28 :     if (s->options.max_partition_order < 0)
     340          28 :         s->options.max_partition_order = ((int[]){  2,  2,  3,  3,  3,  8,  8,  8,  8,  8,  8,  8,  8})[level];
     341             : 
     342             : #if FF_API_PRIVATE_OPT
     343             : FF_DISABLE_DEPRECATION_WARNINGS
     344          28 :     if (avctx->min_prediction_order >= 0) {
     345           0 :         if (s->options.lpc_type == FF_LPC_TYPE_FIXED) {
     346           0 :             if (avctx->min_prediction_order > MAX_FIXED_ORDER) {
     347           0 :                 av_log(avctx, AV_LOG_WARNING,
     348             :                        "invalid min prediction order %d, clamped to %d\n",
     349             :                        avctx->min_prediction_order, MAX_FIXED_ORDER);
     350           0 :                 avctx->min_prediction_order = MAX_FIXED_ORDER;
     351             :             }
     352           0 :         } else if (avctx->min_prediction_order < MIN_LPC_ORDER ||
     353           0 :                    avctx->min_prediction_order > MAX_LPC_ORDER) {
     354           0 :             av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
     355             :                    avctx->min_prediction_order);
     356           0 :             return AVERROR(EINVAL);
     357             :         }
     358           0 :         s->options.min_prediction_order = avctx->min_prediction_order;
     359             :     }
     360          28 :     if (avctx->max_prediction_order >= 0) {
     361           0 :         if (s->options.lpc_type == FF_LPC_TYPE_FIXED) {
     362           0 :             if (avctx->max_prediction_order > MAX_FIXED_ORDER) {
     363           0 :                 av_log(avctx, AV_LOG_WARNING,
     364             :                        "invalid max prediction order %d, clamped to %d\n",
     365             :                        avctx->max_prediction_order, MAX_FIXED_ORDER);
     366           0 :                 avctx->max_prediction_order = MAX_FIXED_ORDER;
     367             :             }
     368           0 :         } else if (avctx->max_prediction_order < MIN_LPC_ORDER ||
     369           0 :                    avctx->max_prediction_order > MAX_LPC_ORDER) {
     370           0 :             av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
     371             :                    avctx->max_prediction_order);
     372           0 :             return AVERROR(EINVAL);
     373             :         }
     374           0 :         s->options.max_prediction_order = avctx->max_prediction_order;
     375             :     }
     376             : FF_ENABLE_DEPRECATION_WARNINGS
     377             : #endif
     378          28 :     if (s->options.lpc_type == FF_LPC_TYPE_NONE) {
     379           0 :         s->options.min_prediction_order = 0;
     380           0 :         s->options.max_prediction_order = 0;
     381          28 :     } else if (s->options.lpc_type == FF_LPC_TYPE_FIXED) {
     382           3 :         if (s->options.min_prediction_order > MAX_FIXED_ORDER) {
     383           0 :             av_log(avctx, AV_LOG_WARNING,
     384             :                    "invalid min prediction order %d, clamped to %d\n",
     385             :                    s->options.min_prediction_order, MAX_FIXED_ORDER);
     386           0 :             s->options.min_prediction_order = MAX_FIXED_ORDER;
     387             :         }
     388           3 :         if (s->options.max_prediction_order > MAX_FIXED_ORDER) {
     389           1 :             av_log(avctx, AV_LOG_WARNING,
     390             :                    "invalid max prediction order %d, clamped to %d\n",
     391             :                    s->options.max_prediction_order, MAX_FIXED_ORDER);
     392           1 :             s->options.max_prediction_order = MAX_FIXED_ORDER;
     393             :         }
     394             :     }
     395             : 
     396          28 :     if (s->options.max_prediction_order < s->options.min_prediction_order) {
     397           0 :         av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
     398             :                s->options.min_prediction_order, s->options.max_prediction_order);
     399           0 :         return AVERROR(EINVAL);
     400             :     }
     401             : 
     402          28 :     if (avctx->frame_size > 0) {
     403           0 :         if (avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
     404           0 :                 avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
     405           0 :             av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
     406             :                    avctx->frame_size);
     407           0 :             return AVERROR(EINVAL);
     408             :         }
     409             :     } else {
     410          28 :         s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
     411             :     }
     412          28 :     s->max_blocksize = s->avctx->frame_size;
     413             : 
     414             :     /* set maximum encoded frame size in verbatim mode */
     415          28 :     s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,
     416             :                                                   s->channels,
     417          28 :                                                   s->avctx->bits_per_raw_sample);
     418             : 
     419             :     /* initialize MD5 context */
     420          28 :     s->md5ctx = av_md5_alloc();
     421          28 :     if (!s->md5ctx)
     422           0 :         return AVERROR(ENOMEM);
     423          28 :     av_md5_init(s->md5ctx);
     424             : 
     425          28 :     streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
     426          28 :     if (!streaminfo)
     427           0 :         return AVERROR(ENOMEM);
     428          28 :     write_streaminfo(s, streaminfo);
     429          28 :     avctx->extradata = streaminfo;
     430          28 :     avctx->extradata_size = FLAC_STREAMINFO_SIZE;
     431             : 
     432          28 :     s->frame_count   = 0;
     433          28 :     s->min_framesize = s->max_framesize;
     434             : 
     435          32 :     if (channels == 3 &&
     436          32 :             avctx->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) ||
     437           0 :         channels == 4 &&
     438           0 :             avctx->channel_layout != AV_CH_LAYOUT_2_2 &&
     439          28 :             avctx->channel_layout != AV_CH_LAYOUT_QUAD ||
     440           0 :         channels == 5 &&
     441           0 :             avctx->channel_layout != AV_CH_LAYOUT_5POINT0 &&
     442          28 :             avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK ||
     443           4 :         channels == 6 &&
     444           8 :             avctx->channel_layout != AV_CH_LAYOUT_5POINT1 &&
     445           4 :             avctx->channel_layout != AV_CH_LAYOUT_5POINT1_BACK) {
     446           0 :         if (avctx->channel_layout) {
     447           0 :             av_log(avctx, AV_LOG_ERROR, "Channel layout not supported by Flac, "
     448             :                                              "output stream will have incorrect "
     449             :                                              "channel layout.\n");
     450             :         } else {
     451           0 :             av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
     452             :                                                "will use Flac channel layout for "
     453             :                                                "%d channels.\n", channels);
     454             :         }
     455             :     }
     456             : 
     457          28 :     ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,
     458             :                       s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);
     459             : 
     460          28 :     ff_bswapdsp_init(&s->bdsp);
     461          28 :     ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt, channels,
     462             :                     avctx->bits_per_raw_sample);
     463             : 
     464          28 :     dprint_compression_options(s);
     465             : 
     466          28 :     return ret;
     467             : }
     468             : 
     469             : 
     470        4446 : static void init_frame(FlacEncodeContext *s, int nb_samples)
     471             : {
     472             :     int i, ch;
     473             :     FlacFrame *frame;
     474             : 
     475        4446 :     frame = &s->frame;
     476             : 
     477       31745 :     for (i = 0; i < 16; i++) {
     478       31733 :         if (nb_samples == ff_flac_blocksize_table[i]) {
     479        4434 :             frame->blocksize  = ff_flac_blocksize_table[i];
     480        4434 :             frame->bs_code[0] = i;
     481        4434 :             frame->bs_code[1] = 0;
     482        4434 :             break;
     483             :         }
     484             :     }
     485        4446 :     if (i == 16) {
     486          12 :         frame->blocksize = nb_samples;
     487          12 :         if (frame->blocksize <= 256) {
     488           0 :             frame->bs_code[0] = 6;
     489           0 :             frame->bs_code[1] = frame->blocksize-1;
     490             :         } else {
     491          12 :             frame->bs_code[0] = 7;
     492          12 :             frame->bs_code[1] = frame->blocksize-1;
     493             :         }
     494             :     }
     495             : 
     496       17328 :     for (ch = 0; ch < s->channels; ch++) {
     497       12882 :         FlacSubframe *sub = &frame->subframes[ch];
     498             : 
     499       12882 :         sub->wasted = 0;
     500       12882 :         sub->obits  = s->avctx->bits_per_raw_sample;
     501             : 
     502       12882 :         if (sub->obits > 16)
     503         236 :             sub->rc.coding_mode = CODING_MODE_RICE2;
     504             :         else
     505       12646 :             sub->rc.coding_mode = CODING_MODE_RICE;
     506             :     }
     507             : 
     508        4446 :     frame->verbatim_only = 0;
     509        4446 : }
     510             : 
     511             : 
     512             : /**
     513             :  * Copy channel-interleaved input samples into separate subframes.
     514             :  */
     515        4446 : static void copy_samples(FlacEncodeContext *s, const void *samples)
     516             : {
     517             :     int i, j, ch;
     518             :     FlacFrame *frame;
     519        8892 :     int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -
     520        4446 :                 s->avctx->bits_per_raw_sample;
     521             : 
     522             : #define COPY_SAMPLES(bits) do {                                     \
     523             :     const int ## bits ## _t *samples0 = samples;                    \
     524             :     frame = &s->frame;                                              \
     525             :     for (i = 0, j = 0; i < frame->blocksize; i++)                   \
     526             :         for (ch = 0; ch < s->channels; ch++, j++)                   \
     527             :             frame->subframes[ch].samples[i] = samples0[j] >> shift; \
     528             : } while (0)
     529             : 
     530        4446 :     if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16)
     531        4328 :         COPY_SAMPLES(16);
     532             :     else
     533         118 :         COPY_SAMPLES(32);
     534        4446 : }
     535             : 
     536             : 
     537       98573 : static uint64_t rice_count_exact(const int32_t *res, int n, int k)
     538             : {
     539             :     int i;
     540       98573 :     uint64_t count = 0;
     541             : 
     542    44840737 :     for (i = 0; i < n; i++) {
     543    44742164 :         int32_t v = -2 * res[i] - 1;
     544    44742164 :         v ^= v >> 31;
     545    44742164 :         count += (v >> k) + 1 + k;
     546             :     }
     547       98573 :     return count;
     548             : }
     549             : 
     550             : 
     551       12882 : static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub,
     552             :                                      int pred_order)
     553             : {
     554             :     int p, porder, psize;
     555             :     int i, part_end;
     556       12882 :     uint64_t count = 0;
     557             : 
     558             :     /* subframe header */
     559       12882 :     count += 8;
     560             : 
     561       12882 :     if (sub->wasted)
     562        5200 :         count += sub->wasted;
     563             : 
     564             :     /* subframe */
     565       12882 :     if (sub->type == FLAC_SUBFRAME_CONSTANT) {
     566        5428 :         count += sub->obits;
     567        7454 :     } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
     568           0 :         count += s->frame.blocksize * sub->obits;
     569             :     } else {
     570             :         /* warm-up samples */
     571        7454 :         count += pred_order * sub->obits;
     572             : 
     573             :         /* LPC coefficients */
     574        7454 :         if (sub->type == FLAC_SUBFRAME_LPC)
     575        6580 :             count += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
     576             : 
     577             :         /* rice-encoded block */
     578        7454 :         count += 2;
     579             : 
     580             :         /* partition order */
     581        7454 :         porder = sub->rc.porder;
     582        7454 :         psize  = s->frame.blocksize >> porder;
     583        7454 :         count += 4;
     584             : 
     585             :         /* residual */
     586        7454 :         i        = pred_order;
     587        7454 :         part_end = psize;
     588      106027 :         for (p = 0; p < 1 << porder; p++) {
     589       98573 :             int k = sub->rc.params[p];
     590       98573 :             count += sub->rc.coding_mode;
     591       98573 :             count += rice_count_exact(&sub->residual[i], part_end - i, k);
     592       98573 :             i = part_end;
     593       98573 :             part_end = FFMIN(s->frame.blocksize, part_end + psize);
     594             :         }
     595             :     }
     596             : 
     597       12882 :     return count;
     598             : }
     599             : 
     600             : 
     601             : #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
     602             : 
     603             : /**
     604             :  * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
     605             :  */
     606     3835107 : static int find_optimal_param(uint64_t sum, int n, int max_param)
     607             : {
     608             :     int k;
     609             :     uint64_t sum2;
     610             : 
     611     3835107 :     if (sum <= n >> 1)
     612        8900 :         return 0;
     613     3826207 :     sum2 = sum - (n >> 1);
     614     3826207 :     k    = av_log2(av_clipl_int32(sum2 / n));
     615     3826207 :     return FFMIN(k, max_param);
     616             : }
     617             : 
     618       27285 : static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)
     619             : {
     620       27285 :     int bestk = 0;
     621       27285 :     int64_t bestbits = INT64_MAX;
     622             :     int k;
     623             : 
     624      436560 :     for (k = 0; k <= max_param; k++) {
     625      409275 :         int64_t bits = sums[k][i];
     626      409275 :         if (bits < bestbits) {
     627      253571 :             bestbits = bits;
     628      253571 :             bestk = k;
     629             :         }
     630             :     }
     631             : 
     632       27285 :     return bestk;
     633             : }
     634             : 
     635       87698 : static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder,
     636             :                                          uint64_t sums[32][MAX_PARTITIONS],
     637             :                                          int n, int pred_order, int max_param, int exact)
     638             : {
     639             :     int i;
     640             :     int k, cnt, part;
     641             :     uint64_t all_bits;
     642             : 
     643       87698 :     part     = (1 << porder);
     644       87698 :     all_bits = 4 * part;
     645             : 
     646       87698 :     cnt = (n >> porder) - pred_order;
     647     3940202 :     for (i = 0; i < part; i++) {
     648     3852504 :         if (exact) {
     649       27285 :             k = find_optimal_param_exact(sums, i, max_param);
     650       27285 :             all_bits += sums[k][i];
     651             :         } else {
     652     3825219 :             k = find_optimal_param(sums[0][i], cnt, max_param);
     653     3825219 :             all_bits += rice_encode_count(sums[0][i], cnt, k);
     654             :         }
     655     3852504 :         rc->params[i] = k;
     656     3852504 :         cnt = n >> porder;
     657             :     }
     658             : 
     659       87698 :     rc->porder = porder;
     660             : 
     661       87698 :     return all_bits;
     662             : }
     663             : 
     664             : 
     665       12076 : static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order,
     666             :                          uint64_t sums[32][MAX_PARTITIONS])
     667             : {
     668             :     int i, k;
     669             :     int parts;
     670             :     const uint32_t *res, *res_end;
     671             : 
     672             :     /* sums for highest level */
     673       12076 :     parts   = (1 << pmax);
     674             : 
     675       49618 :     for (k = 0; k <= kmax; k++) {
     676       37542 :         res     = &data[pred_order];
     677       37542 :         res_end = &data[n >> pmax];
     678     2173560 :         for (i = 0; i < parts; i++) {
     679     2136018 :             if (kmax) {
     680      218280 :                 uint64_t sum = (1LL + k) * (res_end - res);
     681    31761285 :                 while (res < res_end)
     682    31324725 :                     sum += *(res++) >> k;
     683      218280 :                 sums[k][i] = sum;
     684             :             } else {
     685     1917738 :                 uint64_t sum = 0;
     686    68579077 :                 while (res < res_end)
     687    64743601 :                     sum += *(res++);
     688     1917738 :                 sums[k][i] = sum;
     689             :             }
     690     2136018 :             res_end += n >> pmax;
     691             :         }
     692             :     }
     693       12076 : }
     694             : 
     695       75622 : static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
     696             : {
     697             :     int i, k;
     698       75622 :     int parts = (1 << level);
     699     1995836 :     for (i = 0; i < parts; i++) {
     700     4018690 :         for (k=0; k<=kmax; k++)
     701     2098476 :             sums[k][i] = sums[k][2*i] + sums[k][2*i+1];
     702             :     }
     703       75622 : }
     704             : 
     705       12076 : static uint64_t calc_rice_params(RiceContext *rc,
     706             :                                  uint32_t udata[FLAC_MAX_BLOCKSIZE],
     707             :                                  uint64_t sums[32][MAX_PARTITIONS],
     708             :                                  int pmin, int pmax,
     709             :                                  const int32_t *data, int n, int pred_order, int exact)
     710             : {
     711             :     int i;
     712             :     uint64_t bits[MAX_PARTITION_ORDER+1];
     713             :     int opt_porder;
     714             :     RiceContext tmp_rc;
     715       12076 :     int kmax = (1 << rc->coding_mode) - 2;
     716             : 
     717             :     av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
     718             :     av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
     719             :     av_assert1(pmin <= pmax);
     720             : 
     721       12076 :     tmp_rc.coding_mode = rc->coding_mode;
     722             : 
     723    66876678 :     for (i = 0; i < n; i++)
     724    66864602 :         udata[i] = (2 * data[i]) ^ (data[i] >> 31);
     725             : 
     726       12076 :     calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums);
     727             : 
     728       12076 :     opt_porder = pmin;
     729       12076 :     bits[pmin] = UINT32_MAX;
     730       12076 :     for (i = pmax; ; ) {
     731      163320 :         bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums, n, pred_order, kmax, exact);
     732       87698 :         if (bits[i] < bits[opt_porder] || pmax == pmin) {
     733       70006 :             opt_porder = i;
     734       70006 :             *rc = tmp_rc;
     735             :         }
     736       87698 :         if (i == pmin)
     737       12076 :             break;
     738       75622 :         calc_sum_next(--i, sums, exact ? kmax : 0);
     739             :     }
     740             : 
     741       12076 :     return bits[opt_porder];
     742             : }
     743             : 
     744             : 
     745       24152 : static int get_max_p_order(int max_porder, int n, int order)
     746             : {
     747       24152 :     int porder = FFMIN(max_porder, av_log2(n^(n-1)));
     748       24152 :     if (order > 0)
     749       22572 :         porder = FFMIN(porder, av_log2(n/order));
     750       24152 :     return porder;
     751             : }
     752             : 
     753             : 
     754       12076 : static uint64_t find_subframe_rice_params(FlacEncodeContext *s,
     755             :                                           FlacSubframe *sub, int pred_order)
     756             : {
     757       12076 :     int pmin = get_max_p_order(s->options.min_partition_order,
     758             :                                s->frame.blocksize, pred_order);
     759       12076 :     int pmax = get_max_p_order(s->options.max_partition_order,
     760             :                                s->frame.blocksize, pred_order);
     761             : 
     762       12076 :     uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode;
     763       12076 :     if (sub->type == FLAC_SUBFRAME_LPC)
     764        7524 :         bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
     765       12076 :     bits += calc_rice_params(&sub->rc, sub->rc_udata, sub->rc_sums, pmin, pmax, sub->residual,
     766             :                              s->frame.blocksize, pred_order, s->options.exact_rice_parameters);
     767       12076 :     return bits;
     768             : }
     769             : 
     770             : 
     771        4552 : static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
     772             :                                   int order)
     773             : {
     774             :     int i;
     775             : 
     776       13844 :     for (i = 0; i < order; i++)
     777        9292 :         res[i] = smp[i];
     778             : 
     779        4552 :     if (order == 0) {
     780      909430 :         for (i = order; i < n; i++)
     781      908640 :             res[i] = smp[i];
     782        3762 :     } else if (order == 1) {
     783     1900908 :         for (i = order; i < n; i++)
     784     1899976 :             res[i] = smp[i] - smp[i-1];
     785        2830 :     } else if (order == 2) {
     786        1004 :         int a = smp[order-1] - smp[order-2];
     787     1091772 :         for (i = order; i < n; i += 2) {
     788     1090768 :             int b    = smp[i  ] - smp[i-1];
     789     1090768 :             res[i]   = b - a;
     790     1090768 :             a        = smp[i+1] - smp[i  ];
     791     1090768 :             res[i+1] = a - b;
     792             :         }
     793        1826 :     } else if (order == 3) {
     794         952 :         int a = smp[order-1] -   smp[order-2];
     795         952 :         int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
     796      875574 :         for (i = order; i < n; i += 2) {
     797      874622 :             int b    = smp[i  ] - smp[i-1];
     798      874622 :             int d    = b - a;
     799      874622 :             res[i]   = d - c;
     800      874622 :             a        = smp[i+1] - smp[i  ];
     801      874622 :             c        = a - b;
     802      874622 :             res[i+1] = c - d;
     803             :         }
     804             :     } else {
     805         874 :         int a = smp[order-1] -   smp[order-2];
     806         874 :         int c = smp[order-1] - 2*smp[order-2] +   smp[order-3];
     807         874 :         int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
     808      815948 :         for (i = order; i < n; i += 2) {
     809      815074 :             int b    = smp[i  ] - smp[i-1];
     810      815074 :             int d    = b - a;
     811      815074 :             int f    = d - c;
     812      815074 :             res[i  ] = f - e;
     813      815074 :             a        = smp[i+1] - smp[i  ];
     814      815074 :             c        = a - b;
     815      815074 :             e        = c - d;
     816      815074 :             res[i+1] = e - f;
     817             :         }
     818             :     }
     819        4552 : }
     820             : 
     821             : 
     822       12882 : static int encode_residual_ch(FlacEncodeContext *s, int ch)
     823             : {
     824             :     int i, n;
     825             :     int min_order, max_order, opt_order, omethod;
     826             :     FlacFrame *frame;
     827             :     FlacSubframe *sub;
     828             :     int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
     829             :     int shift[MAX_LPC_ORDER];
     830             :     int32_t *res, *smp;
     831             : 
     832       12882 :     frame = &s->frame;
     833       12882 :     sub   = &frame->subframes[ch];
     834       12882 :     res   = sub->residual;
     835       12882 :     smp   = sub->samples;
     836       12882 :     n     = frame->blocksize;
     837             : 
     838             :     /* CONSTANT */
     839    34347726 :     for (i = 1; i < n; i++)
     840    34342298 :         if(smp[i] != smp[0])
     841        7454 :             break;
     842       12882 :     if (i == n) {
     843        5428 :         sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
     844        5428 :         res[0] = smp[0];
     845        5428 :         return subframe_count_exact(s, sub, 0);
     846             :     }
     847             : 
     848             :     /* VERBATIM */
     849        7454 :     if (frame->verbatim_only || n < 5) {
     850           0 :         sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
     851           0 :         memcpy(res, smp, n * sizeof(int32_t));
     852           0 :         return subframe_count_exact(s, sub, 0);
     853             :     }
     854             : 
     855        7454 :     min_order  = s->options.min_prediction_order;
     856        7454 :     max_order  = s->options.max_prediction_order;
     857        7454 :     omethod    = s->options.prediction_order_method;
     858             : 
     859             :     /* FIXED */
     860        7454 :     sub->type = FLAC_SUBFRAME_FIXED;
     861       14908 :     if (s->options.lpc_type == FF_LPC_TYPE_NONE  ||
     862       14034 :         s->options.lpc_type == FF_LPC_TYPE_FIXED || n <= max_order) {
     863             :         uint64_t bits[MAX_FIXED_ORDER+1];
     864         874 :         if (max_order > MAX_FIXED_ORDER)
     865           0 :             max_order = MAX_FIXED_ORDER;
     866         874 :         opt_order = 0;
     867         874 :         bits[0]   = UINT32_MAX;
     868        5062 :         for (i = min_order; i <= max_order; i++) {
     869        4188 :             encode_residual_fixed(res, smp, n, i);
     870        4188 :             bits[i] = find_subframe_rice_params(s, sub, i);
     871        4188 :             if (bits[i] < bits[opt_order])
     872        2592 :                 opt_order = i;
     873             :         }
     874         874 :         sub->order     = opt_order;
     875         874 :         sub->type_code = sub->type | sub->order;
     876         874 :         if (sub->order != max_order) {
     877         364 :             encode_residual_fixed(res, smp, n, sub->order);
     878         364 :             find_subframe_rice_params(s, sub, sub->order);
     879             :         }
     880         874 :         return subframe_count_exact(s, sub, sub->order);
     881             :     }
     882             : 
     883             :     /* LPC */
     884        6580 :     sub->type = FLAC_SUBFRAME_LPC;
     885        6580 :     opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, smp, n, min_order, max_order,
     886             :                                   s->options.lpc_coeff_precision, coefs, shift, s->options.lpc_type,
     887             :                                   s->options.lpc_passes, omethod,
     888             :                                   MIN_LPC_SHIFT, MAX_LPC_SHIFT, 0);
     889             : 
     890        6580 :     if (omethod == ORDER_METHOD_2LEVEL ||
     891        6344 :         omethod == ORDER_METHOD_4LEVEL ||
     892         236 :         omethod == ORDER_METHOD_8LEVEL) {
     893         236 :         int levels = 1 << omethod;
     894             :         uint64_t bits[1 << ORDER_METHOD_8LEVEL];
     895         236 :         int order       = -1;
     896         236 :         int opt_index   = levels-1;
     897         236 :         opt_order       = max_order-1;
     898         236 :         bits[opt_index] = UINT32_MAX;
     899        1180 :         for (i = levels-1; i >= 0; i--) {
     900         944 :             int last_order = order;
     901         944 :             order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
     902         944 :             order = av_clip(order, min_order - 1, max_order - 1);
     903         944 :             if (order == last_order)
     904           0 :                 continue;
     905         944 :             if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(order) <= 32) {
     906           0 :                 s->flac_dsp.lpc16_encode(res, smp, n, order+1, coefs[order],
     907             :                                          shift[order]);
     908             :             } else {
     909         944 :                 s->flac_dsp.lpc32_encode(res, smp, n, order+1, coefs[order],
     910             :                                          shift[order]);
     911             :             }
     912         944 :             bits[i] = find_subframe_rice_params(s, sub, order+1);
     913         944 :             if (bits[i] < bits[opt_index]) {
     914          58 :                 opt_index = i;
     915          58 :                 opt_order = order;
     916             :             }
     917             :         }
     918         236 :         opt_order++;
     919        6344 :     } else if (omethod == ORDER_METHOD_SEARCH) {
     920             :         // brute-force optimal order search
     921             :         uint64_t bits[MAX_LPC_ORDER];
     922           0 :         opt_order = 0;
     923           0 :         bits[0]   = UINT32_MAX;
     924           0 :         for (i = min_order-1; i < max_order; i++) {
     925           0 :             if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) {
     926           0 :                 s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]);
     927             :             } else {
     928           0 :                 s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]);
     929             :             }
     930           0 :             bits[i] = find_subframe_rice_params(s, sub, i+1);
     931           0 :             if (bits[i] < bits[opt_order])
     932           0 :                 opt_order = i;
     933             :         }
     934           0 :         opt_order++;
     935        6344 :     } else if (omethod == ORDER_METHOD_LOG) {
     936             :         uint64_t bits[MAX_LPC_ORDER];
     937             :         int step;
     938             : 
     939           0 :         opt_order = min_order - 1 + (max_order-min_order)/3;
     940           0 :         memset(bits, -1, sizeof(bits));
     941             : 
     942           0 :         for (step = 16; step; step >>= 1) {
     943           0 :             int last = opt_order;
     944           0 :             for (i = last-step; i <= last+step; i += step) {
     945           0 :                 if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX)
     946           0 :                     continue;
     947           0 :                 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) {
     948           0 :                     s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]);
     949             :                 } else {
     950           0 :                     s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]);
     951             :                 }
     952           0 :                 bits[i] = find_subframe_rice_params(s, sub, i+1);
     953           0 :                 if (bits[i] < bits[opt_order])
     954           0 :                     opt_order = i;
     955             :             }
     956             :         }
     957           0 :         opt_order++;
     958             :     }
     959             : 
     960        6580 :     if (s->options.multi_dim_quant) {
     961           0 :         int allsteps = 1;
     962             :         int i, step, improved;
     963           0 :         int64_t best_score = INT64_MAX;
     964             :         int32_t qmax;
     965             : 
     966           0 :         qmax = (1 << (s->options.lpc_coeff_precision - 1)) - 1;
     967             : 
     968           0 :         for (i=0; i<opt_order; i++)
     969           0 :             allsteps *= 3;
     970             : 
     971             :         do {
     972           0 :             improved = 0;
     973           0 :             for (step = 0; step < allsteps; step++) {
     974           0 :                 int tmp = step;
     975             :                 int32_t lpc_try[MAX_LPC_ORDER];
     976           0 :                 int64_t score = 0;
     977           0 :                 int diffsum = 0;
     978             : 
     979           0 :                 for (i=0; i<opt_order; i++) {
     980           0 :                     int diff = ((tmp + 1) % 3) - 1;
     981           0 :                     lpc_try[i] = av_clip(coefs[opt_order - 1][i] + diff, -qmax, qmax);
     982           0 :                     tmp /= 3;
     983           0 :                     diffsum += !!diff;
     984             :                 }
     985           0 :                 if (diffsum >8)
     986           0 :                     continue;
     987             : 
     988           0 :                 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order - 1) <= 32) {
     989           0 :                     s->flac_dsp.lpc16_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]);
     990             :                 } else {
     991           0 :                     s->flac_dsp.lpc32_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]);
     992             :                 }
     993           0 :                 score = find_subframe_rice_params(s, sub, opt_order);
     994           0 :                 if (score < best_score) {
     995           0 :                     best_score = score;
     996           0 :                     memcpy(coefs[opt_order-1], lpc_try, sizeof(*coefs));
     997           0 :                     improved=1;
     998             :                 }
     999             :             }
    1000           0 :         } while(improved);
    1001             :     }
    1002             : 
    1003        6580 :     sub->order     = opt_order;
    1004        6580 :     sub->type_code = sub->type | (sub->order-1);
    1005        6580 :     sub->shift     = shift[sub->order-1];
    1006       22186 :     for (i = 0; i < sub->order; i++)
    1007       15606 :         sub->coefs[i] = coefs[sub->order-1][i];
    1008             : 
    1009        6580 :     if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order) <= 32) {
    1010        5233 :         s->flac_dsp.lpc16_encode(res, smp, n, sub->order, sub->coefs, sub->shift);
    1011             :     } else {
    1012        1347 :         s->flac_dsp.lpc32_encode(res, smp, n, sub->order, sub->coefs, sub->shift);
    1013             :     }
    1014             : 
    1015        6580 :     find_subframe_rice_params(s, sub, sub->order);
    1016             : 
    1017        6580 :     return subframe_count_exact(s, sub, sub->order);
    1018             : }
    1019             : 
    1020             : 
    1021        4446 : static int count_frame_header(FlacEncodeContext *s)
    1022             : {
    1023             :     uint8_t av_unused tmp;
    1024             :     int count;
    1025             : 
    1026             :     /*
    1027             :     <14> Sync code
    1028             :     <1>  Reserved
    1029             :     <1>  Blocking strategy
    1030             :     <4>  Block size in inter-channel samples
    1031             :     <4>  Sample rate
    1032             :     <4>  Channel assignment
    1033             :     <3>  Sample size in bits
    1034             :     <1>  Reserved
    1035             :     */
    1036        4446 :     count = 32;
    1037             : 
    1038             :     /* coded frame number */
    1039        4446 :     PUT_UTF8(s->frame_count, tmp, count += 8;)
    1040             : 
    1041             :     /* explicit block size */
    1042        4446 :     if (s->frame.bs_code[0] == 6)
    1043           0 :         count += 8;
    1044        4446 :     else if (s->frame.bs_code[0] == 7)
    1045          12 :         count += 16;
    1046             : 
    1047             :     /* explicit sample rate */
    1048        4446 :     count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12) * 2) * 8;
    1049             : 
    1050             :     /* frame header CRC-8 */
    1051        4446 :     count += 8;
    1052             : 
    1053        4446 :     return count;
    1054             : }
    1055             : 
    1056             : 
    1057        4446 : static int encode_frame(FlacEncodeContext *s)
    1058             : {
    1059             :     int ch;
    1060             :     uint64_t count;
    1061             : 
    1062        4446 :     count = count_frame_header(s);
    1063             : 
    1064       17328 :     for (ch = 0; ch < s->channels; ch++)
    1065       12882 :         count += encode_residual_ch(s, ch);
    1066             : 
    1067        4446 :     count += (8 - (count & 7)) & 7; // byte alignment
    1068        4446 :     count += 16;                    // CRC-16
    1069             : 
    1070        4446 :     count >>= 3;
    1071        4446 :     if (count > INT_MAX)
    1072           0 :         return AVERROR_BUG;
    1073        4446 :     return count;
    1074             : }
    1075             : 
    1076             : 
    1077        4446 : static void remove_wasted_bits(FlacEncodeContext *s)
    1078             : {
    1079             :     int ch, i;
    1080             : 
    1081       17328 :     for (ch = 0; ch < s->channels; ch++) {
    1082       12882 :         FlacSubframe *sub = &s->frame.subframes[ch];
    1083       12882 :         int32_t v         = 0;
    1084             : 
    1085    68337366 :         for (i = 0; i < s->frame.blocksize; i++) {
    1086    68326738 :             v |= sub->samples[i];
    1087    68326738 :             if (v & 1)
    1088        2254 :                 break;
    1089             :         }
    1090             : 
    1091       12882 :         if (v && !(v & 1)) {
    1092        5200 :             v = ff_ctz(v);
    1093             : 
    1094    34034000 :             for (i = 0; i < s->frame.blocksize; i++)
    1095    34028800 :                 sub->samples[i] >>= v;
    1096             : 
    1097        5200 :             sub->wasted = v;
    1098        5200 :             sub->obits -= v;
    1099             : 
    1100             :             /* for 24-bit, check if removing wasted bits makes the range better
    1101             :                suited for using RICE instead of RICE2 for entropy coding */
    1102        5200 :             if (sub->obits <= 17)
    1103        5200 :                 sub->rc.coding_mode = CODING_MODE_RICE;
    1104             :         }
    1105             :     }
    1106        4446 : }
    1107             : 
    1108             : 
    1109        2472 : static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n,
    1110             :                                 int max_rice_param)
    1111             : {
    1112             :     int i, best;
    1113             :     int32_t lt, rt;
    1114             :     uint64_t sum[4];
    1115             :     uint64_t score[4];
    1116             :     int k;
    1117             : 
    1118             :     /* calculate sum of 2nd order residual for each channel */
    1119        2472 :     sum[0] = sum[1] = sum[2] = sum[3] = 0;
    1120    14267187 :     for (i = 2; i < n; i++) {
    1121    14264715 :         lt = left_ch[i]  - 2*left_ch[i-1]  + left_ch[i-2];
    1122    14264715 :         rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
    1123    14264715 :         sum[2] += FFABS((lt + rt) >> 1);
    1124    14264715 :         sum[3] += FFABS(lt - rt);
    1125    14264715 :         sum[0] += FFABS(lt);
    1126    14264715 :         sum[1] += FFABS(rt);
    1127             :     }
    1128             :     /* estimate bit counts */
    1129       12360 :     for (i = 0; i < 4; i++) {
    1130        9888 :         k      = find_optimal_param(2 * sum[i], n, max_rice_param);
    1131        9888 :         sum[i] = rice_encode_count( 2 * sum[i], n, k);
    1132             :     }
    1133             : 
    1134             :     /* calculate score for each mode */
    1135        2472 :     score[0] = sum[0] + sum[1];
    1136        2472 :     score[1] = sum[0] + sum[3];
    1137        2472 :     score[2] = sum[1] + sum[3];
    1138        2472 :     score[3] = sum[2] + sum[3];
    1139             : 
    1140             :     /* return mode with lowest score */
    1141        2472 :     best = 0;
    1142        9888 :     for (i = 1; i < 4; i++)
    1143        7416 :         if (score[i] < score[best])
    1144        1740 :             best = i;
    1145             : 
    1146        2472 :     return best;
    1147             : }
    1148             : 
    1149             : 
    1150             : /**
    1151             :  * Perform stereo channel decorrelation.
    1152             :  */
    1153        4446 : static void channel_decorrelation(FlacEncodeContext *s)
    1154             : {
    1155             :     FlacFrame *frame;
    1156             :     int32_t *left, *right;
    1157             :     int i, n;
    1158             : 
    1159        4446 :     frame = &s->frame;
    1160        4446 :     n     = frame->blocksize;
    1161        4446 :     left  = frame->subframes[0].samples;
    1162        4446 :     right = frame->subframes[1].samples;
    1163             : 
    1164        4446 :     if (s->channels != 2) {
    1165        1610 :         frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
    1166        1610 :         return;
    1167             :     }
    1168             : 
    1169        2836 :     if (s->options.ch_mode < 0) {
    1170        2472 :         int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2;
    1171        2472 :         frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param);
    1172             :     } else
    1173         364 :         frame->ch_mode = s->options.ch_mode;
    1174             : 
    1175             :     /* perform decorrelation and adjust bits-per-sample */
    1176        2836 :     if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
    1177        1050 :         return;
    1178        1786 :     if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
    1179             :         int32_t tmp;
    1180     1065516 :         for (i = 0; i < n; i++) {
    1181     1065265 :             tmp      = left[i];
    1182     1065265 :             left[i]  = (tmp + right[i]) >> 1;
    1183     1065265 :             right[i] =  tmp - right[i];
    1184             :         }
    1185         251 :         frame->subframes[1].obits++;
    1186        1535 :     } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
    1187     6514126 :         for (i = 0; i < n; i++)
    1188     6512822 :             right[i] = left[i] - right[i];
    1189        1304 :         frame->subframes[1].obits++;
    1190             :     } else {
    1191      787821 :         for (i = 0; i < n; i++)
    1192      787590 :             left[i] -= right[i];
    1193         231 :         frame->subframes[0].obits++;
    1194             :     }
    1195             : }
    1196             : 
    1197             : 
    1198        4446 : static void write_utf8(PutBitContext *pb, uint32_t val)
    1199             : {
    1200             :     uint8_t tmp;
    1201        4446 :     PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
    1202        4446 : }
    1203             : 
    1204             : 
    1205        4446 : static void write_frame_header(FlacEncodeContext *s)
    1206             : {
    1207             :     FlacFrame *frame;
    1208             :     int crc;
    1209             : 
    1210        4446 :     frame = &s->frame;
    1211             : 
    1212        4446 :     put_bits(&s->pb, 16, 0xFFF8);
    1213        4446 :     put_bits(&s->pb, 4, frame->bs_code[0]);
    1214        4446 :     put_bits(&s->pb, 4, s->sr_code[0]);
    1215             : 
    1216        4446 :     if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
    1217        2660 :         put_bits(&s->pb, 4, s->channels-1);
    1218             :     else
    1219        1786 :         put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1);
    1220             : 
    1221        4446 :     put_bits(&s->pb, 3, s->bps_code);
    1222        4446 :     put_bits(&s->pb, 1, 0);
    1223        4446 :     write_utf8(&s->pb, s->frame_count);
    1224             : 
    1225        4446 :     if (frame->bs_code[0] == 6)
    1226           0 :         put_bits(&s->pb, 8, frame->bs_code[1]);
    1227        4446 :     else if (frame->bs_code[0] == 7)
    1228          12 :         put_bits(&s->pb, 16, frame->bs_code[1]);
    1229             : 
    1230        4446 :     if (s->sr_code[0] == 12)
    1231         918 :         put_bits(&s->pb, 8, s->sr_code[1]);
    1232        3528 :     else if (s->sr_code[0] > 12)
    1233           0 :         put_bits(&s->pb, 16, s->sr_code[1]);
    1234             : 
    1235        4446 :     flush_put_bits(&s->pb);
    1236        4446 :     crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf,
    1237        4446 :                  put_bits_count(&s->pb) >> 3);
    1238        4446 :     put_bits(&s->pb, 8, crc);
    1239        4446 : }
    1240             : 
    1241             : 
    1242        4446 : static void write_subframes(FlacEncodeContext *s)
    1243             : {
    1244             :     int ch;
    1245             : 
    1246       17328 :     for (ch = 0; ch < s->channels; ch++) {
    1247       12882 :         FlacSubframe *sub = &s->frame.subframes[ch];
    1248             :         int i, p, porder, psize;
    1249             :         int32_t *part_end;
    1250       12882 :         int32_t *res       =  sub->residual;
    1251       12882 :         int32_t *frame_end = &sub->residual[s->frame.blocksize];
    1252             : 
    1253             :         /* subframe header */
    1254       12882 :         put_bits(&s->pb, 1, 0);
    1255       12882 :         put_bits(&s->pb, 6, sub->type_code);
    1256       12882 :         put_bits(&s->pb, 1, !!sub->wasted);
    1257       12882 :         if (sub->wasted)
    1258        5200 :             put_bits(&s->pb, sub->wasted, 1);
    1259             : 
    1260             :         /* subframe */
    1261       12882 :         if (sub->type == FLAC_SUBFRAME_CONSTANT) {
    1262        5428 :             put_sbits(&s->pb, sub->obits, res[0]);
    1263        7454 :         } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
    1264           0 :             while (res < frame_end)
    1265           0 :                 put_sbits(&s->pb, sub->obits, *res++);
    1266             :         } else {
    1267             :             /* warm-up samples */
    1268       25652 :             for (i = 0; i < sub->order; i++)
    1269       18198 :                 put_sbits(&s->pb, sub->obits, *res++);
    1270             : 
    1271             :             /* LPC coefficients */
    1272        7454 :             if (sub->type == FLAC_SUBFRAME_LPC) {
    1273        6580 :                 int cbits = s->options.lpc_coeff_precision;
    1274        6580 :                 put_bits( &s->pb, 4, cbits-1);
    1275        6580 :                 put_sbits(&s->pb, 5, sub->shift);
    1276       22186 :                 for (i = 0; i < sub->order; i++)
    1277       15606 :                     put_sbits(&s->pb, cbits, sub->coefs[i]);
    1278             :             }
    1279             : 
    1280             :             /* rice-encoded block */
    1281        7454 :             put_bits(&s->pb, 2, sub->rc.coding_mode - 4);
    1282             : 
    1283             :             /* partition order */
    1284        7454 :             porder  = sub->rc.porder;
    1285        7454 :             psize   = s->frame.blocksize >> porder;
    1286        7454 :             put_bits(&s->pb, 4, porder);
    1287             : 
    1288             :             /* residual */
    1289        7454 :             part_end  = &sub->residual[psize];
    1290      106027 :             for (p = 0; p < 1 << porder; p++) {
    1291       98573 :                 int k = sub->rc.params[p];
    1292       98573 :                 put_bits(&s->pb, sub->rc.coding_mode, k);
    1293    44939310 :                 while (res < part_end)
    1294    44742164 :                     set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0);
    1295       98573 :                 part_end = FFMIN(frame_end, part_end + psize);
    1296             :             }
    1297             :         }
    1298             :     }
    1299        4446 : }
    1300             : 
    1301             : 
    1302        4446 : static void write_frame_footer(FlacEncodeContext *s)
    1303             : {
    1304             :     int crc;
    1305        4446 :     flush_put_bits(&s->pb);
    1306        4446 :     crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf,
    1307        4446 :                             put_bits_count(&s->pb)>>3));
    1308        4446 :     put_bits(&s->pb, 16, crc);
    1309        4446 :     flush_put_bits(&s->pb);
    1310        4446 : }
    1311             : 
    1312             : 
    1313        4446 : static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)
    1314             : {
    1315        4446 :     init_put_bits(&s->pb, avpkt->data, avpkt->size);
    1316        4446 :     write_frame_header(s);
    1317        4446 :     write_subframes(s);
    1318        4446 :     write_frame_footer(s);
    1319        4446 :     return put_bits_count(&s->pb) >> 3;
    1320             : }
    1321             : 
    1322             : 
    1323        4446 : static int update_md5_sum(FlacEncodeContext *s, const void *samples)
    1324             : {
    1325             :     const uint8_t *buf;
    1326        8892 :     int buf_size = s->frame.blocksize * s->channels *
    1327        4446 :                    ((s->avctx->bits_per_raw_sample + 7) / 8);
    1328             : 
    1329        4446 :     if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {
    1330         118 :         av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size);
    1331         118 :         if (!s->md5_buffer)
    1332           0 :             return AVERROR(ENOMEM);
    1333             :     }
    1334             : 
    1335        4446 :     if (s->avctx->bits_per_raw_sample <= 16) {
    1336        4328 :         buf = (const uint8_t *)samples;
    1337             : #if HAVE_BIGENDIAN
    1338             :         s->bdsp.bswap16_buf((uint16_t *) s->md5_buffer,
    1339             :                             (const uint16_t *) samples, buf_size / 2);
    1340             :         buf = s->md5_buffer;
    1341             : #endif
    1342             :     } else {
    1343             :         int i;
    1344         118 :         const int32_t *samples0 = samples;
    1345         118 :         uint8_t *tmp            = s->md5_buffer;
    1346             : 
    1347     3840118 :         for (i = 0; i < s->frame.blocksize * s->channels; i++) {
    1348     3840000 :             int32_t v = samples0[i] >> 8;
    1349     3840000 :             AV_WL24(tmp + 3*i, v);
    1350             :         }
    1351         118 :         buf = s->md5_buffer;
    1352             :     }
    1353        4446 :     av_md5_update(s->md5ctx, buf, buf_size);
    1354             : 
    1355        4446 :     return 0;
    1356             : }
    1357             : 
    1358             : 
    1359        4470 : static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
    1360             :                              const AVFrame *frame, int *got_packet_ptr)
    1361             : {
    1362             :     FlacEncodeContext *s;
    1363             :     int frame_bytes, out_bytes, ret;
    1364             : 
    1365        4470 :     s = avctx->priv_data;
    1366             : 
    1367             :     /* when the last block is reached, update the header in extradata */
    1368        4470 :     if (!frame) {
    1369          24 :         s->max_framesize = s->max_encoded_framesize;
    1370          24 :         av_md5_final(s->md5ctx, s->md5sum);
    1371          24 :         write_streaminfo(s, avctx->extradata);
    1372             : 
    1373             : #if FF_API_SIDEDATA_ONLY_PKT
    1374             : FF_DISABLE_DEPRECATION_WARNINGS
    1375          24 :         if (avctx->side_data_only_packets && !s->flushed) {
    1376             : FF_ENABLE_DEPRECATION_WARNINGS
    1377             : #else
    1378             :         if (!s->flushed) {
    1379             : #endif
    1380          12 :             uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
    1381             :                                                          avctx->extradata_size);
    1382          12 :             if (!side_data)
    1383           0 :                 return AVERROR(ENOMEM);
    1384          12 :             memcpy(side_data, avctx->extradata, avctx->extradata_size);
    1385             : 
    1386          12 :             avpkt->pts = s->next_pts;
    1387             : 
    1388          12 :             *got_packet_ptr = 1;
    1389          12 :             s->flushed = 1;
    1390             :         }
    1391             : 
    1392          24 :         return 0;
    1393             :     }
    1394             : 
    1395             :     /* change max_framesize for small final frame */
    1396        4446 :     if (frame->nb_samples < s->frame.blocksize) {
    1397          12 :         s->max_framesize = ff_flac_get_max_frame_size(frame->nb_samples,
    1398             :                                                       s->channels,
    1399             :                                                       avctx->bits_per_raw_sample);
    1400             :     }
    1401             : 
    1402        4446 :     init_frame(s, frame->nb_samples);
    1403             : 
    1404        4446 :     copy_samples(s, frame->data[0]);
    1405             : 
    1406        4446 :     channel_decorrelation(s);
    1407             : 
    1408        4446 :     remove_wasted_bits(s);
    1409             : 
    1410        4446 :     frame_bytes = encode_frame(s);
    1411             : 
    1412             :     /* Fall back on verbatim mode if the compressed frame is larger than it
    1413             :        would be if encoded uncompressed. */
    1414        4446 :     if (frame_bytes < 0 || frame_bytes > s->max_framesize) {
    1415           0 :         s->frame.verbatim_only = 1;
    1416           0 :         frame_bytes = encode_frame(s);
    1417           0 :         if (frame_bytes < 0) {
    1418           0 :             av_log(avctx, AV_LOG_ERROR, "Bad frame count\n");
    1419           0 :             return frame_bytes;
    1420             :         }
    1421             :     }
    1422             : 
    1423        4446 :     if ((ret = ff_alloc_packet2(avctx, avpkt, frame_bytes, 0)) < 0)
    1424           0 :         return ret;
    1425             : 
    1426        4446 :     out_bytes = write_frame(s, avpkt);
    1427             : 
    1428        4446 :     s->frame_count++;
    1429        4446 :     s->sample_count += frame->nb_samples;
    1430        4446 :     if ((ret = update_md5_sum(s, frame->data[0])) < 0) {
    1431           0 :         av_log(avctx, AV_LOG_ERROR, "Error updating MD5 checksum\n");
    1432           0 :         return ret;
    1433             :     }
    1434        4446 :     if (out_bytes > s->max_encoded_framesize)
    1435         207 :         s->max_encoded_framesize = out_bytes;
    1436        4446 :     if (out_bytes < s->min_framesize)
    1437          43 :         s->min_framesize = out_bytes;
    1438             : 
    1439        4446 :     avpkt->pts      = frame->pts;
    1440        4446 :     avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
    1441        4446 :     avpkt->size     = out_bytes;
    1442             : 
    1443        4446 :     s->next_pts = avpkt->pts + avpkt->duration;
    1444             : 
    1445        4446 :     *got_packet_ptr = 1;
    1446        4446 :     return 0;
    1447             : }
    1448             : 
    1449             : 
    1450          28 : static av_cold int flac_encode_close(AVCodecContext *avctx)
    1451             : {
    1452          28 :     if (avctx->priv_data) {
    1453          28 :         FlacEncodeContext *s = avctx->priv_data;
    1454          28 :         av_freep(&s->md5ctx);
    1455          28 :         av_freep(&s->md5_buffer);
    1456          28 :         ff_lpc_end(&s->lpc_ctx);
    1457             :     }
    1458          28 :     av_freep(&avctx->extradata);
    1459          28 :     avctx->extradata_size = 0;
    1460          28 :     return 0;
    1461             : }
    1462             : 
    1463             : #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
    1464             : static const AVOption options[] = {
    1465             : { "lpc_coeff_precision", "LPC coefficient precision", offsetof(FlacEncodeContext, options.lpc_coeff_precision), AV_OPT_TYPE_INT, {.i64 = 15 }, 0, MAX_LPC_PRECISION, FLAGS },
    1466             : { "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" },
    1467             : { "none",     NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_NONE },     INT_MIN, INT_MAX, FLAGS, "lpc_type" },
    1468             : { "fixed",    NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_FIXED },    INT_MIN, INT_MAX, FLAGS, "lpc_type" },
    1469             : { "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
    1470             : { "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
    1471             : { "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 },
    1472             : { "min_partition_order",  NULL, offsetof(FlacEncodeContext, options.min_partition_order),  AV_OPT_TYPE_INT, {.i64 = -1 },      -1, MAX_PARTITION_ORDER, FLAGS },
    1473             : { "max_partition_order",  NULL, offsetof(FlacEncodeContext, options.max_partition_order),  AV_OPT_TYPE_INT, {.i64 = -1 },      -1, MAX_PARTITION_ORDER, FLAGS },
    1474             : { "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" },
    1475             : { "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST },    INT_MIN, INT_MAX, FLAGS, "predm" },
    1476             : { "2level",     NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_2LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
    1477             : { "4level",     NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_4LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
    1478             : { "8level",     NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_8LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
    1479             : { "search",     NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, INT_MIN, INT_MAX, FLAGS, "predm" },
    1480             : { "log",        NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_LOG },    INT_MIN, INT_MAX, FLAGS, "predm" },
    1481             : { "ch_mode", "Stereo decorrelation mode", offsetof(FlacEncodeContext, options.ch_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, FLAC_CHMODE_MID_SIDE, FLAGS, "ch_mode" },
    1482             : { "auto",       NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1                      }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
    1483             : { "indep",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_INDEPENDENT }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
    1484             : { "left_side",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_LEFT_SIDE   }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
    1485             : { "right_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_RIGHT_SIDE  }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
    1486             : { "mid_side",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_MID_SIDE    }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
    1487             : { "exact_rice_parameters", "Calculate rice parameters exactly", offsetof(FlacEncodeContext, options.exact_rice_parameters), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
    1488             : { "multi_dim_quant",       "Multi-dimensional quantization",    offsetof(FlacEncodeContext, options.multi_dim_quant),       AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
    1489             : { "min_prediction_order", NULL, offsetof(FlacEncodeContext, options.min_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },
    1490             : { "max_prediction_order", NULL, offsetof(FlacEncodeContext, options.max_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },
    1491             : 
    1492             : { NULL },
    1493             : };
    1494             : 
    1495             : static const AVClass flac_encoder_class = {
    1496             :     .class_name = "FLAC encoder",
    1497             :     .item_name  = av_default_item_name,
    1498             :     .option     = options,
    1499             :     .version    = LIBAVUTIL_VERSION_INT,
    1500             : };
    1501             : 
    1502             : AVCodec ff_flac_encoder = {
    1503             :     .name           = "flac",
    1504             :     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
    1505             :     .type           = AVMEDIA_TYPE_AUDIO,
    1506             :     .id             = AV_CODEC_ID_FLAC,
    1507             :     .priv_data_size = sizeof(FlacEncodeContext),
    1508             :     .init           = flac_encode_init,
    1509             :     .encode2        = flac_encode_frame,
    1510             :     .close          = flac_encode_close,
    1511             :     .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_LOSSLESS,
    1512             :     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
    1513             :                                                      AV_SAMPLE_FMT_S32,
    1514             :                                                      AV_SAMPLE_FMT_NONE },
    1515             :     .priv_class     = &flac_encoder_class,
    1516             : };

Generated by: LCOV version 1.13