---
libavcodec/rv10.c | 84 ++++++++++++++++++-----------------
libavcodec/rv30.c | 31 ++++++-------
libavcodec/rv34.c | 130 ++++++++++++++++++++++++++++--------------------------
libavcodec/rv34.h | 8 ++--
libavcodec/rv40.c | 64 ++++++++++++++-------------
5 files changed, 165 insertions(+), 152 deletions(-)
diff --git a/libavcodec/rv10.c b/libavcodec/rv10.c
index 3b5f4df..e816bc2 100644
--- a/libavcodec/rv10.c
+++ b/libavcodec/rv10.c
@@ -30,6 +30,7 @@
#include "libavutil/imgutils.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "error_resilience.h"
#include "h263.h"
#include "h263data.h"
@@ -40,6 +41,7 @@
#include "mpeg4video.h"
#include "mpegvideodata.h"
#include "rv10.h"
+#include "vlc.h"
#define RV_GET_MAJOR_VER(x) ((x) >> 28)
#define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
@@ -200,39 +202,39 @@ int ff_rv_decode_dc(MpegEncContext *s, int n)
int code;
if (n < 4) {
- code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
+ code = bitstream_read_vlc(&s->bc, rv_dc_lum.table, DC_VLC_BITS, 2);
if (code < 0) {
/* XXX: I don't understand why they use LONGER codes than
* necessary. The following code would be completely useless
* if they had thought about it !!! */
- code = get_bits(&s->gb, 7);
+ code = bitstream_read(&s->bc, 7);
if (code == 0x7c) {
- code = (int8_t) (get_bits(&s->gb, 7) + 1);
+ code = (int8_t) (bitstream_read(&s->bc, 7) + 1);
} else if (code == 0x7d) {
- code = -128 + get_bits(&s->gb, 7);
+ code = -128 + bitstream_read(&s->bc, 7);
} else if (code == 0x7e) {
- if (get_bits1(&s->gb) == 0)
- code = (int8_t) (get_bits(&s->gb, 8) + 1);
+ if (bitstream_read_bit(&s->bc) == 0)
+ code = (int8_t) (bitstream_read(&s->bc, 8) + 1);
else
- code = (int8_t) (get_bits(&s->gb, 8));
+ code = (int8_t) (bitstream_read(&s->bc, 8));
} else if (code == 0x7f) {
- skip_bits(&s->gb, 11);
+ bitstream_skip(&s->bc, 11);
code = 1;
}
} else {
code -= 128;
}
} else {
- code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
+ code = bitstream_read_vlc(&s->bc, rv_dc_chrom.table, DC_VLC_BITS, 2);
/* same remark */
if (code < 0) {
- code = get_bits(&s->gb, 9);
+ code = bitstream_read(&s->bc, 9);
if (code == 0x1fc) {
- code = (int8_t) (get_bits(&s->gb, 7) + 1);
+ code = (int8_t) (bitstream_read(&s->bc, 7) + 1);
} else if (code == 0x1fd) {
- code = -128 + get_bits(&s->gb, 7);
+ code = -128 + bitstream_read(&s->bc, 7);
} else if (code == 0x1fe) {
- skip_bits(&s->gb, 9);
+ bitstream_skip(&s->bc, 9);
code = 1;
} else {
av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
@@ -250,9 +252,9 @@ static int rv10_decode_picture_header(MpegEncContext *s)
{
int mb_count, pb_frame, marker, mb_xy;
- marker = get_bits1(&s->gb);
+ marker = bitstream_read_bit(&s->bc);
- if (get_bits1(&s->gb))
+ if (bitstream_read_bit(&s->bc))
s->pict_type = AV_PICTURE_TYPE_P;
else
s->pict_type = AV_PICTURE_TYPE_I;
@@ -260,7 +262,7 @@ static int rv10_decode_picture_header(MpegEncContext *s)
if (!marker)
av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
- pb_frame = get_bits1(&s->gb);
+ pb_frame = bitstream_read_bit(&s->bc);
ff_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
@@ -269,7 +271,7 @@ static int rv10_decode_picture_header(MpegEncContext *s)
return AVERROR_PATCHWELCOME;
}
- s->qscale = get_bits(&s->gb, 5);
+ s->qscale = bitstream_read(&s->bc, 5);
if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
return AVERROR_INVALIDDATA;
@@ -278,9 +280,9 @@ static int rv10_decode_picture_header(MpegEncContext *s)
if (s->pict_type == AV_PICTURE_TYPE_I) {
if (s->rv10_version == 3) {
/* specific MPEG like DC coding not used */
- s->last_dc[0] = get_bits(&s->gb, 8);
- s->last_dc[1] = get_bits(&s->gb, 8);
- s->last_dc[2] = get_bits(&s->gb, 8);
+ s->last_dc[0] = bitstream_read(&s->bc, 8);
+ s->last_dc[1] = bitstream_read(&s->bc, 8);
+ s->last_dc[2] = bitstream_read(&s->bc, 8);
ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
s->last_dc[1], s->last_dc[2]);
}
@@ -289,16 +291,16 @@ static int rv10_decode_picture_header(MpegEncContext *s)
* to display the macroblocks is coded here */
mb_xy = s->mb_x + s->mb_y * s->mb_width;
- if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
- s->mb_x = get_bits(&s->gb, 6); /* mb_x */
- s->mb_y = get_bits(&s->gb, 6); /* mb_y */
- mb_count = get_bits(&s->gb, 12);
+ if (bitstream_peek(&s->bc, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
+ s->mb_x = bitstream_read(&s->bc, 6); /* mb_x */
+ s->mb_y = bitstream_read(&s->bc, 6); /* mb_y */
+ mb_count = bitstream_read(&s->bc, 12);
} else {
s->mb_x = 0;
s->mb_y = 0;
mb_count = s->mb_width * s->mb_height;
}
- skip_bits(&s->gb, 3); /* ignored */
+ bitstream_skip(&s->bc, 3); /* ignored */
s->f_code = 1;
s->unrestricted_mv = 1;
@@ -311,7 +313,7 @@ static int rv20_decode_picture_header(RVDecContext *rv)
int seq, mb_pos, i, ret;
int rpr_bits;
- i = get_bits(&s->gb, 2);
+ i = bitstream_read(&s->bc, 2);
switch (i) {
case 0:
s->pict_type = AV_PICTURE_TYPE_I;
@@ -335,31 +337,31 @@ static int rv20_decode_picture_header(RVDecContext *rv)
return AVERROR_INVALIDDATA;
}
- if (get_bits1(&s->gb)) {
+ if (bitstream_read_bit(&s->bc)) {
av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
return AVERROR_INVALIDDATA;
}
- s->qscale = get_bits(&s->gb, 5);
+ s->qscale = bitstream_read(&s->bc, 5);
if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
return AVERROR_INVALIDDATA;
}
if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
- s->loop_filter = get_bits1(&s->gb);
+ s->loop_filter = bitstream_read_bit(&s->bc);
if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
- seq = get_bits(&s->gb, 8) << 7;
+ seq = bitstream_read(&s->bc, 8) << 7;
else
- seq = get_bits(&s->gb, 13) << 2;
+ seq = bitstream_read(&s->bc, 13) << 2;
rpr_bits = s->avctx->extradata[1] & 7;
if (rpr_bits) {
int f, new_w, new_h;
rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
- f = get_bits(&s->gb, rpr_bits);
+ f = bitstream_read(&s->bc, rpr_bits);
if (f) {
if (s->avctx->extradata_size < 8 + 2 * f) {
@@ -420,11 +422,11 @@ static int rv20_decode_picture_header(RVDecContext *rv)
}
}
- s->no_rounding = get_bits1(&s->gb);
+ s->no_rounding = bitstream_read_bit(&s->bc);
if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
// binary decoder reads 3+2 bits here but they don't seem to be used
- skip_bits(&s->gb, 5);
+ bitstream_skip(&s->bc, 5);
s->f_code = 1;
s->unrestricted_mv = 1;
@@ -539,7 +541,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, const
uint8_t *buf,
int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
active_bits_size = buf_size * 8;
- init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
+ bitstream_init8(&s->bc, buf, FFMAX(buf_size, buf_size2));
if (s->codec_id == AV_CODEC_ID_RV10)
mb_count = rv10_decode_picture_header(s);
else
@@ -627,23 +629,23 @@ static int rv10_decode_packet(AVCodecContext *avctx,
const uint8_t *buf,
// Repeat the slice end check from ff_h263_decode_mb with our active
// bitstream size
if (ret != SLICE_ERROR) {
- int v = show_bits(&s->gb, 16);
+ int v = bitstream_peek(&s->bc, 16);
- if (get_bits_count(&s->gb) + 16 > active_bits_size)
- v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
+ if (bitstream_tell(&s->bc) + 16 > active_bits_size)
+ v >>= bitstream_tell(&s->bc) + 16 - active_bits_size;
if (!v)
ret = SLICE_END;
}
- if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
- 8 * buf_size2 >= get_bits_count(&s->gb)) {
+ if (ret != SLICE_ERROR && active_bits_size < bitstream_tell(&s->bc) &&
+ 8 * buf_size2 >= bitstream_tell(&s->bc)) {
active_bits_size = buf_size2 * 8;
av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
8 * buf_size, active_bits_size);
ret = SLICE_OK;
}
- if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
+ if (ret == SLICE_ERROR || active_bits_size < bitstream_tell(&s->bc)) {
av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
s->mb_y);
return AVERROR_INVALIDDATA;
diff --git a/libavcodec/rv30.c b/libavcodec/rv30.c
index bf22df5..d400cf4 100644
--- a/libavcodec/rv30.c
+++ b/libavcodec/rv30.c
@@ -25,6 +25,7 @@
*/
#include "avcodec.h"
+#include "bitstream.h"
#include "mpegutils.h"
#include "mpegvideo.h"
#include "golomb.h"
@@ -33,7 +34,7 @@
#include "rv30data.h"
-static int rv30_parse_slice_header(RV34DecContext *r, GetBitContext *gb,
SliceInfo *si)
+static int rv30_parse_slice_header(RV34DecContext *r, BitstreamContext *bc,
SliceInfo *si)
{
AVCodecContext *avctx = r->s.avctx;
int mb_bits;
@@ -42,16 +43,16 @@ static int rv30_parse_slice_header(RV34DecContext *r,
GetBitContext *gb, SliceIn
int rpr;
memset(si, 0, sizeof(SliceInfo));
- if(get_bits(gb, 3))
+ if(bitstream_read(bc, 3))
return -1;
- si->type = get_bits(gb, 2);
+ si->type = bitstream_read(bc, 2);
if(si->type == 1) si->type = 0;
- if(get_bits1(gb))
+ if(bitstream_read_bit(bc))
return -1;
- si->quant = get_bits(gb, 5);
- skip_bits1(gb);
- si->pts = get_bits(gb, 13);
- rpr = get_bits(gb, r->rpr);
+ si->quant = bitstream_read(bc, 5);
+ bitstream_skip(bc, 1);
+ si->pts = bitstream_read(bc, 13);
+ rpr = bitstream_read(bc, r->rpr);
if(rpr){
if (avctx->extradata_size < rpr * 2 + 8) {
av_log(avctx, AV_LOG_ERROR,
@@ -66,22 +67,22 @@ static int rv30_parse_slice_header(RV34DecContext *r,
GetBitContext *gb, SliceIn
si->width = w;
si->height = h;
mb_size = ((w + 15) >> 4) * ((h + 15) >> 4);
- mb_bits = ff_rv34_get_start_offset(gb, mb_size);
- si->start = get_bits(gb, mb_bits);
- skip_bits1(gb);
+ mb_bits = ff_rv34_get_start_offset(bc, mb_size);
+ si->start = bitstream_read(bc, mb_bits);
+ bitstream_skip(bc, 1);
return 0;
}
/**
* Decode 4x4 intra types array.
*/
-static int rv30_decode_intra_types(RV34DecContext *r, GetBitContext *gb,
int8_t *dst)
+static int rv30_decode_intra_types(RV34DecContext *r, BitstreamContext *bc,
int8_t *dst)
{
int i, j, k;
for(i = 0; i < 4; i++, dst += r->intra_types_stride - 4){
for(j = 0; j < 4; j+= 2){
- unsigned code = svq3_get_ue_golomb(gb) << 1;
+ unsigned code = svq3_get_ue_golomb(bc) << 1;
if(code >= 81*2){
av_log(r->s.avctx, AV_LOG_ERROR, "Incorrect intra prediction
code\n");
return -1;
@@ -108,8 +109,8 @@ static int rv30_decode_mb_info(RV34DecContext *r)
static const int rv30_p_types[6] = { RV34_MB_SKIP, RV34_MB_P_16x16,
RV34_MB_P_8x8, -1, RV34_MB_TYPE_INTRA, RV34_MB_TYPE_INTRA16x16 };
static const int rv30_b_types[6] = { RV34_MB_SKIP, RV34_MB_B_DIRECT,
RV34_MB_B_FORWARD, RV34_MB_B_BACKWARD, RV34_MB_TYPE_INTRA,
RV34_MB_TYPE_INTRA16x16 };
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
- unsigned code = svq3_get_ue_golomb(gb);
+ BitstreamContext *bc = &s->bc;
+ unsigned code = svq3_get_ue_golomb(bc);
if (code > 11) {
av_log(s->avctx, AV_LOG_ERROR, "Incorrect MB type code\n");
diff --git a/libavcodec/rv34.c b/libavcodec/rv34.c
index 5fa71d8..75eef13 100644
--- a/libavcodec/rv34.c
+++ b/libavcodec/rv34.c
@@ -27,6 +27,7 @@
#include "libavutil/internal.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "error_resilience.h"
#include "mpegutils.h"
#include "mpegvideo.h"
@@ -37,6 +38,7 @@
#include "qpeldsp.h"
#include "rectangle.h"
#include "thread.h"
+#include "vlc.h"
#include "rv34vlc.h"
#include "rv34data.h"
@@ -184,7 +186,7 @@ static av_cold void rv34_init_tables(void)
/**
* Decode coded block pattern.
*/
-static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
+static int rv34_decode_cbp(BitstreamContext *bc, RV34VLC *vlc, int table)
{
int pattern, code, cbp=0;
int ones;
@@ -193,7 +195,7 @@ static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc,
int table)
const int *curshift = shifts;
int i, t, mask;
- code = get_vlc2(gb, vlc->cbppattern[table].table, 9, 2);
+ code = bitstream_read_vlc(bc, vlc->cbppattern[table].table, 9, 2);
pattern = code & 0xF;
code >>= 4;
@@ -201,13 +203,14 @@ static int rv34_decode_cbp(GetBitContext *gb, RV34VLC
*vlc, int table)
for(mask = 8; mask; mask >>= 1, curshift++){
if(pattern & mask)
- cbp |= get_vlc2(gb, vlc->cbp[table][ones].table,
vlc->cbp[table][ones].bits, 1) << curshift[0];
+ cbp |= bitstream_read_vlc(bc, vlc->cbp[table][ones].table,
+ vlc->cbp[table][ones].bits, 1) <<
curshift[0];
}
for(i = 0; i < 4; i++){
t = (modulo_three_table[code] >> (6 - 2*i)) & 3;
if(t == 1)
- cbp |= cbp_masks[get_bits1(gb)] << i;
+ cbp |= cbp_masks[bitstream_read_bit(bc)] << i;
if(t == 2)
cbp |= cbp_masks[2] << i;
}
@@ -217,18 +220,19 @@ static int rv34_decode_cbp(GetBitContext *gb, RV34VLC
*vlc, int table)
/**
* Get one coefficient value from the bitstream and store it.
*/
-static inline void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext
*gb, VLC* vlc, int q)
+static inline void decode_coeff(int16_t *dst, int coef, int esc,
BitstreamContext *bc,
+ VLC* vlc, int q)
{
if(coef){
if(coef == esc){
- coef = get_vlc2(gb, vlc->table, 9, 2);
+ coef = bitstream_read_vlc(bc, vlc->table, 9, 2);
if(coef > 23){
coef -= 23;
- coef = 22 + ((1 << coef) | get_bits(gb, coef));
+ coef = 22 + ((1 << coef) | bitstream_read(bc, coef));
}
coef += esc;
}
- if(get_bits1(gb))
+ if(bitstream_read_bit(bc))
coef = -coef;
*dst = (coef*q + 8) >> 4;
}
@@ -237,39 +241,39 @@ static inline void decode_coeff(int16_t *dst, int coef,
int esc, GetBitContext *
/**
* Decode 2x2 subblock of coefficients.
*/
-static inline void decode_subblock(int16_t *dst, int code, const int
is_block2, GetBitContext *gb, VLC *vlc, int q)
+static inline void decode_subblock(int16_t *dst, int code, const int
is_block2, BitstreamContext *bc, VLC *vlc, int q)
{
int flags = modulo_three_table[code];
- decode_coeff( dst+0*4+0, (flags >> 6) , 3, gb, vlc, q);
+ decode_coeff( dst+0*4+0, (flags >> 6) , 3, bc, vlc, q);
if(is_block2){
- decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q);
- decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q);
+ decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, bc, vlc, q);
+ decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, bc, vlc, q);
}else{
- decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q);
- decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q);
+ decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, bc, vlc, q);
+ decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, bc, vlc, q);
}
- decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q);
+ decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, bc, vlc, q);
}
/**
* Decode a single coefficient.
*/
-static inline void decode_subblock1(int16_t *dst, int code, GetBitContext *gb,
VLC *vlc, int q)
+static inline void decode_subblock1(int16_t *dst, int code, BitstreamContext
*bc, VLC *vlc, int q)
{
int coeff = modulo_three_table[code] >> 6;
- decode_coeff(dst, coeff, 3, gb, vlc, q);
+ decode_coeff(dst, coeff, 3, bc, vlc, q);
}
-static inline void decode_subblock3(int16_t *dst, int code, GetBitContext *gb,
VLC *vlc,
+static inline void decode_subblock3(int16_t *dst, int code, BitstreamContext
*bc, VLC *vlc,
int q_dc, int q_ac1, int q_ac2)
{
int flags = modulo_three_table[code];
- decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc);
- decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
- decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
- decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
+ decode_coeff(dst+0*4+0, (flags >> 6) , 3, bc, vlc, q_dc);
+ decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, bc, vlc, q_ac1);
+ decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, bc, vlc, q_ac1);
+ decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, bc, vlc, q_ac2);
}
/**
@@ -283,36 +287,37 @@ static inline void decode_subblock3(int16_t *dst, int
code, GetBitContext *gb, V
* o--o
*/
-static int rv34_decode_block(int16_t *dst, GetBitContext *gb, RV34VLC *rvlc,
int fc, int sc, int q_dc, int q_ac1, int q_ac2)
+static int rv34_decode_block(int16_t *dst, BitstreamContext *bc, RV34VLC *rvlc,
+ int fc, int sc, int q_dc, int q_ac1, int q_ac2)
{
int code, pattern, has_ac = 1;
- code = get_vlc2(gb, rvlc->first_pattern[fc].table, 9, 2);
+ code = bitstream_read_vlc(bc, rvlc->first_pattern[fc].table, 9, 2);
pattern = code & 0x7;
code >>= 3;
if (modulo_three_table[code] & 0x3F) {
- decode_subblock3(dst, code, gb, &rvlc->coefficient, q_dc, q_ac1,
q_ac2);
+ decode_subblock3(dst, code, bc, &rvlc->coefficient, q_dc, q_ac1,
q_ac2);
} else {
- decode_subblock1(dst, code, gb, &rvlc->coefficient, q_dc);
+ decode_subblock1(dst, code, bc, &rvlc->coefficient, q_dc);
if (!pattern)
return 0;
has_ac = 0;
}
if(pattern & 4){
- code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
- decode_subblock(dst + 4*0+2, code, 0, gb, &rvlc->coefficient, q_ac2);
+ code = bitstream_read_vlc(bc, rvlc->second_pattern[sc].table, 9, 2);
+ decode_subblock(dst + 4*0+2, code, 0, bc, &rvlc->coefficient, q_ac2);
}
if(pattern & 2){ // Looks like coefficients 1 and 2 are swapped for this
block
- code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
- decode_subblock(dst + 4*2+0, code, 1, gb, &rvlc->coefficient, q_ac2);
+ code = bitstream_read_vlc(bc, rvlc->second_pattern[sc].table, 9, 2);
+ decode_subblock(dst + 4*2+0, code, 1, bc, &rvlc->coefficient, q_ac2);
}
if(pattern & 1){
- code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2);
- decode_subblock(dst + 4*2+2, code, 0, gb, &rvlc->coefficient, q_ac2);
+ code = bitstream_read_vlc(bc, rvlc->third_pattern[sc].table, 9, 2);
+ decode_subblock(dst + 4*2+2, code, 0, bc, &rvlc->coefficient, q_ac2);
}
return has_ac | pattern;
}
@@ -326,7 +331,7 @@ static int rv34_decode_block(int16_t *dst, GetBitContext
*gb, RV34VLC *rvlc, int
* Decode starting slice position.
* @todo Maybe replace with ff_h263_decode_mba() ?
*/
-int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
+int ff_rv34_get_start_offset(BitstreamContext *bc, int mb_size)
{
int i;
for(i = 0; i < 5; i++)
@@ -352,25 +357,25 @@ static inline RV34VLC* choose_vlc_set(int quant, int mod,
int type)
static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
{
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int t;
- r->is16 = get_bits1(gb);
+ r->is16 = bitstream_read_bit(bc);
if(r->is16){
s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA16x16;
r->block_type = RV34_MB_TYPE_INTRA16x16;
- t = get_bits(gb, 2);
+ t = bitstream_read(bc, 2);
fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t,
sizeof(intra_types[0]));
r->luma_vlc = 2;
}else{
if(!r->rv30){
- if(!get_bits1(gb))
+ if(!bitstream_read_bit(bc))
av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n");
}
s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA;
r->block_type = RV34_MB_TYPE_INTRA;
- if(r->decode_intra_types(r, gb, intra_types) < 0)
+ if(r->decode_intra_types(r, bc, intra_types) < 0)
return -1;
r->luma_vlc = 1;
}
@@ -378,7 +383,7 @@ static int rv34_decode_intra_mb_header(RV34DecContext *r,
int8_t *intra_types)
r->chroma_vlc = 0;
r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
- return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
+ return rv34_decode_cbp(bc, r->cur_vlcs, r->is16);
}
/**
@@ -387,7 +392,7 @@ static int rv34_decode_intra_mb_header(RV34DecContext *r,
int8_t *intra_types)
static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
{
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int i, t;
@@ -413,11 +418,11 @@ static int rv34_decode_inter_mb_header(RV34DecContext *r,
int8_t *intra_types)
if(IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){
if(r->is16){
- t = get_bits(gb, 2);
+ t = bitstream_read(bc, 2);
fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t,
sizeof(intra_types[0]));
r->luma_vlc = 2;
}else{
- if(r->decode_intra_types(r, gb, intra_types) < 0)
+ if(r->decode_intra_types(r, bc, intra_types) < 0)
return -1;
r->luma_vlc = 1;
}
@@ -435,7 +440,7 @@ static int rv34_decode_inter_mb_header(RV34DecContext *r,
int8_t *intra_types)
}
}
- return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
+ return rv34_decode_cbp(bc, r->cur_vlcs, r->is16);
}
/** @} */ //bitstream functions
@@ -847,15 +852,15 @@ static const int num_mvs[RV34_MB_TYPES] = { 0, 0, 1, 4,
1, 1, 0, 0, 2, 2, 2, 1 }
static int rv34_decode_mv(RV34DecContext *r, int block_type)
{
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, j, k, l;
int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
int next_bt;
memset(r->dmv, 0, sizeof(r->dmv));
for(i = 0; i < num_mvs[block_type]; i++){
- r->dmv[i][0] = svq3_get_se_golomb(gb);
- r->dmv[i][1] = svq3_get_se_golomb(gb);
+ r->dmv[i][0] = svq3_get_se_golomb(bc);
+ r->dmv[i][1] = svq3_get_se_golomb(bc);
}
switch(block_type){
case RV34_MB_TYPE_INTRA:
@@ -1002,7 +1007,7 @@ static inline void rv34_process_block(RV34DecContext *r,
{
MpegEncContext *s = &r->s;
int16_t *ptr = s->block[0];
- int has_ac = rv34_decode_block(ptr, &s->gb, r->cur_vlcs,
+ int has_ac = rv34_decode_block(ptr, &s->bc, r->cur_vlcs,
fc, sc, q_dc, q_ac, q_ac);
if(has_ac){
r->rdsp.rv34_idct_add(pdst, stride, ptr);
@@ -1016,7 +1021,7 @@ static void rv34_output_i16x16(RV34DecContext *r, int8_t
*intra_types, int cbp)
{
LOCAL_ALIGNED_16(int16_t, block16, [16]);
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int q_dc = rv34_qscale_tab[ r->luma_dc_quant_i[s->qscale] ],
q_ac = rv34_qscale_tab[s->qscale];
uint8_t *dst = s->dest[0];
@@ -1025,7 +1030,7 @@ static void rv34_output_i16x16(RV34DecContext *r, int8_t
*intra_types, int cbp)
memset(block16, 0, 16 * sizeof(*block16));
- has_ac = rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc,
q_ac);
+ has_ac = rv34_decode_block(block16, bc, r->cur_vlcs, 3, 0, q_dc, q_dc,
q_ac);
if(has_ac)
r->rdsp.rv34_inv_transform(block16);
else
@@ -1040,7 +1045,7 @@ static void rv34_output_i16x16(RV34DecContext *r, int8_t
*intra_types, int cbp)
int dc = block16[i + j*4];
if(cbp & 1){
- has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc,
0, q_ac, q_ac, q_ac);
+ has_ac = rv34_decode_block(ptr, bc, r->cur_vlcs, r->luma_vlc,
0, q_ac, q_ac, q_ac);
}else
has_ac = 0;
@@ -1184,7 +1189,7 @@ static int rv34_set_deblock_coef(RV34DecContext *r)
static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
{
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
uint8_t *dst = s->dest[0];
int16_t *ptr = s->block[0];
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -1230,7 +1235,7 @@ static int rv34_decode_inter_macroblock(RV34DecContext
*r, int8_t *intra_types)
memset(block16, 0, 16 * sizeof(*block16));
q_dc = rv34_qscale_tab[ r->luma_dc_quant_p[s->qscale] ];
q_ac = rv34_qscale_tab[s->qscale];
- if (rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc,
q_ac))
+ if (rv34_decode_block(block16, bc, r->cur_vlcs, 3, 0, q_dc, q_dc,
q_ac))
r->rdsp.rv34_inv_transform(block16);
else
r->rdsp.rv34_inv_transform_dc(block16);
@@ -1242,7 +1247,7 @@ static int rv34_decode_inter_macroblock(RV34DecContext
*r, int8_t *intra_types)
int dc = block16[i + j*4];
if(cbp & 1){
- has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs,
r->luma_vlc, 0, q_ac, q_ac, q_ac);
+ has_ac = rv34_decode_block(ptr, bc, r->cur_vlcs,
r->luma_vlc, 0, q_ac, q_ac, q_ac);
}else
has_ac = 0;
@@ -1338,8 +1343,8 @@ static int check_slice_end(RV34DecContext *r,
MpegEncContext *s)
return 1;
if(r->s.mb_skip_run > 1)
return 0;
- bits = get_bits_left(&s->gb);
- if(bits < 0 || (bits < 8 && !show_bits(&s->gb, bits)))
+ bits = bitstream_bits_left(&s->bc);
+ if(bits < 0 || (bits < 8 && !bitstream_peek(&s->bc, bits)))
return 1;
return 0;
}
@@ -1394,12 +1399,12 @@ static int rv34_decoder_realloc(RV34DecContext *r)
static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf,
int buf_size)
{
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int mb_pos, slice_type;
int res;
- init_get_bits(&r->s.gb, buf, buf_size*8);
- res = r->parse_slice_header(r, gb, &r->si);
+ bitstream_init8(&r->s.bc, buf, buf_size);
+ res = r->parse_slice_header(r, bc, &r->si);
if(res < 0){
av_log(s->avctx, AV_LOG_ERROR, "Incorrect or unknown slice header\n");
return -1;
@@ -1645,8 +1650,9 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
return AVERROR_INVALIDDATA;
}
- init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr, 0),
(buf_size-get_slice_offset(avctx, slices_hdr, 0))*8);
- if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){
+ bitstream_init8(&s->bc, buf+get_slice_offset(avctx, slices_hdr, 0),
+ (buf_size-get_slice_offset(avctx, slices_hdr, 0)));
+ if(r->parse_slice_header(r, &r->s.bc, &si) < 0 || si.start){
av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
return AVERROR_INVALIDDATA;
}
@@ -1761,8 +1767,8 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
break;
}
- init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr,
i+1), (buf_size-get_slice_offset(avctx, slices_hdr, i+1))*8);
- if(r->parse_slice_header(r, &r->s.gb, &si) < 0){
+ bitstream_init8(&s->bc, buf+get_slice_offset(avctx, slices_hdr,
i+1), (buf_size-get_slice_offset(avctx, slices_hdr, i+1)));
+ if(r->parse_slice_header(r, &r->s.bc, &si) < 0){
if(i+2 < slice_count)
size = get_slice_offset(avctx, slices_hdr, i+2) - offset;
else
diff --git a/libavcodec/rv34.h b/libavcodec/rv34.h
index 0ac24bf..dedef5f 100644
--- a/libavcodec/rv34.h
+++ b/libavcodec/rv34.h
@@ -28,7 +28,9 @@
#define AVCODEC_RV34_H
#include "avcodec.h"
+#include "bitstream.h"
#include "mpegvideo.h"
+#include "vlc.h"
#include "h264pred.h"
#include "rv34dsp.h"
@@ -121,16 +123,16 @@ typedef struct RV34DecContext{
uint8_t *tmp_b_block_uv[4];
uint8_t *tmp_b_block_base;
- int (*parse_slice_header)(struct RV34DecContext *r, GetBitContext *gb,
SliceInfo *si);
+ int (*parse_slice_header)(struct RV34DecContext *r, BitstreamContext *bc,
SliceInfo *si);
int (*decode_mb_info)(struct RV34DecContext *r);
- int (*decode_intra_types)(struct RV34DecContext *r, GetBitContext *gb,
int8_t *dst);
+ int (*decode_intra_types)(struct RV34DecContext *r, BitstreamContext *bc,
int8_t *dst);
void (*loop_filter)(struct RV34DecContext *r, int row);
}RV34DecContext;
/**
* common decoding functions
*/
-int ff_rv34_get_start_offset(GetBitContext *gb, int blocks);
+int ff_rv34_get_start_offset(BitstreamContext *bc, int blocks);
int ff_rv34_decode_init(AVCodecContext *avctx);
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt);
int ff_rv34_decode_end(AVCodecContext *avctx);
diff --git a/libavcodec/rv40.c b/libavcodec/rv40.c
index e6c77e8..129fa20 100644
--- a/libavcodec/rv40.c
+++ b/libavcodec/rv40.c
@@ -27,9 +27,11 @@
#include "libavutil/imgutils.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "mpegutils.h"
#include "mpegvideo.h"
#include "golomb.h"
+#include "vlc.h"
#include "rv34.h"
#include "rv40vlc2.h"
@@ -101,15 +103,15 @@ static av_cold void rv40_init_tables(void)
* If the width/height is the standard one then it's coded as a 3-bit index.
* Otherwise it is coded as escaped 8-bit portions.
*/
-static int get_dimension(GetBitContext *gb, const int *dim)
+static int get_dimension(BitstreamContext *bc, const int *dim)
{
- int t = get_bits(gb, 3);
+ int t = bitstream_read(bc, 3);
int val = dim[t];
if(val < 0)
- val = dim[get_bits1(gb) - val];
+ val = dim[bitstream_read_bit(bc) - val];
if(!val){
do{
- t = get_bits(gb, 8);
+ t = bitstream_read(bc, 8);
val += t << 2;
}while(t == 0xFF);
}
@@ -119,13 +121,13 @@ static int get_dimension(GetBitContext *gb, const int
*dim)
/**
* Get encoded picture size - usually this is called from
rv40_parse_slice_header.
*/
-static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)
+static void rv40_parse_picture_size(BitstreamContext *bc, int *w, int *h)
{
- *w = get_dimension(gb, rv40_standard_widths);
- *h = get_dimension(gb, rv40_standard_heights);
+ *w = get_dimension(bc, rv40_standard_widths);
+ *h = get_dimension(bc, rv40_standard_heights);
}
-static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb,
SliceInfo *si)
+static int rv40_parse_slice_header(RV34DecContext *r, BitstreamContext *bc,
SliceInfo *si)
{
int mb_bits;
int w = r->s.width, h = r->s.height;
@@ -133,25 +135,25 @@ static int rv40_parse_slice_header(RV34DecContext *r,
GetBitContext *gb, SliceIn
int ret;
memset(si, 0, sizeof(SliceInfo));
- if(get_bits1(gb))
+ if(bitstream_read_bit(bc))
return AVERROR_INVALIDDATA;
- si->type = get_bits(gb, 2);
+ si->type = bitstream_read(bc, 2);
if(si->type == 1) si->type = 0;
- si->quant = get_bits(gb, 5);
- if(get_bits(gb, 2))
+ si->quant = bitstream_read(bc, 5);
+ if(bitstream_read(bc, 2))
return AVERROR_INVALIDDATA;
- si->vlc_set = get_bits(gb, 2);
- skip_bits1(gb);
- si->pts = get_bits(gb, 13);
- if(!si->type || !get_bits1(gb))
- rv40_parse_picture_size(gb, &w, &h);
+ si->vlc_set = bitstream_read(bc, 2);
+ bitstream_skip(bc, 1);
+ si->pts = bitstream_read(bc, 13);
+ if(!si->type || !bitstream_read_bit(bc))
+ rv40_parse_picture_size(bc, &w, &h);
if ((ret = av_image_check_size(w, h, 0, r->s.avctx)) < 0)
return ret;
si->width = w;
si->height = h;
mb_size = ((w + 15) >> 4) * ((h + 15) >> 4);
- mb_bits = ff_rv34_get_start_offset(gb, mb_size);
- si->start = get_bits(gb, mb_bits);
+ mb_bits = ff_rv34_get_start_offset(bc, mb_size);
+ si->start = bitstream_read(bc, mb_bits);
return 0;
}
@@ -159,7 +161,7 @@ static int rv40_parse_slice_header(RV34DecContext *r,
GetBitContext *gb, SliceIn
/**
* Decode 4x4 intra types array.
*/
-static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb,
int8_t *dst)
+static int rv40_decode_intra_types(RV34DecContext *r, BitstreamContext *bc,
int8_t *dst)
{
MpegEncContext *s = &r->s;
int i, j, k, v;
@@ -169,7 +171,7 @@ static int rv40_decode_intra_types(RV34DecContext *r,
GetBitContext *gb, int8_t
for(i = 0; i < 4; i++, dst += r->intra_types_stride){
if(!i && s->first_slice_line){
- pattern = get_vlc2(gb, aic_top_vlc.table, AIC_TOP_BITS, 1);
+ pattern = bitstream_read_vlc(bc, aic_top_vlc.table, AIC_TOP_BITS,
1);
dst[0] = (pattern >> 2) & 2;
dst[1] = (pattern >> 1) & 2;
dst[2] = pattern & 2;
@@ -192,23 +194,23 @@ static int rv40_decode_intra_types(RV34DecContext *r,
GetBitContext *gb, int8_t
if(pattern == rv40_aic_table_index[k])
break;
if(j < 3 && k < MODE2_PATTERNS_NUM){ //pattern is found, decoding
2 coefficients
- v = get_vlc2(gb, aic_mode2_vlc[k].table, AIC_MODE2_BITS, 2);
+ v = bitstream_read_vlc(bc, aic_mode2_vlc[k].table,
AIC_MODE2_BITS, 2);
*ptr++ = v/9;
*ptr++ = v%9;
j++;
}else{
if(B != -1 && C != -1)
- v = get_vlc2(gb, aic_mode1_vlc[B + C*10].table,
AIC_MODE1_BITS, 1);
+ v = bitstream_read_vlc(bc, aic_mode1_vlc[B + C*10].table,
AIC_MODE1_BITS, 1);
else{ // tricky decoding
v = 0;
switch(C){
case -1: // code 0 -> 1, 1 -> 0
if(B < 2)
- v = get_bits1(gb) ^ 1;
+ v = bitstream_read_bit(bc) ^ 1;
break;
case 0:
case 2: // code 0 -> 2, 1 -> 0
- v = (get_bits1(gb) ^ 1) << 1;
+ v = (bitstream_read_bit(bc) ^ 1) << 1;
break;
}
}
@@ -225,13 +227,13 @@ static int rv40_decode_intra_types(RV34DecContext *r,
GetBitContext *gb, int8_t
static int rv40_decode_mb_info(RV34DecContext *r)
{
MpegEncContext *s = &r->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int q, i;
int prev_type = 0;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
if(!r->s.mb_skip_run)
- r->s.mb_skip_run = svq3_get_ue_golomb(gb) + 1;
+ r->s.mb_skip_run = svq3_get_ue_golomb(bc) + 1;
if(--r->s.mb_skip_run)
return RV34_MB_SKIP;
@@ -259,17 +261,17 @@ static int rv40_decode_mb_info(RV34DecContext *r)
if(s->pict_type == AV_PICTURE_TYPE_P){
prev_type = block_num_to_ptype_vlc_num[prev_type];
- q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1);
+ q = bitstream_read_vlc(bc, ptype_vlc[prev_type].table, PTYPE_VLC_BITS,
1);
if(q < PBTYPE_ESCAPE)
return q;
- q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1);
+ q = bitstream_read_vlc(bc, ptype_vlc[prev_type].table, PTYPE_VLC_BITS,
1);
av_log(s->avctx, AV_LOG_ERROR, "Dquant for P-frame\n");
}else{
prev_type = block_num_to_btype_vlc_num[prev_type];
- q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1);
+ q = bitstream_read_vlc(bc, btype_vlc[prev_type].table, BTYPE_VLC_BITS,
1);
if(q < PBTYPE_ESCAPE)
return q;
- q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1);
+ q = bitstream_read_vlc(bc, btype_vlc[prev_type].table, BTYPE_VLC_BITS,
1);
av_log(s->avctx, AV_LOG_ERROR, "Dquant for B-frame\n");
}
return 0;
--
2.1.4
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
