Go to the documentation of this file.
40 #define FLAC_SUBFRAME_CONSTANT 0
41 #define FLAC_SUBFRAME_VERBATIM 1
42 #define FLAC_SUBFRAME_FIXED 8
43 #define FLAC_SUBFRAME_LPC 32
45 #define MAX_FIXED_ORDER 4
46 #define MAX_PARTITION_ORDER 8
47 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
48 #define MAX_LPC_PRECISION 15
49 #define MIN_LPC_SHIFT 0
50 #define MAX_LPC_SHIFT 15
151 put_bits(&pb, 5,
s->avctx->bits_per_raw_sample - 1);
153 put_bits(&pb, 24, (
s->sample_count & 0xFFFFFF000LL) >> 12);
154 put_bits(&pb, 12,
s->sample_count & 0x000000FFFLL);
156 memcpy(&
header[18],
s->md5sum, 16);
172 target = (samplerate * block_time_ms) / 1000;
173 for (
i = 0;
i < 16;
i++) {
198 av_log(avctx,
AV_LOG_DEBUG,
" lpc type: Levinson-Durbin recursion with Welch window\n");
274 for (
i = 4;
i < 12;
i++) {
284 if (freq % 1000 == 0 && freq < 255000) {
286 s->sr_code[1] = freq / 1000;
287 }
else if (freq % 10 == 0 && freq < 655350) {
289 s->sr_code[1] = freq / 10;
290 }
else if (freq < 65535) {
292 s->sr_code[1] = freq;
297 s->samplerate = freq;
302 s->options.compression_level = 5;
306 level =
s->options.compression_level;
309 s->options.compression_level);
313 s->options.block_time_ms = ((
int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[
level];
322 if (
s->options.min_prediction_order < 0)
323 s->options.min_prediction_order = ((
int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[
level];
324 if (
s->options.max_prediction_order < 0)
325 s->options.max_prediction_order = ((
int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[
level];
327 if (
s->options.prediction_order_method < 0)
334 if (
s->options.min_partition_order >
s->options.max_partition_order) {
336 s->options.min_partition_order,
s->options.max_partition_order);
339 if (
s->options.min_partition_order < 0)
340 s->options.min_partition_order = ((
int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[
level];
341 if (
s->options.max_partition_order < 0)
342 s->options.max_partition_order = ((
int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[
level];
345 s->options.min_prediction_order = 0;
346 s->options.max_prediction_order = 0;
350 "invalid min prediction order %d, clamped to %d\n",
356 "invalid max prediction order %d, clamped to %d\n",
362 if (
s->options.max_prediction_order <
s->options.min_prediction_order) {
364 s->options.min_prediction_order,
s->options.max_prediction_order);
378 s->max_blocksize =
s->avctx->frame_size;
383 s->avctx->bits_per_raw_sample);
399 s->min_framesize =
s->max_framesize;
414 "output stream will have incorrect "
415 "channel layout.\n");
418 "will use Flac channel layout for "
443 for (
i = 0;
i < 16;
i++) {
447 frame->bs_code[1] = 0;
452 frame->blocksize = nb_samples;
453 if (
frame->blocksize <= 256) {
454 frame->bs_code[0] = 6;
457 frame->bs_code[0] = 7;
462 for (ch = 0; ch <
s->channels; ch++) {
466 sub->obits =
s->avctx->bits_per_raw_sample;
474 frame->verbatim_only = 0;
486 s->avctx->bits_per_raw_sample;
488 #define COPY_SAMPLES(bits) do { \
489 const int ## bits ## _t *samples0 = samples; \
491 for (i = 0, j = 0; i < frame->blocksize; i++) \
492 for (ch = 0; ch < s->channels; ch++, j++) \
493 frame->subframes[ch].samples[i] = samples0[j] >> shift; \
508 for (
i = 0;
i < n;
i++) {
511 count += (v >> k) + 1 + k;
520 int p, porder, psize;
528 count +=
sub->wasted;
534 count +=
s->frame.blocksize *
sub->obits;
537 count += pred_order *
sub->obits;
541 count += 4 + 5 + pred_order *
s->options.lpc_coeff_precision;
547 porder =
sub->rc.porder;
548 psize =
s->frame.blocksize >> porder;
554 for (p = 0; p < 1 << porder; p++) {
555 int k =
sub->rc.params[p];
556 count +=
sub->rc.coding_mode;
559 part_end =
FFMIN(
s->frame.blocksize, part_end + psize);
567 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
579 sum2 = sum - (n >> 1);
581 return FFMIN(k, max_param);
587 int64_t bestbits = INT64_MAX;
590 for (k = 0; k <= max_param; k++) {
591 int64_t
bits = sums[k][
i];
592 if (
bits < bestbits) {
603 int n,
int pred_order,
int max_param,
int exact)
609 part = (1 << porder);
612 cnt = (n >> porder) - pred_order;
613 for (
i = 0;
i < part;
i++) {
616 all_bits += sums[k][
i];
636 const uint32_t *res, *res_end;
641 for (k = 0; k <= kmax; k++) {
642 res = &
data[pred_order];
643 res_end = &
data[n >> pmax];
644 for (
i = 0;
i < parts;
i++) {
646 uint64_t sum = (1LL + k) * (res_end - res);
647 while (res < res_end)
648 sum += *(res++) >> k;
652 while (res < res_end)
656 res_end += n >> pmax;
664 int parts = (1 <<
level);
665 for (
i = 0;
i < parts;
i++) {
666 for (k=0; k<=kmax; k++)
667 sums[k][
i] = sums[k][2*
i] + sums[k][2*
i+1];
675 const int32_t *
data,
int n,
int pred_order,
int exact)
689 for (
i = 0;
i < n;
i++)
692 calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums);
695 bits[pmin] = UINT32_MAX;
698 if (
bits[
i] <
bits[opt_porder] || pmax == pmin) {
707 return bits[opt_porder];
724 s->frame.blocksize, pred_order);
726 s->frame.blocksize, pred_order);
728 uint64_t
bits = 8 + pred_order *
sub->obits + 2 +
sub->rc.coding_mode;
730 bits += 4 + 5 + pred_order *
s->options.lpc_coeff_precision;
732 s->frame.blocksize, pred_order,
s->options.exact_rice_parameters);
742 for (
i = 0;
i < order;
i++)
746 for (
i = order;
i < n;
i++)
748 }
else if (order == 1) {
749 for (
i = order;
i < n;
i++)
750 res[
i] = smp[
i] - smp[
i-1];
751 }
else if (order == 2) {
752 int a = smp[order-1] - smp[order-2];
753 for (
i = order;
i < n;
i += 2) {
754 int b = smp[
i ] - smp[
i-1];
756 a = smp[
i+1] - smp[
i ];
759 }
else if (order == 3) {
760 int a = smp[order-1] - smp[order-2];
761 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
762 for (
i = order;
i < n;
i += 2) {
763 int b = smp[
i ] - smp[
i-1];
766 a = smp[
i+1] - smp[
i ];
771 int a = smp[order-1] - smp[order-2];
772 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
773 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
774 for (
i = order;
i < n;
i += 2) {
775 int b = smp[
i ] - smp[
i-1];
779 a = smp[
i+1] - smp[
i ];
791 int min_order, max_order, opt_order, omethod;
802 n =
frame->blocksize;
805 for (
i = 1;
i < n;
i++)
815 if (
frame->verbatim_only || n < 5) {
817 memcpy(res, smp, n *
sizeof(
int32_t));
821 min_order =
s->options.min_prediction_order;
822 max_order =
s->options.max_prediction_order;
823 omethod =
s->options.prediction_order_method;
833 bits[0] = UINT32_MAX;
834 for (
i = min_order;
i <= max_order;
i++) {
840 sub->order = opt_order;
842 if (
sub->order != max_order) {
852 s->options.lpc_coeff_precision, coefs,
shift,
s->options.lpc_type,
853 s->options.lpc_passes, omethod,
859 int levels = 1 << omethod;
862 int opt_index = levels-1;
863 opt_order = max_order-1;
864 bits[opt_index] = UINT32_MAX;
865 for (
i = levels-1;
i >= 0;
i--) {
866 int last_order = order;
867 order = min_order + (((max_order-min_order+1) * (
i+1)) / levels)-1;
868 order =
av_clip(order, min_order - 1, max_order - 1);
869 if (order == last_order)
871 if (
s->bps_code * 4 +
s->options.lpc_coeff_precision +
av_log2(order) <= 32) {
872 s->flac_dsp.lpc16_encode(res, smp, n, order+1, coefs[order],
875 s->flac_dsp.lpc32_encode(res, smp, n, order+1, coefs[order],
889 bits[0] = UINT32_MAX;
890 for (
i = min_order-1;
i < max_order;
i++) {
891 if (
s->bps_code * 4 +
s->options.lpc_coeff_precision +
av_log2(
i) <= 32) {
892 s->flac_dsp.lpc16_encode(res, smp, n,
i+1, coefs[
i],
shift[
i]);
894 s->flac_dsp.lpc32_encode(res, smp, n,
i+1, coefs[
i],
shift[
i]);
905 opt_order = min_order - 1 + (max_order-min_order)/3;
909 int last = opt_order;
911 if (i < min_order-1 || i >= max_order ||
bits[
i] < UINT32_MAX)
913 if (
s->bps_code * 4 +
s->options.lpc_coeff_precision +
av_log2(
i) <= 32) {
914 s->flac_dsp.lpc32_encode(res, smp, n,
i+1, coefs[
i],
shift[
i]);
916 s->flac_dsp.lpc16_encode(res, smp, n,
i+1, coefs[
i],
shift[
i]);
926 if (
s->options.multi_dim_quant) {
928 int i,
step, improved;
929 int64_t best_score = INT64_MAX;
932 qmax = (1 << (
s->options.lpc_coeff_precision - 1)) - 1;
934 for (
i=0;
i<opt_order;
i++)
945 for (
i=0;
i<opt_order;
i++) {
946 int diff = ((
tmp + 1) % 3) - 1;
947 lpc_try[
i] =
av_clip(coefs[opt_order - 1][
i] +
diff, -qmax, qmax);
954 if (
s->bps_code * 4 +
s->options.lpc_coeff_precision +
av_log2(opt_order - 1) <= 32) {
955 s->flac_dsp.lpc16_encode(res, smp, n, opt_order, lpc_try,
shift[opt_order-1]);
957 s->flac_dsp.lpc32_encode(res, smp, n, opt_order, lpc_try,
shift[opt_order-1]);
960 if (score < best_score) {
962 memcpy(coefs[opt_order-1], lpc_try,
sizeof(*coefs));
969 sub->order = opt_order;
970 sub->type_code =
sub->type | (
sub->order-1);
972 for (
i = 0;
i <
sub->order;
i++)
973 sub->coefs[
i] = coefs[
sub->order-1][
i];
975 if (
s->bps_code * 4 +
s->options.lpc_coeff_precision +
av_log2(opt_order) <= 32) {
976 s->flac_dsp.lpc16_encode(res, smp, n,
sub->order,
sub->coefs,
sub->shift);
978 s->flac_dsp.lpc32_encode(res, smp, n,
sub->order,
sub->coefs,
sub->shift);
1008 if (
s->frame.bs_code[0] == 6)
1010 else if (
s->frame.bs_code[0] == 7)
1014 count += ((
s->sr_code[0] == 12) + (
s->sr_code[0] > 12) * 2) * 8;
1030 for (ch = 0; ch <
s->channels; ch++)
1033 count += (8 - (count & 7)) & 7;
1037 if (count > INT_MAX)
1047 for (ch = 0; ch <
s->channels; ch++) {
1051 for (
i = 0;
i <
s->frame.blocksize;
i++) {
1052 v |=
sub->samples[
i];
1057 if (v && !(v & 1)) {
1060 for (
i = 0;
i <
s->frame.blocksize;
i++)
1061 sub->samples[
i] >>= v;
1068 if (
sub->obits <= 17)
1085 sum[0] = sum[1] = sum[2] = sum[3] = 0;
1086 for (
i = 2;
i < n;
i++) {
1087 lt = left_ch[
i] - 2*left_ch[
i-1] + left_ch[
i-2];
1088 rt = right_ch[
i] - 2*right_ch[
i-1] + right_ch[
i-2];
1089 sum[2] +=
FFABS((lt + rt) >> 1);
1090 sum[3] +=
FFABS(lt - rt);
1091 sum[0] +=
FFABS(lt);
1092 sum[1] +=
FFABS(rt);
1095 for (
i = 0;
i < 4;
i++) {
1101 score[0] = sum[0] + sum[1];
1102 score[1] = sum[0] + sum[3];
1103 score[2] = sum[1] + sum[3];
1104 score[3] = sum[2] + sum[3];
1108 for (
i = 1;
i < 4;
i++)
1109 if (score[
i] < score[best])
1126 n =
frame->blocksize;
1128 right =
frame->subframes[1].samples;
1130 if (
s->channels != 2) {
1135 if (
s->options.ch_mode < 0) {
1136 int max_rice_param = (1 <<
frame->subframes[0].rc.coding_mode) - 2;
1139 frame->ch_mode =
s->options.ch_mode;
1146 for (
i = 0;
i < n;
i++) {
1149 right[
i] =
tmp - right[
i];
1151 frame->subframes[1].obits++;
1153 for (
i = 0;
i < n;
i++)
1154 right[
i] =
left[
i] - right[
i];
1155 frame->subframes[1].obits++;
1157 for (
i = 0;
i < n;
i++)
1159 frame->subframes[0].obits++;
1191 if (
frame->bs_code[0] == 6)
1193 else if (
frame->bs_code[0] == 7)
1196 if (
s->sr_code[0] == 12)
1198 else if (
s->sr_code[0] > 12)
1212 for (ch = 0; ch <
s->channels; ch++) {
1214 int i, p, porder, psize;
1234 for (
i = 0;
i <
sub->order;
i++)
1239 int cbits =
s->options.lpc_coeff_precision;
1242 for (
i = 0;
i <
sub->order;
i++)
1250 porder =
sub->rc.porder;
1251 psize =
s->frame.blocksize >> porder;
1255 part_end = &
sub->residual[psize];
1256 for (p = 0; p < 1 << porder; p++) {
1257 int k =
sub->rc.params[p];
1259 while (res < part_end)
1292 int buf_size =
s->frame.blocksize *
s->channels *
1293 ((
s->avctx->bits_per_raw_sample + 7) / 8);
1295 if (
s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {
1301 if (
s->avctx->bits_per_raw_sample <= 16) {
1302 buf = (
const uint8_t *)
samples;
1304 s->bdsp.bswap16_buf((uint16_t *)
s->md5_buffer,
1305 (
const uint16_t *)
samples, buf_size / 2);
1306 buf =
s->md5_buffer;
1311 uint8_t *
tmp =
s->md5_buffer;
1313 for (
i = 0;
i <
s->frame.blocksize *
s->channels;
i++) {
1317 buf =
s->md5_buffer;
1329 int frame_bytes, out_bytes,
ret;
1335 s->max_framesize =
s->max_encoded_framesize;
1346 avpkt->
pts =
s->next_pts;
1348 *got_packet_ptr = 1;
1356 if (
frame->nb_samples <
s->frame.blocksize) {
1374 if (frame_bytes < 0 || frame_bytes >
s->max_framesize) {
1375 s->frame.verbatim_only = 1;
1377 if (frame_bytes < 0) {
1389 s->sample_count +=
frame->nb_samples;
1394 if (out_bytes >
s->max_encoded_framesize)
1395 s->max_encoded_framesize = out_bytes;
1396 if (out_bytes < s->min_framesize)
1397 s->min_framesize = out_bytes;
1406 *got_packet_ptr = 1;
1421 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1424 {
"lpc_type",
"LPC algorithm", offsetof(
FlacEncodeContext,
options.lpc_type),
AV_OPT_TYPE_INT, {.i64 =
FF_LPC_TYPE_DEFAULT },
FF_LPC_TYPE_DEFAULT,
FF_LPC_TYPE_NB-1,
FLAGS,
"lpc_type" },
1432 {
"prediction_order_method",
"Search method for selecting prediction order", offsetof(
FlacEncodeContext,
options.prediction_order_method),
AV_OPT_TYPE_INT, {.i64 = -1 }, -1,
ORDER_METHOD_LOG,
FLAGS,
"predm" },
1439 {
"ch_mode",
"Stereo decorrelation mode", offsetof(
FlacEncodeContext,
options.ch_mode),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1,
FLAC_CHMODE_MID_SIDE,
FLAGS,
"ch_mode" },
int frame_size
Number of samples per channel in an audio frame.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define PUT_UTF8(val, tmp, PUT_BYTE)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
FFLPCType
LPC analysis type.
#define AV_CH_LAYOUT_5POINT0_BACK
int32_t samples[FLAC_MAX_BLOCKSIZE]
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static av_cold int flac_encode_init(AVCodecContext *avctx)
uint64_t channel_layout
Audio channel layout.
static int put_bytes_output(const PutBitContext *s)
int sample_rate
samples per second
static void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (flac).
int exact_rice_parameters
#define MAX_PARTITION_ORDER
static float sub(float src0, float src1)
static enum AVSampleFormat sample_fmts[]
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
This structure describes decoded (raw) audio or video data.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
@ FF_LPC_TYPE_CHOLESKY
Cholesky factorization.
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)
int prediction_order_method
static int select_blocksize(int samplerate, int block_time_ms)
Set blocksize based on samplerate.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
static uint64_t find_subframe_rice_params(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)
#define ORDER_METHOD_4LEVEL
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
static double val(void *priv, double ch)
#define AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_QUAD
@ FF_LPC_TYPE_DEFAULT
use the codec default LPC type
const int32_t ff_flac_blocksize_table[16]
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void write_subframes(FlacEncodeContext *s)
int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
Calculate an estimate for the maximum frame size based on verbatim mode.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static void remove_wasted_bits(FlacEncodeContext *s)
#define FLAC_SUBFRAME_LPC
#define COPY_SAMPLES(bits)
static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder, uint64_t sums[32][MAX_PARTITIONS], int n, int pred_order, int max_param, int exact)
#define FLAC_SUBFRAME_VERBATIM
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define FLAC_SUBFRAME_CONSTANT
const int ff_flac_sample_rate_table[16]
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
FlacSubframe subframes[FLAC_MAX_CHANNELS]
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
#define FLAC_SUBFRAME_FIXED
const char * av_default_item_name(void *ptr)
Return the context name.
#define AV_CH_LAYOUT_5POINT1
#define FLAC_STREAMINFO_SIZE
#define ORDER_METHOD_SEARCH
int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)
Calculate LPC coefficients for multiple orders.
#define AV_CH_FRONT_CENTER
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static uint64_t rice_count_exact(const int32_t *res, int n, int k)
int max_encoded_framesize
static int encode_residual_ch(FlacEncodeContext *s, int ch)
static int get_max_p_order(int max_porder, int n, int order)
#define ORDER_METHOD_8LEVEL
static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
unsigned int md5_buffer_size
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static void channel_decorrelation(FlacEncodeContext *s)
Perform stereo channel decorrelation.
@ FF_LPC_TYPE_NB
Not part of ABI.
enum AVSampleFormat sample_fmt
audio sample format
static int encode_frame(FlacEncodeContext *s)
static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order, uint64_t sums[32][MAX_PARTITIONS])
int32_t residual[FLAC_MAX_BLOCKSIZE+11]
CompressionOptions options
static const uint8_t header[24]
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
#define AV_CH_LAYOUT_5POINT1_BACK
static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)
static const AVOption options[]
int32_t coefs[MAX_LPC_ORDER]
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
int channels
number of audio channels
#define AV_CH_LAYOUT_5POINT0
static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static void write_utf8(PutBitContext *pb, uint32_t val)
static int count_frame_header(FlacEncodeContext *s)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
AVSampleFormat
Audio sample formats.
static void write_frame_header(FlacEncodeContext *s)
static void write_frame_footer(FlacEncodeContext *s)
@ AV_SAMPLE_FMT_S16
signed 16 bits
const char * name
Name of the codec implementation.
static void copy_samples(FlacEncodeContext *s, const void *samples)
Copy channel-interleaved input samples into separate subframes.
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n, int max_rice_param)
static uint64_t calc_rice_params(RiceContext *rc, uint32_t udata[FLAC_MAX_BLOCKSIZE], uint64_t sums[32][MAX_PARTITIONS], int pmin, int pmax, const int32_t *data, int n, int pred_order, int exact)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
const AVCodec ff_flac_encoder
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, int order)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
#define FLAC_MAX_CHANNELS
#define MAX_LPC_PRECISION
main external API structure.
uint64_t rc_sums[32][MAX_PARTITIONS]
uint32_t rc_udata[FLAC_MAX_BLOCKSIZE]
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)
static void frame_end(MpegEncContext *s)
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Filter the word “frame” indicates either a video frame or a group of audio samples
void av_md5_update(AVMD5 *ctx, const uint8_t *src, size_t len)
Update hash value.
static void init_frame(FlacEncodeContext *s, int nb_samples)
int params[MAX_PARTITIONS]
static int shift(int a, int b)
#define FLAC_MAX_BLOCKSIZE
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static av_always_inline int diff(const uint32_t a, const uint32_t b)
This structure stores compressed data.
enum CodingMode coding_mode
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static int find_optimal_param(uint64_t sum, int n, int max_param)
Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
static av_cold void dprint_compression_options(FlacEncodeContext *s)
static int update_md5_sum(FlacEncodeContext *s, const void *samples)
static av_cold int flac_encode_close(AVCodecContext *avctx)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static const AVClass flac_encoder_class
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
Write streaminfo metadata block to byte array.
#define ORDER_METHOD_2LEVEL
#define FLAC_MIN_BLOCKSIZE
@ FF_LPC_TYPE_NONE
do not use LPC prediction or use all zero coefficients
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
@ AV_SAMPLE_FMT_S32
signed 32 bits
@ FF_LPC_TYPE_LEVINSON
Levinson-Durbin recursion.
@ FLAC_CHMODE_INDEPENDENT
#define rice_encode_count(sum, n, k)
av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)
Initialize LPCContext.
@ FF_LPC_TYPE_FIXED
fixed LPC coefficients