http://blog.gmane.org/gmane.comp.video.libav.devel hourly 1 1901-01-01T00:00+00:00 http://gmane.org/img/gmane-25t.png http://gmane.org http://permalink.gmane.org/gmane.comp.video.libav.devel/46316 <pre>--- mostly as rfc/call for testing but it should be good enough anyway --- libavcodec/proresenc.c | 241 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 220 insertions(+), 21 deletions(-) diff --git a/libavcodec/proresenc.c b/libavcodec/proresenc.c index 5a8cea8..d989f8c 100644 --- a/libavcodec/proresenc.c +++ b/libavcodec/proresenc.c &lt; at &gt;&lt; at &gt; -21,6 +21,7 &lt; at &gt;&lt; at &gt; */ #include "libavutil/opt.h" +#include "libavutil/pixdesc.h" #include "avcodec.h" #include "dsputil.h" #include "put_bits.h" &lt; at &gt;&lt; at &gt; -34,13 +35,14 &lt; at &gt;&lt; at &gt; #define MAX_MBS_PER_SLICE 8 -#define MAX_PLANES 3 // should be increased to 4 when there's AV_PIX_FMT_YUV444AP10 +#define MAX_PLANES 4 enum { PRORES_PROFILE_PROXY = 0, PRORES_PROFILE_LT, PRORES_PROFILE_STANDARD, PRORES_PROFILE_HQ, + PRORES_PROFILE_4444, }; enum { &lt; at &gt;&lt; at &gt; -119,7 +121,7 &lt; at &gt;&lt; at &gt; static const struct prores_profile { int max_quant; int br_tab[NUM_MB_LIMITS]; int quant; -} prores_profile_info[4] = { +} prores_profile_info[5] = { { .full_name = "proxy", .tag = MKTAG('a', 'p', 'c', 'o'), &lt; at &gt;&lt; at &gt; -151,8 +153,15 &lt; at &gt;&lt; at &gt; static const struct prores_profile { .max_quant = 6, .br_tab = { 1566, 1216, 1070, 950 }, .quant = QUANT_MAT_HQ, + }, + { + .full_name = "4444", + .tag = MKTAG('a', 'p', '4', 'h'), + .min_quant = 1, + .max_quant = 6, + .br_tab = { 2350, 1828, 1600, 1425 }, + .quant = QUANT_MAT_HQ, } -// for 4444 profile bitrate numbers are { 2350, 1828, 1600, 1425 } }; #define TRELLIS_WIDTH 16 &lt; at &gt;&lt; at &gt; -195,6 +204,7 &lt; at &gt;&lt; at &gt; typedef struct ProresContext { int num_planes; int bits_per_mb; int force_quant; + int alpha_bits; char *vendor; int quant_sel; &lt; at &gt;&lt; at &gt; -280,6 +290,34 &lt; at &gt;&lt; at &gt; static void get_slice_data(ProresContext *ctx, const uint16_t *src, } } +static void get_alpha_data(ProresContext *ctx, const uint16_t *src, + int linesize, int x, int y, int w, int h, + int16_t *blocks, int mbs_per_slice, int abits) +{ + const int slice_width = 16 * mbs_per_slice; + int i, j, copy_w, copy_h; + + copy_w = FFMIN(w - x, slice_width); + copy_h = FFMIN(h - y, 16); + for (i = 0; i &lt; copy_h; i++) { + memcpy(blocks, src, copy_w * sizeof(*src)); + if (abits == 8) + for (j = 0; j &lt; copy_w; j++) + blocks[j] &gt;&gt;= 2; + else + for (j = 0; j &lt; copy_w; j++) + blocks[j] = (blocks[j] &lt;&lt; 6) | (blocks[j] &gt;&gt; 4); + for (j = copy_w; j &lt; slice_width; j++) + blocks[j] = blocks[copy_w - 1]; + blocks += slice_width; + src += linesize &gt;&gt; 1; + } + for (; i &lt; 16; i++) { + memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks)); + blocks += slice_width; + } +} + /** * Write an unsigned rice/exp golomb codeword. */ &lt; at &gt;&lt; at &gt; -394,6 +432,73 &lt; at &gt;&lt; at &gt; static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb, return (put_bits_count(pb) - saved_pos) &gt;&gt; 3; } +static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits) +{ + const int mask = (1 &lt;&lt; abits) - 1; + const int dbits = (abits == 8) ? 4 : 7; + const int dsize = 1 &lt;&lt; dbits - 1; + int diff = cur - prev; + + diff &amp;= mask; + if (diff &gt;= (1 &lt;&lt; abits) - dsize) + diff -= 1 &lt;&lt; abits; + if (diff &lt; -dsize || diff &gt; dsize || !diff) { + put_bits(pb, 1, 1); + put_bits(pb, abits, diff); + } else { + put_bits(pb, 1, 0); + put_bits(pb, dbits - 1, FFABS(diff) - 1); + put_bits(pb, 1, diff &lt; 0); + } +} + +static void put_alpha_run(PutBitContext *pb, int run) +{ + if (run) { + put_bits(pb, 1, 0); + if (run &lt; 0x10) + put_bits(pb, 4, run); + else + put_bits(pb, 15, run); + } else { + put_bits(pb, 1, 1); + } +} + +// todo alpha quantisation for high quants +static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, + const uint16_t *src, int linesize, + int mbs_per_slice, uint16_t *blocks, + int quant) +{ + const int abits = ctx-&gt;alpha_bits; + const int mask = (1 &lt;&lt; abits) - 1; + const int num_coeffs = mbs_per_slice * 256; + int saved_pos = put_bits_count(pb); + int prev = mask, cur; + int idx = 0; + int run = 0; + + cur = blocks[idx++]; + put_alpha_diff(pb, cur, prev, abits); + prev = cur; + do { + cur = blocks[idx++]; + if (cur != prev) { + put_alpha_run (pb, run); + put_alpha_diff(pb, cur, prev, abits); + prev = cur; + run = 0; + } else { + run++; + } + } while (idx &lt; num_coeffs); + if (run) + put_alpha_run(pb, run); + flush_put_bits(pb); + return (put_bits_count(pb) - saved_pos) &gt;&gt; 3; +} + static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, &lt; at &gt;&lt; at &gt; -444,14 +549,23 &lt; at &gt;&lt; at &gt; static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, src = (const uint16_t*)(pic-&gt;data[i] + yp * linesize + line_add * pic-&gt;linesize[i]) + xp; - get_slice_data(ctx, src, linesize, xp, yp, - pwidth, avctx-&gt;height / ctx-&gt;pictures_per_frame, - ctx-&gt;blocks[0], ctx-&gt;emu_buf, - mbs_per_slice, num_cblocks, is_chroma); - sizes[i] = encode_slice_plane(ctx, pb, src, linesize, - mbs_per_slice, ctx-&gt;blocks[0], - num_cblocks, plane_factor, - qmat); + if (i &lt; 3) { + get_slice_data(ctx, src, linesize, xp, yp, + pwidth, avctx-&gt;height / ctx-&gt;pictures_per_frame, + ctx-&gt;blocks[0], ctx-&gt;emu_buf, + mbs_per_slice, num_cblocks, is_chroma); + sizes[i] = encode_slice_plane(ctx, pb, src, linesize, + mbs_per_slice, ctx-&gt;blocks[0], + num_cblocks, plane_factor, + qmat); + } else { + get_alpha_data(ctx, src, linesize, xp, yp, + pwidth, avctx-&gt;height / ctx-&gt;pictures_per_frame, + ctx-&gt;blocks[0], mbs_per_slice, ctx-&gt;alpha_bits); + sizes[i] = encode_alpha_plane(ctx, pb, src, linesize, + mbs_per_slice, ctx-&gt;blocks[0], + quant); + } total_size += sizes[i]; } return total_size; &lt; at &gt;&lt; at &gt; -564,6 +678,66 &lt; at &gt;&lt; at &gt; static int estimate_slice_plane(ProresContext *ctx, int *error, int plane, return FFALIGN(bits, 8); } +static int est_alpha_diff(int cur, int prev, int abits) +{ + const int mask = (1 &lt;&lt; abits) - 1; + const int dbits = (abits == 8) ? 4 : 7; + const int dsize = 1 &lt;&lt; dbits - 1; + int diff = cur - prev; + + diff &amp;= mask; + if (diff &gt;= (1 &lt;&lt; abits) - dsize) + diff -= 1 &lt;&lt; abits; + if (diff &lt; -dsize || diff &gt; dsize || !diff) + return abits + 1; + else + return dbits + 1; +} + +static int estimate_alpha_plane(ProresContext *ctx, int *error, + const uint16_t *src, int linesize, + int mbs_per_slice, int quant, + int16_t *blocks) +{ + const int abits = ctx-&gt;alpha_bits; + const int mask = (1 &lt;&lt; abits) - 1; + const int num_coeffs = mbs_per_slice * 256; + int prev = mask, cur; + int idx = 0; + int run = 0; + int bits; + + *error = 0; + cur = blocks[idx++]; + bits = est_alpha_diff(cur, prev, abits); + prev = cur; + do { + cur = blocks[idx++]; + if (cur != prev) { + if (!run) + bits++; + else if (run &lt; 0x10) + bits += 4; + else + bits += 15; + bits += est_alpha_diff(cur, prev, abits); + prev = cur; + run = 0; + } else { + run++; + } + } while (idx &lt; num_coeffs); + + if (run) { + if (run &lt; 0x10) + bits += 4; + else + bits += 15; + } + + return bits; +} + static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td) &lt; at &gt;&lt; at &gt; -610,10 +784,16 &lt; at &gt;&lt; at &gt; static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic, src = (const uint16_t*)(pic-&gt;data[i] + yp * linesize[i] + line_add * pic-&gt;linesize[i]) + xp; - get_slice_data(ctx, src, linesize[i], xp, yp, - pwidth, avctx-&gt;height / ctx-&gt;pictures_per_frame, - td-&gt;blocks[i], td-&gt;emu_buf, - mbs_per_slice, num_cblocks[i], is_chroma[i]); + if (i &lt; 3) { + get_slice_data(ctx, src, linesize[i], xp, yp, + pwidth, avctx-&gt;height / ctx-&gt;pictures_per_frame, + td-&gt;blocks[i], td-&gt;emu_buf, + mbs_per_slice, num_cblocks[i], is_chroma[i]); + } else { + get_alpha_data(ctx, src, linesize[i], xp, yp, + pwidth, avctx-&gt;height / ctx-&gt;pictures_per_frame, + td-&gt;blocks[i], mbs_per_slice, ctx-&gt;alpha_bits); + } } for (q = min_quant; q &lt; max_quant + 2; q++) { &lt; at &gt;&lt; at &gt; -625,13 +805,16 &lt; at &gt;&lt; at &gt; static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic, for (q = min_quant; q &lt;= max_quant; q++) { bits = 0; error = 0; - for (i = 0; i &lt; ctx-&gt;num_planes; i++) { + for (i = 0; i &lt; ctx-&gt;num_planes - !!ctx-&gt;alpha_bits; i++) { bits += estimate_slice_plane(ctx, &amp;error, i, src, linesize[i], mbs_per_slice, num_cblocks[i], plane_factor[i], ctx-&gt;quants[q], td); } + if (ctx-&gt;alpha_bits) + bits += estimate_alpha_plane(ctx, &amp;error, src, linesize[3], + mbs_per_slice, q, td-&gt;blocks[3]); if (bits &gt; 65000 * 8) { error = SCORE_LIMIT; break; &lt; at &gt;&lt; at &gt; -654,13 +837,16 &lt; at &gt;&lt; at &gt; static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic, for (i = 0; i &lt; 64; i++) qmat[i] = ctx-&gt;quant_mat[i] * q; } - for (i = 0; i &lt; ctx-&gt;num_planes; i++) { + for (i = 0; i &lt; ctx-&gt;num_planes - !!ctx-&gt;alpha_bits; i++) { bits += estimate_slice_plane(ctx, &amp;error, i, src, linesize[i], mbs_per_slice, num_cblocks[i], plane_factor[i], qmat, td); } + if (ctx-&gt;alpha_bits) + bits += estimate_alpha_plane(ctx, &amp;error, src, linesize[3], + mbs_per_slice, q, td-&gt;blocks[3]); if (bits &lt;= ctx-&gt;bits_per_mb * mbs_per_slice) break; } &lt; at &gt;&lt; at &gt; -782,7 +968,7 &lt; at &gt;&lt; at &gt; static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, bytestream_put_byte (&amp;buf, avctx-&gt;color_primaries); bytestream_put_byte (&amp;buf, avctx-&gt;color_trc); bytestream_put_byte (&amp;buf, avctx-&gt;colorspace); - bytestream_put_byte (&amp;buf, 0x40); // source format and alpha information + bytestream_put_byte (&amp;buf, 0x40 | (ctx-&gt;alpha_bits &gt;&gt; 3)); bytestream_put_byte (&amp;buf, 0); // reserved if (ctx-&gt;quant_sel != QUANT_MAT_DEFAULT) { bytestream_put_byte (&amp;buf, 0x03); // matrix flags - both matrices are present &lt; at &gt;&lt; at &gt; -904,12 +1090,20 &lt; at &gt;&lt; at &gt; static av_cold int encode_init(AVCodecContext *avctx) "there should be an integer power of two MBs per slice\n"); return AVERROR(EINVAL); } + if (av_pix_fmt_desc_get(avctx-&gt;pix_fmt)-&gt;flags &amp; AV_PIX_FMT_FLAG_ALPHA) { + if (ctx-&gt;alpha_bits &amp; 7) { + av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n"); + return AVERROR(EINVAL); + } + } else { + ctx-&gt;alpha_bits = 0; + } ctx-&gt;chroma_factor = avctx-&gt;pix_fmt == AV_PIX_FMT_YUV422P10 ? CFACTOR_Y422 : CFACTOR_Y444; ctx-&gt;profile_info = prores_profile_info + ctx-&gt;profile; - ctx-&gt;num_planes = 3; + ctx-&gt;num_planes = 3 + !!ctx-&gt;alpha_bits; ctx-&gt;mb_width = FFALIGN(avctx-&gt;width, 16) &gt;&gt; 4; &lt; at &gt;&lt; at &gt; -1025,7 +1219,7 &lt; at &gt;&lt; at &gt; static const AVOption options[] = { AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE }, { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = PRORES_PROFILE_STANDARD }, - PRORES_PROFILE_PROXY, PRORES_PROFILE_HQ, VE, "profile" }, + PRORES_PROFILE_PROXY, PRORES_PROFILE_4444, VE, "profile" }, { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY }, 0, 0, VE, "profile" }, { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT }, &lt; at &gt;&lt; at &gt; -1034,6 +1228,8 &lt; at &gt;&lt; at &gt; static const AVOption options[] = { 0, 0, VE, "profile" }, { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ }, 0, 0, VE, "profile" }, + { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 }, + 0, 0, VE, "profile" }, { "vendor", "vendor ID", OFFSET(vendor), AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE }, { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb), &lt; at &gt;&lt; at &gt; -1052,6 +1248,8 &lt; at &gt;&lt; at &gt; static const AVOption options[] = { 0, 0, VE, "quant_mat" }, { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT }, 0, 0, VE, "quant_mat" }, + { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT, + { .i64 = 16 }, 0, 16, VE }, { NULL } }; &lt; at &gt;&lt; at &gt; -1073,7 +1271,8 &lt; at &gt;&lt; at &gt; AVCodec ff_prores_encoder = { .capabilities = CODEC_CAP_SLICE_THREADS, .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"), .pix_fmts = (const enum AVPixelFormat[]) { - AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_NONE + AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, + AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE }, .priv_class = &amp;proresenc_class, }; </pre> Kostya Shishkov 2013-05-25T15:30:35 http://permalink.gmane.org/gmane.comp.video.libav.devel/46315 <pre> Checked it doesn't match icc on linux seems good to go to me. I'd push the set in a while if nobody is against. lu </pre> Luca Barbato 2013-05-25T14:39:28 http://permalink.gmane.org/gmane.comp.video.libav.devel/46314 <pre> Looks good to me - especially since it doesn't add anything weird outside of the icl sections it probably shouldn't hurt anything else either. // Martin </pre> Martin Storsjö 2013-05-25T14:32:12 http://permalink.gmane.org/gmane.comp.video.libav.devel/46313 <pre>Currently if no custom block VLC is specified for band, a default block VLC will be used, while the global block VLC stored in the context should be used instead. This fixes decoding of one sample I have. --- FATE tests are left to the people who like it. --- libavcodec/indeo4.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/libavcodec/indeo4.c b/libavcodec/indeo4.c index eb34688..7571435 100644 --- a/libavcodec/indeo4.c +++ b/libavcodec/indeo4.c &lt; at &gt;&lt; at &gt; -362,9 +362,12 &lt; at &gt;&lt; at &gt; static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band, } /* decode block huffman codebook */ - if (ff_ivi_dec_huff_desc(&amp;ctx-&gt;gb, get_bits1(&amp;ctx-&gt;gb), IVI_BLK_HUFF, - &amp;band-&gt;blk_vlc, avctx)) - return AVERROR_INVALIDDATA; + if (!get_bits1(&amp;ctx-&gt;gb)) + band-&gt;blk_vlc.tab = ctx-&gt;blk_vlc.tab; + else + if (ff_ivi_dec_huff_desc(&amp;ctx-&gt;gb, 1, IVI_BLK_HUFF, + &amp;band-&gt;blk_vlc, avctx)) + return AVERROR_INVALIDDATA; /* select appropriate rvmap table for this band */ band-&gt;rvmap_sel = get_bits1(&amp;ctx-&gt;gb) ? get_bits(&amp;ctx-&gt;gb, 3) : 8; </pre> Kostya Shishkov 2013-05-25T10:45:44 http://permalink.gmane.org/gmane.comp.video.libav.devel/46312 <pre>--- One of my samples uses 4x4 Haar transform, another one has 1D Haar transforms, so why not implement them all? --- libavcodec/indeo4.c | 14 ++-- libavcodec/ivi_dsp.c | 204 ++++++++++++++++++++++++++++++++++++++++++++++++-- libavcodec/ivi_dsp.h | 89 ++++++++++++++++++++++ 3 files changed, 294 insertions(+), 13 deletions(-) diff --git a/libavcodec/indeo4.c b/libavcodec/indeo4.c index 8820a2c..eb34688 100644 --- a/libavcodec/indeo4.c +++ b/libavcodec/indeo4.c &lt; at &gt;&lt; at &gt; -56,8 +56,8 &lt; at &gt;&lt; at &gt; static const struct { int is_2d_trans; } transforms[18] = { { ff_ivi_inverse_haar_8x8, ff_ivi_dc_haar_2d, 1 }, - { NULL, NULL, 0 }, /* inverse Haar 8x1 */ - { NULL, NULL, 0 }, /* inverse Haar 1x8 */ + { ff_ivi_row_haar8, ff_ivi_dc_haar_2d, 0 }, + { ff_ivi_col_haar8, ff_ivi_dc_haar_2d, 0 }, { ff_ivi_put_pixels_8x8, ff_ivi_put_dc_pixel_8x8, 1 }, { ff_ivi_inverse_slant_8x8, ff_ivi_dc_slant_2d, 1 }, { ff_ivi_row_slant8, ff_ivi_dc_row_slant, 1 }, &lt; at &gt;&lt; at &gt; -65,13 +65,13 &lt; at &gt;&lt; at &gt; static const struct { { NULL, NULL, 0 }, /* inverse DCT 8x8 */ { NULL, NULL, 0 }, /* inverse DCT 8x1 */ { NULL, NULL, 0 }, /* inverse DCT 1x8 */ - { NULL, NULL, 0 }, /* inverse Haar 4x4 */ + { ff_ivi_inverse_haar_4x4, ff_ivi_dc_haar_2d, 1 }, { ff_ivi_inverse_slant_4x4, ff_ivi_dc_slant_2d, 1 }, { NULL, NULL, 0 }, /* no transform 4x4 */ - { NULL, NULL, 0 }, /* inverse Haar 1x4 */ - { NULL, NULL, 0 }, /* inverse Haar 4x1 */ - { NULL, NULL, 0 }, /* inverse slant 1x4 */ - { NULL, NULL, 0 }, /* inverse slant 4x1 */ + { ff_ivi_row_haar4, ff_ivi_dc_haar_2d, 0 }, + { ff_ivi_col_haar4, ff_ivi_dc_haar_2d, 0 }, + { ff_ivi_row_slant4, ff_ivi_dc_row_slant, 0 }, + { ff_ivi_col_slant4, ff_ivi_dc_col_slant, 0 }, { NULL, NULL, 0 }, /* inverse DCT 4x4 */ }; diff --git a/libavcodec/ivi_dsp.c b/libavcodec/ivi_dsp.c index f5efa65..bd1f523 100644 --- a/libavcodec/ivi_dsp.c +++ b/libavcodec/ivi_dsp.c &lt; at &gt;&lt; at &gt; -248,12 +248,14 &lt; at &gt;&lt; at &gt; void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst, d8 = COMPENSATE(t8); } /** inverse 4-point Haar transform */ -#define INV_HAAR4(s1, s3, s5, s7) {\ - HAAR_BFLY(s1, s5); HAAR_BFLY(s1, s3); HAAR_BFLY(s5, s7);\ - s1 = COMPENSATE(s1);\ - s3 = COMPENSATE(s3);\ - s5 = COMPENSATE(s5);\ - s7 = COMPENSATE(s7); } +#define INV_HAAR4(s1, s3, s5, s7, d1, d2, d3, d4, t0, t1, t2, t3, t4) {\ + IVI_HAAR_BFLY(s1, s3, t0, t1, t4);\ + IVI_HAAR_BFLY(t0, s5, t2, t3, t4);\ + d1 = COMPENSATE(t2);\ + d2 = COMPENSATE(t3);\ + IVI_HAAR_BFLY(t1, s7, t2, t3, t4);\ + d3 = COMPENSATE(t2);\ + d4 = COMPENSATE(t3); } void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags) &lt; at &gt;&lt; at &gt; -310,6 +312,153 &lt; at &gt;&lt; at &gt; void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch, #undef COMPENSATE } +void ff_ivi_row_haar8(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags) +{ + int i; + int t0, t1, t2, t3, t4, t5, t6, t7, t8; + + /* apply the InvHaar8 to all rows */ +#define COMPENSATE(x) (x) + for (i = 0; i &lt; 8; i++) { + if ( !in[0] &amp;&amp; !in[1] &amp;&amp; !in[2] &amp;&amp; !in[3] + &amp;&amp; !in[4] &amp;&amp; !in[5] &amp;&amp; !in[6] &amp;&amp; !in[7]) { + memset(out, 0, 8 * sizeof(out[0])); + } else { + INV_HAAR8(in[0], in[1], in[2], in[3], + in[4], in[5], in[6], in[7], + out[0], out[1], out[2], out[3], + out[4], out[5], out[6], out[7], + t0, t1, t2, t3, t4, t5, t6, t7, t8); + } + in += 8; + out += pitch; + } +#undef COMPENSATE +} + +void ff_ivi_col_haar8(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags) +{ + int i; + int t0, t1, t2, t3, t4, t5, t6, t7, t8; + + /* apply the InvHaar8 to all columns */ +#define COMPENSATE(x) (x) + for (i = 0; i &lt; 8; i++) { + if (flags[i]) { + INV_HAAR8(in[ 0], in[ 8], in[16], in[24], + in[32], in[40], in[48], in[56], + out[0 * pitch], out[1 * pitch], + out[2 * pitch], out[3 * pitch], + out[4 * pitch], out[5 * pitch], + out[6 * pitch], out[7 * pitch], + t0, t1, t2, t3, t4, t5, t6, t7, t8); + } else + out[0 * pitch] = out[1 * pitch] = + out[2 * pitch] = out[3 * pitch] = + out[4 * pitch] = out[5 * pitch] = + out[6 * pitch] = out[7 * pitch] = 0; + + in++; + out++; + } +#undef COMPENSATE +} + +void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags) +{ + int i, shift, sp1, sp2; + const int32_t *src; + int32_t *dst; + int tmp[16]; + int t0, t1, t2, t3, t4; + + /* apply the InvHaar4 to all columns */ +#define COMPENSATE(x) (x) + src = in; + dst = tmp; + for (i = 0; i &lt; 4; i++) { + if (flags[i]) { + /* pre-scaling */ + shift = !(i &amp; 2); + sp1 = src[0] &lt;&lt; shift; + sp2 = src[4] &lt;&lt; shift; + INV_HAAR4( sp1, sp2, src[8], src[12], + dst[0], dst[4], dst[8], dst[12], + t0, t1, t2, t3, t4); + } else + dst[0] = dst[4] = dst[8] = dst[12] = 0; + + src++; + dst++; + } +#undef COMPENSATE + + /* apply the InvHaar8 to all rows */ +#define COMPENSATE(x) (x) + src = tmp; + for (i = 0; i &lt; 4; i++) { + if (!src[0] &amp;&amp; !src[1] &amp;&amp; !src[2] &amp;&amp; !src[3]) { + memset(out, 0, 4 * sizeof(out[0])); + } else { + INV_HAAR4(src[0], src[1], src[2], src[3], + out[0], out[1], out[2], out[3], + t0, t1, t2, t3, t4); + } + src += 4; + out += pitch; + } +#undef COMPENSATE +} + +void ff_ivi_row_haar4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags) +{ + int i; + int t0, t1, t2, t3, t4; + + /* apply the InvHaar4 to all rows */ +#define COMPENSATE(x) (x) + for (i = 0; i &lt; 4; i++) { + if (!in[0] &amp;&amp; !in[1] &amp;&amp; !in[2] &amp;&amp; !in[3]) { + memset(out, 0, 4 * sizeof(out[0])); + } else { + INV_HAAR4(in[0], in[1], in[2], in[3], + out[0], out[1], out[2], out[3], + t0, t1, t2, t3, t4); + } + in += 4; + out += pitch; + } +#undef COMPENSATE +} + +void ff_ivi_col_haar4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags) +{ + int i; + int t0, t1, t2, t3, t4; + + /* apply the InvHaar8 to all columns */ +#define COMPENSATE(x) (x) + for (i = 0; i &lt; 4; i++) { + if (flags[i]) { + INV_HAAR4(in[0], in[4], in[8], in[12], + out[0 * pitch], out[1 * pitch], + out[2 * pitch], out[3 * pitch], + t0, t1, t2, t3, t4); + } else + out[0 * pitch] = out[1 * pitch] = + out[2 * pitch] = out[3 * pitch] = 0; + + in++; + out++; + } +#undef COMPENSATE +} + void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size) { &lt; at &gt;&lt; at &gt; -546,6 +695,49 &lt; at &gt;&lt; at &gt; void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, uint32_t pitch, int bl } } +void ff_ivi_row_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags) +{ + int i; + int t0, t1, t2, t3, t4; + +#define COMPENSATE(x) ((x + 1)&gt;&gt;1) + for (i = 0; i &lt; 4; i++) { + if (!in[0] &amp;&amp; !in[1] &amp;&amp; !in[2] &amp;&amp; !in[3]) { + memset(out, 0, 4*sizeof(out[0])); + } else { + IVI_INV_SLANT4( in[0], in[1], in[2], in[3], + out[0], out[1], out[2], out[3], + t0, t1, t2, t3, t4); + } + in += 4; + out += pitch; + } +#undef COMPENSATE +} + +void ff_ivi_col_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags) +{ + int i, row2; + int t0, t1, t2, t3, t4; + + row2 = pitch &lt;&lt; 1; + +#define COMPENSATE(x) ((x + 1)&gt;&gt;1) + for (i = 0; i &lt; 4; i++) { + if (flags[i]) { + IVI_INV_SLANT4(in[0], in[4], in[8], in[12], + out[0], out[pitch], out[row2], out[row2 + pitch], + t0, t1, t2, t3, t4); + } else { + out[0] = out[pitch] = out[row2] = out[row2 + pitch] = 0; + } + + in++; + out++; + } +#undef COMPENSATE +} + void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags) { diff --git a/libavcodec/ivi_dsp.h b/libavcodec/ivi_dsp.h index c46f8b2..31d37e3 100644 --- a/libavcodec/ivi_dsp.h +++ b/libavcodec/ivi_dsp.h &lt; at &gt;&lt; at &gt; -66,6 +66,71 &lt; at &gt;&lt; at &gt; void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags); /** + * one-dimensional inverse 8-point Haar transform on rows for Indeo 4 + * + * &lt; at &gt;param[in] in pointer to the vector of transform coefficients + * &lt; at &gt;param[out] out pointer to the output buffer (frame) + * &lt; at &gt;param[in] pitch pitch to move to the next y line + * &lt; at &gt;param[in] flags pointer to the array of column flags: + * != 0 - non_empty column, 0 - empty one + * (this array must be filled by caller) + */ +void ff_ivi_row_haar8(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags); + +/** + * one-dimensional inverse 8-point Haar transform on columns for Indeo 4 + * + * &lt; at &gt;param[in] in pointer to the vector of transform coefficients + * &lt; at &gt;param[out] out pointer to the output buffer (frame) + * &lt; at &gt;param[in] pitch pitch to move to the next y line + * &lt; at &gt;param[in] flags pointer to the array of column flags: + * != 0 - non_empty column, 0 - empty one + * (this array must be filled by caller) + */ +void ff_ivi_col_haar8(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags); + +/** + * two-dimensional inverse Haar 4x4 transform for Indeo 4 + * + * &lt; at &gt;param[in] in pointer to the vector of transform coefficients + * &lt; at &gt;param[out] out pointer to the output buffer (frame) + * &lt; at &gt;param[in] pitch pitch to move to the next y line + * &lt; at &gt;param[in] flags pointer to the array of column flags: + * != 0 - non_empty column, 0 - empty one + * (this array must be filled by caller) + */ +void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags); + +/** + * one-dimensional inverse 4-point Haar transform on rows for Indeo 4 + * + * &lt; at &gt;param[in] in pointer to the vector of transform coefficients + * &lt; at &gt;param[out] out pointer to the output buffer (frame) + * &lt; at &gt;param[in] pitch pitch to move to the next y line + * &lt; at &gt;param[in] flags pointer to the array of column flags: + * != 0 - non_empty column, 0 - empty one + * (this array must be filled by caller) + */ +void ff_ivi_row_haar4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags); + +/** + * one-dimensional inverse 4-point Haar transform on columns for Indeo 4 + * + * &lt; at &gt;param[in] in pointer to the vector of transform coefficients + * &lt; at &gt;param[out] out pointer to the output buffer (frame) + * &lt; at &gt;param[in] pitch pitch to move to the next y line + * &lt; at &gt;param[in] flags pointer to the array of column flags: + * != 0 - non_empty column, 0 - empty one + * (this array must be filled by caller) + */ +void ff_ivi_col_haar4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags); + +/** * DC-only two-dimensional inverse Haar transform for Indeo 4. * Performing the inverse transform in this case is equivalent to * spreading DC_coeff &gt;&gt; 3 over the whole block. &lt; at &gt;&lt; at &gt; -142,6 +207,30 &lt; at &gt;&lt; at &gt; void ff_ivi_col_slant8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags); /** + * inverse 1D row slant transform + * + * &lt; at &gt;param[in] in pointer to the vector of transform coefficients + * &lt; at &gt;param[out] out pointer to the output buffer (frame) + * &lt; at &gt;param[in] pitch pitch to move to the next y line + * &lt; at &gt;param[in] flags pointer to the array of column flags (unused here) + */ +void ff_ivi_row_slant4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags); + +/** + * inverse 1D column slant transform + * + * &lt; at &gt;param[in] in pointer to the vector of transform coefficients + * &lt; at &gt;param[out] out pointer to the output buffer (frame) + * &lt; at &gt;param[in] pitch pitch to move to the next y line + * &lt; at &gt;param[in] flags pointer to the array of column flags: + * != 0 - non_empty column, 0 - empty one + * (this array must be filled by caller) + */ +void ff_ivi_col_slant4(const int32_t *in, int16_t *out, uint32_t pitch, + const uint8_t *flags); + +/** * DC-only inverse row slant transform */ void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size); </pre> Kostya Shishkov 2013-05-25T10:43:50 http://permalink.gmane.org/gmane.comp.video.libav.devel/46311 <pre> Yea, it doesn't work for all cases. Just tested again and it didn't work for this: "Microsoft (R) C/C++ Optimizing Compiler" </pre> Alex Smith 2013-05-25T10:11:36 http://permalink.gmane.org/gmane.comp.video.libav.devel/46310 <pre>Initial support for the ICL compiler on windows. Requires a new c99wrap with ICL support (1.0.2+). Currently not much different speed wise compared to msvc. In the future with a few changes it can be made to support the inline asm. This would be the primary reason for using it. Passed all fate tests, versions tested: 13.1.1.171 (2013 Update 3) x86 and x64 12.1.5.344 (2011 Update 11) x86 and x64 --- configure | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/configure b/configure index 819f9e6..b956645 100755 --- a/configure +++ b/configure &lt; at &gt;&lt; at &gt; -2227,6 +2227,13 &lt; at &gt;&lt; at &gt; case "$toolchain" in ar_default="lib" target_os_default="win32" ;; + icl) + cc_default="c99wrap -noconv icl" + ld_default="c99wrap xilink" + nm_default="dumpbin -symbols" + ar_default="xilib" + target_os_default="win32" + ;; gcov) add_cflags -fprofile-arcs -ftest-coverage add_ldflags -fprofile-arcs -ftest-coverage &lt; at &gt;&lt; at &gt; -2554,6 +2561,31 &lt; at &gt;&lt; at &gt; probe_cc(){ if [ $pfx = hostcc ]; then append _cflags -Dsnprintf=_snprintf fi + elif $_cc 2&gt;&amp;1 | grep -q Intel; then + _type=icl + _ident=$($cc 2&gt;&amp;1 | head -n1) + _depflags='-QMMD -QMF$(&lt; at &gt;:.o=.d) -QMT$&lt; at &gt;' + # Not only is O3 broken on 13.x+ but it's slower on all previous versions (tested) as well + _cflags_speed="-O2" + _cflags_size="-O1 -Oi" # -O1 without -Oi miscompiles stuff + # Nonstandard output options, to avoid msys path conversion issues, relies on wrapper to remap it + if $_cc 2&gt;&amp;1 | grep -q Linker; then + _ld_o='-out $&lt; at &gt;' + else + _ld_o='-Fe$&lt; at &gt;' + fi + _cc_o='-Fo $&lt; at &gt;' + _cc_e='-P' + _flags_filter=msvc_flags + _ld_lib='lib%.a' + _ld_path='-libpath:' + # -Qdiag-error to make icl error when presented with certain unknown arguments + _flags='-nologo -Qdiag-error:10157 -Qdiag-error:4044' + # -Qvec- -Qsimd- to prevent miscompilation, -GS for consistency with msvc which enables it by default + _cflags='-D_USE_MATH_DEFINES -Dinline=__inline -FIstdlib.h -Dstrtoll=_strtoi64 -Qstd=c99 -Qms0 -Qvec- -Qsimd- -GS' + if [ $pfx = hostcc ]; then + append _cflags -Dsnprintf=_snprintf + fi fi eval ${pfx}_type=\$_type &lt; at &gt;&lt; at &gt; -3868,6 +3900,13 &lt; at &gt;&lt; at &gt; elif enabled pathscale; then add_cflags -fstrict-overflow -OPT:wrap_around_unsafe_opt=OFF elif enabled msvc; then enabled x86_32 &amp;&amp; disable aligned_stack +elif enabled icl; then + enabled x86_32 &amp;&amp; disable aligned_stack + check_cflags -W1 # Just warnings, no remark spam + # basically -fstrict-aliasing for icl that doesn't work (correctly) on 13.x+ + check_cpp_condition "windows.h" "__ICL &lt; 1300" &amp;&amp; add_cflags -Qansi-alias + # icl will pass the inline asm tests but inline asm is currently not supported (build will fail) + disable inline_asm fi case $target_os in -- 1.8.1.msysgit.1 </pre> Alex Smith 2013-05-25T10:07:42 http://permalink.gmane.org/gmane.comp.video.libav.devel/46309 <pre> Looks fine, thanks for the explanation. lu </pre> Luca Barbato 2013-05-25T10:06:14 http://permalink.gmane.org/gmane.comp.video.libav.devel/46308 <pre>From: Laurent &lt;laurent.aml-Re5JQEeQqe8AvxtiuMwx3w&lt; at &gt;public.gmane.org&gt; Change the check_exec_crash test to use a function pointer instead of simply calling the function. The EBP availability test will crash when compiled with ICL likely due to compiler optimization shenanigans. Originally the check_exec_crash code was moved out of main to fix a problem with gcc's treatment of non-leaf main on x86_32. libav already moved the code out of main but the addition of the function pointer will prevent any inlining which fixes the remaining problem. A function pointer is used since it is compiler agnostic (as opposed to say __attribute__ ((noinline)) which would only work with gcc compatible compilers). Conflicts: configure --- configure | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/configure b/configure index e3cf0b9..819f9e6 100755 --- a/configure +++ b/configure &lt; at &gt;&lt; at &gt; -908,9 +908,10 &lt; at &gt;&lt; at &gt; check_exec_crash(){ static void sighandler(int sig){ raise(SIGTERM); } -int foo(void){ +int func(void){ $code } +int (*func_ptr)(void) = func; int main(void){ signal(SIGILL, sighandler); signal(SIGFPE, sighandler); &lt; at &gt;&lt; at &gt; -918,7 +919,7 &lt; at &gt;&lt; at &gt; int main(void){ #ifdef SIGBUS signal(SIGBUS, sighandler); #endif - foo(); + return func_ptr(); } EOF } -- 1.8.1.msysgit.1 </pre> Alex Smith 2013-05-25T10:01:29 http://permalink.gmane.org/gmane.comp.video.libav.devel/46307 <pre> Can we use that or there is something wrong with this setup? lu </pre> Luca Barbato 2013-05-25T10:03:28 http://permalink.gmane.org/gmane.comp.video.libav.devel/46306 <pre>I'm tempted to want to just drop this patch. Nothing I've tried or that has been suggested works for all versions involved. This change or a more complicated regex in the ICL patch isn't strictly nessasary as both work just fine without them. Feel free to make more suggestions if you've got them and I'll give it a shot. </pre> Alex Smith 2013-05-25T09:39:57 http://permalink.gmane.org/gmane.comp.video.libav.devel/46305 <pre>size filter insane scalarproduct_and_madd_int16_altivec(int16_t *v1, const int16_t * Confirming this fixes fate-lossless-monkeysaudio-394b1-extrahigh on AltiVec-enabled PPC builds. </pre> Sean McGovern 2013-05-24T18:48:58 http://permalink.gmane.org/gmane.comp.video.libav.devel/46304 <pre>the second and third sources were incremented only by half of the needed size --- The loop was iterated only once in the previous tests and the higher filter orders that expose this bug happen only on APE files with extrahigh or insane compression level. I've tested favourite 3.99 insane compression file to verify that conjecture and that this fix works for it. And it makes fate-lossless-monkeysaudio-394b1-extrahigh pass on AltiVec PPC too. --- libavcodec/ppc/int_altivec.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libavcodec/ppc/int_altivec.c b/libavcodec/ppc/int_altivec.c index 67d119c..8357ca7 100644 --- a/libavcodec/ppc/int_altivec.c +++ b/libavcodec/ppc/int_altivec.c &lt; at &gt;&lt; at &gt; -129,8 +129,8 &lt; at &gt;&lt; at &gt; static int32_t scalarproduct_and_madd_int16_altivec(int16_t *v1, const int16_t * pv1[0] = vec_mladd(t0, muls, i0); pv1[1] = vec_mladd(t1, muls, i1); pv1 += 2; - v2 += 8; - v3 += 8; + v2 += 16; + v3 += 16; } while(--order); res = vec_splat(vec_sums(res, zero_s32v), 3); vec_ste(res, 0, &amp;ires); </pre> Kostya Shishkov 2013-05-24T17:49:35 http://permalink.gmane.org/gmane.comp.video.libav.devel/46303 <pre> Good work, this looks good, a few comments below .. I'd say "during init" instead of "in init". I think it should be s/are processed/were processed/ here. s/This does not/It does not/ Diego </pre> Diego Biurrun 2013-05-24T11:40:48 http://permalink.gmane.org/gmane.comp.video.libav.devel/46302 <pre> LGTM </pre> Kostya Shishkov 2013-05-24T09:32:02 http://permalink.gmane.org/gmane.comp.video.libav.devel/46301 <pre>This fixes build failures on windows since 2a6eaeaa8. --- libavutil/cpu.c | 1 + 1 file changed, 1 insertion(+) diff --git a/libavutil/cpu.c b/libavutil/cpu.c index b95158b..17273b6 100644 --- a/libavutil/cpu.c +++ b/libavutil/cpu.c &lt; at &gt;&lt; at &gt; -19,6 +19,7 &lt; at &gt;&lt; at &gt; #include "cpu.h" #include "config.h" #include "opt.h" +#include "common.h" #if HAVE_SCHED_GETAFFINITY #define _GNU_SOURCE </pre> Martin Storsjö 2013-05-24T09:24:56 http://permalink.gmane.org/gmane.comp.video.libav.devel/46300 <pre>--- libavfilter/avfilter.h | 104 +++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 86 insertions(+), 18 deletions(-) diff --git a/libavfilter/avfilter.h b/libavfilter/avfilter.h index 9baf64e..b8d85a9 100644 --- a/libavfilter/avfilter.h +++ b/libavfilter/avfilter.h &lt; at &gt;&lt; at &gt; -407,20 +407,42 &lt; at &gt;&lt; at &gt; enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx); * callback functions used to interact with the filter. */ typedef struct AVFilter { - const char *name; ///&lt; filter name + /** + * Filter name. Must be non-NULL and unique among filters. + */ + const char *name; /** - * A description for the filter. You should use the - * NULL_IF_CONFIG_SMALL() macro to define it. + * A description of the filter. May be NULL. + * + * You should use the NULL_IF_CONFIG_SMALL() macro to define it. */ const char *description; - const AVFilterPad *inputs; ///&lt; NULL terminated list of inputs. NULL if none - const AVFilterPad *outputs; ///&lt; NULL terminated list of outputs. NULL if none + /** + * List of inputs, terminated by a zeroed element. + * + * NULL if there are no (static) inputs. Instances of filters with + * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in + * this list. + */ + const AVFilterPad *inputs; + /** + * List of outputs, terminated by a zeroed element. + * + * NULL if there are no (static) outputs. Instances of filters with + * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in + * this list. + */ + const AVFilterPad *outputs; /** - * A class for the private data, used to access filter private - * AVOptions. + * A class for the private data, used to declare filter private AVOptions. + * This field is NULL for filters that do not declare any options. + * + * If this field is non-NULL, the first member of the filter private data + * must be a pointer to AVClass, which will be set by libavfilter generic + * code to this class. */ const AVClass *priv_class; &lt; at &gt;&lt; at &gt; -438,29 +460,71 &lt; at &gt;&lt; at &gt; typedef struct AVFilter { */ /** - * Filter initialization function. Called when all the options have been - * set. + * Filter initialization function. + * + * This callback will be called only once during the filter lifetime, after + * all the options have been set, but before links between filters are + * established and format negotiation is done. + * + * Basic filter initialization should be done here. Filters with dynamic + * inputs and/or outputs should create those inputs/outputs here based on + * provided options. No more changes to this filter's inputs/outputs can be + * done after this callback. + * + * This callback must not assume that the filter links exist or frame + * parameters are known. + * + * &lt; at &gt;ref AVFilter.uninit "uninit" is guaranteed to be called even if + * initialization fails, so this callback does not have to clean up on + * failure. + * + * &lt; at &gt;return 0 on success, a negative AVERROR on failure */ int (*init)(AVFilterContext *ctx); /** - * Should be set instead of init by the filters that want to pass a - * dictionary of AVOptions to nested contexts that are allocated in - * init. + * Should be set instead of &lt; at &gt;ref AVFilter.init "init" by the filters that + * want to pass a dictionary of AVOptions to nested contexts that are + * allocated in init. + * + * On return, the options dict should be freed and replaced with one that + * contains all the options which could not be processed by this filter (or + * with NULL if all the options are processed). + * + * Otherwise the semantics is the same as for &lt; at &gt;ref AVFilter.init "init". */ int (*init_dict)(AVFilterContext *ctx, AVDictionary **options); /** - * Filter uninitialization function. Should deallocate any memory held - * by the filter, release any buffer references, etc. This does not need - * to deallocate the AVFilterContext-&gt;priv memory itself. + * Filter uninitialization function. + * + * Called only once right before the filter is freed. Should deallocate any + * memory held by the filter, release any buffer references, etc. This does + * not need to deallocate the AVFilterContext.priv memory itself. + * + * This callback may be called even if &lt; at &gt;ref AVFilter.init "init" was not + * called or failed, so it must be prepared to handle such a situation. */ void (*uninit)(AVFilterContext *ctx); /** - * Queries formats supported by the filter and its pads, and sets the - * in_formats for links connected to its output pads, and out_formats - * for links connected to its input pads. + * Query formats supported by the filter on its inputs and outputs. + * + * This callback is called after the filter is initialized (so the inputs + * and outputs are fixed), shortly before the format negotiation. This + * callback may be called more than once. + * + * This callback must set AVFilterLink.out_formats on every input link and + * AVFilterLink.in_formats on every output link to a list of pixel/sample + * formats that the filter supports on that link. For audio links, this + * filter must also set &lt; at &gt;ref AVFilterLink.in_samplerates "in_samplerates" / + * &lt; at &gt;ref AVFilterLink.out_samplerates "out_samplerates" and + * &lt; at &gt;ref AVFilterLink.in_channel_layouts "in_channel_layouts" / + * &lt; at &gt;ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously. + * + * This callback may be NULL for filters with one input, in which case + * libavfilter assumes that it supports all input formats and preserves + * them on output. * * &lt; at &gt;return zero on success, a negative value corresponding to an * AVERROR code otherwise &lt; at &gt;&lt; at &gt; -469,6 +533,10 &lt; at &gt;&lt; at &gt; typedef struct AVFilter { int priv_size; ///&lt; size of private data to allocate for the filter + /** + * Used by the filter registration system. Must not be touched by any other + * code. + */ struct AVFilter *next; } AVFilter; </pre> Anton Khirnov 2013-05-24T07:07:26 http://permalink.gmane.org/gmane.comp.video.libav.devel/46299 <pre>2013/5/24 Diego Biurrun &lt;diego-NvuzD6AdJSiELgA04lAiVw&lt; at &gt;public.gmane.org&gt; Here you are. </pre> Yusuke Nakamura 2013-05-23T18:12:41 http://permalink.gmane.org/gmane.comp.video.libav.devel/46298 <pre> Please make the entries AV_PICTURE_STRUCTURE_FOO. Diego </pre> Diego Biurrun 2013-05-23T17:27:28 http://permalink.gmane.org/gmane.comp.video.libav.devel/46297 <pre> LGTM Something about rename detection is missing from your Git confiugaration. RTFM please. Diego </pre> Diego Biurrun 2013-05-23T17:25:46 http://permalink.gmane.org/gmane.comp.video.libav.devel/46296 <pre> Looks fine. </pre> Luca Barbato 2013-05-23T13:37:17 Search the mailing list at Gmane query http://search.gmane.org/?group=$group=gmane.comp.video.libav.devel