* FLAC audio encoder
* Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com>
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * Libav is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "libavutil/avassert.h"
#include "libavutil/crc.h"
#include "libavutil/intmath.h"
#include "libavutil/md5.h"
#define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
#define MAX_LPC_PRECISION 15
#define MAX_LPC_SHIFT 15
-#define MAX_RICE_PARAM 14
+
+enum CodingMode {
+ CODING_MODE_RICE = 4,
+ CODING_MODE_RICE2 = 5,
+};
typedef struct CompressionOptions {
int compression_level;
} CompressionOptions;
typedef struct RiceContext {
+ enum CodingMode coding_mode;
int porder;
int params[MAX_PARTITIONS];
} RiceContext;
int channels;
int samplerate;
int sr_code[2];
+ int bps_code;
int max_blocksize;
int min_framesize;
int max_framesize;
put_bits(&pb, 24, s->max_framesize);
put_bits(&pb, 20, s->samplerate);
put_bits(&pb, 3, s->channels-1);
- put_bits(&pb, 5, 15); /* bits per sample - 1 */
+ put_bits(&pb, 5, s->avctx->bits_per_raw_sample - 1);
/* write 36-bit sample count in 2 put_bits() calls */
put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
put_bits(&pb, 12, s->sample_count & 0x000000FFFLL);
int target;
int blocksize;
- assert(samplerate > 0);
+ av_assert0(samplerate > 0);
blocksize = ff_flac_blocksize_table[1];
target = (samplerate * block_time_ms) / 1000;
for (i = 0; i < 16; i++) {
s->avctx = avctx;
- if (avctx->sample_fmt != AV_SAMPLE_FMT_S16)
- return -1;
+ switch (avctx->sample_fmt) {
+ case AV_SAMPLE_FMT_S16:
+ avctx->bits_per_raw_sample = 16;
+ s->bps_code = 4;
+ break;
+ case AV_SAMPLE_FMT_S32:
+ if (avctx->bits_per_raw_sample != 24)
+ av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");
+ avctx->bits_per_raw_sample = 24;
+ s->bps_code = 6;
+ break;
+ }
if (channels < 1 || channels > FLAC_MAX_CHANNELS)
return -1;
/* set maximum encoded frame size in verbatim mode */
s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,
- s->channels, 16);
+ s->channels,
+ s->avctx->bits_per_raw_sample);
/* initialize MD5 context */
s->md5ctx = av_md5_alloc();
return AVERROR(ENOMEM);
#endif
+ if (channels == 3 &&
+ avctx->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) ||
+ channels == 4 &&
+ avctx->channel_layout != AV_CH_LAYOUT_2_2 &&
+ avctx->channel_layout != AV_CH_LAYOUT_QUAD ||
+ channels == 5 &&
+ avctx->channel_layout != AV_CH_LAYOUT_5POINT0 &&
+ avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK ||
+ channels == 6 &&
+ avctx->channel_layout != AV_CH_LAYOUT_5POINT1 &&
+ avctx->channel_layout != AV_CH_LAYOUT_5POINT1_BACK) {
+ if (avctx->channel_layout) {
+ av_log(avctx, AV_LOG_ERROR, "Channel layout not supported by Flac, "
+ "output stream will have incorrect "
+ "channel layout.\n");
+ } else {
+ av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
+ "will use Flac channel layout for "
+ "%d channels.\n", channels);
+ }
+ }
+
ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,
s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);
ff_dsputil_init(&s->dsp, avctx);
- ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt, 16);
+ ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt,
+ avctx->bits_per_raw_sample);
dprint_compression_options(s);
}
for (ch = 0; ch < s->channels; ch++) {
- frame->subframes[ch].wasted = 0;
- frame->subframes[ch].obits = 16;
+ FlacSubframe *sub = &frame->subframes[ch];
+
+ sub->wasted = 0;
+ sub->obits = s->avctx->bits_per_raw_sample;
+
+ if (sub->obits > 16)
+ sub->rc.coding_mode = CODING_MODE_RICE2;
+ else
+ sub->rc.coding_mode = CODING_MODE_RICE;
}
frame->verbatim_only = 0;
/**
* Copy channel-interleaved input samples into separate subframes.
*/
-static void copy_samples(FlacEncodeContext *s, const int16_t *samples)
+static void copy_samples(FlacEncodeContext *s, const void *samples)
{
int i, j, ch;
FlacFrame *frame;
-
- frame = &s->frame;
- for (i = 0, j = 0; i < frame->blocksize; i++)
- for (ch = 0; ch < s->channels; ch++, j++)
- frame->subframes[ch].samples[i] = samples[j];
+ int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -
+ s->avctx->bits_per_raw_sample;
+
+#define COPY_SAMPLES(bits) do { \
+ const int ## bits ## _t *samples0 = samples; \
+ frame = &s->frame; \
+ for (i = 0, j = 0; i < frame->blocksize; i++) \
+ for (ch = 0; ch < s->channels; ch++, j++) \
+ frame->subframes[ch].samples[i] = samples0[j] >> shift; \
+} while (0)
+
+ if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16)
+ COPY_SAMPLES(16);
+ else
+ COPY_SAMPLES(32);
}
part_end = psize;
for (p = 0; p < 1 << porder; p++) {
int k = sub->rc.params[p];
- count += 4;
+ count += sub->rc.coding_mode;
count += rice_count_exact(&sub->residual[i], part_end - i, k);
i = part_end;
part_end = FFMIN(s->frame.blocksize, part_end + psize);
/**
* Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
*/
-static int find_optimal_param(uint64_t sum, int n)
+static int find_optimal_param(uint64_t sum, int n, int max_param)
{
int k;
uint64_t sum2;
return 0;
sum2 = sum - (n >> 1);
k = av_log2(av_clipl_int32(sum2 / n));
- return FFMIN(k, MAX_RICE_PARAM);
+ return FFMIN(k, max_param);
}
uint64_t *sums, int n, int pred_order)
{
int i;
- int k, cnt, part;
+ int k, cnt, part, max_param;
uint64_t all_bits;
+ max_param = (1 << rc->coding_mode) - 2;
+
part = (1 << porder);
all_bits = 4 * part;
cnt = (n >> porder) - pred_order;
for (i = 0; i < part; i++) {
- k = find_optimal_param(sums[i], cnt);
+ k = find_optimal_param(sums[i], cnt, max_param);
rc->params[i] = k;
all_bits += rice_encode_count(sums[i], cnt, k);
cnt = n >> porder;
uint32_t *udata;
uint64_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
- assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
- assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
- assert(pmin <= pmax);
+ av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
+ av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
+ av_assert1(pmin <= pmax);
+
+ tmp_rc.coding_mode = rc->coding_mode;
udata = av_malloc(n * sizeof(uint32_t));
for (i = 0; i < n; i++)
int pmax = get_max_p_order(s->options.max_partition_order,
s->frame.blocksize, pred_order);
- uint64_t bits = 8 + pred_order * sub->obits + 2 + 4;
+ uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode;
if (sub->type == FLAC_SUBFRAME_LPC)
bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
bits += calc_rice_params(&sub->rc, pmin, pmax, sub->residual,
sub->wasted = v;
sub->obits -= v;
+
+ /* for 24-bit, check if removing wasted bits makes the range better
+ suited for using RICE instead of RICE2 for entropy coding */
+ if (sub->obits <= 17)
+ sub->rc.coding_mode = CODING_MODE_RICE;
}
}
}
-static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
+static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n,
+ int max_rice_param)
{
int i, best;
int32_t lt, rt;
}
/* estimate bit counts */
for (i = 0; i < 4; i++) {
- k = find_optimal_param(2 * sum[i], n);
+ k = find_optimal_param(2 * sum[i], n, max_rice_param);
sum[i] = rice_encode_count( 2 * sum[i], n, k);
}
return;
}
- if (s->options.ch_mode < 0)
- frame->ch_mode = estimate_stereo_mode(left, right, n);
- else
+ if (s->options.ch_mode < 0) {
+ int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2;
+ frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param);
+ } else
frame->ch_mode = s->options.ch_mode;
/* perform decorrelation and adjust bits-per-sample */
else
put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1);
- put_bits(&s->pb, 3, 4); /* bits-per-sample code */
+ put_bits(&s->pb, 3, s->bps_code);
put_bits(&s->pb, 1, 0);
write_utf8(&s->pb, s->frame_count);
}
/* rice-encoded block */
- put_bits(&s->pb, 2, 0);
+ put_bits(&s->pb, 2, sub->rc.coding_mode - 4);
/* partition order */
porder = sub->rc.porder;
part_end = &sub->residual[psize];
for (p = 0; p < 1 << porder; p++) {
int k = sub->rc.params[p];
- put_bits(&s->pb, 4, k);
+ put_bits(&s->pb, sub->rc.coding_mode, k);
while (res < part_end)
set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0);
part_end = FFMIN(frame_end, part_end + psize);
}
-static int update_md5_sum(FlacEncodeContext *s, const int16_t *samples)
+static int update_md5_sum(FlacEncodeContext *s, const void *samples)
{
const uint8_t *buf;
- int buf_size = s->frame.blocksize * s->channels * 2;
+ int buf_size = s->frame.blocksize * s->channels *
+ ((s->avctx->bits_per_raw_sample + 7) / 8);
- if (HAVE_BIGENDIAN) {
+ if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {
av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size);
if (!s->md5_buffer)
return AVERROR(ENOMEM);
}
- buf = (const uint8_t *)samples;
+ if (s->avctx->bits_per_raw_sample <= 16) {
+ buf = (const uint8_t *)samples;
#if HAVE_BIGENDIAN
- s->dsp.bswap16_buf((uint16_t *)s->md5_buffer,
- (const uint16_t *)samples, buf_size / 2);
- buf = s->md5_buffer;
+ s->dsp.bswap16_buf((uint16_t *)s->md5_buffer,
+ (const uint16_t *)samples, buf_size / 2);
+ buf = s->md5_buffer;
#endif
+ } else {
+ int i;
+ const int32_t *samples0 = samples;
+ uint8_t *tmp = s->md5_buffer;
+
+ for (i = 0; i < s->frame.blocksize * s->channels; i++) {
+ int32_t v = samples0[i] >> 8;
+ *tmp++ = (v ) & 0xFF;
+ *tmp++ = (v >> 8) & 0xFF;
+ *tmp++ = (v >> 16) & 0xFF;
+ }
+ buf = s->md5_buffer;
+ }
av_md5_update(s->md5ctx, buf, buf_size);
return 0;
const AVFrame *frame, int *got_packet_ptr)
{
FlacEncodeContext *s;
- const int16_t *samples;
int frame_bytes, out_bytes, ret;
s = avctx->priv_data;
write_streaminfo(s, avctx->extradata);
return 0;
}
- samples = (const int16_t *)frame->data[0];
/* change max_framesize for small final frame */
if (frame->nb_samples < s->frame.blocksize) {
s->max_framesize = ff_flac_get_max_frame_size(frame->nb_samples,
- s->channels, 16);
+ s->channels,
+ avctx->bits_per_raw_sample);
}
init_frame(s, frame->nb_samples);
- copy_samples(s, samples);
+ copy_samples(s, frame->data[0]);
channel_decorrelation(s);
}
}
- if ((ret = ff_alloc_packet(avpkt, frame_bytes))) {
- av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
+ if ((ret = ff_alloc_packet2(avctx, avpkt, frame_bytes)))
return ret;
- }
out_bytes = write_frame(s, avpkt);
s->frame_count++;
s->sample_count += frame->nb_samples;
- if ((ret = update_md5_sum(s, samples)) < 0) {
+ if ((ret = update_md5_sum(s, frame->data[0])) < 0) {
av_log(avctx, AV_LOG_ERROR, "Error updating MD5 checksum\n");
return ret;
}
.init = flac_encode_init,
.encode2 = flac_encode_frame,
.close = flac_encode_close,
- .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
+ .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_LOSSLESS,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+ AV_SAMPLE_FMT_S32,
AV_SAMPLE_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
.priv_class = &flac_encoder_class,
projects / ffmpeg / blobdiff