---
libavcodec/dxva2_vc1.c | 3 +-
libavcodec/vaapi_vc1.c | 3 +-
libavcodec/vc1.c | 448 ++++++++++++++++++++++++------------------------
libavcodec/vc1.h | 12 +-
libavcodec/vc1_block.c | 322 +++++++++++++++++++---------------
libavcodec/vc1_parser.c | 15 +-
libavcodec/vc1_pred.c | 13 +-
libavcodec/vc1data.h | 4 +-
libavcodec/vc1dec.c | 127 +++++++-------
9 files changed, 502 insertions(+), 445 deletions(-)
diff --git a/libavcodec/dxva2_vc1.c b/libavcodec/dxva2_vc1.c
index d170e18..cbfca24 100644
--- a/libavcodec/dxva2_vc1.c
+++ b/libavcodec/dxva2_vc1.c
@@ -20,6 +20,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "bitstream.h"
#include "mpegutils.h"
#include "vc1.h"
#include "vc1data.h"
@@ -154,7 +155,7 @@ static void fill_slice(AVCodecContext *avctx,
DXVA_SliceInfo *slice,
slice->dwSliceDataLocation = position;
slice->bStartCodeBitOffset = 0;
slice->bReservedBits = 0;
- slice->wMBbitOffset = get_bits_count(&s->gb);
+ slice->wMBbitOffset = bitstream_tell(&s->bc);
slice->wNumberMBsInSlice = s->mb_width * s->mb_height; /* XXX We assume
1 slice */
slice->wQuantizerScaleCode = v->pq;
slice->wBadSliceChopping = 0;
diff --git a/libavcodec/vaapi_vc1.c b/libavcodec/vaapi_vc1.c
index 4022549..7c84284 100644
--- a/libavcodec/vaapi_vc1.c
+++ b/libavcodec/vaapi_vc1.c
@@ -20,6 +20,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "bitstream.h"
#include "vaapi_internal.h"
#include "internal.h"
#include "vc1.h"
@@ -325,7 +326,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext *avctx,
const uint8_t *buffer,
slice_param = (VASliceParameterBufferVC1
*)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size);
if (!slice_param)
return -1;
- slice_param->macroblock_offset = get_bits_count(&s->gb);
+ slice_param->macroblock_offset = bitstream_tell(&s->bc);
slice_param->slice_vertical_position = s->mb_y;
return 0;
}
diff --git a/libavcodec/vc1.c b/libavcodec/vc1.c
index 7a93e97..a57cc6f 100644
--- a/libavcodec/vc1.c
+++ b/libavcodec/vc1.c
@@ -29,12 +29,14 @@
#include "libavutil/attributes.h"
#include "internal.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "mpegvideo.h"
#include "vc1.h"
#include "vc1data.h"
#include "wmv2data.h"
#include "unary.h"
#include "simple_idct.h"
+#include "vlc.h"
/***********************************************************************/
/**
@@ -65,16 +67,16 @@ enum Imode {
* @param[in] stride of this buffer
*/
static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
- GetBitContext *gb)
+ BitstreamContext *bc)
{
int x, y;
for (y = 0; y < height; y++) {
- if (!get_bits1(gb)) //rowskip
+ if (!bitstream_read_bit(bc)) //rowskip
memset(plane, 0, width);
else
for (x = 0; x < width; x++)
- plane[x] = get_bits1(gb);
+ plane[x] = bitstream_read_bit(bc);
plane += stride;
}
}
@@ -87,17 +89,17 @@ static void decode_rowskip(uint8_t* plane, int width, int
height, int stride,
* @todo FIXME: Optimize
*/
static void decode_colskip(uint8_t* plane, int width, int height, int stride,
- GetBitContext *gb)
+ BitstreamContext *bc)
{
int x, y;
for (x = 0; x < width; x++) {
- if (!get_bits1(gb)) //colskip
+ if (!bitstream_read_bit(bc)) //colskip
for (y = 0; y < height; y++)
plane[y*stride] = 0;
else
for (y = 0; y < height; y++)
- plane[y*stride] = get_bits1(gb);
+ plane[y*stride] = bitstream_read_bit(bc);
plane ++;
}
}
@@ -111,7 +113,7 @@ static void decode_colskip(uint8_t* plane, int width, int
height, int stride,
*/
static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
{
- GetBitContext *gb = &v->s.gb;
+ BitstreamContext *bc = &v->s.bc;
int imode, x, y, code, offset;
uint8_t invert, *planep = data;
@@ -120,8 +122,8 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag,
VC1Context *v)
width = v->s.mb_width;
height = v->s.mb_height >> v->field_mode;
stride = v->s.mb_stride;
- invert = get_bits1(gb);
- imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
+ invert = bitstream_read_bit(bc);
+ imode = bitstream_read_vlc(bc, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS,
1);
*raw_flag = 0;
switch (imode) {
@@ -132,14 +134,14 @@ static int bitplane_decoding(uint8_t* data, int
*raw_flag, VC1Context *v)
case IMODE_DIFF2:
case IMODE_NORM2:
if ((height * width) & 1) {
- *planep++ = get_bits1(gb);
+ *planep++ = bitstream_read_bit(bc);
offset = 1;
}
else
offset = 0;
// decode bitplane as one long line
for (y = offset; y < height * width; y += 2) {
- code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
+ code = bitstream_read_vlc(bc, ff_vc1_norm2_vlc.table,
VC1_NORM2_VLC_BITS, 1);
*planep++ = code & 1;
offset++;
if (offset == width) {
@@ -159,7 +161,8 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag,
VC1Context *v)
if (!(height % 3) && (width % 3)) { // use 2x3 decoding
for (y = 0; y < height; y += 3) {
for (x = width & 1; x < width; x += 2) {
- code = get_vlc2(gb, ff_vc1_norm6_vlc.table,
VC1_NORM6_VLC_BITS, 2);
+ code = bitstream_read_vlc(bc, ff_vc1_norm6_vlc.table,
+ VC1_NORM6_VLC_BITS, 2);
if (code < 0) {
av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6
VLC\n");
return -1;
@@ -174,12 +177,13 @@ static int bitplane_decoding(uint8_t* data, int
*raw_flag, VC1Context *v)
planep += stride * 3;
}
if (width & 1)
- decode_colskip(data, 1, height, stride, &v->s.gb);
+ decode_colskip(data, 1, height, stride, &v->s.bc);
} else { // 3x2
planep += (height & 1) * stride;
for (y = height & 1; y < height; y += 2) {
for (x = width % 3; x < width; x += 3) {
- code = get_vlc2(gb, ff_vc1_norm6_vlc.table,
VC1_NORM6_VLC_BITS, 2);
+ code = bitstream_read_vlc(bc, ff_vc1_norm6_vlc.table,
+ VC1_NORM6_VLC_BITS, 2);
if (code < 0) {
av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6
VLC\n");
return -1;
@@ -195,16 +199,16 @@ static int bitplane_decoding(uint8_t* data, int
*raw_flag, VC1Context *v)
}
x = width % 3;
if (x)
- decode_colskip(data, x, height, stride, &v->s.gb);
+ decode_colskip(data, x, height, stride, &v->s.bc);
if (height & 1)
- decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
+ decode_rowskip(data + x, width - x, 1, stride, &v->s.bc);
}
break;
case IMODE_ROWSKIP:
- decode_rowskip(data, width, height, stride, &v->s.gb);
+ decode_rowskip(data, width, height, stride, &v->s.bc);
break;
case IMODE_COLSKIP:
- decode_colskip(data, width, height, stride, &v->s.gb);
+ decode_colskip(data, width, height, stride, &v->s.bc);
break;
default:
break;
@@ -240,36 +244,36 @@ static int bitplane_decoding(uint8_t* data, int
*raw_flag, VC1Context *v)
*/
static int vop_dquant_decoding(VC1Context *v)
{
- GetBitContext *gb = &v->s.gb;
+ BitstreamContext *bc = &v->s.bc;
int pqdiff;
//variable size
if (v->dquant == 2) {
- pqdiff = get_bits(gb, 3);
+ pqdiff = bitstream_read(bc, 3);
if (pqdiff == 7)
- v->altpq = get_bits(gb, 5);
+ v->altpq = bitstream_read(bc, 5);
else
v->altpq = v->pq + pqdiff + 1;
} else {
- v->dquantfrm = get_bits1(gb);
+ v->dquantfrm = bitstream_read_bit(bc);
if (v->dquantfrm) {
- v->dqprofile = get_bits(gb, 2);
+ v->dqprofile = bitstream_read(bc, 2);
switch (v->dqprofile) {
case DQPROFILE_SINGLE_EDGE:
case DQPROFILE_DOUBLE_EDGES:
- v->dqsbedge = get_bits(gb, 2);
+ v->dqsbedge = bitstream_read(bc, 2);
break;
case DQPROFILE_ALL_MBS:
- v->dqbilevel = get_bits1(gb);
+ v->dqbilevel = bitstream_read_bit(bc);
if (!v->dqbilevel)
v->halfpq = 0;
default:
break; //Forbidden ?
}
if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
- pqdiff = get_bits(gb, 3);
+ pqdiff = bitstream_read(bc, 3);
if (pqdiff == 7)
- v->altpq = get_bits(gb, 5);
+ v->altpq = bitstream_read(bc, 5);
else
v->altpq = v->pq + pqdiff + 1;
}
@@ -278,19 +282,19 @@ static int vop_dquant_decoding(VC1Context *v)
return 0;
}
-static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
+static int decode_sequence_header_adv(VC1Context *v, BitstreamContext *bc);
/**
* Decode Simple/Main Profiles sequence header
* @see Figure 7-8, p16-17
* @param avctx Codec context
- * @param gb GetBit context initialized from Codec context extra_data
+ * @param bc Bitstream context initialized from Codec context extra_data
* @return Status
*/
-int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v,
GetBitContext *gb)
+int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v,
BitstreamContext *bc)
{
- av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
- v->profile = get_bits(gb, 2);
+ av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", bitstream_peek(bc, 32));
+ v->profile = bitstream_read(bc, 2);
if (v->profile == PROFILE_COMPLEX) {
av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully
supported\n");
}
@@ -298,12 +302,12 @@ int ff_vc1_decode_sequence_header(AVCodecContext *avctx,
VC1Context *v, GetBitCo
if (v->profile == PROFILE_ADVANCED) {
v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
- return decode_sequence_header_adv(v, gb);
+ return decode_sequence_header_adv(v, bc);
} else {
v->zz_8x4 = ff_wmv2_scantableA;
v->zz_4x8 = ff_wmv2_scantableB;
- v->res_y411 = get_bits1(gb);
- v->res_sprite = get_bits1(gb);
+ v->res_y411 = bitstream_read_bit(bc);
+ v->res_sprite = bitstream_read_bit(bc);
if (v->res_y411) {
av_log(avctx, AV_LOG_ERROR,
"Old interlaced mode is not supported\n");
@@ -312,10 +316,10 @@ int ff_vc1_decode_sequence_header(AVCodecContext *avctx,
VC1Context *v, GetBitCo
}
// (fps-2)/4 (->30)
- v->frmrtq_postproc = get_bits(gb, 3); //common
+ v->frmrtq_postproc = bitstream_read(bc, 3); //common
// (bitrate-32kbps)/64kbps
- v->bitrtq_postproc = get_bits(gb, 5); //common
- v->s.loop_filter = get_bits1(gb); //common
+ v->bitrtq_postproc = bitstream_read(bc, 5); //common
+ v->s.loop_filter = bitstream_read_bit(bc); //common
if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
av_log(avctx, AV_LOG_ERROR,
"LOOPFILTER shall not be enabled in Simple Profile\n");
@@ -323,9 +327,9 @@ int ff_vc1_decode_sequence_header(AVCodecContext *avctx,
VC1Context *v, GetBitCo
if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
v->s.loop_filter = 0;
- v->res_x8 = get_bits1(gb); //reserved
- v->multires = get_bits1(gb);
- v->res_fasttx = get_bits1(gb);
+ v->res_x8 = bitstream_read_bit(bc); //reserved
+ v->multires = bitstream_read_bit(bc);
+ v->res_fasttx = bitstream_read_bit(bc);
if (!v->res_fasttx) {
v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
@@ -337,23 +341,23 @@ int ff_vc1_decode_sequence_header(AVCodecContext *avctx,
VC1Context *v, GetBitCo
v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
}
- v->fastuvmc = get_bits1(gb); //common
+ v->fastuvmc = bitstream_read_bit(bc); //common
if (!v->profile && !v->fastuvmc) {
av_log(avctx, AV_LOG_ERROR,
"FASTUVMC unavailable in Simple Profile\n");
return -1;
}
- v->extended_mv = get_bits1(gb); //common
+ v->extended_mv = bitstream_read_bit(bc); //common
if (!v->profile && v->extended_mv)
{
av_log(avctx, AV_LOG_ERROR,
"Extended MVs unavailable in Simple Profile\n");
return -1;
}
- v->dquant = get_bits(gb, 2); //common
- v->vstransform = get_bits1(gb); //common
+ v->dquant = bitstream_read(bc, 2); //common
+ v->vstransform = bitstream_read_bit(bc); //common
- v->res_transtab = get_bits1(gb);
+ v->res_transtab = bitstream_read_bit(bc);
if (v->res_transtab)
{
av_log(avctx, AV_LOG_ERROR,
@@ -361,33 +365,33 @@ int ff_vc1_decode_sequence_header(AVCodecContext *avctx,
VC1Context *v, GetBitCo
return -1;
}
- v->overlap = get_bits1(gb); //common
+ v->overlap = bitstream_read_bit(bc); //common
- v->resync_marker = get_bits1(gb);
- v->rangered = get_bits1(gb);
+ v->resync_marker = bitstream_read_bit(bc);
+ v->rangered = bitstream_read_bit(bc);
if (v->rangered && v->profile == PROFILE_SIMPLE) {
av_log(avctx, AV_LOG_INFO,
"RANGERED should be set to 0 in Simple Profile\n");
}
- v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
- v->quantizer_mode = get_bits(gb, 2); //common
+ v->s.max_b_frames = avctx->max_b_frames = bitstream_read(bc, 3); //common
+ v->quantizer_mode = bitstream_read(bc, 2); //common
- v->finterpflag = get_bits1(gb); //common
+ v->finterpflag = bitstream_read_bit(bc); //common
if (v->res_sprite) {
- v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11);
- v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
- skip_bits(gb, 5); //frame rate
- v->res_x8 = get_bits1(gb);
- if (get_bits1(gb)) { // something to do with DC VLC selection
+ v->s.avctx->width = v->s.avctx->coded_width = bitstream_read(bc, 11);
+ v->s.avctx->height = v->s.avctx->coded_height = bitstream_read(bc, 11);
+ bitstream_skip(bc, 5); //frame rate
+ v->res_x8 = bitstream_read_bit(bc);
+ if (bitstream_read_bit(bc)) { // something to do with DC VLC selection
av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
return -1;
}
- skip_bits(gb, 3); //slice code
+ bitstream_skip(bc, 3); //slice code
v->res_rtm_flag = 0;
} else {
- v->res_rtm_flag = get_bits1(gb); //reserved
+ v->res_rtm_flag = bitstream_read_bit(bc); //reserved
}
if (!v->res_rtm_flag) {
av_log(avctx, AV_LOG_ERROR,
@@ -396,7 +400,7 @@ int ff_vc1_decode_sequence_header(AVCodecContext *avctx,
VC1Context *v, GetBitCo
}
//TODO: figure out what they mean (always 0x402F)
if (!v->res_fasttx)
- skip_bits(gb, 16);
+ bitstream_skip(bc, 16);
av_log(avctx, AV_LOG_DEBUG,
"Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
"LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
@@ -409,14 +413,14 @@ int ff_vc1_decode_sequence_header(AVCodecContext *avctx,
VC1Context *v, GetBitCo
return 0;
}
-static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
+static int decode_sequence_header_adv(VC1Context *v, BitstreamContext *bc)
{
v->res_rtm_flag = 1;
- v->level = get_bits(gb, 3);
+ v->level = bitstream_read(bc, 3);
if (v->level >= 5) {
av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
}
- v->chromaformat = get_bits(gb, 2);
+ v->chromaformat = bitstream_read(bc, 2);
if (v->chromaformat != 1) {
av_log(v->s.avctx, AV_LOG_ERROR,
"Only 4:2:0 chroma format supported\n");
@@ -424,20 +428,20 @@ static int decode_sequence_header_adv(VC1Context *v,
GetBitContext *gb)
}
// (fps-2)/4 (->30)
- v->frmrtq_postproc = get_bits(gb, 3); //common
+ v->frmrtq_postproc = bitstream_read(bc, 3); //common
// (bitrate-32kbps)/64kbps
- v->bitrtq_postproc = get_bits(gb, 5); //common
- v->postprocflag = get_bits1(gb); //common
+ v->bitrtq_postproc = bitstream_read(bc, 5); //common
+ v->postprocflag = bitstream_read_bit(bc); //common
- v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
- v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
+ v->s.avctx->coded_width = (bitstream_read(bc, 12) + 1) << 1;
+ v->s.avctx->coded_height = (bitstream_read(bc, 12) + 1) << 1;
v->s.avctx->width = v->s.avctx->coded_width;
v->s.avctx->height = v->s.avctx->coded_height;
- v->broadcast = get_bits1(gb);
- v->interlace = get_bits1(gb);
- v->tfcntrflag = get_bits1(gb);
- v->finterpflag = get_bits1(gb);
- skip_bits1(gb); // reserved
+ v->broadcast = bitstream_read_bit(bc);
+ v->interlace = bitstream_read_bit(bc);
+ v->tfcntrflag = bitstream_read_bit(bc);
+ v->finterpflag = bitstream_read_bit(bc);
+ bitstream_skip(bc, 1); // reserved
av_log(v->s.avctx, AV_LOG_DEBUG,
"Advanced Profile level %i:\nfrmrtq_postproc=%i,
bitrtq_postproc=%i\n"
@@ -447,25 +451,25 @@ static int decode_sequence_header_adv(VC1Context *v,
GetBitContext *gb)
v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
v->tfcntrflag, v->finterpflag);
- v->psf = get_bits1(gb);
+ v->psf = bitstream_read_bit(bc);
if (v->psf) { //PsF, 6.1.13
av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode:
not supported (yet)\n");
return -1;
}
v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
- if (get_bits1(gb)) { //Display Info - decoding is not affected by it
+ if (bitstream_read_bit(bc)) { //Display Info - decoding is not affected by
it
int w, h, ar = 0;
av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
- w = get_bits(gb, 14) + 1;
- h = get_bits(gb, 14) + 1;
+ w = bitstream_read(bc, 14) + 1;
+ h = bitstream_read(bc, 14) + 1;
av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
- if (get_bits1(gb))
- ar = get_bits(gb, 4);
+ if (bitstream_read_bit(bc))
+ ar = bitstream_read(bc, 4);
if (ar && ar < 14) {
v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
} else if (ar == 15) {
- w = get_bits(gb, 8) + 1;
- h = get_bits(gb, 8) + 1;
+ w = bitstream_read(bc, 8) + 1;
+ h = bitstream_read(bc, 8) + 1;
v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
} else {
av_reduce(&v->s.avctx->sample_aspect_ratio.num,
@@ -479,14 +483,14 @@ static int decode_sequence_header_adv(VC1Context *v,
GetBitContext *gb)
v->s.avctx->sample_aspect_ratio.num,
v->s.avctx->sample_aspect_ratio.den);
- if (get_bits1(gb)) { //framerate stuff
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) { //framerate stuff
+ if (bitstream_read_bit(bc)) {
v->s.avctx->framerate.den = 32;
- v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
+ v->s.avctx->framerate.num = bitstream_read(bc, 16) + 1;
} else {
int nr, dr;
- nr = get_bits(gb, 8);
- dr = get_bits(gb, 4);
+ nr = bitstream_read(bc, 8);
+ dr = bitstream_read(bc, 4);
if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
@@ -498,63 +502,63 @@ static int decode_sequence_header_adv(VC1Context *v,
GetBitContext *gb)
}
}
- if (get_bits1(gb)) {
- v->color_prim = get_bits(gb, 8);
- v->transfer_char = get_bits(gb, 8);
- v->matrix_coef = get_bits(gb, 8);
+ if (bitstream_read_bit(bc)) {
+ v->color_prim = bitstream_read(bc, 8);
+ v->transfer_char = bitstream_read(bc, 8);
+ v->matrix_coef = bitstream_read(bc, 8);
}
}
- v->hrd_param_flag = get_bits1(gb);
+ v->hrd_param_flag = bitstream_read_bit(bc);
if (v->hrd_param_flag) {
int i;
- v->hrd_num_leaky_buckets = get_bits(gb, 5);
- skip_bits(gb, 4); //bitrate exponent
- skip_bits(gb, 4); //buffer size exponent
+ v->hrd_num_leaky_buckets = bitstream_read(bc, 5);
+ bitstream_skip(bc, 4); //bitrate exponent
+ bitstream_skip(bc, 4); //buffer size exponent
for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
- skip_bits(gb, 16); //hrd_rate[n]
- skip_bits(gb, 16); //hrd_buffer[n]
+ bitstream_skip(bc, 16); //hrd_rate[n]
+ bitstream_skip(bc, 16); //hrd_buffer[n]
}
}
return 0;
}
-int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v,
GetBitContext *gb)
+int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v,
BitstreamContext *bc)
{
int i;
- av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
- v->broken_link = get_bits1(gb);
- v->closed_entry = get_bits1(gb);
- v->panscanflag = get_bits1(gb);
- v->refdist_flag = get_bits1(gb);
- v->s.loop_filter = get_bits1(gb);
- v->fastuvmc = get_bits1(gb);
- v->extended_mv = get_bits1(gb);
- v->dquant = get_bits(gb, 2);
- v->vstransform = get_bits1(gb);
- v->overlap = get_bits1(gb);
- v->quantizer_mode = get_bits(gb, 2);
+ av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", bitstream_peek(bc, 32));
+ v->broken_link = bitstream_read_bit(bc);
+ v->closed_entry = bitstream_read_bit(bc);
+ v->panscanflag = bitstream_read_bit(bc);
+ v->refdist_flag = bitstream_read_bit(bc);
+ v->s.loop_filter = bitstream_read_bit(bc);
+ v->fastuvmc = bitstream_read_bit(bc);
+ v->extended_mv = bitstream_read_bit(bc);
+ v->dquant = bitstream_read(bc, 2);
+ v->vstransform = bitstream_read_bit(bc);
+ v->overlap = bitstream_read_bit(bc);
+ v->quantizer_mode = bitstream_read(bc, 2);
if (v->hrd_param_flag) {
for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
- skip_bits(gb, 8); //hrd_full[n]
+ bitstream_skip(bc, 8); //hrd_full[n]
}
}
- if (get_bits1(gb)) {
- avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
- avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
+ if (bitstream_read_bit(bc)) {
+ avctx->width = avctx->coded_width = (bitstream_read(bc, 12) + 1) <<
1;
+ avctx->height = avctx->coded_height = (bitstream_read(bc, 12) + 1) <<
1;
}
if (v->extended_mv)
- v->extended_dmv = get_bits1(gb);
- if ((v->range_mapy_flag = get_bits1(gb))) {
+ v->extended_dmv = bitstream_read_bit(bc);
+ if ((v->range_mapy_flag = bitstream_read_bit(bc))) {
av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect
wrong picture\n");
- v->range_mapy = get_bits(gb, 3);
+ v->range_mapy = bitstream_read(bc, 3);
}
- if ((v->range_mapuv_flag = get_bits1(gb))) {
+ if ((v->range_mapuv_flag = bitstream_read_bit(bc))) {
av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect
wrong picture\n");
- v->range_mapuv = get_bits(gb, 3);
+ v->range_mapuv = bitstream_read(bc, 3);
}
av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
@@ -617,25 +621,25 @@ static void rotate_luts(VC1Context *v)
}
}
-int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
+int ff_vc1_parse_frame_header(VC1Context *v, BitstreamContext* bc)
{
int pqindex, lowquant, status;
if (v->finterpflag)
- v->interpfrm = get_bits1(gb);
+ v->interpfrm = bitstream_read_bit(bc);
if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
v->respic =
v->rangered =
- v->multires = get_bits(gb, 2) == 1;
+ v->multires = bitstream_read(bc, 2) == 1;
else
- skip_bits(gb, 2); //framecnt unused
+ bitstream_skip(bc, 2); //framecnt unused
v->rangeredfrm = 0;
if (v->rangered)
- v->rangeredfrm = get_bits1(gb);
- v->s.pict_type = get_bits1(gb);
+ v->rangeredfrm = bitstream_read_bit(bc);
+ v->s.pict_type = bitstream_read_bit(bc);
if (v->s.avctx->max_b_frames) {
if (!v->s.pict_type) {
- if (get_bits1(gb))
+ if (bitstream_read_bit(bc))
v->s.pict_type = AV_PICTURE_TYPE_I;
else
v->s.pict_type = AV_PICTURE_TYPE_B;
@@ -646,14 +650,15 @@ int ff_vc1_parse_frame_header(VC1Context *v,
GetBitContext* gb)
v->bi_type = 0;
if (v->s.pict_type == AV_PICTURE_TYPE_B) {
- v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table,
VC1_BFRACTION_VLC_BITS, 1);
+ v->bfraction_lut_index = bitstream_read_vlc(bc,
ff_vc1_bfraction_vlc.table,
+ VC1_BFRACTION_VLC_BITS, 1);
v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
if (v->bfraction == 0) {
v->s.pict_type = AV_PICTURE_TYPE_BI;
}
}
if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type ==
AV_PICTURE_TYPE_BI)
- skip_bits(gb, 7); // skip buffer fullness
+ bitstream_skip(bc, 7); // skip buffer fullness
if (v->parse_only)
return 0;
@@ -665,7 +670,7 @@ int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext*
gb)
v->rnd ^= 1;
/* Quantizer stuff */
- pqindex = get_bits(gb, 5);
+ pqindex = bitstream_read(bc, 5);
if (!pqindex)
return -1;
if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
@@ -680,23 +685,23 @@ int ff_vc1_parse_frame_header(VC1Context *v,
GetBitContext* gb)
v->pquantizer = 0;
v->pqindex = pqindex;
if (pqindex < 9)
- v->halfpq = get_bits1(gb);
+ v->halfpq = bitstream_read_bit(bc);
else
v->halfpq = 0;
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
- v->pquantizer = get_bits1(gb);
+ v->pquantizer = bitstream_read_bit(bc);
v->dquantfrm = 0;
if (v->extended_mv == 1)
- v->mvrange = get_unary(gb, 0, 3);
+ v->mvrange = get_unary(bc, 0, 3);
v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
v->range_x = 1 << (v->k_x - 1);
v->range_y = 1 << (v->k_y - 1);
if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
- v->respic = get_bits(gb, 2);
+ v->respic = bitstream_read(bc, 2);
if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type ==
AV_PICTURE_TYPE_BI)) {
- v->x8_type = get_bits1(gb);
+ v->x8_type = bitstream_read_bit(bc);
} else
v->x8_type = 0;
ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
@@ -713,11 +718,11 @@ int ff_vc1_parse_frame_header(VC1Context *v,
GetBitContext* gb)
else v->tt_index = 2;
lowquant = (v->pq > 12) ? 0 : 1;
- v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
+ v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(bc, 1, 4)];
if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
- v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1,
3)];
- v->lumscale = get_bits(gb, 6);
- v->lumshift = get_bits(gb, 6);
+ v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(bc, 1,
3)];
+ v->lumscale = bitstream_read(bc, 6);
+ v->lumshift = bitstream_read(bc, 6);
v->last_use_ic = 1;
/* fill lookup tables for intensity compensation */
INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0],
v->last_lutuv[0], 1);
@@ -754,8 +759,8 @@ int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext*
gb)
"Imode: %i, Invert: %i\n", status>>1, status&1);
/* Hopefully this is correct for P-frames */
- v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
- v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
+ v->s.mv_table_index = bitstream_read(bc, 2); //but using ff_vc1_ tables
+ v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[bitstream_read(bc, 2)];
if (v->dquant) {
av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
@@ -764,9 +769,9 @@ int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext*
gb)
v->ttfrm = 0; //FIXME Is that so ?
if (v->vstransform) {
- v->ttmbf = get_bits1(gb);
+ v->ttmbf = bitstream_read_bit(bc);
if (v->ttmbf) {
- v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
+ v->ttfrm = ff_vc1_ttfrm_to_tt[bitstream_read(bc, 2)];
}
} else {
v->ttmbf = 1;
@@ -778,7 +783,7 @@ int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext*
gb)
else if (v->pq < 13) v->tt_index = 1;
else v->tt_index = 2;
- v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV :
MV_PMODE_1MV_HPEL_BILIN;
+ v->mv_mode = bitstream_read_bit(bc) ? MV_PMODE_1MV :
MV_PMODE_1MV_HPEL_BILIN;
v->qs_last = v->s.quarter_sample;
v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
v->s.mspel = v->s.quarter_sample;
@@ -794,8 +799,8 @@ int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext*
gb)
av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
"Imode: %i, Invert: %i\n", status>>1, status&1);
- v->s.mv_table_index = get_bits(gb, 2);
- v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
+ v->s.mv_table_index = bitstream_read(bc, 2);
+ v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[bitstream_read(bc, 2)];
if (v->dquant) {
av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
@@ -804,9 +809,9 @@ int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext*
gb)
v->ttfrm = 0;
if (v->vstransform) {
- v->ttmbf = get_bits1(gb);
+ v->ttmbf = bitstream_read_bit(bc);
if (v->ttmbf) {
- v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
+ v->ttfrm = ff_vc1_ttfrm_to_tt[bitstream_read(bc, 2)];
}
} else {
v->ttmbf = 1;
@@ -817,12 +822,12 @@ int ff_vc1_parse_frame_header(VC1Context *v,
GetBitContext* gb)
if (!v->x8_type) {
/* AC Syntax */
- v->c_ac_table_index = decode012(gb);
+ v->c_ac_table_index = bitstream_decode012(bc);
if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type ==
AV_PICTURE_TYPE_BI) {
- v->y_ac_table_index = decode012(gb);
+ v->y_ac_table_index = bitstream_decode012(bc);
}
/* DC Syntax */
- v->s.dc_table_index = get_bits1(gb);
+ v->s.dc_table_index = bitstream_read_bit(bc);
}
if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
@@ -832,7 +837,7 @@ int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext*
gb)
return 0;
}
-int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
+int ff_vc1_parse_frame_header_adv(VC1Context *v, BitstreamContext* bc)
{
int pqindex, lowquant;
int status;
@@ -852,7 +857,7 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
field_mode = 0;
if (v->interlace) {
- fcm = decode012(gb);
+ fcm = bitstream_decode012(bc);
if (fcm) {
if (fcm == ILACE_FIELD)
field_mode = 1;
@@ -867,13 +872,13 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
if (v->field_mode) {
v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
- v->fptype = get_bits(gb, 3);
+ v->fptype = bitstream_read(bc, 3);
v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P :
AV_PICTURE_TYPE_I;
if (v->fptype & 4) // B-picture
v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI :
AV_PICTURE_TYPE_B;
} else {
v->s.mb_height = v->s.height + 15 >> 4;
- switch (get_unary(gb, 0, 4)) {
+ switch (get_unary(bc, 0, 4)) {
case 0:
v->s.pict_type = AV_PICTURE_TYPE_P;
break;
@@ -893,13 +898,13 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
}
}
if (v->tfcntrflag)
- skip_bits(gb, 8);
+ bitstream_skip(bc, 8);
if (v->broadcast) {
if (!v->interlace || v->psf) {
- v->rptfrm = get_bits(gb, 2);
+ v->rptfrm = bitstream_read(bc, 2);
} else {
- v->tff = get_bits1(gb);
- v->rff = get_bits1(gb);
+ v->tff = bitstream_read_bit(bc);
+ v->rff = bitstream_read_bit(bc);
}
}
if (v->panscanflag) {
@@ -909,19 +914,20 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
if (v->p_frame_skipped) {
return 0;
}
- v->rnd = get_bits1(gb);
+ v->rnd = bitstream_read_bit(bc);
if (v->interlace)
- v->uvsamp = get_bits1(gb);
+ v->uvsamp = bitstream_read_bit(bc);
if (v->field_mode) {
if (!v->refdist_flag)
v->refdist = 0;
else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type !=
AV_PICTURE_TYPE_BI)) {
- v->refdist = get_bits(gb, 2);
+ v->refdist = bitstream_read(bc, 2);
if (v->refdist == 3)
- v->refdist += get_unary(gb, 0, 16);
+ v->refdist += get_unary(bc, 0, 16);
}
if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type ==
AV_PICTURE_TYPE_BI)) {
- v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table,
VC1_BFRACTION_VLC_BITS, 1);
+ v->bfraction_lut_index = bitstream_read_vlc(bc,
ff_vc1_bfraction_vlc.table,
+
VC1_BFRACTION_VLC_BITS, 1);
v->bfraction =
ff_vc1_bfraction_lut[v->bfraction_lut_index];
v->frfd = (v->bfraction * v->refdist) >> 8;
v->brfd = v->refdist - v->frfd - 1;
@@ -932,9 +938,10 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
}
if (v->fcm == PROGRESSIVE) {
if (v->finterpflag)
- v->interpfrm = get_bits1(gb);
+ v->interpfrm = bitstream_read_bit(bc);
if (v->s.pict_type == AV_PICTURE_TYPE_B) {
- v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table,
VC1_BFRACTION_VLC_BITS, 1);
+ v->bfraction_lut_index = bitstream_read_vlc(bc,
ff_vc1_bfraction_vlc.table,
+
VC1_BFRACTION_VLC_BITS, 1);
v->bfraction =
ff_vc1_bfraction_lut[v->bfraction_lut_index];
if (v->bfraction == 0) {
v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen
here */
@@ -945,7 +952,7 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
parse_common_info:
if (v->field_mode)
v->cur_field_type = !(v->tff ^ v->second_field);
- pqindex = get_bits(gb, 5);
+ pqindex = bitstream_read(bc, 5);
if (!pqindex)
return -1;
v->pqindex = pqindex;
@@ -961,13 +968,13 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
v->pquantizer = 0;
v->pqindex = pqindex;
if (pqindex < 9)
- v->halfpq = get_bits1(gb);
+ v->halfpq = bitstream_read_bit(bc);
else
v->halfpq = 0;
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
- v->pquantizer = get_bits1(gb);
+ v->pquantizer = bitstream_read_bit(bc);
if (v->postprocflag)
- v->postproc = get_bits(gb, 2);
+ v->postproc = bitstream_read(bc, 2);
if (v->parse_only)
return 0;
@@ -992,7 +999,7 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
"Imode: %i, Invert: %i\n", status>>1, status&1);
v->condover = CONDOVER_NONE;
if (v->overlap && v->pq <= 8) {
- v->condover = decode012(gb);
+ v->condover = bitstream_decode012(bc);
if (v->condover == CONDOVER_SELECT) {
status = bitplane_decoding(v->over_flags_plane,
&v->overflg_is_raw, v);
if (status < 0)
@@ -1004,27 +1011,27 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
break;
case AV_PICTURE_TYPE_P:
if (v->field_mode) {
- v->numref = get_bits1(gb);
+ v->numref = bitstream_read_bit(bc);
if (!v->numref) {
- v->reffield = get_bits1(gb);
+ v->reffield = bitstream_read_bit(bc);
v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
}
}
if (v->extended_mv)
- v->mvrange = get_unary(gb, 0, 3);
+ v->mvrange = get_unary(bc, 0, 3);
else
v->mvrange = 0;
if (v->interlace) {
if (v->extended_dmv)
- v->dmvrange = get_unary(gb, 0, 3);
+ v->dmvrange = get_unary(bc, 0, 3);
else
v->dmvrange = 0;
if (v->fcm == ILACE_FRAME) { // interlaced frame picture
- v->fourmvswitch = get_bits1(gb);
- v->intcomp = get_bits1(gb);
+ v->fourmvswitch = bitstream_read_bit(bc);
+ v->intcomp = bitstream_read_bit(bc);
if (v->intcomp) {
- v->lumscale = get_bits(gb, 6);
- v->lumshift = get_bits(gb, 6);
+ v->lumscale = bitstream_read(bc, 6);
+ v->lumshift = bitstream_read(bc, 6);
INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0],
v->last_lutuv[0], 1);
INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1],
v->last_lutuv[1], 1);
v->last_use_ic = 1;
@@ -1032,20 +1039,20 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw,
v);
av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
"Imode: %i, Invert: %i\n", status>>1, status&1);
- mbmodetab = get_bits(gb, 2);
+ mbmodetab = bitstream_read(bc, 2);
if (v->fourmvswitch)
v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
else
v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
- imvtab = get_bits(gb, 2);
+ imvtab = bitstream_read(bc, 2);
v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
// interlaced p-picture cbpcy range is [1, 63]
- icbptab = get_bits(gb, 3);
+ icbptab = bitstream_read(bc, 3);
v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
- twomvbptab = get_bits(gb, 2);
+ twomvbptab = bitstream_read(bc, 2);
v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
if (v->fourmvswitch) {
- fourmvbptab = get_bits(gb, 2);
+ fourmvbptab = bitstream_read(bc, 2);
v->fourmvbp_vlc =
&ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
}
}
@@ -1063,27 +1070,27 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
v->tt_index = 2;
if (v->fcm != ILACE_FRAME) {
int mvmode;
- mvmode = get_unary(gb, 1, 4);
+ mvmode = get_unary(bc, 1, 4);
lowquant = (v->pq > 12) ? 0 : 1;
v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
int mvmode2;
- mvmode2 = get_unary(gb, 1, 3);
+ mvmode2 = get_unary(bc, 1, 3);
v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
if (v->field_mode) {
- v->intcompfield = decode210(gb) ^ 3;
+ v->intcompfield = bitstream_decode210(bc) ^ 3;
} else
v->intcompfield = 3;
v->lumscale2 = v->lumscale = 32;
v->lumshift2 = v->lumshift = 0;
if (v->intcompfield & 1) {
- v->lumscale = get_bits(gb, 6);
- v->lumshift = get_bits(gb, 6);
+ v->lumscale = bitstream_read(bc, 6);
+ v->lumshift = bitstream_read(bc, 6);
}
if ((v->intcompfield & 2) && v->field_mode) {
- v->lumscale2 = get_bits(gb, 6);
- v->lumshift2 = get_bits(gb, 6);
+ v->lumscale2 = bitstream_read(bc, 6);
+ v->lumshift2 = bitstream_read(bc, 6);
} else if(!v->field_mode) {
v->lumscale2 = v->lumscale;
v->lumshift2 = v->lumshift;
@@ -1137,24 +1144,24 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
"Imode: %i, Invert: %i\n", status>>1, status&1);
/* Hopefully this is correct for P-frames */
- v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
- v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
+ v->s.mv_table_index = bitstream_read(bc, 2); //but using ff_vc1_
tables
+ v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[bitstream_read(bc, 2)];
} else if (v->fcm == ILACE_FRAME) { // frame interlaced
v->qs_last = v->s.quarter_sample;
v->s.quarter_sample = 1;
v->s.mspel = 1;
} else { // field interlaced
- mbmodetab = get_bits(gb, 3);
- imvtab = get_bits(gb, 2 + v->numref);
+ mbmodetab = bitstream_read(bc, 3);
+ imvtab = bitstream_read(bc, 2 + v->numref);
if (!v->numref)
v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
else
v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
- icbptab = get_bits(gb, 3);
+ icbptab = bitstream_read(bc, 3);
v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode ==
MV_PMODE_MIXED_MV) {
- fourmvbptab = get_bits(gb, 2);
+ fourmvbptab = bitstream_read(bc, 2);
v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
} else {
@@ -1168,9 +1175,9 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
v->ttfrm = 0; //FIXME Is that so ?
if (v->vstransform) {
- v->ttmbf = get_bits1(gb);
+ v->ttmbf = bitstream_read_bit(bc);
if (v->ttmbf) {
- v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
+ v->ttfrm = ff_vc1_ttfrm_to_tt[bitstream_read(bc, 2)];
}
} else {
v->ttmbf = 1;
@@ -1179,14 +1186,15 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
break;
case AV_PICTURE_TYPE_B:
if (v->fcm == ILACE_FRAME) {
- v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table,
VC1_BFRACTION_VLC_BITS, 1);
+ v->bfraction_lut_index = bitstream_read_vlc(bc,
ff_vc1_bfraction_vlc.table,
+
VC1_BFRACTION_VLC_BITS, 1);
v->bfraction =
ff_vc1_bfraction_lut[v->bfraction_lut_index];
if (v->bfraction == 0) {
return -1;
}
}
if (v->extended_mv)
- v->mvrange = get_unary(gb, 0, 3);
+ v->mvrange = get_unary(bc, 0, 3);
else
v->mvrange = 0;
v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12
13
@@ -1204,8 +1212,8 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
if (v->field_mode) {
int mvmode;
if (v->extended_dmv)
- v->dmvrange = get_unary(gb, 0, 3);
- mvmode = get_unary(gb, 1, 3);
+ v->dmvrange = get_unary(bc, 0, 3);
+ mvmode = get_unary(bc, 1, 3);
lowquant = (v->pq > 12) ? 0 : 1;
v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
v->qs_last = v->s.quarter_sample;
@@ -1216,24 +1224,24 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
return -1;
av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
"Imode: %i, Invert: %i\n", status>>1, status&1);
- mbmodetab = get_bits(gb, 3);
+ mbmodetab = bitstream_read(bc, 3);
if (v->mv_mode == MV_PMODE_MIXED_MV)
v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
else
v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
- imvtab = get_bits(gb, 3);
+ imvtab = bitstream_read(bc, 3);
v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
- icbptab = get_bits(gb, 3);
+ icbptab = bitstream_read(bc, 3);
v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
if (v->mv_mode == MV_PMODE_MIXED_MV) {
- fourmvbptab = get_bits(gb, 2);
+ fourmvbptab = bitstream_read(bc, 2);
v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
}
v->numref = 1; // interlaced field B pictures are always 2-ref
} else if (v->fcm == ILACE_FRAME) {
if (v->extended_dmv)
- v->dmvrange = get_unary(gb, 0, 3);
- if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
+ v->dmvrange = get_unary(bc, 0, 3);
+ if (bitstream_read_bit(bc)) /* intcomp - present but shall always
be 0 */
av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set
for B picture\n");
v->intcomp = 0;
v->mv_mode = MV_PMODE_1MV;
@@ -1251,19 +1259,19 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
return -1;
av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
"Imode: %i, Invert: %i\n", status>>1, status&1);
- mbmodetab = get_bits(gb, 2);
+ mbmodetab = bitstream_read(bc, 2);
v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
- imvtab = get_bits(gb, 2);
+ imvtab = bitstream_read(bc, 2);
v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
// interlaced p/b-picture cbpcy range is [1, 63]
- icbptab = get_bits(gb, 3);
+ icbptab = bitstream_read(bc, 3);
v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
- twomvbptab = get_bits(gb, 2);
+ twomvbptab = bitstream_read(bc, 2);
v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
- fourmvbptab = get_bits(gb, 2);
+ fourmvbptab = bitstream_read(bc, 2);
v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
} else {
- v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV :
MV_PMODE_1MV_HPEL_BILIN;
+ v->mv_mode = bitstream_read_bit(bc) ? MV_PMODE_1MV :
MV_PMODE_1MV_HPEL_BILIN;
v->qs_last = v->s.quarter_sample;
v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
v->s.mspel = v->s.quarter_sample;
@@ -1277,8 +1285,8 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
return -1;
av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
"Imode: %i, Invert: %i\n", status>>1, status&1);
- v->s.mv_table_index = get_bits(gb, 2);
- v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
+ v->s.mv_table_index = bitstream_read(bc, 2);
+ v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[bitstream_read(bc, 2)];
}
if (v->dquant) {
@@ -1288,9 +1296,9 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
v->ttfrm = 0;
if (v->vstransform) {
- v->ttmbf = get_bits1(gb);
+ v->ttmbf = bitstream_read_bit(bc);
if (v->ttmbf) {
- v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
+ v->ttfrm = ff_vc1_ttfrm_to_tt[bitstream_read(bc, 2)];
}
} else {
v->ttmbf = 1;
@@ -1305,12 +1313,12 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v,
GetBitContext* gb)
}
/* AC Syntax */
- v->c_ac_table_index = decode012(gb);
+ v->c_ac_table_index = bitstream_decode012(bc);
if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type ==
AV_PICTURE_TYPE_BI) {
- v->y_ac_table_index = decode012(gb);
+ v->y_ac_table_index = bitstream_decode012(bc);
}
/* DC Syntax */
- v->s.dc_table_index = get_bits1(gb);
+ v->s.dc_table_index = bitstream_read_bit(bc);
if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type ==
AV_PICTURE_TYPE_BI)
&& v->dquant) {
av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
diff --git a/libavcodec/vc1.h b/libavcodec/vc1.h
index 5087b7c..a3af59e 100644
--- a/libavcodec/vc1.h
+++ b/libavcodec/vc1.h
@@ -24,11 +24,13 @@
#define AVCODEC_VC1_H
#include "avcodec.h"
+#include "bitstream.h"
#include "h264chroma.h"
#include "mpegvideo.h"
#include "intrax8.h"
#include "vc1_common.h"
#include "vc1dsp.h"
+#include "vlc.h"
#define AC_VLC_BITS 9
@@ -384,15 +386,15 @@ typedef struct VC1Context{
* Decode Simple/Main Profiles sequence header
* @see Figure 7-8, p16-17
* @param avctx Codec context
- * @param gb GetBit context initialized from Codec context extra_data
+ * @param bc Bitstream context initialized from Codec context extra_data
* @return Status
*/
-int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v,
GetBitContext *gb);
+int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v,
BitstreamContext *bc);
-int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v,
GetBitContext *gb);
+int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v,
BitstreamContext *bc);
-int ff_vc1_parse_frame_header (VC1Context *v, GetBitContext *gb);
-int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb);
+int ff_vc1_parse_frame_header (VC1Context *v, BitstreamContext *bc);
+int ff_vc1_parse_frame_header_adv(VC1Context *v, BitstreamContext *bc);
int ff_vc1_init_common(VC1Context *v);
int ff_vc1_decode_init_alloc_tables(VC1Context *v);
diff --git a/libavcodec/vc1_block.c b/libavcodec/vc1_block.c
index 0e1018c..40dfab4 100644
--- a/libavcodec/vc1_block.c
+++ b/libavcodec/vc1_block.c
@@ -27,6 +27,7 @@
*/
#include "avcodec.h"
+#include "bitstream.h"
#include "mpegutils.h"
#include "mpegvideo.h"
#include "msmpeg4data.h"
@@ -35,6 +36,7 @@
#include "vc1_pred.h"
#include "vc1acdata.h"
#include "vc1data.h"
+#include "vlc.h"
#define MB_INTRA_VLC_BITS 9
#define DC_VLC_BITS 9
@@ -173,13 +175,13 @@ static void vc1_put_signed_blocks_clamped(VC1Context *v)
int edges = 0; \
if (v->dqprofile == DQPROFILE_ALL_MBS) { \
if (v->dqbilevel) { \
- mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
+ mquant = (bitstream_read_bit(bc)) ? v->altpq : v->pq; \
} else { \
- mqdiff = get_bits(gb, 3); \
+ mqdiff = bitstream_read(bc, 3); \
if (mqdiff != 7) \
mquant = v->pq + mqdiff; \
else \
- mquant = get_bits(gb, 5); \
+ mquant = bitstream_read(bc, 5); \
} \
} \
if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
@@ -211,7 +213,7 @@ static void vc1_put_signed_blocks_clamped(VC1Context *v)
* @param _dmv_y Vertical differential for decoded MV
*/
#define GET_MVDATA(_dmv_x, _dmv_y) \
- index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
+ index = 1 + bitstream_read_vlc(bc,
ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
VC1_MV_DIFF_VLC_BITS, 2); \
if (index > 36) { \
mb_has_coeffs = 1; \
@@ -222,8 +224,8 @@ static void vc1_put_signed_blocks_clamped(VC1Context *v)
if (!index) { \
_dmv_x = _dmv_y = 0; \
} else if (index == 35) { \
- _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
- _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
+ _dmv_x = bitstream_read(bc, v->k_x - 1 + s->quarter_sample); \
+ _dmv_y = bitstream_read(bc, v->k_y - 1 + s->quarter_sample); \
} else if (index == 36) { \
_dmv_x = 0; \
_dmv_y = 0; \
@@ -233,7 +235,7 @@ static void vc1_put_signed_blocks_clamped(VC1Context *v)
if (!s->quarter_sample && index1 == 5) val = 1; \
else val = 0; \
if (size_table[index1] - val > 0) \
- val = get_bits(gb, size_table[index1] - val); \
+ val = bitstream_read(bc, size_table[index1] - val); \
else val = 0; \
sign = 0 - (val&1); \
_dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
@@ -242,7 +244,7 @@ static void vc1_put_signed_blocks_clamped(VC1Context *v)
if (!s->quarter_sample && index1 == 5) val = 1; \
else val = 0; \
if (size_table[index1] - val > 0) \
- val = get_bits(gb, size_table[index1] - val); \
+ val = bitstream_read(bc, size_table[index1] - val); \
else val = 0; \
sign = 0 - (val & 1); \
_dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
@@ -253,7 +255,7 @@ static av_always_inline void
get_mvdata_interlaced(VC1Context *v, int *dmv_x,
{
int index, index1;
int extend_x = 0, extend_y = 0;
- GetBitContext *gb = &v->s.gb;
+ BitstreamContext *bc = &v->s.bc;
int bits, esc;
int val, sign;
const int* offs_tab;
@@ -276,10 +278,10 @@ static av_always_inline void
get_mvdata_interlaced(VC1Context *v, int *dmv_x,
extend_x = extend_y = 1;
break;
}
- index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
+ index = bitstream_read_vlc(bc, v->imv_vlc->table, bits, 3);
if (index == esc) {
- *dmv_x = get_bits(gb, v->k_x);
- *dmv_y = get_bits(gb, v->k_y);
+ *dmv_x = bitstream_read(bc, v->k_x);
+ *dmv_y = bitstream_read(bc, v->k_y);
if (v->numref) {
if (pred_flag) {
*pred_flag = *dmv_y & 1;
@@ -296,7 +298,7 @@ static av_always_inline void
get_mvdata_interlaced(VC1Context *v, int *dmv_x,
offs_tab = offset_table1;
index1 = (index + 1) % 9;
if (index1 != 0) {
- val = get_bits(gb, index1 + extend_x);
+ val = bitstream_read(bc, index1 + extend_x);
sign = 0 -(val & 1);
*dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
} else
@@ -307,7 +309,7 @@ static av_always_inline void
get_mvdata_interlaced(VC1Context *v, int *dmv_x,
offs_tab = offset_table1;
index1 = (index + 1) / 9;
if (index1 > v->numref) {
- val = get_bits(gb, (index1 + (extend_y << v->numref)) >>
v->numref);
+ val = bitstream_read(bc, (index1 + (extend_y << v->numref)) >>
v->numref);
sign = 0 - (val & 1);
*dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) -
sign;
} else
@@ -526,20 +528,22 @@ static inline int vc1_coded_block_pred(MpegEncContext *
s, int n,
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
int *value, int codingset)
{
- GetBitContext *gb = &v->s.gb;
+ BitstreamContext *bc = &v->s.bc;
int index, escape, run = 0, level = 0, lst = 0;
- index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS,
3);
+ index = bitstream_read_vlc(bc, ff_vc1_ac_coeff_table[codingset].table,
+ AC_VLC_BITS, 3);
if (index != ff_vc1_ac_sizes[codingset] - 1) {
run = vc1_index_decode_table[codingset][index][0];
level = vc1_index_decode_table[codingset][index][1];
- lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb)
< 0;
- if (get_bits1(gb))
+ lst = index >= vc1_last_decode_table[codingset] ||
bitstream_bits_left(bc) < 0;
+ if (bitstream_read_bit(bc))
level = -level;
} else {
- escape = decode210(gb);
+ escape = bitstream_decode210(bc);
if (escape != 2) {
- index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table,
AC_VLC_BITS, 3);
+ index = bitstream_read_vlc(bc,
ff_vc1_ac_coeff_table[codingset].table,
+ AC_VLC_BITS, 3);
run = vc1_index_decode_table[codingset][index][0];
level = vc1_index_decode_table[codingset][index][1];
lst = index >= vc1_last_decode_table[codingset];
@@ -554,24 +558,24 @@ static void vc1_decode_ac_coeff(VC1Context *v, int *last,
int *skip,
else
run += vc1_delta_run_table[codingset][level] + 1;
}
- if (get_bits1(gb))
+ if (bitstream_read_bit(bc))
level = -level;
} else {
int sign;
- lst = get_bits1(gb);
+ lst = bitstream_read_bit(bc);
if (v->s.esc3_level_length == 0) {
if (v->pq < 8 || v->dquantfrm) { // table 59
- v->s.esc3_level_length = get_bits(gb, 3);
+ v->s.esc3_level_length = bitstream_read(bc, 3);
if (!v->s.esc3_level_length)
- v->s.esc3_level_length = get_bits(gb, 2) + 8;
+ v->s.esc3_level_length = bitstream_read(bc, 2) + 8;
} else { // table 60
- v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
+ v->s.esc3_level_length = get_unary(bc, 1, 6) + 2;
}
- v->s.esc3_run_length = 3 + get_bits(gb, 2);
+ v->s.esc3_run_length = 3 + bitstream_read(bc, 2);
}
- run = get_bits(gb, v->s.esc3_run_length);
- sign = get_bits1(gb);
- level = get_bits(gb, v->s.esc3_level_length);
+ run = bitstream_read(bc, v->s.esc3_run_length);
+ sign = bitstream_read_bit(bc);
+ level = bitstream_read(bc, v->s.esc3_level_length);
if (sign)
level = -level;
}
@@ -592,7 +596,7 @@ static void vc1_decode_ac_coeff(VC1Context *v, int *last,
int *skip,
static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
int coded, int codingset)
{
- GetBitContext *gb = &v->s.gb;
+ BitstreamContext *bc = &v->s.bc;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int i;
@@ -602,9 +606,11 @@ static int vc1_decode_i_block(VC1Context *v, int16_t
block[64], int n,
/* Get DC differential */
if (n < 4) {
- dcdiff = get_vlc2(&s->gb,
ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
+ dcdiff = bitstream_read_vlc(&s->bc,
ff_msmp4_dc_luma_vlc[s->dc_table_index].table,
+ DC_VLC_BITS, 3);
} else {
- dcdiff = get_vlc2(&s->gb,
ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
+ dcdiff = bitstream_read_vlc(&s->bc,
ff_msmp4_dc_chroma_vlc[s->dc_table_index].table,
+ DC_VLC_BITS, 3);
}
if (dcdiff < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
@@ -613,16 +619,16 @@ static int vc1_decode_i_block(VC1Context *v, int16_t
block[64], int n,
if (dcdiff) {
if (dcdiff == 119 /* ESC index value */) {
/* TODO: Optimize */
- if (v->pq == 1) dcdiff = get_bits(gb, 10);
- else if (v->pq == 2) dcdiff = get_bits(gb, 9);
- else dcdiff = get_bits(gb, 8);
+ if (v->pq == 1) dcdiff = bitstream_read(bc, 10);
+ else if (v->pq == 2) dcdiff = bitstream_read(bc, 9);
+ else dcdiff = bitstream_read(bc, 8);
} else {
if (v->pq == 1)
- dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
+ dcdiff = (dcdiff << 2) + bitstream_read(bc, 2) - 3;
else if (v->pq == 2)
- dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
+ dcdiff = (dcdiff << 1) + bitstream_read_bit(bc) - 1;
}
- if (get_bits1(gb))
+ if (bitstream_read_bit(bc))
dcdiff = -dcdiff;
}
@@ -755,7 +761,7 @@ not_coded:
static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
int coded, int codingset, int mquant)
{
- GetBitContext *gb = &v->s.gb;
+ BitstreamContext *bc = &v->s.bc;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int i;
@@ -770,9 +776,11 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t
block[64], int n,
/* Get DC differential */
if (n < 4) {
- dcdiff = get_vlc2(&s->gb,
ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
+ dcdiff = bitstream_read_vlc(&s->bc,
ff_msmp4_dc_luma_vlc[s->dc_table_index].table,
+ DC_VLC_BITS, 3);
} else {
- dcdiff = get_vlc2(&s->gb,
ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
+ dcdiff = bitstream_read_vlc(&s->bc,
ff_msmp4_dc_chroma_vlc[s->dc_table_index].table,
+ DC_VLC_BITS, 3);
}
if (dcdiff < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
@@ -781,16 +789,16 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t
block[64], int n,
if (dcdiff) {
if (dcdiff == 119 /* ESC index value */) {
/* TODO: Optimize */
- if (mquant == 1) dcdiff = get_bits(gb, 10);
- else if (mquant == 2) dcdiff = get_bits(gb, 9);
- else dcdiff = get_bits(gb, 8);
+ if (mquant == 1) dcdiff = bitstream_read(bc, 10);
+ else if (mquant == 2) dcdiff = bitstream_read(bc, 9);
+ else dcdiff = bitstream_read(bc, 8);
} else {
if (mquant == 1)
- dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
+ dcdiff = (dcdiff << 2) + bitstream_read(bc, 2) - 3;
else if (mquant == 2)
- dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
+ dcdiff = (dcdiff << 1) + bitstream_read_bit(bc) - 1;
}
- if (get_bits1(gb))
+ if (bitstream_read_bit(bc))
dcdiff = -dcdiff;
}
@@ -967,7 +975,7 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t
block[64], int n,
static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
int coded, int mquant, int codingset)
{
- GetBitContext *gb = &v->s.gb;
+ BitstreamContext *bc = &v->s.bc;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int i;
@@ -991,9 +999,11 @@ static int vc1_decode_intra_block(VC1Context *v, int16_t
block[64], int n,
/* Get DC differential */
if (n < 4) {
- dcdiff = get_vlc2(&s->gb,
ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
+ dcdiff = bitstream_read_vlc(&s->bc,
ff_msmp4_dc_luma_vlc[s->dc_table_index].table,
+ DC_VLC_BITS, 3);
} else {
- dcdiff = get_vlc2(&s->gb,
ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
+ dcdiff = bitstream_read_vlc(&s->bc,
ff_msmp4_dc_chroma_vlc[s->dc_table_index].table,
+ DC_VLC_BITS, 3);
}
if (dcdiff < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
@@ -1002,16 +1012,16 @@ static int vc1_decode_intra_block(VC1Context *v,
int16_t block[64], int n,
if (dcdiff) {
if (dcdiff == 119 /* ESC index value */) {
/* TODO: Optimize */
- if (mquant == 1) dcdiff = get_bits(gb, 10);
- else if (mquant == 2) dcdiff = get_bits(gb, 9);
- else dcdiff = get_bits(gb, 8);
+ if (mquant == 1) dcdiff = bitstream_read(bc, 10);
+ else if (mquant == 2) dcdiff = bitstream_read(bc, 9);
+ else dcdiff = bitstream_read(bc, 8);
} else {
if (mquant == 1)
- dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
+ dcdiff = (dcdiff << 2) + bitstream_read(bc, 2) - 3;
else if (mquant == 2)
- dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
+ dcdiff = (dcdiff << 1) + bitstream_read_bit(bc) - 1;
}
- if (get_bits1(gb))
+ if (bitstream_read_bit(bc))
dcdiff = -dcdiff;
}
@@ -1180,7 +1190,7 @@ static int vc1_decode_p_block(VC1Context *v, int16_t
block[64], int n,
int *ttmb_out)
{
MpegEncContext *s = &v->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, j;
int subblkpat = 0;
int scale, off, idx, last, skip, value;
@@ -1190,15 +1200,17 @@ static int vc1_decode_p_block(VC1Context *v, int16_t
block[64], int n,
s->bdsp.clear_block(block);
if (ttmb == -1) {
- ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb,
ff_vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
+ ttblk = ff_vc1_ttblk_to_tt[v->tt_index][bitstream_read_vlc(bc,
ff_vc1_ttblk_vlc[v->tt_index].table,
+
VC1_TTBLK_VLC_BITS, 1)];
}
if (ttblk == TT_4X4) {
- subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table,
VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
+ subblkpat = ~(bitstream_read_vlc(bc,
ff_vc1_subblkpat_vlc[v->tt_index].table,
+ VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
}
if ((ttblk != TT_8X8 && ttblk != TT_4X4)
&& ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
|| (!v->res_rtm_flag && !first_block))) {
- subblkpat = decode012(gb);
+ subblkpat = bitstream_decode012(bc);
if (subblkpat)
subblkpat ^= 3; // swap decoded pattern bits
if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
@@ -1341,7 +1353,7 @@ static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
static int vc1_decode_p_mb(VC1Context *v)
{
MpegEncContext *s = &v->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp; /* cbp decoding stuff */
@@ -1360,11 +1372,11 @@ static int vc1_decode_p_mb(VC1Context *v)
mquant = v->pq; /* lossy initialization */
if (v->mv_type_is_raw)
- fourmv = get_bits1(gb);
+ fourmv = bitstream_read_bit(bc);
else
fourmv = v->mv_type_mb_plane[mb_pos];
if (v->skip_is_raw)
- skipped = get_bits1(gb);
+ skipped = bitstream_read_bit(bc);
else
skipped = v->s.mbskip_table[mb_pos];
@@ -1382,12 +1394,13 @@ static int vc1_decode_p_mb(VC1Context *v)
/* FIXME Set DC val for inter block ? */
if (s->mb_intra && !mb_has_coeffs) {
GET_MQUANT();
- s->ac_pred = get_bits1(gb);
+ s->ac_pred = bitstream_read_bit(bc);
cbp = 0;
} else if (mb_has_coeffs) {
if (s->mb_intra)
- s->ac_pred = get_bits1(gb);
- cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
+ s->ac_pred = bitstream_read_bit(bc);
+ cbp = bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
GET_MQUANT();
} else {
mquant = v->pq;
@@ -1396,8 +1409,8 @@ static int vc1_decode_p_mb(VC1Context *v)
s->current_picture.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
- VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc,
ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
if (!s->mb_intra) ff_vc1_mc_1mv(v, 0);
dst_idx = 0;
for (i = 0; i < 6; i++) {
@@ -1460,7 +1473,8 @@ static int vc1_decode_p_mb(VC1Context *v)
int intra_count = 0, coded_inter = 0;
int is_intra[6], is_coded[6];
/* Get CBPCY */
- cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
+ cbp = bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
for (i = 0; i < 6; i++) {
val = ((cbp >> (5 - i)) & 1);
s->dc_val[0][s->block_index[i]] = 0;
@@ -1507,12 +1521,13 @@ static int vc1_decode_p_mb(VC1Context *v)
}
}
if (intrapred)
- s->ac_pred = get_bits1(gb);
+ s->ac_pred = bitstream_read_bit(bc);
else
s->ac_pred = 0;
}
if (!v->ttmbf && coded_inter)
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc,
ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
for (i = 0; i < 6; i++) {
dst_idx += i >> 2;
off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 *
s->linesize);
@@ -1585,7 +1600,7 @@ end:
static int vc1_decode_p_mb_intfr(VC1Context *v)
{
MpegEncContext *s = &v->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@@ -1605,14 +1620,16 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
mquant = v->pq; /* Lossy initialization */
if (v->skip_is_raw)
- skipped = get_bits1(gb);
+ skipped = bitstream_read_bit(bc);
else
skipped = v->s.mbskip_table[mb_pos];
if (!skipped) {
if (v->fourmvswitch)
- idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table,
VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
+ idx_mbmode = bitstream_read_vlc(bc, v->mbmode_vlc->table,
+ VC1_INTFR_4MV_MBMODE_VLC_BITS, 2);
// try getting this done
else
- idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table,
VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
+ idx_mbmode = bitstream_read_vlc(bc, v->mbmode_vlc->table,
+ VC1_INTFR_NON4MV_MBMODE_VLC_BITS,
2); // in a single line
switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
/* store the motion vector type in a flag (useful later) */
case MV_PMODE_INTFR_4MV:
@@ -1651,11 +1668,12 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
s->mb_intra = 1;
s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
- fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
- mb_has_coeffs = get_bits1(gb);
+ fieldtx = v->fieldtx_plane[mb_pos] = bitstream_read_bit(bc);
+ mb_has_coeffs = bitstream_read_bit(bc);
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
- v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
+ v->s.ac_pred = v->acpred_plane[mb_pos] = bitstream_read_bit(bc);
GET_MQUANT();
s->current_picture.qscale_table[mb_pos] = mquant;
/* Set DC scale - y and c use the same (not sure if necessary
here) */
@@ -1694,13 +1712,15 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
} else { // inter MB
mb_has_coeffs =
ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] ==
MV_PMODE_INTFR_2MV_FIELD) {
- v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table,
VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
+ v->twomvbp = bitstream_read_vlc(bc, v->twomvbp_vlc->table,
VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
} else {
if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] ==
MV_PMODE_INTFR_4MV)
|| (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]
== MV_PMODE_INTFR_4MV_FIELD)) {
- v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table,
VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
+ v->fourmvbp = bitstream_read_vlc(bc,
v->fourmvbp_vlc->table,
+
VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
}
}
s->mb_intra = v->is_intra[s->mb_x] = 0;
@@ -1754,7 +1774,8 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
GET_MQUANT(); // p. 227
s->current_picture.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && cbp)
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc,
ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
for (i = 0; i < 6; i++) {
s->dc_val[0][s->block_index[i]] = 0;
dst_idx += i >> 2;
@@ -1798,7 +1819,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
static int vc1_decode_p_mb_intfi(VC1Context *v)
{
MpegEncContext *s = &v->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@@ -1816,7 +1837,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
mquant = v->pq; /* Lossy initialization */
- idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
+ idx_mbmode = bitstream_read_vlc(bc, v->mbmode_vlc->table,
VC1_IF_MBMODE_VLC_BITS, 2);
if (idx_mbmode <= 1) { // intra MB
v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
s->mb_intra = 1;
@@ -1828,10 +1849,11 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
/* Set DC scale - y and c use the same (not sure if necessary here) */
s->y_dc_scale = s->y_dc_scale_table[mquant];
s->c_dc_scale = s->c_dc_scale_table[mquant];
- v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
+ v->s.ac_pred = v->acpred_plane[mb_pos] = bitstream_read_bit(bc);
mb_has_coeffs = idx_mbmode & 1;
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_ICBPCY_VLC_BITS, 2);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_ICBPCY_VLC_BITS, 2);
dst_idx = 0;
for (i = 0; i < 6; i++) {
v->a_avail = v->c_avail = 0;
@@ -1869,7 +1891,8 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
ff_vc1_mc_1mv(v, 0);
mb_has_coeffs = !(idx_mbmode & 2);
} else { // 4-MV
- v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table,
VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
+ v->fourmvbp = bitstream_read_vlc(bc, v->fourmvbp_vlc->table,
+ VC1_4MV_BLOCK_PATTERN_VLC_BITS,
1);
for (i = 0; i < 6; i++) {
if (i < 4) {
dmv_x = dmv_y = pred_flag = 0;
@@ -1885,13 +1908,15 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
mb_has_coeffs = idx_mbmode & 1;
}
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
if (cbp) {
GET_MQUANT();
}
s->current_picture.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && cbp) {
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc, ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
}
dst_idx = 0;
for (i = 0; i < 6; i++) {
@@ -1921,7 +1946,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
static void vc1_decode_b_mb(VC1Context *v)
{
MpegEncContext *s = &v->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@@ -1940,11 +1965,11 @@ static void vc1_decode_b_mb(VC1Context *v)
s->mb_intra = 0;
if (v->dmb_is_raw)
- direct = get_bits1(gb);
+ direct = bitstream_read_bit(bc);
else
direct = v->direct_mb_plane[mb_pos];
if (v->skip_is_raw)
- skipped = get_bits1(gb);
+ skipped = bitstream_read_bit(bc);
else
skipped = v->s.mbskip_table[mb_pos];
@@ -1962,7 +1987,7 @@ static void vc1_decode_b_mb(VC1Context *v)
dmv_y[1] = dmv_y[0];
}
if (skipped || !s->mb_intra) {
- bmvtype = decode012(gb);
+ bmvtype = bitstream_decode012(bc);
switch (bmvtype) {
case 0:
bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ?
BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
@@ -1987,12 +2012,14 @@ static void vc1_decode_b_mb(VC1Context *v)
return;
}
if (direct) {
- cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
+ cbp = bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
GET_MQUANT();
s->mb_intra = 0;
s->current_picture.qscale_table[mb_pos] = mquant;
if (!v->ttmbf)
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc, ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
@@ -2006,7 +2033,7 @@ static void vc1_decode_b_mb(VC1Context *v)
if (s->mb_intra && !mb_has_coeffs) {
GET_MQUANT();
s->current_picture.qscale_table[mb_pos] = mquant;
- s->ac_pred = get_bits1(gb);
+ s->ac_pred = bitstream_read_bit(bc);
cbp = 0;
ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
} else {
@@ -2024,12 +2051,14 @@ static void vc1_decode_b_mb(VC1Context *v)
vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
}
if (s->mb_intra)
- s->ac_pred = get_bits1(gb);
- cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
+ s->ac_pred = bitstream_read_bit(bc);
+ cbp = bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
GET_MQUANT();
s->current_picture.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc,
ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
}
}
dst_idx = 0;
@@ -2076,7 +2105,7 @@ static void vc1_decode_b_mb(VC1Context *v)
static void vc1_decode_b_mb_intfi(VC1Context *v)
{
MpegEncContext *s = &v->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@@ -2094,7 +2123,8 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
mquant = v->pq; /* Lossy initialization */
s->mb_intra = 0;
- idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
+ idx_mbmode = bitstream_read_vlc(bc, v->mbmode_vlc->table,
+ VC1_IF_MBMODE_VLC_BITS, 2);
if (idx_mbmode <= 1) { // intra MB
v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
s->mb_intra = 1;
@@ -2106,10 +2136,11 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
/* Set DC scale - y and c use the same (not sure if necessary here) */
s->y_dc_scale = s->y_dc_scale_table[mquant];
s->c_dc_scale = s->c_dc_scale_table[mquant];
- v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
+ v->s.ac_pred = v->acpred_plane[mb_pos] = bitstream_read_bit(bc);
mb_has_coeffs = idx_mbmode & 1;
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_ICBPCY_VLC_BITS, 2);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_ICBPCY_VLC_BITS, 2);
dst_idx = 0;
for (i = 0; i < 6; i++) {
v->a_avail = v->c_avail = 0;
@@ -2142,7 +2173,7 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
if (v->fmb_is_raw)
- fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
+ fwd = v->forward_mb_plane[mb_pos] = bitstream_read_bit(bc);
else
fwd = v->forward_mb_plane[mb_pos];
if (idx_mbmode <= 5) { // 1-MV
@@ -2151,7 +2182,7 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
if (fwd)
bmvtype = BMV_TYPE_FORWARD;
else {
- bmvtype = decode012(gb);
+ bmvtype = bitstream_decode012(bc);
switch (bmvtype) {
case 0:
bmvtype = BMV_TYPE_BACKWARD;
@@ -2161,7 +2192,7 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
break;
case 2:
bmvtype = BMV_TYPE_INTERPOLATED;
- interpmvp = get_bits1(gb);
+ interpmvp = bitstream_read_bit(bc);
}
}
v->bmvtype = bmvtype;
@@ -2182,7 +2213,8 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
if (fwd)
bmvtype = BMV_TYPE_FORWARD;
v->bmvtype = bmvtype;
- v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table,
VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
+ v->fourmvbp = bitstream_read_vlc(bc, v->fourmvbp_vlc->table,
+ VC1_4MV_BLOCK_PATTERN_VLC_BITS,
1);
for (i = 0; i < 6; i++) {
if (i < 4) {
dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
@@ -2201,13 +2233,15 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
mb_has_coeffs = idx_mbmode & 1;
}
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
if (cbp) {
GET_MQUANT();
}
s->current_picture.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && cbp) {
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc, ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
}
dst_idx = 0;
for (i = 0; i < 6; i++) {
@@ -2233,7 +2267,7 @@ static void vc1_decode_b_mb_intfi(VC1Context *v)
static int vc1_decode_b_mb_intfr(VC1Context *v)
{
MpegEncContext *s = &v->s;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@@ -2255,12 +2289,13 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
mquant = v->pq; /* Lossy initialization */
s->mb_intra = 0;
if (v->skip_is_raw)
- skipped = get_bits1(gb);
+ skipped = bitstream_read_bit(bc);
else
skipped = v->s.mbskip_table[mb_pos];
if (!skipped) {
- idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table,
VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
+ idx_mbmode = bitstream_read_vlc(bc, v->mbmode_vlc->table,
+ VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] ==
MV_PMODE_INTFR_2MV_FIELD) {
twomv = 1;
v->blk_mv_type[s->block_index[0]] = 1;
@@ -2276,7 +2311,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
}
if (v->dmb_is_raw)
- direct = get_bits1(gb);
+ direct = bitstream_read_bit(bc);
else
direct = v->direct_mb_plane[mb_pos];
@@ -2318,11 +2353,12 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
s->mb_intra = 1;
s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
- fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
- mb_has_coeffs = get_bits1(gb);
+ fieldtx = v->fieldtx_plane[mb_pos] = bitstream_read_bit(bc);
+ mb_has_coeffs = bitstream_read_bit(bc);
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
- v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
+ v->s.ac_pred = v->acpred_plane[mb_pos] = bitstream_read_bit(bc);
GET_MQUANT();
s->current_picture.qscale_table[mb_pos] = mquant;
/* Set DC scale - y and c use the same (not sure if necessary here) */
@@ -2360,7 +2396,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
s->mb_intra = v->is_intra[s->mb_x] = 0;
if (!direct) {
if (skipped || !s->mb_intra) {
- bmvtype = decode012(gb);
+ bmvtype = bitstream_decode012(bc);
switch (bmvtype) {
case 0:
bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ?
BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
@@ -2374,18 +2410,21 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
}
if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
- mvsw = get_bits1(gb);
+ mvsw = bitstream_read_bit(bc);
}
if (!skipped) { // inter MB
mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
if (mb_has_coeffs)
- cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table,
VC1_CBPCY_P_VLC_BITS, 2);
+ cbp = 1 + bitstream_read_vlc(&v->s.bc, v->cbpcy_vlc->table,
+ VC1_CBPCY_P_VLC_BITS, 2);
if (!direct) {
if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
- v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table,
VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
+ v->fourmvbp = bitstream_read_vlc(bc,
v->fourmvbp_vlc->table,
+
VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
} else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) {
- v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table,
VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
+ v->twomvbp = bitstream_read_vlc(bc, v->twomvbp_vlc->table,
+
VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
}
}
@@ -2495,7 +2534,8 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
GET_MQUANT(); // p. 227
s->current_picture.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && cbp)
- ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
+ ttmb = bitstream_read_vlc(bc,
ff_vc1_ttmb_vlc[v->tt_index].table,
+ VC1_TTMB_VLC_BITS, 2);
for (i = 0; i < 6; i++) {
s->dc_val[0][s->block_index[i]] = 0;
dst_idx += i >> 2;
@@ -2636,8 +2676,9 @@ static void vc1_decode_i_blocks(VC1Context *v)
s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
// do actual MB decoding and displaying
- cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table,
MB_INTRA_VLC_BITS, 2);
- v->s.ac_pred = get_bits1(&v->s.gb);
+ cbp = bitstream_read_vlc(&v->s.bc, ff_msmp4_mb_i_vlc.table,
+ MB_INTRA_VLC_BITS, 2);
+ v->s.ac_pred = bitstream_read_bit(&v->s.bc);
for (k = 0; k < 6; k++) {
val = ((cbp >> (5 - k)) & 1);
@@ -2696,10 +2737,10 @@ static void vc1_decode_i_blocks(VC1Context *v)
if (v->s.loop_filter)
ff_vc1_loop_filter_iblk(v, v->pq);
- if (get_bits_count(&s->gb) > v->bits) {
+ if (bitstream_tell(&s->bc) > v->bits) {
ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i >
%i\n",
- get_bits_count(&s->gb), v->bits);
+ bitstream_tell(&s->bc), v->bits);
return;
}
}
@@ -2729,7 +2770,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v)
int mb_pos;
int mquant = v->pq;
int mqdiff;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
/* select coding mode used for VLC tables selection */
switch (v->y_ac_table_index) {
@@ -2781,15 +2822,16 @@ static void vc1_decode_i_blocks_adv(VC1Context *v)
// do actual MB decoding and displaying
if (v->fieldtx_is_raw)
- v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
- cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table,
MB_INTRA_VLC_BITS, 2);
+ v->fieldtx_plane[mb_pos] = bitstream_read_bit(&v->s.bc);
+ cbp = bitstream_read_vlc(&v->s.bc, ff_msmp4_mb_i_vlc.table,
+ MB_INTRA_VLC_BITS, 2);
if (v->acpred_is_raw)
- v->s.ac_pred = get_bits1(&v->s.gb);
+ v->s.ac_pred = bitstream_read_bit(&v->s.bc);
else
v->s.ac_pred = v->acpred_plane[mb_pos];
if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
- v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
+ v->over_flags_plane[mb_pos] = bitstream_read_bit(&v->s.bc);
GET_MQUANT();
@@ -2824,11 +2866,11 @@ static void vc1_decode_i_blocks_adv(VC1Context *v)
if (v->s.loop_filter)
ff_vc1_loop_filter_iblk_delayed(v, v->pq);
- if (get_bits_count(&s->gb) > v->bits) {
+ if (bitstream_tell(&s->bc) > v->bits) {
// TODO: may need modification to handle slice coding
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y,
ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i >
%i\n",
- get_bits_count(&s->gb), v->bits);
+ bitstream_tell(&s->bc), v->bits);
return;
}
}
@@ -2902,11 +2944,11 @@ static void vc1_decode_p_blocks(VC1Context *v)
else vc1_decode_p_mb(v);
if (s->mb_y != s->start_mb_y && apply_loop_filter)
ff_vc1_apply_p_loop_filter(v);
- if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) <
0) {
+ if (bitstream_tell(&s->bc) > v->bits || bitstream_tell(&s->bc) <
0) {
// TODO: may need modification to handle slice coding
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y,
ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i
at %ix%i\n",
- get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
+ bitstream_tell(&s->bc), v->bits, s->mb_x, s->mb_y);
return;
}
}
@@ -2973,11 +3015,11 @@ static void vc1_decode_b_blocks(VC1Context *v)
vc1_decode_b_mb_intfr(v);
else
vc1_decode_b_mb(v);
- if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) <
0) {
+ if (bitstream_tell(&s->bc) > v->bits || bitstream_tell(&s->bc) <
0) {
// TODO: may need modification to handle slice coding
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y,
ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i
at %ix%i\n",
- get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
+ bitstream_tell(&s->bc), v->bits, s->mb_x, s->mb_y);
return;
}
if (v->s.loop_filter)
@@ -3023,7 +3065,7 @@ void ff_vc1_decode_blocks(VC1Context *v)
v->s.esc3_level_length = 0;
if (v->x8_type) {
ff_intrax8_decode_picture(&v->x8, &v->s.current_picture,
- &v->s.gb, &v->s.mb_x, &v->s.mb_y,
+ &v->s.bc, &v->s.mb_x, &v->s.mb_y,
2 * v->pq + v->halfpq, v->pq *
!v->pquantizer,
v->s.loop_filter, v->s.low_delay);
diff --git a/libavcodec/vc1_parser.c b/libavcodec/vc1_parser.c
index 38b62f7..c8ad87a 100644
--- a/libavcodec/vc1_parser.c
+++ b/libavcodec/vc1_parser.c
@@ -26,9 +26,10 @@
*/
#include "libavutil/attributes.h"
+
+#include "bitstream.h"
#include "parser.h"
#include "vc1.h"
-#include "get_bits.h"
/** The maximum number of bytes of a sequence, entry point or
* frame header whose values we pay any attention to */
@@ -62,22 +63,22 @@ static void vc1_extract_header(AVCodecParserContext *s,
AVCodecContext *avctx,
{
/* Parse the header we just finished unescaping */
VC1ParseContext *vpc = s->priv_data;
- GetBitContext gb;
+ BitstreamContext bc;
vpc->v.s.avctx = avctx;
vpc->v.parse_only = 1;
- init_get_bits(&gb, buf, buf_size * 8);
+ bitstream_init8(&bc, buf, buf_size);
switch (vpc->prev_start_code) {
case VC1_CODE_SEQHDR & 0xFF:
- ff_vc1_decode_sequence_header(avctx, &vpc->v, &gb);
+ ff_vc1_decode_sequence_header(avctx, &vpc->v, &bc);
break;
case VC1_CODE_ENTRYPOINT & 0xFF:
- ff_vc1_decode_entry_point(avctx, &vpc->v, &gb);
+ ff_vc1_decode_entry_point(avctx, &vpc->v, &bc);
break;
case VC1_CODE_FRAME & 0xFF:
if(vpc->v.profile < PROFILE_ADVANCED)
- ff_vc1_parse_frame_header (&vpc->v, &gb);
+ ff_vc1_parse_frame_header (&vpc->v, &bc);
else
- ff_vc1_parse_frame_header_adv(&vpc->v, &gb);
+ ff_vc1_parse_frame_header_adv(&vpc->v, &bc);
/* keep AV_PICTURE_TYPE_BI internal to VC1 */
if (vpc->v.s.pict_type == AV_PICTURE_TYPE_BI)
diff --git a/libavcodec/vc1_pred.c b/libavcodec/vc1_pred.c
index 25be787..16f46c0 100644
--- a/libavcodec/vc1_pred.c
+++ b/libavcodec/vc1_pred.c
@@ -26,6 +26,7 @@
* VC-1 and WMV3 block decoding routines
*/
+#include "bitstream.h"
#include "mathops.h"
#include "mpegutils.h"
#include "mpegvideo.h"
@@ -416,7 +417,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int
dmv_y,
else
sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
if (sum > hybridmv_thresh) {
- if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
+ if (bitstream_read_bit(&s->bc)) { // read HYBRIDPRED bit
px = field_predA[0];
py = field_predA[1];
} else {
@@ -429,7 +430,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int
dmv_y,
else
sum = FFABS(px - field_predC[0]) + FFABS(py -
field_predC[1]);
if (sum > hybridmv_thresh) {
- if (get_bits1(&s->gb)) {
+ if (bitstream_read_bit(&s->bc)) {
px = field_predA[0];
py = field_predA[1];
} else {
@@ -781,7 +782,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int
dmv_y[2],
else
sum = FFABS(px - A[0]) + FFABS(py - A[1]);
if (sum > 32) {
- if (get_bits1(&s->gb)) {
+ if (bitstream_read_bit(&s->bc)) {
px = A[0];
py = A[1];
} else {
@@ -794,7 +795,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int
dmv_y[2],
else
sum = FFABS(px - C[0]) + FFABS(py - C[1]);
if (sum > 32) {
- if (get_bits1(&s->gb)) {
+ if (bitstream_read_bit(&s->bc)) {
px = A[0];
py = A[1];
} else {
@@ -860,7 +861,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int
dmv_y[2],
else
sum = FFABS(px - A[0]) + FFABS(py - A[1]);
if (sum > 32) {
- if (get_bits1(&s->gb)) {
+ if (bitstream_read_bit(&s->bc)) {
px = A[0];
py = A[1];
} else {
@@ -873,7 +874,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int
dmv_y[2],
else
sum = FFABS(px - C[0]) + FFABS(py - C[1]);
if (sum > 32) {
- if (get_bits1(&s->gb)) {
+ if (bitstream_read_bit(&s->bc)) {
px = A[0];
py = A[1];
} else {
diff --git a/libavcodec/vc1data.h b/libavcodec/vc1data.h
index 66c569b..372af90 100644
--- a/libavcodec/vc1data.h
+++ b/libavcodec/vc1data.h
@@ -30,7 +30,9 @@
#include <stdint.h>
#include "libavutil/rational.h"
-#include "get_bits.h"
+
+#include "bitstream.h"
+#include "vlc.h"
/** Table for conversion between TTBLK and TTMB */
extern const int ff_vc1_ttblk_to_tt[3][8];
diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c
index 3d042d0..64a78c2 100644
--- a/libavcodec/vc1dec.c
+++ b/libavcodec/vc1dec.c
@@ -28,7 +28,7 @@
#include "avcodec.h"
#include "blockdsp.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "internal.h"
#include "mpeg_er.h"
#include "mpegvideo.h"
@@ -59,52 +59,52 @@ typedef struct SpriteData {
int effect_params1[15], effect_params2[10]; ///< effect parameters in
16.16 fixed point format
} SpriteData;
-static inline int get_fp_val(GetBitContext* gb)
+static inline int get_fp_val(BitstreamContext* bc)
{
- return (get_bits_long(gb, 30) - (1 << 29)) << 1;
+ return (bitstream_read(bc, 30) - (1 << 29)) << 1;
}
-static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
+static void vc1_sprite_parse_transform(BitstreamContext* bc, int c[7])
{
c[1] = c[3] = 0;
- switch (get_bits(gb, 2)) {
+ switch (bitstream_read(bc, 2)) {
case 0:
c[0] = 1 << 16;
- c[2] = get_fp_val(gb);
+ c[2] = get_fp_val(bc);
c[4] = 1 << 16;
break;
case 1:
- c[0] = c[4] = get_fp_val(gb);
- c[2] = get_fp_val(gb);
+ c[0] = c[4] = get_fp_val(bc);
+ c[2] = get_fp_val(bc);
break;
case 2:
- c[0] = get_fp_val(gb);
- c[2] = get_fp_val(gb);
- c[4] = get_fp_val(gb);
+ c[0] = get_fp_val(bc);
+ c[2] = get_fp_val(bc);
+ c[4] = get_fp_val(bc);
break;
case 3:
- c[0] = get_fp_val(gb);
- c[1] = get_fp_val(gb);
- c[2] = get_fp_val(gb);
- c[3] = get_fp_val(gb);
- c[4] = get_fp_val(gb);
+ c[0] = get_fp_val(bc);
+ c[1] = get_fp_val(bc);
+ c[2] = get_fp_val(bc);
+ c[3] = get_fp_val(bc);
+ c[4] = get_fp_val(bc);
break;
}
- c[5] = get_fp_val(gb);
- if (get_bits1(gb))
- c[6] = get_fp_val(gb);
+ c[5] = get_fp_val(bc);
+ if (bitstream_read_bit(bc))
+ c[6] = get_fp_val(bc);
else
c[6] = 1 << 16;
}
-static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
+static void vc1_parse_sprites(VC1Context *v, BitstreamContext* bc, SpriteData*
sd)
{
AVCodecContext *avctx = v->s.avctx;
int sprite, i;
for (sprite = 0; sprite <= v->two_sprites; sprite++) {
- vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
+ vc1_sprite_parse_transform(bc, sd->coefs[sprite]);
if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
avpriv_request_sample(avctx, "Non-zero rotation coefficients");
av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
@@ -115,19 +115,19 @@ static void vc1_parse_sprites(VC1Context *v,
GetBitContext* gb, SpriteData* sd)
av_log(avctx, AV_LOG_DEBUG, "\n");
}
- skip_bits(gb, 2);
- if (sd->effect_type = get_bits_long(gb, 30)) {
- switch (sd->effect_pcount1 = get_bits(gb, 4)) {
+ bitstream_skip(bc, 2);
+ if (sd->effect_type = bitstream_read(bc, 30)) {
+ switch (sd->effect_pcount1 = bitstream_read(bc, 4)) {
case 7:
- vc1_sprite_parse_transform(gb, sd->effect_params1);
+ vc1_sprite_parse_transform(bc, sd->effect_params1);
break;
case 14:
- vc1_sprite_parse_transform(gb, sd->effect_params1);
- vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
+ vc1_sprite_parse_transform(bc, sd->effect_params1);
+ vc1_sprite_parse_transform(bc, sd->effect_params1 + 7);
break;
default:
for (i = 0; i < sd->effect_pcount1; i++)
- sd->effect_params1[i] = get_fp_val(gb);
+ sd->effect_params1[i] = get_fp_val(bc);
}
if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6])
{
// effect 13 is simple alpha blending and matches the opacity above
@@ -139,7 +139,7 @@ static void vc1_parse_sprites(VC1Context *v, GetBitContext*
gb, SpriteData* sd)
av_log(avctx, AV_LOG_DEBUG, "\n");
}
- sd->effect_pcount2 = get_bits(gb, 16);
+ sd->effect_pcount2 = bitstream_read(bc, 16);
if (sd->effect_pcount2 > 10) {
av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
return;
@@ -147,7 +147,7 @@ static void vc1_parse_sprites(VC1Context *v, GetBitContext*
gb, SpriteData* sd)
i = -1;
av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
while (++i < sd->effect_pcount2) {
- sd->effect_params2[i] = get_fp_val(gb);
+ sd->effect_params2[i] = get_fp_val(bc);
av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
sd->effect_params2[i] / (1 << 16),
(abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 <<
16));
@@ -155,13 +155,12 @@ static void vc1_parse_sprites(VC1Context *v,
GetBitContext* gb, SpriteData* sd)
av_log(avctx, AV_LOG_DEBUG, "\n");
}
}
- if (sd->effect_flag = get_bits1(gb))
+ if (sd->effect_flag = bitstream_read_bit(bc))
av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
- if (get_bits_count(gb) >= gb->size_in_bits +
- (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
+ if (bitstream_tell(bc) <= (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 :
0))
av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
- if (get_bits_count(gb) < gb->size_in_bits - 8)
+ if (bitstream_bits_left(bc) > 8)
av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
}
@@ -262,13 +261,13 @@ static void vc1_draw_sprites(VC1Context *v, SpriteData*
sd)
}
-static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
+static int vc1_decode_sprites(VC1Context *v, BitstreamContext* bc)
{
MpegEncContext *s = &v->s;
AVCodecContext *avctx = s->avctx;
SpriteData sd;
- vc1_parse_sprites(v, gb, &sd);
+ vc1_parse_sprites(v, bc, &sd);
if (!s->current_picture.f->data[0]) {
av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
@@ -415,7 +414,7 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx)
{
VC1Context *v = avctx->priv_data;
MpegEncContext *s = &v->s;
- GetBitContext gb;
+ BitstreamContext bc;
/* save the container output size for WMImage */
v->output_width = avctx->width;
@@ -443,15 +442,15 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx)
// the last byte of the extradata is a version number, 1 for the
// samples we can decode
- init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
+ bitstream_init8(&bc, avctx->extradata, avctx->extradata_size);
- if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
+ if (ff_vc1_decode_sequence_header(avctx, v, &bc) < 0)
return -1;
- count = avctx->extradata_size*8 - get_bits_count(&gb);
+ count = avctx->extradata_size*8 - bitstream_tell(&bc);
if (count > 0) {
av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
- count, get_bits_long(&gb, FFMIN(count, 32)));
+ count, bitstream_read(&bc, FFMIN(count, 32)));
} else if (count < 0) {
av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
}
@@ -477,17 +476,17 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx)
if (size <= 0)
continue;
buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
- init_get_bits(&gb, buf2, buf2_size * 8);
+ bitstream_init8(&bc, buf2, buf2_size);
switch (AV_RB32(start)) {
case VC1_CODE_SEQHDR:
- if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
+ if (ff_vc1_decode_sequence_header(avctx, v, &bc) < 0) {
av_free(buf2);
return -1;
}
seq_initialized = 1;
break;
case VC1_CODE_ENTRYPOINT:
- if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
+ if (ff_vc1_decode_entry_point(avctx, v, &bc) < 0) {
av_free(buf2);
return -1;
}
@@ -598,7 +597,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
int mb_height, n_slices1;
struct {
uint8_t *buf;
- GetBitContext gb;
+ BitstreamContext bc;
int mby_start;
} *slices = NULL, *tmp;
@@ -647,7 +646,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
goto err;
buf_size3 = vc1_unescape_buffer(start + 4, size,
slices[n_slices].buf);
- init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
+ bitstream_init(&slices[n_slices].bc, slices[n_slices].buf,
buf_size3 << 3);
/* assuming that the field marker is at the exact middle,
hope it's correct */
@@ -658,8 +657,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
}
case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
- init_get_bits(&s->gb, buf2, buf_size2 * 8);
- ff_vc1_decode_entry_point(avctx, v, &s->gb);
+ bitstream_init8(&s->bc, buf2, buf_size2);
+ ff_vc1_decode_entry_point(avctx, v, &s->bc);
break;
case VC1_CODE_SLICE: {
int buf_size3;
@@ -672,9 +671,9 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
goto err;
buf_size3 = vc1_unescape_buffer(start + 4, size,
slices[n_slices].buf);
- init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
+ bitstream_init(&slices[n_slices].bc, slices[n_slices].buf,
buf_size3 << 3);
- slices[n_slices].mby_start =
get_bits(&slices[n_slices].gb, 9);
+ slices[n_slices].mby_start =
bitstream_read(&slices[n_slices].bc, 9);
n_slices++;
break;
}
@@ -697,7 +696,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
if (!slices[n_slices].buf)
goto err;
buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size -
divider - 4, slices[n_slices].buf);
- init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
+ bitstream_init(&slices[n_slices].bc, slices[n_slices].buf,
buf_size3 << 3);
slices[n_slices].mby_start = s->mb_height >> 1;
n_slices1 = n_slices - 1;
@@ -707,13 +706,13 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
} else {
buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
}
- init_get_bits(&s->gb, buf2, buf_size2*8);
+ bitstream_init8(&s->bc, buf2, buf_size2);
} else
- init_get_bits(&s->gb, buf, buf_size*8);
+ bitstream_init8(&s->bc, buf, buf_size);
if (v->res_sprite) {
- v->new_sprite = !get_bits1(&s->gb);
- v->two_sprites = get_bits1(&s->gb);
+ v->new_sprite = !bitstream_read_bit(&s->bc);
+ v->two_sprites = bitstream_read_bit(&s->bc);
/* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE
means
we're using the sprite compositor. These are intentionally kept
separate
so you can get the raw sprites by using the wmv3 decoder for WMVP or
@@ -755,11 +754,11 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
v->pic_header_flag = 0;
v->first_pic_header_flag = 1;
if (v->profile < PROFILE_ADVANCED) {
- if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
+ if (ff_vc1_parse_frame_header(v, &s->bc) < 0) {
goto err;
}
} else {
- if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
+ if (ff_vc1_parse_frame_header_adv(v, &s->bc) < 0) {
goto err;
}
}
@@ -858,15 +857,15 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
if (i) {
v->pic_header_flag = 0;
if (v->field_mode && i == n_slices1 + 2) {
- if ((header_ret = ff_vc1_parse_frame_header_adv(v,
&s->gb)) < 0) {
+ if ((header_ret = ff_vc1_parse_frame_header_adv(v,
&s->bc)) < 0) {
av_log(v->s.avctx, AV_LOG_ERROR, "Field header
damaged\n");
if (avctx->err_recognition & AV_EF_EXPLODE)
goto err;
continue;
}
- } else if (get_bits1(&s->gb)) {
+ } else if (bitstream_read_bit(&s->bc)) {
v->pic_header_flag = 1;
- if ((header_ret = ff_vc1_parse_frame_header_adv(v,
&s->gb)) < 0) {
+ if ((header_ret = ff_vc1_parse_frame_header_adv(v,
&s->bc)) < 0) {
av_log(v->s.avctx, AV_LOG_ERROR, "Slice header
damaged\n");
if (avctx->err_recognition & AV_EF_EXPLODE)
goto err;
@@ -883,7 +882,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
s->end_mb_y = (i <= n_slices1 + 1) ? mb_height :
FFMIN(mb_height, slices[i].mby_start % mb_height);
ff_vc1_decode_blocks(v);
if (i != n_slices)
- s->gb = slices[i].gb;
+ s->bc = slices[i].bc;
}
if (v->field_mode) {
v->second_field = 0;
@@ -898,8 +897,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, void
*data,
}
}
ff_dlog(s->avctx, "Consumed %i/%i bits\n",
- get_bits_count(&s->gb), s->gb.size_in_bits);
-// if (get_bits_count(&s->gb) > buf_size * 8)
+ bitstream_tell(&s->bc), s->bc.size_in_bits);
+// if (bitstream_tell(&s->bc) > buf_size * 8)
// return -1;
if (!v->field_mode)
ff_er_frame_end(&s->er);
@@ -914,7 +913,7 @@ image:
if (avctx->skip_frame >= AVDISCARD_NONREF)
goto end;
#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
- if (vc1_decode_sprites(v, &s->gb))
+ if (vc1_decode_sprites(v, &s->bc))
goto err;
#endif
if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
--
2.1.4
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
