---
libavcodec/mss1.c | 15 +++++-----
libavcodec/mss12.h | 4 +--
libavcodec/mss2.c | 79 ++++++++++++++++++++++++++-------------------------
libavcodec/mss4.c | 83 +++++++++++++++++++++++++++---------------------------
4 files changed, 93 insertions(+), 88 deletions(-)
diff --git a/libavcodec/mss1.c b/libavcodec/mss1.c
index a31af06..9f4d6bc 100644
--- a/libavcodec/mss1.c
+++ b/libavcodec/mss1.c
@@ -25,6 +25,7 @@
*/
#include "avcodec.h"
+#include "bitstream.h"
#include "internal.h"
#include "mss12.h"
@@ -56,7 +57,7 @@ static void arith_normalise(ArithCoder *c)
c->low <<= 1;
c->high <<= 1;
c->high |= 1;
- c->value |= get_bits1(c->gbc.gb);
+ c->value |= bitstream_read_bit(c->gbc.bc);
}
}
@@ -107,12 +108,12 @@ static int arith_get_prob(ArithCoder *c, int16_t *probs)
ARITH_GET_MODEL_SYM()
-static void arith_init(ArithCoder *c, GetBitContext *gb)
+static void arith_init(ArithCoder *c, BitstreamContext *bc)
{
c->low = 0;
c->high = 0xFFFF;
- c->value = get_bits(gb, 16);
- c->gbc.gb = gb;
+ c->value = bitstream_read(bc, 16);
+ c->gbc.bc = bc;
c->get_model_sym = arith_get_model_sym;
c->get_number = arith_get_number;
}
@@ -143,13 +144,13 @@ static int mss1_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
int buf_size = avpkt->size;
MSS1Context *ctx = avctx->priv_data;
MSS12Context *c = &ctx->ctx;
- GetBitContext gb;
+ BitstreamContext bc;
ArithCoder acoder;
int pal_changed = 0;
int ret;
- init_get_bits(&gb, buf, buf_size * 8);
- arith_init(&acoder, &gb);
+ bitstream_init8(&bc, buf, buf_size);
+ arith_init(&acoder, &bc);
if ((ret = ff_reget_buffer(avctx, ctx->pic)) < 0) {
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
diff --git a/libavcodec/mss12.h b/libavcodec/mss12.h
index 5b1fee8..6936951 100644
--- a/libavcodec/mss12.h
+++ b/libavcodec/mss12.h
@@ -28,7 +28,7 @@
#include "libavutil/intreadwrite.h"
#include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "bytestream.h"
#define MODEL_MIN_SYMS 2
@@ -48,7 +48,7 @@ typedef struct Model {
typedef struct ArithCoder {
int low, high, value;
union {
- GetBitContext *gb;
+ BitstreamContext *bc;
GetByteContext *gB;
} gbc;
int (*get_model_sym)(struct ArithCoder *c, Model *m);
diff --git a/libavcodec/mss2.c b/libavcodec/mss2.c
index 2c993f6..50eec86 100644
--- a/libavcodec/mss2.c
+++ b/libavcodec/mss2.c
@@ -24,6 +24,8 @@
*/
#include "libavutil/avassert.h"
+
+#include "bitstream.h"
#include "error_resilience.h"
#include "internal.h"
#include "mpeg_er.h"
@@ -33,6 +35,7 @@
#include "wmv2data.h"
#include "mss12.h"
#include "mss2dsp.h"
+#include "vlc.h"
typedef struct MSS2Context {
VC1Context v;
@@ -232,7 +235,7 @@ static int decode_555(GetByteContext *gB, uint16_t *dst,
int stride,
return 0;
}
-static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, int pal_stride,
+static int decode_rle(BitstreamContext *bc, uint8_t *pal_dst, int pal_stride,
uint8_t *rgb_dst, int rgb_stride, uint32_t *pal,
int keyframe, int kf_slipt, int slice, int w, int h)
{
@@ -250,10 +253,10 @@ static int decode_rle(GetBitContext *gb, uint8_t
*pal_dst, int pal_stride,
if (!keyframe) {
int x, y, clipw, cliph;
- x = get_bits(gb, 12);
- y = get_bits(gb, 12);
- clipw = get_bits(gb, 12) + 1;
- cliph = get_bits(gb, 12) + 1;
+ x = bitstream_read(bc, 12);
+ y = bitstream_read(bc, 12);
+ clipw = bitstream_read(bc, 12) + 1;
+ cliph = bitstream_read(bc, 12) + 1;
if (x + clipw > w || y + cliph > h)
return AVERROR_INVALIDDATA;
@@ -276,11 +279,11 @@ static int decode_rle(GetBitContext *gb, uint8_t
*pal_dst, int pal_stride,
/* read explicit codes */
do {
while (current_codes--) {
- int symbol = get_bits(gb, 8);
+ int symbol = bitstream_read(bc, 8);
if (symbol >= 204 - keyframe)
symbol += 14 - keyframe;
else if (symbol > 189)
- symbol = get_bits1(gb) + (symbol << 1) - 190;
+ symbol = bitstream_read_bit(bc) + (symbol << 1) - 190;
if (bits[symbol])
return AVERROR_INVALIDDATA;
bits[symbol] = current_length;
@@ -290,7 +293,7 @@ static int decode_rle(GetBitContext *gb, uint8_t *pal_dst,
int pal_stride,
current_length++;
next_code <<= 1;
remaining_codes = (1 << current_length) - next_code;
- current_codes = get_bits(gb, av_ceil_log2(remaining_codes + 1));
+ current_codes = bitstream_read(bc, av_ceil_log2(remaining_codes +
1));
if (current_length > 22 || current_codes > remaining_codes)
return AVERROR_INVALIDDATA;
} while (current_codes != remaining_codes);
@@ -327,18 +330,18 @@ static int decode_rle(GetBitContext *gb, uint8_t
*pal_dst, int pal_stride,
uint8_t *rp = rgb_dst;
do {
if (repeat-- < 1) {
- int b = get_vlc2(gb, vlc.table, 9, 3);
+ int b = bitstream_read_vlc(bc, vlc.table, 9, 3);
if (b < 256)
last_symbol = b;
else if (b < 268) {
b -= 256;
if (b == 11)
- b = get_bits(gb, 4) + 10;
+ b = bitstream_read(bc, 4) + 10;
if (!b)
repeat = 0;
else
- repeat = get_bits(gb, b);
+ repeat = bitstream_read(bc, b);
repeat += (1 << b) - 1;
@@ -381,11 +384,11 @@ static int decode_wmv9(AVCodecContext *avctx, const
uint8_t *buf, int buf_size,
ff_mpeg_flush(avctx);
- init_get_bits(&s->gb, buf, buf_size * 8);
+ bitstream_init8(&s->bc, buf, buf_size);
s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;
- if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
+ if (ff_vc1_parse_frame_header(v, &s->bc) < 0) {
av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
return AVERROR_INVALIDDATA;
}
@@ -467,7 +470,7 @@ static int mss2_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
MSS2Context *ctx = avctx->priv_data;
MSS12Context *c = &ctx->c;
AVFrame *frame = data;
- GetBitContext gb;
+ BitstreamContext bc;
GetByteContext gB;
ArithCoder acoder;
@@ -477,27 +480,27 @@ static int mss2_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
int used_rects = 0, i, implicit_rect = 0, av_uninit(wmv9_mask);
av_assert0(AV_INPUT_BUFFER_PADDING_SIZE >=
- ARITH2_PADDING + (MIN_CACHE_BITS + 7) / 8);
+ ARITH2_PADDING + (25 + 7) / 8);
- init_get_bits(&gb, buf, buf_size * 8);
+ bitstream_init8(&bc, buf, buf_size);
- if (keyframe = get_bits1(&gb))
- skip_bits(&gb, 7);
- has_wmv9 = get_bits1(&gb);
- has_mv = keyframe ? 0 : get_bits1(&gb);
- is_rle = get_bits1(&gb);
- is_555 = is_rle && get_bits1(&gb);
+ if (keyframe = bitstream_read_bit(&bc))
+ bitstream_skip(&bc, 7);
+ has_wmv9 = bitstream_read_bit(&bc);
+ has_mv = keyframe ? 0 : bitstream_read_bit(&bc);
+ is_rle = bitstream_read_bit(&bc);
+ is_555 = is_rle && bitstream_read_bit(&bc);
if (c->slice_split > 0)
ctx->split_position = c->slice_split;
else if (c->slice_split < 0) {
- if (get_bits1(&gb)) {
- if (get_bits1(&gb)) {
- if (get_bits1(&gb))
- ctx->split_position = get_bits(&gb, 16);
+ if (bitstream_read_bit(&bc)) {
+ if (bitstream_read_bit(&bc)) {
+ if (bitstream_read_bit(&bc))
+ ctx->split_position = bitstream_read(&bc, 16);
else
- ctx->split_position = get_bits(&gb, 12);
+ ctx->split_position = bitstream_read(&bc, 12);
} else
- ctx->split_position = get_bits(&gb, 8) << 4;
+ ctx->split_position = bitstream_read(&bc, 8) << 4;
} else {
if (keyframe)
ctx->split_position = avctx->height / 2;
@@ -509,9 +512,9 @@ static int mss2_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
ctx->split_position > avctx->height - 1))
return AVERROR_INVALIDDATA;
- align_get_bits(&gb);
- buf += get_bits_count(&gb) >> 3;
- buf_size -= get_bits_count(&gb) >> 3;
+ bitstream_align(&bc);
+ buf += bitstream_tell(&bc) >> 3;
+ buf_size -= bitstream_tell(&bc) >> 3;
if (buf_size < 1)
return AVERROR_INVALIDDATA;
@@ -641,24 +644,24 @@ static int mss2_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
ff_mss12_slicecontext_reset(&ctx->sc[1]);
}
if (is_rle) {
- init_get_bits(&gb, buf, buf_size * 8);
- if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
+ bitstream_init8(&bc, buf, buf_size);
+ if (ret = decode_rle(&bc, c->pal_pic, c->pal_stride,
c->rgb_pic, c->rgb_stride, c->pal, keyframe,
ctx->split_position, 0,
avctx->width, avctx->height))
return ret;
- align_get_bits(&gb);
+ bitstream_align(&bc);
if (c->slice_split)
- if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
+ if (ret = decode_rle(&bc, c->pal_pic, c->pal_stride,
c->rgb_pic, c->rgb_stride, c->pal,
keyframe,
ctx->split_position, 1,
avctx->width, avctx->height))
return ret;
- align_get_bits(&gb);
- buf += get_bits_count(&gb) >> 3;
- buf_size -= get_bits_count(&gb) >> 3;
+ bitstream_align(&bc);
+ buf += bitstream_tell(&bc) >> 3;
+ buf_size -= bitstream_tell(&bc) >> 3;
} else if (!implicit_rect || wmv9_mask != -1) {
if (c->corrupted)
return AVERROR_INVALIDDATA;
diff --git a/libavcodec/mss4.c b/libavcodec/mss4.c
index a953a57..06492ee 100644
--- a/libavcodec/mss4.c
+++ b/libavcodec/mss4.c
@@ -26,11 +26,12 @@
*/
#include "avcodec.h"
+#include "bitstream.h"
#include "bytestream.h"
-#include "get_bits.h"
#include "internal.h"
#include "mss34dsp.h"
#include "unary.h"
+#include "vlc.h"
#define HEADER_SIZE 8
@@ -202,28 +203,28 @@ static av_cold void mss4_free_vlcs(MSS4Context *ctx)
* nbits = 1 -> -1, 1
* nbits = 2 -> -3, -2, 2, 3
*/
-static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
+static av_always_inline int get_coeff_bits(BitstreamContext *bc, int nbits)
{
int val;
if (!nbits)
return 0;
- val = get_bits(gb, nbits);
+ val = bitstream_read(bc, nbits);
if (val < (1 << (nbits - 1)))
val -= (1 << nbits) - 1;
return val;
}
-static inline int get_coeff(GetBitContext *gb, VLC *vlc)
+static inline int get_coeff(BitstreamContext *bc, VLC *vlc)
{
- int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
+ int val = bitstream_read_vlc(bc, vlc->table, vlc->bits, 2);
- return get_coeff_bits(gb, val);
+ return get_coeff_bits(bc, val);
}
-static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
+static int mss4_decode_dct(BitstreamContext *bc, VLC *dc_vlc, VLC *ac_vlc,
int *block, int *dc_cache,
int bx, int by, uint16_t *quant_mat)
{
@@ -231,7 +232,7 @@ static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc,
VLC *ac_vlc,
memset(block, 0, sizeof(*block) * 64);
- dc = get_coeff(gb, dc_vlc);
+ dc = get_coeff(bc, dc_vlc);
// DC prediction is the same as in MSS3
if (by) {
if (bx) {
@@ -255,7 +256,7 @@ static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc,
VLC *ac_vlc,
block[0] = dc * quant_mat[0];
while (pos < 64) {
- val = get_vlc2(gb, ac_vlc->table, 9, 2);
+ val = bitstream_read_vlc(bc, ac_vlc->table, 9, 2);
if (!val)
return 0;
if (val == -1)
@@ -265,7 +266,7 @@ static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc,
VLC *ac_vlc,
continue;
}
skip = val >> 4;
- val = get_coeff_bits(gb, val & 0xF);
+ val = get_coeff_bits(bc, val & 0xF);
pos += skip;
if (pos >= 64)
return -1;
@@ -278,7 +279,7 @@ static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc,
VLC *ac_vlc,
return pos == 64 ? 0 : -1;
}
-static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
+static int mss4_decode_dct_block(MSS4Context *c, BitstreamContext *bc,
uint8_t *dst[3], int mb_x, int mb_y)
{
int i, j, k, ret;
@@ -289,7 +290,7 @@ static int mss4_decode_dct_block(MSS4Context *c,
GetBitContext *gb,
int xpos = mb_x * 2 + i;
c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];
- ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
+ ret = mss4_decode_dct(bc, c->dc_vlc, c->ac_vlc, c->block,
c->dc_cache[j],
xpos, mb_y * 2 + j, c->quant_mat[0]);
if (ret)
@@ -305,7 +306,7 @@ static int mss4_decode_dct_block(MSS4Context *c,
GetBitContext *gb,
for (i = 1; i < 3; i++) {
c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
- ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
+ ret = mss4_decode_dct(bc, c->dc_vlc + 1, c->ac_vlc + 1,
c->block, c->dc_cache[i + 1], mb_x, mb_y,
c->quant_mat[1]);
if (ret)
@@ -326,7 +327,7 @@ static int mss4_decode_dct_block(MSS4Context *c,
GetBitContext *gb,
return 0;
}
-static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
+static void read_vec_pos(BitstreamContext *bc, int *vec_pos, int *sel_flag,
int *sel_len, int *prev)
{
int i, y_flag = 0;
@@ -336,10 +337,10 @@ static void read_vec_pos(GetBitContext *gb, int *vec_pos,
int *sel_flag,
vec_pos[i] = 0;
continue;
}
- if ((!i && !y_flag) || get_bits1(gb)) {
+ if ((!i && !y_flag) || bitstream_read_bit(bc)) {
if (sel_len[i] > 0) {
int pval = prev[i];
- vec_pos[i] = get_bits(gb, sel_len[i]);
+ vec_pos[i] = bitstream_read(bc, sel_len[i]);
if (vec_pos[i] >= pval)
vec_pos[i]++;
} else {
@@ -352,14 +353,14 @@ static void read_vec_pos(GetBitContext *gb, int *vec_pos,
int *sel_flag,
}
}
-static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
+static int get_value_cached(BitstreamContext *bc, int vec_pos, uint8_t *vec,
int vec_size, int component, int shift, int *prev)
{
if (vec_pos < vec_size)
return vec[vec_pos];
- if (!get_bits1(gb))
+ if (!bitstream_read_bit(bc))
return prev[component];
- prev[component] = get_bits(gb, 8 - shift) << shift;
+ prev[component] = bitstream_read(bc, 8 - shift) << shift;
return prev[component];
}
@@ -376,7 +377,7 @@ static int get_value_cached(GetBitContext *gb, int vec_pos,
uint8_t *vec,
* positions can be updated or reused from the state of the previous line
* or previous pixel.
*/
-static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
+static int mss4_decode_image_block(MSS4Context *ctx, BitstreamContext *bc,
uint8_t *picdst[3], int mb_x, int mb_y)
{
uint8_t vec[3][4];
@@ -395,9 +396,9 @@ static int mss4_decode_image_block(MSS4Context *ctx,
GetBitContext *gb,
dst[i] = ctx->imgbuf[i];
for (i = 0; i < 3; i++) {
- vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
+ vec_len[i] = vec_len_syms[!!i][get_unary(bc, 0, 3)];
for (j = 0; j < vec_len[i]; j++) {
- vec[i][j] = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
+ vec[i][j] = get_coeff(bc, &ctx->vec_entry_vlc[!!i]);
vec[i][j] += ctx->prev_vec[i][j];
ctx->prev_vec[i][j] = vec[i][j];
}
@@ -406,16 +407,16 @@ static int mss4_decode_image_block(MSS4Context *ctx,
GetBitContext *gb,
}
for (j = 0; j < 16; j++) {
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
split = 0;
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
prev_mode[0] = 0;
vals[0] = vals[1] = vals[2] = 0;
mode = 2;
} else {
- mode = get_bits1(gb);
+ mode = bitstream_read_bit(bc);
if (mode)
- split = get_bits(gb, 4);
+ split = bitstream_read(bc, 4);
}
for (i = 0; i < 16; i++) {
if (mode <= 1) {
@@ -423,21 +424,21 @@ static int mss4_decode_image_block(MSS4Context *ctx,
GetBitContext *gb,
vals[1] = (prev_mode[i] >> 3) & 7;
vals[2] = prev_mode[i] >> 6;
if (mode == 1 && i == split) {
- read_vec_pos(gb, vals, sel_flag, sel_len, vals);
+ read_vec_pos(bc, vals, sel_flag, sel_len, vals);
}
} else if (mode == 2) {
- if (get_bits1(gb))
- read_vec_pos(gb, vals, sel_flag, sel_len, vals);
+ if (bitstream_read_bit(bc))
+ read_vec_pos(bc, vals, sel_flag, sel_len, vals);
}
for (k = 0; k < 3; k++)
- *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
+ *dst[k]++ = get_value_cached(bc, vals[k], vec[k],
vec_len[k], k,
val_shift, prev_pix);
prev_mode[i] = MKVAL(vals);
}
} else {
- if (get_bits1(gb)) {
- split = get_bits(gb, 4);
+ if (bitstream_read_bit(bc)) {
+ split = bitstream_read(bc, 4);
if (split >= prev_split)
split++;
prev_split = split;
@@ -450,7 +451,7 @@ static int mss4_decode_image_block(MSS4Context *ctx,
GetBitContext *gb,
vals[2] = prev_mode[0] >> 6;
for (i = 0; i < 3; i++) {
for (k = 0; k < split; k++) {
- *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
+ *dst[i]++ = get_value_cached(bc, vals[i], vec[i],
vec_len[i], i, val_shift,
prev_pix);
prev_mode[k] = MKVAL(vals);
@@ -462,13 +463,13 @@ static int mss4_decode_image_block(MSS4Context *ctx,
GetBitContext *gb,
vals[0] = prev_vec1 & 7;
vals[1] = (prev_vec1 >> 3) & 7;
vals[2] = prev_vec1 >> 6;
- if (get_bits1(gb)) {
- read_vec_pos(gb, vals, sel_flag, sel_len, vals);
+ if (bitstream_read_bit(bc)) {
+ read_vec_pos(bc, vals, sel_flag, sel_len, vals);
prev_vec1 = MKVAL(vals);
}
for (i = 0; i < 3; i++) {
for (k = 0; k < 16 - split; k++) {
- *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
+ *dst[i]++ = get_value_cached(bc, vals[i], vec[i],
vec_len[i], i, val_shift,
prev_pix);
prev_mode[split + k] = MKVAL(vals);
@@ -511,7 +512,7 @@ static int mss4_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MSS4Context *c = avctx->priv_data;
- GetBitContext gb;
+ BitstreamContext bb;
GetByteContext bc;
uint8_t *dst[3];
int width, height, quality, frame_type;
@@ -574,7 +575,7 @@ static int mss4_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
}
- init_get_bits(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
+ bitstream_init8(&bb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE));
mb_width = FFALIGN(width, 16) >> 4;
mb_height = FFALIGN(height, 16) >> 4;
@@ -586,10 +587,10 @@ static int mss4_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
for (y = 0; y < mb_height; y++) {
memset(c->dc_cache, 0, sizeof(c->dc_cache));
for (x = 0; x < mb_width; x++) {
- blk_type = decode012(&gb);
+ blk_type = bitstream_decode012(&bb);
switch (blk_type) {
case DCT_BLOCK:
- if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
+ if (mss4_decode_dct_block(c, &bb, dst, x, y) < 0) {
av_log(avctx, AV_LOG_ERROR,
"Error decoding DCT block %d,%d\n",
x, y);
@@ -597,7 +598,7 @@ static int mss4_decode_frame(AVCodecContext *avctx, void
*data, int *got_frame,
}
break;
case IMAGE_BLOCK:
- if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
+ if (mss4_decode_image_block(c, &bb, dst, x, y) < 0) {
av_log(avctx, AV_LOG_ERROR,
"Error decoding VQ block %d,%d\n",
x, y);
--
2.1.4
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
