virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-08-04 22:03:09 +02:00
Code Issues Releases Activity

avcodec/h263dec: Stop using MpegEncContext.gb

Browse Source 
Add a GetBitContext to H263DecContext instead. This is in preparation
for removing MpegEncContext.gb.
Also move last_resync_gb to H263DecContext.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt
2025-06-19 20:29:40 +02:00
parent 77add26918
commit 8a4accc24d
13 changed files with 588 additions and 583 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
libavcodec/flvdec.c
View File

@ -31,26 +31,26 @@ int ff_flv_decode_picture_header(H263DecContext *const h)
int format, width, height; int format, width, height;
/* picture header */ /* picture header */
if (get_bits(&h->c.gb, 17) != 1) { if (get_bits(&h->gb, 17) != 1) {
av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture start code\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture start code\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
format = get_bits(&h->c.gb, 5); format = get_bits(&h->gb, 5);
if (format != 0 && format != 1) { if (format != 0 && format != 1) {
av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture format\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture format\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
h->c.h263_flv = format + 1; h->c.h263_flv = format + 1;
h->c.picture_number = get_bits(&h->c.gb, 8); /* picture timestamp */ h->c.picture_number = get_bits(&h->gb, 8); /* picture timestamp */
format = get_bits(&h->c.gb, 3); format = get_bits(&h->gb, 3);
switch (format) { switch (format) {
case 0: case 0:
width = get_bits(&h->c.gb, 8); width = get_bits(&h->gb, 8);
height = get_bits(&h->c.gb, 8); height = get_bits(&h->gb, 8);
break; break;
case 1: case 1:
width = get_bits(&h->c.gb, 16); width = get_bits(&h->gb, 16);
height = get_bits(&h->c.gb, 16); height = get_bits(&h->gb, 16);
break; break;
case 2: case 2:
width = 352; width = 352;
@ -81,18 +81,18 @@ int ff_flv_decode_picture_header(H263DecContext *const h)
h->c.width = width; h->c.width = width;
h->c.height = height; h->c.height = height;
h->c.pict_type = AV_PICTURE_TYPE_I + get_bits(&h->c.gb, 2); h->c.pict_type = AV_PICTURE_TYPE_I + get_bits(&h->gb, 2);
h->c.droppable = h->c.pict_type > AV_PICTURE_TYPE_P; h->c.droppable = h->c.pict_type > AV_PICTURE_TYPE_P;
if (h->c.droppable) if (h->c.droppable)
h->c.pict_type = AV_PICTURE_TYPE_P; h->c.pict_type = AV_PICTURE_TYPE_P;
skip_bits1(&h->c.gb); /* deblocking flag */ skip_bits1(&h->gb); /* deblocking flag */
h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->gb, 5);
h->c.h263_long_vectors = 0; h->c.h263_long_vectors = 0;
/* PEI */ /* PEI */
if (skip_1stop_8data_bits(&h->c.gb) < 0) if (skip_1stop_8data_bits(&h->gb) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (h->c.ehc_mode) if (h->c.ehc_mode)

52
libavcodec/h263dec.c
View File

@ -187,7 +187,7 @@ static int decode_slice(H263DecContext *const h)
const int mb_size = 16 >> h->c.avctx->lowres; const int mb_size = 16 >> h->c.avctx->lowres;
int ret; int ret;
h->c.last_resync_gb = h->c.gb; h->last_resync_gb = h->gb;
h->c.first_slice_line = 1; h->c.first_slice_line = 1;
h->c.resync_mb_x = h->c.mb_x; h->c.resync_mb_x = h->c.mb_x;
h->c.resync_mb_y = h->c.mb_y; h->c.resync_mb_y = h->c.mb_y;
@ -200,8 +200,8 @@ static int decode_slice(H263DecContext *const h)
} }
if (h->c.avctx->hwaccel) { if (h->c.avctx->hwaccel) {
const uint8_t *start = h->c.gb.buffer + get_bits_count(&h->c.gb) / 8; const uint8_t *start = h->gb.buffer + get_bits_count(&h->gb) / 8;
ret = FF_HW_CALL(h->c.avctx, decode_slice, start, h->c.gb.buffer_end - start); ret = FF_HW_CALL(h->c.avctx, decode_slice, start, h->gb.buffer_end - start);
// ensure we exit decode loop // ensure we exit decode loop
h->c.mb_y = h->c.mb_height; h->c.mb_y = h->c.mb_height;
return ret; return ret;
@ -253,7 +253,7 @@ static int decode_slice(H263DecContext *const h)
h->c.mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
h->c.mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
ff_dlog(h->c.avctx, "%d %06X\n", ff_dlog(h->c.avctx, "%d %06X\n",
get_bits_count(&h->c.gb), show_bits(&h->c.gb, 24)); get_bits_count(&h->gb), show_bits(&h->gb, 24));
ff_tlog(NULL, "Decoding MB at %dx%d\n", h->c.mb_x, h->c.mb_y); ff_tlog(NULL, "Decoding MB at %dx%d\n", h->c.mb_x, h->c.mb_y);
ret = h->decode_mb(h); ret = h->decode_mb(h);
@ -300,7 +300,7 @@ static int decode_slice(H263DecContext *const h)
ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y,
h->c.mb_x, h->c.mb_y, ER_MB_ERROR & part_mask); h->c.mb_x, h->c.mb_y, ER_MB_ERROR & part_mask);
if ((h->c.avctx->err_recognition & AV_EF_IGNORE_ERR) && get_bits_left(&h->c.gb) > 0) if ((h->c.avctx->err_recognition & AV_EF_IGNORE_ERR) && get_bits_left(&h->gb) > 0)
continue; continue;
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -321,29 +321,29 @@ static int decode_slice(H263DecContext *const h)
// Detect incorrect padding with wrong stuffing codes used by NEC N-02B // Detect incorrect padding with wrong stuffing codes used by NEC N-02B
if (h->c.codec_id == AV_CODEC_ID_MPEG4 && if (h->c.codec_id == AV_CODEC_ID_MPEG4 &&
(h->c.workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&h->c.gb) >= 48 && get_bits_left(&h->gb) >= 48 &&
show_bits(&h->c.gb, 24) == 0x4010 && show_bits(&h->gb, 24) == 0x4010 &&
!h->c.data_partitioning) !h->c.data_partitioning)
h->c.padding_bug_score += 32; h->c.padding_bug_score += 32;
/* try to detect the padding bug */ /* try to detect the padding bug */
if (h->c.codec_id == AV_CODEC_ID_MPEG4 && if (h->c.codec_id == AV_CODEC_ID_MPEG4 &&
(h->c.workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&h->c.gb) >= 0 && get_bits_left(&h->gb) >= 0 &&
get_bits_left(&h->c.gb) < 137 && get_bits_left(&h->gb) < 137 &&
!h->c.data_partitioning) { !h->c.data_partitioning) {
const int bits_count = get_bits_count(&h->c.gb); const int bits_count = get_bits_count(&h->gb);
const int bits_left = h->c.gb.size_in_bits - bits_count; const int bits_left = h->gb.size_in_bits - bits_count;
if (bits_left == 0) { if (bits_left == 0) {
h->c.padding_bug_score += 16; h->c.padding_bug_score += 16;
} else if (bits_left != 1) { } else if (bits_left != 1) {
int v = show_bits(&h->c.gb, 8); int v = show_bits(&h->gb, 8);
v |= 0x7F >> (7 - (bits_count & 7)); v |= 0x7F >> (7 - (bits_count & 7));
if (v == 0x7F && bits_left <= 8) if (v == 0x7F && bits_left <= 8)
h->c.padding_bug_score--; h->c.padding_bug_score--;
else if (v == 0x7F && ((get_bits_count(&h->c.gb) + 8) & 8) && else if (v == 0x7F && ((get_bits_count(&h->gb) + 8) & 8) &&
bits_left <= 16) bits_left <= 16)
h->c.padding_bug_score += 4; h->c.padding_bug_score += 4;
else else
@ -353,10 +353,10 @@ static int decode_slice(H263DecContext *const h)
if (h->c.codec_id == AV_CODEC_ID_H263 && if (h->c.codec_id == AV_CODEC_ID_H263 &&
(h->c.workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&h->c.gb) >= 8 && get_bits_left(&h->gb) >= 8 &&
get_bits_left(&h->c.gb) < 300 && get_bits_left(&h->gb) < 300 &&
h->c.pict_type == AV_PICTURE_TYPE_I && h->c.pict_type == AV_PICTURE_TYPE_I &&
show_bits(&h->c.gb, 8) == 0 && show_bits(&h->gb, 8) == 0 &&
!h->c.data_partitioning) { !h->c.data_partitioning) {
h->c.padding_bug_score += 32; h->c.padding_bug_score += 32;
@ -364,8 +364,8 @@ static int decode_slice(H263DecContext *const h)
if (h->c.codec_id == AV_CODEC_ID_H263 && if (h->c.codec_id == AV_CODEC_ID_H263 &&
(h->c.workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&h->c.gb) >= 64 && get_bits_left(&h->gb) >= 64 &&
AV_RB64(h->c.gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) { AV_RB64(h->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) {
h->c.padding_bug_score += 32; h->c.padding_bug_score += 32;
} }
@ -380,7 +380,7 @@ static int decode_slice(H263DecContext *const h)
// handle formats which don't have unique end markers // handle formats which don't have unique end markers
if (h->c.msmpeg4_version != MSMP4_UNUSED || (h->c.workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly if (h->c.msmpeg4_version != MSMP4_UNUSED || (h->c.workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly
int left = get_bits_left(&h->c.gb); int left = get_bits_left(&h->gb);
int max_extra = 7; int max_extra = 7;
/* no markers in M$ crap */ /* no markers in M$ crap */
@ -398,7 +398,7 @@ static int decode_slice(H263DecContext *const h)
if (left > max_extra) if (left > max_extra)
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"discarding %d junk bits at end, next would be %X\n", "discarding %d junk bits at end, next would be %X\n",
left, show_bits(&h->c.gb, 24)); left, show_bits(&h->gb, 24));
else if (left < 0) else if (left < 0)
av_log(h->c.avctx, AV_LOG_ERROR, "overreading %d bits\n", -left); av_log(h->c.avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
else else
@ -410,7 +410,7 @@ static int decode_slice(H263DecContext *const h)
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"slice end not reached but screenspace end (%d left %06X, score= %d)\n", "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
get_bits_left(&h->c.gb), show_bits(&h->c.gb, 24), h->c.padding_bug_score); get_bits_left(&h->gb), show_bits(&h->gb, 24), h->c.padding_bug_score);
ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, h->c.mb_x, h->c.mb_y, ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, h->c.mb_x, h->c.mb_y,
ER_MB_END & part_mask); ER_MB_END & part_mask);
@ -452,8 +452,8 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
return 0; return 0;
} }
// h->c.gb might be overridden in ff_mpeg4_decode_picture_header() below. // h->gb might be overridden in ff_mpeg4_decode_picture_header() below.
ret = init_get_bits8(&h->c.gb, buf, buf_size); ret = init_get_bits8(&h->gb, buf, buf_size);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -504,7 +504,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
avctx->has_b_frames = !h->c.low_delay; avctx->has_b_frames = !h->c.low_delay;
if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) { if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
if (h->c.pict_type != AV_PICTURE_TYPE_B && h->c.mb_num/2 > get_bits_left(&h->c.gb)) if (h->c.pict_type != AV_PICTURE_TYPE_B && h->c.mb_num/2 > get_bits_left(&h->gb))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ff_mpeg4_workaround_bugs(avctx); ff_mpeg4_workaround_bugs(avctx);
if (h->c.studio_profile != (h->c.idsp.idct == NULL)) if (h->c.studio_profile != (h->c.idsp.idct == NULL))
@ -554,7 +554,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
if (avctx->hwaccel) { if (avctx->hwaccel) {
ret = FF_HW_CALL(avctx, start_frame, NULL, ret = FF_HW_CALL(avctx, start_frame, NULL,
h->c.gb.buffer, h->c.gb.buffer_end - h->c.gb.buffer); h->gb.buffer, h->gb.buffer_end - h->gb.buffer);
if (ret < 0 ) if (ret < 0 )
return ret; return ret;
} }
@ -582,7 +582,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
while (h->c.mb_y < h->c.mb_height) { while (h->c.mb_y < h->c.mb_height) {
if (h->c.msmpeg4_version != MSMP4_UNUSED) { if (h->c.msmpeg4_version != MSMP4_UNUSED) {
if (h->c.slice_height == 0 || h->c.mb_x != 0 || slice_ret < 0 || if (h->c.slice_height == 0 || h->c.mb_x != 0 || slice_ret < 0 ||
(h->c.mb_y % h->c.slice_height) != 0 || get_bits_left(&h->c.gb) < 0) (h->c.mb_y % h->c.slice_height) != 0 || get_bits_left(&h->gb) < 0)
break; break;
} else { } else {
int prev_x = h->c.mb_x, prev_y = h->c.mb_y; int prev_x = h->c.mb_x, prev_y = h->c.mb_y;

5
libavcodec/h263dec.h
View File

@ -20,6 +20,7 @@
#ifndef AVCODEC_H263DEC_H #ifndef AVCODEC_H263DEC_H
#define AVCODEC_H263DEC_H #define AVCODEC_H263DEC_H
#include "get_bits.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "vlc.h" #include "vlc.h"
#include "libavutil/mem_internal.h" #include "libavutil/mem_internal.h"
@ -47,8 +48,12 @@ extern VLCElem ff_h263_mv_vlc[];
typedef struct H263DecContext { typedef struct H263DecContext {
MPVContext c; MPVContext c;
GetBitContext gb;
int (*decode_mb)(struct H263DecContext *h); int (*decode_mb)(struct H263DecContext *h);
GetBitContext last_resync_gb; ///< used to search for the next resync marker
DECLARE_ALIGNED_32(int16_t, block)[6][64]; DECLARE_ALIGNED_32(int16_t, block)[6][64];
} H263DecContext; } H263DecContext;

64
libavcodec/intelh263dec.c
View File

@ -30,44 +30,44 @@ int ff_intel_h263_decode_picture_header(H263DecContext *const h)
{ {
int format; int format;
if (get_bits_left(&h->c.gb) == 64) { /* special dummy frames */ if (get_bits_left(&h->gb) == 64) { /* special dummy frames */
return FRAME_SKIPPED; return FRAME_SKIPPED;
} }
/* picture header */ /* picture header */
if (get_bits(&h->c.gb, 22) != 0x20) { if (get_bits(&h->gb, 22) != 0x20) {
av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture start code\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1; return -1;
} }
h->c.picture_number = get_bits(&h->c.gb, 8); /* picture timestamp */ h->c.picture_number = get_bits(&h->gb, 8); /* picture timestamp */
if (check_marker(h->c.avctx, &h->c.gb, "after picture_number") != 1) { if (check_marker(h->c.avctx, &h->gb, "after picture_number") != 1) {
return -1; /* marker */ return -1; /* marker */
} }
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Bad H.263 id\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad H.263 id\n");
return -1; /* H.263 id */ return -1; /* H.263 id */
} }
skip_bits1(&h->c.gb); /* split screen off */ skip_bits1(&h->gb); /* split screen off */
skip_bits1(&h->c.gb); /* camera off */ skip_bits1(&h->gb); /* camera off */
skip_bits1(&h->c.gb); /* freeze picture release off */ skip_bits1(&h->gb); /* freeze picture release off */
format = get_bits(&h->c.gb, 3); format = get_bits(&h->gb, 3);
if (format == 0 || format == 6) { if (format == 0 || format == 6) {
av_log(h->c.avctx, AV_LOG_ERROR, "Intel H.263 free format not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Intel H.263 free format not supported\n");
return -1; return -1;
} }
h->c.pict_type = AV_PICTURE_TYPE_I + get_bits1(&h->c.gb); h->c.pict_type = AV_PICTURE_TYPE_I + get_bits1(&h->gb);
h->c.h263_long_vectors = get_bits1(&h->c.gb); h->c.h263_long_vectors = get_bits1(&h->gb);
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "SAC not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "SAC not supported\n");
return -1; /* SAC: off */ return -1; /* SAC: off */
} }
h->c.obmc = get_bits1(&h->c.gb); h->c.obmc = get_bits1(&h->gb);
h->c.pb_frame = get_bits1(&h->c.gb); h->c.pb_frame = get_bits1(&h->gb);
if (format < 6) { if (format < 6) {
h->c.width = ff_h263_format[format][0]; h->c.width = ff_h263_format[format][0];
@ -75,31 +75,31 @@ int ff_intel_h263_decode_picture_header(H263DecContext *const h)
h->c.avctx->sample_aspect_ratio.num = 12; h->c.avctx->sample_aspect_ratio.num = 12;
h->c.avctx->sample_aspect_ratio.den = 11; h->c.avctx->sample_aspect_ratio.den = 11;
} else { } else {
format = get_bits(&h->c.gb, 3); format = get_bits(&h->gb, 3);
if(format == 0 || format == 7){ if(format == 0 || format == 7){
av_log(h->c.avctx, AV_LOG_ERROR, "Wrong Intel H.263 format\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Wrong Intel H.263 format\n");
return -1; return -1;
} }
if (get_bits(&h->c.gb, 2)) if (get_bits(&h->gb, 2))
av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
h->c.loop_filter = get_bits1(&h->c.gb) * !h->c.avctx->lowres; h->c.loop_filter = get_bits1(&h->gb) * !h->c.avctx->lowres;
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
h->c.pb_frame = 2; h->c.pb_frame = 2;
if (get_bits(&h->c.gb, 5)) if (get_bits(&h->gb, 5))
av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
if (get_bits(&h->c.gb, 5) != 1) if (get_bits(&h->gb, 5) != 1)
av_log(h->c.avctx, AV_LOG_ERROR, "Invalid marker\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Invalid marker\n");
} }
if(format == 6){ if(format == 6){
int ar = get_bits(&h->c.gb, 4); int ar = get_bits(&h->gb, 4);
skip_bits(&h->c.gb, 9); // display width skip_bits(&h->gb, 9); // display width
check_marker(h->c.avctx, &h->c.gb, "in dimensions"); check_marker(h->c.avctx, &h->gb, "in dimensions");
skip_bits(&h->c.gb, 9); // display height skip_bits(&h->gb, 9); // display height
if (ar == 15) { if (ar == 15) {
h->c.avctx->sample_aspect_ratio.num = get_bits(&h->c.gb, 8); // aspect ratio - width h->c.avctx->sample_aspect_ratio.num = get_bits(&h->gb, 8); // aspect ratio - width
h->c.avctx->sample_aspect_ratio.den = get_bits(&h->c.gb, 8); // aspect ratio - height h->c.avctx->sample_aspect_ratio.den = get_bits(&h->gb, 8); // aspect ratio - height
} else { } else {
h->c.avctx->sample_aspect_ratio = ff_h263_pixel_aspect[ar]; h->c.avctx->sample_aspect_ratio = ff_h263_pixel_aspect[ar];
} }
@ -107,16 +107,16 @@ int ff_intel_h263_decode_picture_header(H263DecContext *const h)
av_log(h->c.avctx, AV_LOG_ERROR, "Invalid aspect ratio.\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Invalid aspect ratio.\n");
} }
h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->gb, 5);
skip_bits1(&h->c.gb); /* Continuous Presence Multipoint mode: off */ skip_bits1(&h->gb); /* Continuous Presence Multipoint mode: off */
if (h->c.pb_frame) { if (h->c.pb_frame) {
skip_bits(&h->c.gb, 3); //temporal reference for B-frame skip_bits(&h->gb, 3); //temporal reference for B-frame
skip_bits(&h->c.gb, 2); //dbquant skip_bits(&h->gb, 2); //dbquant
} }
/* PEI */ /* PEI */
if (skip_1stop_8data_bits(&h->c.gb) < 0) if (skip_1stop_8data_bits(&h->gb) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
h->c.gob_index = H263_GOB_HEIGHT(h->c.height); h->c.gob_index = H263_GOB_HEIGHT(h->c.height);

339
libavcodec/ituh263dec.c
View File

@ -82,7 +82,7 @@ void ff_h263_show_pict_info(H263DecContext *const h, int h263_plus)
if (h->c.avctx->debug&FF_DEBUG_PICT_INFO) { if (h->c.avctx->debug&FF_DEBUG_PICT_INFO) {
av_log(h->c.avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", av_log(h->c.avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
h->c.qscale, av_get_picture_type_char(h->c.pict_type), h->c.qscale, av_get_picture_type_char(h->c.pict_type),
h->c.gb.size_in_bits, 1-h->c.no_rounding, h->gb.size_in_bits, 1-h->c.no_rounding,
h->c.obmc ? " AP" : "", h->c.obmc ? " AP" : "",
h->c.umvplus ? " UMV" : "", h->c.umvplus ? " UMV" : "",
h->c.h263_long_vectors ? " LONG" : "", h->c.h263_long_vectors ? " LONG" : "",
@ -146,7 +146,7 @@ int ff_h263_decode_mba(H263DecContext *const h)
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
if (h->c.mb_num - 1 <= ff_mba_max[i]) if (h->c.mb_num - 1 <= ff_mba_max[i])
break; break;
mb_pos = get_bits(&h->c.gb, ff_mba_length[i]); mb_pos = get_bits(&h->gb, ff_mba_length[i]);
h->c.mb_x = mb_pos % h->c.mb_width; h->c.mb_x = mb_pos % h->c.mb_width;
h->c.mb_y = mb_pos / h->c.mb_width; h->c.mb_y = mb_pos / h->c.mb_width;
@ -163,41 +163,42 @@ static int h263_decode_gob_header(H263DecContext *const h)
int left; int left;
/* Check for GOB Start Code */ /* Check for GOB Start Code */
val = show_bits(&h->c.gb, 16); val = show_bits(&h->gb, 16);
if(val) if(val)
return -1; return -1;
/* We have a GBSC probably with GSTUFF */ /* We have a GBSC probably with GSTUFF */
skip_bits(&h->c.gb, 16); /* Drop the zeros */ skip_bits(&h->gb, 16); /* Drop the zeros */
left = get_bits_left(&h->c.gb); left = get_bits_left(&h->gb);
left = FFMIN(left, 32); left = FFMIN(left, 32);
//MN: we must check the bits left or we might end in an infinite loop (or segfault) //MN: we must check the bits left or we might end in an infinite loop (or segfault)
for(;left>13; left--){ for(;left>13; left--){
if (get_bits1(&h->c.gb)) break; /* Seek the '1' bit */ if (get_bits1(&h->gb))
break; /* Seek the '1' bit */
} }
if(left<=13) if(left<=13)
return -1; return -1;
if (h->c.h263_slice_structured) { if (h->c.h263_slice_structured) {
if (check_marker(h->c.avctx, &h->c.gb, "before MBA")==0) if (check_marker(h->c.avctx, &h->gb, "before MBA")==0)
return -1; return -1;
ff_h263_decode_mba(h); ff_h263_decode_mba(h);
if (h->c.mb_num > 1583) if (h->c.mb_num > 1583)
if (check_marker(h->c.avctx, &h->c.gb, "after MBA")==0) if (check_marker(h->c.avctx, &h->gb, "after MBA")==0)
return -1; return -1;
h->c.qscale = get_bits(&h->c.gb, 5); /* SQUANT */ h->c.qscale = get_bits(&h->gb, 5); /* SQUANT */
if (check_marker(h->c.avctx, &h->c.gb, "after SQUANT")==0) if (check_marker(h->c.avctx, &h->gb, "after SQUANT")==0)
return -1; return -1;
skip_bits(&h->c.gb, 2); /* GFID */ skip_bits(&h->gb, 2); /* GFID */
}else{ }else{
gob_number = get_bits(&h->c.gb, 5); /* GN */ gob_number = get_bits(&h->gb, 5); /* GN */
h->c.mb_x = 0; h->c.mb_x = 0;
h->c.mb_y = h->c.gob_index* gob_number; h->c.mb_y = h->c.gob_index* gob_number;
skip_bits(&h->c.gb, 2); /* GFID */ skip_bits(&h->gb, 2); /* GFID */
h->c.qscale = get_bits(&h->c.gb, 5); /* GQUANT */ h->c.qscale = get_bits(&h->gb, 5); /* GQUANT */
} }
if (h->c.mb_y >= h->c.mb_height) if (h->c.mb_y >= h->c.mb_height)
@ -220,25 +221,25 @@ int ff_h263_resync(H263DecContext *const h)
/* In MPEG-4 studio mode look for a new slice startcode /* In MPEG-4 studio mode look for a new slice startcode
* and decode slice header */ * and decode slice header */
if (h->c.codec_id==AV_CODEC_ID_MPEG4 && h->c.studio_profile) { if (h->c.codec_id==AV_CODEC_ID_MPEG4 && h->c.studio_profile) {
align_get_bits(&h->c.gb); align_get_bits(&h->gb);
while (get_bits_left(&h->c.gb) >= 32 && show_bits_long(&h->c.gb, 32) != SLICE_STARTCODE) { while (get_bits_left(&h->gb) >= 32 && show_bits_long(&h->gb, 32) != SLICE_STARTCODE) {
get_bits(&h->c.gb, 8); get_bits(&h->gb, 8);
} }
if (get_bits_left(&h->c.gb) >= 32 && show_bits_long(&h->c.gb, 32) == SLICE_STARTCODE) if (get_bits_left(&h->gb) >= 32 && show_bits_long(&h->gb, 32) == SLICE_STARTCODE)
return get_bits_count(&h->c.gb); return get_bits_count(&h->gb);
else else
return -1; return -1;
} }
if (h->c.codec_id==AV_CODEC_ID_MPEG4){ if (h->c.codec_id==AV_CODEC_ID_MPEG4){
skip_bits1(&h->c.gb); skip_bits1(&h->gb);
align_get_bits(&h->c.gb); align_get_bits(&h->gb);
} }
if (show_bits(&h->c.gb, 16) ==0) { if (show_bits(&h->gb, 16) ==0) {
pos = get_bits_count(&h->c.gb); pos = get_bits_count(&h->gb);
if(CONFIG_MPEG4_DECODER && h->c.codec_id==AV_CODEC_ID_MPEG4) if(CONFIG_MPEG4_DECODER && h->c.codec_id==AV_CODEC_ID_MPEG4)
ret = ff_mpeg4_decode_video_packet_header(h); ret = ff_mpeg4_decode_video_packet_header(h);
else else
@ -247,15 +248,15 @@ int ff_h263_resync(H263DecContext *const h)
return pos; return pos;
} }
//OK, it's not where it is supposed to be ... //OK, it's not where it is supposed to be ...
h->c.gb = h->c.last_resync_gb; h->gb = h->last_resync_gb;
align_get_bits(&h->c.gb); align_get_bits(&h->gb);
left = get_bits_left(&h->c.gb); left = get_bits_left(&h->gb);
for(;left>16+1+5+5; left-=8){ for(;left>16+1+5+5; left-=8){
if (show_bits(&h->c.gb, 16) == 0){ if (show_bits(&h->gb, 16) == 0){
GetBitContext bak = h->c.gb; GetBitContext bak = h->gb;
pos = get_bits_count(&h->c.gb); pos = get_bits_count(&h->gb);
if(CONFIG_MPEG4_DECODER && h->c.codec_id==AV_CODEC_ID_MPEG4) if(CONFIG_MPEG4_DECODER && h->c.codec_id==AV_CODEC_ID_MPEG4)
ret = ff_mpeg4_decode_video_packet_header(h); ret = ff_mpeg4_decode_video_packet_header(h);
else else
@ -263,9 +264,9 @@ int ff_h263_resync(H263DecContext *const h)
if(ret>=0) if(ret>=0)
return pos; return pos;
h->c.gb = bak; h->gb = bak;
} }
skip_bits(&h->c.gb, 8); skip_bits(&h->gb, 8);
} }
return -1; return -1;
@ -274,19 +275,19 @@ int ff_h263_resync(H263DecContext *const h)
int ff_h263_decode_motion(H263DecContext *const h, int pred, int f_code) int ff_h263_decode_motion(H263DecContext *const h, int pred, int f_code)
{ {
int code, val, sign, shift; int code, val, sign, shift;
code = get_vlc2(&h->c.gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2); code = get_vlc2(&h->gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2);
if (code == 0) if (code == 0)
return pred; return pred;
if (code < 0) if (code < 0)
return 0xffff; return 0xffff;
sign = get_bits1(&h->c.gb); sign = get_bits1(&h->gb);
shift = f_code - 1; shift = f_code - 1;
val = code; val = code;
if (shift) { if (shift) {
val = (val - 1) << shift; val = (val - 1) << shift;
val |= get_bits(&h->c.gb, shift); val |= get_bits(&h->gb, shift);
val++; val++;
} }
if (sign) if (sign)
@ -313,15 +314,15 @@ static int h263p_decode_umotion(H263DecContext *const h, int pred)
{ {
int code = 0, sign; int code = 0, sign;
if (get_bits1(&h->c.gb)) /* Motion difference = 0 */ if (get_bits1(&h->gb)) /* Motion difference = 0 */
return pred; return pred;
code = 2 + get_bits1(&h->c.gb); code = 2 + get_bits1(&h->gb);
while (get_bits1(&h->c.gb)) while (get_bits1(&h->gb))
{ {
code <<= 1; code <<= 1;
code += get_bits1(&h->c.gb); code += get_bits1(&h->gb);
if (code >= 32768) { if (code >= 32768) {
avpriv_request_sample(h->c.avctx, "Huge DMV"); avpriv_request_sample(h->c.avctx, "Huge DMV");
return 0xffff; return 0xffff;
@ -341,7 +342,7 @@ static int h263p_decode_umotion(H263DecContext *const h, int pred)
*/ */
static void preview_obmc(H263DecContext *const h) static void preview_obmc(H263DecContext *const h)
{ {
GetBitContext gb = h->c.gb; GetBitContext gb = h->gb;
int cbpc, i, pred_x, pred_y, mx, my; int cbpc, i, pred_x, pred_y, mx, my;
int16_t *mot_val; int16_t *mot_val;
@ -357,7 +358,7 @@ static void preview_obmc(H263DecContext *const h)
av_assert2(h->c.pict_type == AV_PICTURE_TYPE_P); av_assert2(h->c.pict_type == AV_PICTURE_TYPE_P);
do{ do{
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
/* skip mb */ /* skip mb */
mot_val = h->c.cur_pic.motion_val[0][h->c.block_index[0]]; mot_val = h->c.cur_pic.motion_val[0][h->c.block_index[0]];
mot_val[0 ]= mot_val[2 ]= mot_val[0 ]= mot_val[2 ]=
@ -368,15 +369,15 @@ static void preview_obmc(H263DecContext *const h)
h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
goto end; goto end;
} }
cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); cbpc = get_vlc2(&h->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
}while(cbpc == 20); }while(cbpc == 20);
if(cbpc & 4){ if(cbpc & 4){
h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA;
}else{ }else{
get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (cbpc & 8) { if (cbpc & 8) {
skip_bits(&h->c.gb, h->c.modified_quant ? (get_bits1(&h->c.gb) ? 1 : 5) : 2); skip_bits(&h->gb, h->c.modified_quant ? (get_bits1(&h->gb) ? 1 : 5) : 2);
} }
if ((cbpc & 16) == 0) { if ((cbpc & 16) == 0) {
@ -411,7 +412,7 @@ static void preview_obmc(H263DecContext *const h)
else else
my = ff_h263_decode_motion(h, pred_y, 1); my = ff_h263_decode_motion(h, pred_y, 1);
if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ skip_bits1(&h->gb); /* Bit stuffing to prevent PSC */
mot_val[0] = mx; mot_val[0] = mx;
mot_val[1] = my; mot_val[1] = my;
} }
@ -425,7 +426,7 @@ end:
h->c.block_index[i] -= 1; h->c.block_index[i] -= 1;
h->c.mb_x--; h->c.mb_x--;
h->c.gb = gb; h->gb = gb;
} }
static void h263_decode_dquant(H263DecContext *const h) static void h263_decode_dquant(H263DecContext *const h)
@ -434,12 +435,12 @@ static void h263_decode_dquant(H263DecContext *const h)
int qscale; int qscale;
if (h->c.modified_quant) { if (h->c.modified_quant) {
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
qscale = ff_modified_quant_tab[get_bits1(&h->c.gb)][h->c.qscale]; qscale = ff_modified_quant_tab[get_bits1(&h->gb)][h->c.qscale];
else else
qscale = get_bits(&h->c.gb, 5); qscale = get_bits(&h->gb, 5);
}else }else
qscale = h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]; qscale = h->c.qscale + quant_tab[get_bits(&h->gb, 2)];
ff_set_qscale(&h->c, qscale); ff_set_qscale(&h->c, qscale);
} }
@ -527,7 +528,7 @@ static int h263_decode_block(H263DecContext *const h, int16_t block[64],
int level, i, j, run; int level, i, j, run;
const RLTable *rl = &ff_h263_rl_inter; const RLTable *rl = &ff_h263_rl_inter;
const uint8_t *scan_table; const uint8_t *scan_table;
GetBitContext gb = h->c.gb; GetBitContext gb = h->gb;
scan_table = h->c.intra_scantable.permutated; scan_table = h->c.intra_scantable.permutated;
if (h->c.h263_aic && h->c.mb_intra) { if (h->c.h263_aic && h->c.mb_intra) {
@ -558,12 +559,12 @@ static int h263_decode_block(H263DecContext *const h, int16_t block[64],
h->c.rv10_first_dc_coded[component] = 1; h->c.rv10_first_dc_coded[component] = 1;
} }
} else { } else {
level = get_bits(&h->c.gb, 8); level = get_bits(&h->gb, 8);
if (level == 255) if (level == 255)
level = 128; level = 128;
} }
}else{ }else{
level = get_bits(&h->c.gb, 8); level = get_bits(&h->gb, 8);
if((level&0x7F) == 0){ if((level&0x7F) == 0){
av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n",
level, h->c.mb_x, h->c.mb_y); level, h->c.mb_x, h->c.mb_y);
@ -584,60 +585,60 @@ static int h263_decode_block(H263DecContext *const h, int16_t block[64],
} }
retry: retry:
{ {
OPEN_READER(re, &h->c.gb); OPEN_READER(re, &h->gb);
i--; // offset by -1 to allow direct indexing of scan_table i--; // offset by -1 to allow direct indexing of scan_table
for(;;) { for(;;) {
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
GET_RL_VLC(level, run, re, &h->c.gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); GET_RL_VLC(level, run, re, &h->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
if (run == 66) { if (run == 66) {
if (level){ if (level){
CLOSE_READER(re, &h->c.gb); CLOSE_READER(re, &h->gb);
av_log(h->c.avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", av_log(h->c.avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n",
h->c.mb_x, h->c.mb_y); h->c.mb_x, h->c.mb_y);
return -1; return -1;
} }
/* escape */ /* escape */
if (CONFIG_FLV_DECODER && h->c.h263_flv > 1) { if (CONFIG_FLV_DECODER && h->c.h263_flv > 1) {
int is11 = SHOW_UBITS(re, &h->c.gb, 1); int is11 = SHOW_UBITS(re, &h->gb, 1);
SKIP_CACHE(re, &h->c.gb, 1); SKIP_CACHE(re, &h->gb, 1);
run = SHOW_UBITS(re, &h->c.gb, 7) + 1; run = SHOW_UBITS(re, &h->gb, 7) + 1;
if (is11) { if (is11) {
SKIP_COUNTER(re, &h->c.gb, 1 + 7); SKIP_COUNTER(re, &h->gb, 1 + 7);
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
level = SHOW_SBITS(re, &h->c.gb, 11); level = SHOW_SBITS(re, &h->gb, 11);
SKIP_COUNTER(re, &h->c.gb, 11); SKIP_COUNTER(re, &h->gb, 11);
} else { } else {
SKIP_CACHE(re, &h->c.gb, 7); SKIP_CACHE(re, &h->gb, 7);
level = SHOW_SBITS(re, &h->c.gb, 7); level = SHOW_SBITS(re, &h->gb, 7);
SKIP_COUNTER(re, &h->c.gb, 1 + 7 + 7); SKIP_COUNTER(re, &h->gb, 1 + 7 + 7);
} }
} else { } else {
run = SHOW_UBITS(re, &h->c.gb, 7) + 1; run = SHOW_UBITS(re, &h->gb, 7) + 1;
SKIP_CACHE(re, &h->c.gb, 7); SKIP_CACHE(re, &h->gb, 7);
level = (int8_t)SHOW_UBITS(re, &h->c.gb, 8); level = (int8_t)SHOW_UBITS(re, &h->gb, 8);
SKIP_COUNTER(re, &h->c.gb, 7 + 8); SKIP_COUNTER(re, &h->gb, 7 + 8);
if(level == -128){ if(level == -128){
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
if (h->c.codec_id == AV_CODEC_ID_RV10) { if (h->c.codec_id == AV_CODEC_ID_RV10) {
/* XXX: should patch encoder too */ /* XXX: should patch encoder too */
level = SHOW_SBITS(re, &h->c.gb, 12); level = SHOW_SBITS(re, &h->gb, 12);
SKIP_COUNTER(re, &h->c.gb, 12); SKIP_COUNTER(re, &h->gb, 12);
}else{ }else{
level = SHOW_UBITS(re, &h->c.gb, 5); level = SHOW_UBITS(re, &h->gb, 5);
SKIP_CACHE(re, &h->c.gb, 5); SKIP_CACHE(re, &h->gb, 5);
level |= SHOW_SBITS(re, &h->c.gb, 6) * (1<<5); level |= SHOW_SBITS(re, &h->gb, 6) * (1<<5);
SKIP_COUNTER(re, &h->c.gb, 5 + 6); SKIP_COUNTER(re, &h->gb, 5 + 6);
} }
} }
} }
} else { } else {
if (SHOW_UBITS(re, &h->c.gb, 1)) if (SHOW_UBITS(re, &h->gb, 1))
level = -level; level = -level;
SKIP_COUNTER(re, &h->c.gb, 1); SKIP_COUNTER(re, &h->gb, 1);
} }
i += run; i += run;
if (i >= 64){ if (i >= 64){
CLOSE_READER(re, &h->c.gb); CLOSE_READER(re, &h->gb);
// redo update without last flag, revert -1 offset // redo update without last flag, revert -1 offset
i = i - run + ((run-1)&63) + 1; i = i - run + ((run-1)&63) + 1;
if (i < 64) { if (i < 64) {
@ -649,7 +650,7 @@ retry:
//Looks like a hack but no, it's the way it is supposed to work ... //Looks like a hack but no, it's the way it is supposed to work ...
rl = &ff_rl_intra_aic; rl = &ff_rl_intra_aic;
i = 0; i = 0;
h->c.gb = gb; h->gb = gb;
h->c.bdsp.clear_block(block); h->c.bdsp.clear_block(block);
goto retry; goto retry;
} }
@ -787,7 +788,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
if (h->c.pict_type == AV_PICTURE_TYPE_P) { if (h->c.pict_type == AV_PICTURE_TYPE_P) {
do{ do{
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
/* skip mb */ /* skip mb */
h->c.mb_intra = 0; h->c.mb_intra = 0;
for(i=0;i<6;i++) for(i=0;i<6;i++)
@ -800,7 +801,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
h->c.mb_skipped = !(h->c.obmc | h->c.loop_filter); h->c.mb_skipped = !(h->c.obmc | h->c.loop_filter);
goto end; goto end;
} }
cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); cbpc = get_vlc2(&h->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
if (cbpc < 0){ if (cbpc < 0){
av_log(h->c.avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n",
h->c.mb_x, h->c.mb_y); h->c.mb_x, h->c.mb_y);
@ -815,9 +816,9 @@ int ff_h263_decode_mb(H263DecContext *const h)
if (h->c.mb_intra) if (h->c.mb_intra)
goto intra; goto intra;
if(h->c.pb_frame && get_bits1(&h->c.gb)) if (h->c.pb_frame && get_bits1(&h->gb))
pb_mv_count = h263_get_modb(&h->c.gb, h->c.pb_frame, &cbpb); pb_mv_count = h263_get_modb(&h->gb, h->c.pb_frame, &cbpb);
cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (cbpy < 0) { if (cbpy < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n",
@ -858,7 +859,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
h->c.mv[0][0][1] = my; h->c.mv[0][0][1] = my;
if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ skip_bits1(&h->gb); /* Bit stuffing to prevent PSC */
} else { } else {
h->c.cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; h->c.cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV;
h->c.mv_type = MV_TYPE_8X8; h->c.mv_type = MV_TYPE_8X8;
@ -880,7 +881,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
h->c.mv[0][i][0] = mx; h->c.mv[0][i][0] = mx;
h->c.mv[0][i][1] = my; h->c.mv[0][i][1] = my;
if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ skip_bits1(&h->gb); /* Bit stuffing to prevent PSC */
mot_val[0] = mx; mot_val[0] = mx;
mot_val[1] = my; mot_val[1] = my;
} }
@ -899,7 +900,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
do{ do{
mb_type = get_vlc2(&h->c.gb, h263_mbtype_b_vlc, mb_type = get_vlc2(&h->gb, h263_mbtype_b_vlc,
H263_MBTYPE_B_VLC_BITS, 2); H263_MBTYPE_B_VLC_BITS, 2);
if (mb_type < 0){ if (mb_type < 0){
av_log(h->c.avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n",
@ -911,13 +912,13 @@ int ff_h263_decode_mb(H263DecContext *const h)
h->c.mb_intra = IS_INTRA(mb_type); h->c.mb_intra = IS_INTRA(mb_type);
if(HAS_CBP(mb_type)){ if(HAS_CBP(mb_type)){
h->c.bdsp.clear_blocks(h->block[0]); h->c.bdsp.clear_blocks(h->block[0]);
cbpc = get_vlc2(&h->c.gb, cbpc_b_vlc, CBPC_B_VLC_BITS, 1); cbpc = get_vlc2(&h->gb, cbpc_b_vlc, CBPC_B_VLC_BITS, 1);
if (h->c.mb_intra) { if (h->c.mb_intra) {
dquant = IS_QUANT(mb_type); dquant = IS_QUANT(mb_type);
goto intra; goto intra;
} }
cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (cbpy < 0){ if (cbpy < 0){
av_log(h->c.avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n",
@ -965,7 +966,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
return SLICE_ERROR; return SLICE_ERROR;
if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ skip_bits1(&h->gb); /* Bit stuffing to prevent PSC */
h->c.mv[0][0][0] = mx; h->c.mv[0][0][0] = mx;
h->c.mv[0][0][1] = my; h->c.mv[0][0][1] = my;
@ -992,7 +993,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
return SLICE_ERROR; return SLICE_ERROR;
if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ skip_bits1(&h->gb); /* Bit stuffing to prevent PSC */
h->c.mv[1][0][0] = mx; h->c.mv[1][0][0] = mx;
h->c.mv[1][0][1] = my; h->c.mv[1][0][1] = my;
@ -1004,7 +1005,7 @@ int ff_h263_decode_mb(H263DecContext *const h)
h->c.cur_pic.mb_type[xy] = mb_type; h->c.cur_pic.mb_type[xy] = mb_type;
} else { /* I-Frame */ } else { /* I-Frame */
do{ do{
cbpc = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); cbpc = get_vlc2(&h->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
if (cbpc < 0){ if (cbpc < 0){
av_log(h->c.avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n",
h->c.mb_x, h->c.mb_y); h->c.mb_x, h->c.mb_y);
@ -1019,18 +1020,18 @@ int ff_h263_decode_mb(H263DecContext *const h)
intra: intra:
h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA;
if (h->c.h263_aic) { if (h->c.h263_aic) {
h->c.ac_pred = get_bits1(&h->c.gb); h->c.ac_pred = get_bits1(&h->gb);
if (h->c.ac_pred) { if (h->c.ac_pred) {
h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
h->c.h263_aic_dir = get_bits1(&h->c.gb); h->c.h263_aic_dir = get_bits1(&h->gb);
} }
}else }else
h->c.ac_pred = 0; h->c.ac_pred = 0;
if (h->c.pb_frame && get_bits1(&h->c.gb)) if (h->c.pb_frame && get_bits1(&h->gb))
pb_mv_count = h263_get_modb(&h->c.gb, h->c.pb_frame, &cbpb); pb_mv_count = h263_get_modb(&h->gb, h->c.pb_frame, &cbpb);
cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if(cbpy<0){ if(cbpy<0){
av_log(h->c.avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n",
h->c.mb_x, h->c.mb_y); h->c.mb_x, h->c.mb_y);
@ -1065,15 +1066,15 @@ intra:
} }
end: end:
if (get_bits_left(&h->c.gb) < 0) if (get_bits_left(&h->gb) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
/* per-MB end of slice check */ /* per-MB end of slice check */
{ {
int v = show_bits(&h->c.gb, 16); int v = show_bits(&h->gb, 16);
if (get_bits_left(&h->c.gb) < 16) { if (get_bits_left(&h->gb) < 16) {
v >>= 16 - get_bits_left(&h->c.gb); v >>= 16 - get_bits_left(&h->gb);
} }
if(v==0) if(v==0)
@ -1089,16 +1090,16 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
int width, height, i, ret; int width, height, i, ret;
int h263_plus; int h263_plus;
align_get_bits(&h->c.gb); align_get_bits(&h->gb);
if (show_bits(&h->c.gb, 2) == 2 && h->c.avctx->frame_num == 0) { if (show_bits(&h->gb, 2) == 2 && h->c.avctx->frame_num == 0) {
av_log(h->c.avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n"); av_log(h->c.avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n");
} }
uint32_t startcode = get_bits(&h->c.gb, 22-8); uint32_t startcode = get_bits(&h->gb, 22-8);
for (i = get_bits_left(&h->c.gb); i>24; i -= 8) { for (i = get_bits_left(&h->gb); i>24; i -= 8) {
startcode = ((startcode << 8) | get_bits(&h->c.gb, 8)) & 0x003FFFFF; startcode = ((startcode << 8) | get_bits(&h->gb, 8)) & 0x003FFFFF;
if(startcode == 0x20) if(startcode == 0x20)
break; break;
@ -1109,25 +1110,25 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
return -1; return -1;
} }
/* temporal reference */ /* temporal reference */
i = get_bits(&h->c.gb, 8); /* picture timestamp */ i = get_bits(&h->gb, 8); /* picture timestamp */
i -= (i - (h->c.picture_number & 0xFF) + 128) & ~0xFF; i -= (i - (h->c.picture_number & 0xFF) + 128) & ~0xFF;
h->c.picture_number = (h->c.picture_number&~0xFF) + i; h->c.picture_number = (h->c.picture_number&~0xFF) + i;
/* PTYPE starts here */ /* PTYPE starts here */
if (check_marker(h->c.avctx, &h->c.gb, "in PTYPE") != 1) { if (check_marker(h->c.avctx, &h->gb, "in PTYPE") != 1) {
return -1; return -1;
} }
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Bad H.263 id\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad H.263 id\n");
return -1; /* H.263 id */ return -1; /* H.263 id */
} }
skip_bits1(&h->c.gb); /* split screen off */ skip_bits1(&h->gb); /* split screen off */
skip_bits1(&h->c.gb); /* camera off */ skip_bits1(&h->gb); /* camera off */
skip_bits1(&h->c.gb); /* freeze picture release off */ skip_bits1(&h->gb); /* freeze picture release off */
int format = get_bits(&h->c.gb, 3); int format = get_bits(&h->gb, 3);
/* /*
0 forbidden 0 forbidden
1 sub-QCIF 1 sub-QCIF
@ -1143,19 +1144,19 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
if (!width) if (!width)
return -1; return -1;
h->c.pict_type = AV_PICTURE_TYPE_I + get_bits1(&h->c.gb); h->c.pict_type = AV_PICTURE_TYPE_I + get_bits1(&h->gb);
h->c.h263_long_vectors = get_bits1(&h->c.gb); h->c.h263_long_vectors = get_bits1(&h->gb);
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "H.263 SAC not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "H.263 SAC not supported\n");
return -1; /* SAC: off */ return -1; /* SAC: off */
} }
h->c.obmc = get_bits1(&h->c.gb); /* Advanced prediction mode */ h->c.obmc = get_bits1(&h->gb); /* Advanced prediction mode */
h->c.pb_frame = get_bits1(&h->c.gb); h->c.pb_frame = get_bits1(&h->gb);
h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->gb, 5);
skip_bits1(&h->c.gb); /* Continuous Presence Multipoint mode: off */ skip_bits1(&h->gb); /* Continuous Presence Multipoint mode: off */
h->c.width = width; h->c.width = width;
h->c.height = height; h->c.height = height;
@ -1166,46 +1167,46 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
/* H.263v2 */ /* H.263v2 */
h263_plus = 1; h263_plus = 1;
ufep = get_bits(&h->c.gb, 3); /* Update Full Extended PTYPE */ ufep = get_bits(&h->gb, 3); /* Update Full Extended PTYPE */
/* ufep other than 0 and 1 are reserved */ /* ufep other than 0 and 1 are reserved */
if (ufep == 1) { if (ufep == 1) {
/* OPPTYPE */ /* OPPTYPE */
format = get_bits(&h->c.gb, 3); format = get_bits(&h->gb, 3);
ff_dlog(h->c.avctx, "ufep=1, format: %d\n", format); ff_dlog(h->c.avctx, "ufep=1, format: %d\n", format);
h->c.custom_pcf = get_bits1(&h->c.gb); h->c.custom_pcf = get_bits1(&h->gb);
h->c.umvplus = get_bits1(&h->c.gb); /* Unrestricted Motion Vector */ h->c.umvplus = get_bits1(&h->gb); /* Unrestricted Motion Vector */
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
} }
h->c.obmc = get_bits1(&h->c.gb); /* Advanced prediction mode */ h->c.obmc = get_bits1(&h->gb); /* Advanced prediction mode */
h->c.h263_aic = get_bits1(&h->c.gb); /* Advanced Intra Coding (AIC) */ h->c.h263_aic = get_bits1(&h->gb); /* Advanced Intra Coding (AIC) */
h->c.loop_filter = get_bits1(&h->c.gb); h->c.loop_filter = get_bits1(&h->gb);
if (h->c.avctx->lowres) if (h->c.avctx->lowres)
h->c.loop_filter = 0; h->c.loop_filter = 0;
h->c.h263_slice_structured= get_bits1(&h->c.gb); h->c.h263_slice_structured = get_bits1(&h->gb);
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
} }
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
} }
h->c.alt_inter_vlc = get_bits1(&h->c.gb); h->c.alt_inter_vlc = get_bits1(&h->gb);
h->c.modified_quant = get_bits1(&h->c.gb); h->c.modified_quant = get_bits1(&h->gb);
if (h->c.modified_quant) if (h->c.modified_quant)
h->c.chroma_qscale_table= ff_h263_chroma_qscale_table; h->c.chroma_qscale_table= ff_h263_chroma_qscale_table;
skip_bits(&h->c.gb, 1); /* Prevent start code emulation */ skip_bits(&h->gb, 1); /* Prevent start code emulation */
skip_bits(&h->c.gb, 3); /* Reserved */ skip_bits(&h->gb, 3); /* Reserved */
} else if (ufep != 0) { } else if (ufep != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); av_log(h->c.avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
return -1; return -1;
} }
/* MPPTYPE */ /* MPPTYPE */
h->c.pict_type = get_bits(&h->c.gb, 3); h->c.pict_type = get_bits(&h->gb, 3);
switch (h->c.pict_type) { switch (h->c.pict_type) {
case 0: h->c.pict_type = AV_PICTURE_TYPE_I; break; case 0: h->c.pict_type = AV_PICTURE_TYPE_I; break;
case 1: h->c.pict_type = AV_PICTURE_TYPE_P; break; case 1: h->c.pict_type = AV_PICTURE_TYPE_P; break;
@ -1215,15 +1216,15 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
default: default:
return -1; return -1;
} }
skip_bits(&h->c.gb, 2); skip_bits(&h->gb, 2);
h->c.no_rounding = get_bits1(&h->c.gb); h->c.no_rounding = get_bits1(&h->gb);
skip_bits(&h->c.gb, 4); skip_bits(&h->gb, 4);
/* Get the picture dimensions */ /* Get the picture dimensions */
if (ufep) { if (ufep) {
if (format == 6) { if (format == 6) {
/* Custom Picture Format (CPFMT) */ /* Custom Picture Format (CPFMT) */
int aspect_ratio_info = get_bits(&h->c.gb, 4); int aspect_ratio_info = get_bits(&h->gb, 4);
ff_dlog(h->c.avctx, "aspect: %d\n", aspect_ratio_info); ff_dlog(h->c.avctx, "aspect: %d\n", aspect_ratio_info);
/* aspect ratios: /* aspect ratios:
0 - forbidden 0 - forbidden
@ -1234,14 +1235,14 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
5 - 40:33 (525-type 16:9) 5 - 40:33 (525-type 16:9)
6-14 - reserved 6-14 - reserved
*/ */
width = (get_bits(&h->c.gb, 9) + 1) * 4; width = (get_bits(&h->gb, 9) + 1) * 4;
check_marker(h->c.avctx, &h->c.gb, "in dimensions"); check_marker(h->c.avctx, &h->gb, "in dimensions");
height = get_bits(&h->c.gb, 9) * 4; height = get_bits(&h->gb, 9) * 4;
ff_dlog(h->c.avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); ff_dlog(h->c.avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
if (aspect_ratio_info == FF_ASPECT_EXTENDED) { if (aspect_ratio_info == FF_ASPECT_EXTENDED) {
/* expected dimensions */ /* expected dimensions */
h->c.avctx->sample_aspect_ratio.num = get_bits(&h->c.gb, 8); h->c.avctx->sample_aspect_ratio.num = get_bits(&h->gb, 8);
h->c.avctx->sample_aspect_ratio.den = get_bits(&h->c.gb, 8); h->c.avctx->sample_aspect_ratio.den = get_bits(&h->gb, 8);
}else{ }else{
h->c.avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info]; h->c.avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info];
} }
@ -1258,8 +1259,8 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
if (h->c.custom_pcf) { if (h->c.custom_pcf) {
h->c.avctx->framerate.num = 1800000; h->c.avctx->framerate.num = 1800000;
h->c.avctx->framerate.den = 1000 + get_bits1(&h->c.gb); h->c.avctx->framerate.den = 1000 + get_bits1(&h->gb);
h->c.avctx->framerate.den *= get_bits(&h->c.gb, 7); h->c.avctx->framerate.den *= get_bits(&h->gb, 7);
if (h->c.avctx->framerate.den == 0) { if (h->c.avctx->framerate.den == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "zero framerate\n"); av_log(h->c.avctx, AV_LOG_ERROR, "zero framerate\n");
return -1; return -1;
@ -1273,30 +1274,30 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
} }
if (h->c.custom_pcf) if (h->c.custom_pcf)
skip_bits(&h->c.gb, 2); //extended Temporal reference skip_bits(&h->gb, 2); //extended Temporal reference
if (ufep) { if (ufep) {
if (h->c.umvplus) { if (h->c.umvplus) {
if(get_bits1(&h->c.gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ if (get_bits1(&h->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
skip_bits1(&h->c.gb); skip_bits1(&h->gb);
} }
if (h->c.h263_slice_structured) { if (h->c.h263_slice_structured) {
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
} }
if (get_bits1(&h->c.gb) != 0) { if (get_bits1(&h->gb) != 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "unordered slices not supported\n"); av_log(h->c.avctx, AV_LOG_ERROR, "unordered slices not supported\n");
} }
} }
if (h->c.pict_type == AV_PICTURE_TYPE_B) { if (h->c.pict_type == AV_PICTURE_TYPE_B) {
skip_bits(&h->c.gb, 4); //ELNUM skip_bits(&h->gb, 4); //ELNUM
if (ufep == 1) { if (ufep == 1) {
skip_bits(&h->c.gb, 4); // RLNUM skip_bits(&h->gb, 4); // RLNUM
} }
} }
} }
h->c.qscale = get_bits(&h->c.gb, 5); h->c.qscale = get_bits(&h->gb, 5);
} }
ret = av_image_check_size(h->c.width, h->c.height, 0, h->c.avctx); ret = av_image_check_size(h->c.width, h->c.height, 0, h->c.avctx);
@ -1304,7 +1305,7 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
return ret; return ret;
if (!(h->c.avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) { if (!(h->c.avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
if ((h->c.width * h->c.height / 256 / 8) > get_bits_left(&h->c.gb)) if ((h->c.width * h->c.height / 256 / 8) > get_bits_left(&h->gb))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -1315,10 +1316,10 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
h->c.gob_index = H263_GOB_HEIGHT(h->c.height); h->c.gob_index = H263_GOB_HEIGHT(h->c.height);
if (h->c.pb_frame) { if (h->c.pb_frame) {
skip_bits(&h->c.gb, 3); /* Temporal reference for B-pictures */ skip_bits(&h->gb, 3); /* Temporal reference for B-pictures */
if (h->c.custom_pcf) if (h->c.custom_pcf)
skip_bits(&h->c.gb, 2); //extended Temporal reference skip_bits(&h->gb, 2); //extended Temporal reference
skip_bits(&h->c.gb, 2); /* Quantization information for B-pictures */ skip_bits(&h->gb, 2); /* Quantization information for B-pictures */
} }
if (h->c.pict_type!=AV_PICTURE_TYPE_B) { if (h->c.pict_type!=AV_PICTURE_TYPE_B) {
@ -1338,17 +1339,17 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
} }
/* PEI */ /* PEI */
if (skip_1stop_8data_bits(&h->c.gb) < 0) if (skip_1stop_8data_bits(&h->gb) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (h->c.h263_slice_structured) { if (h->c.h263_slice_structured) {
if (check_marker(h->c.avctx, &h->c.gb, "SEPB1") != 1) { if (check_marker(h->c.avctx, &h->gb, "SEPB1") != 1) {
return -1; return -1;
} }
ff_h263_decode_mba(h); ff_h263_decode_mba(h);
if (check_marker(h->c.avctx, &h->c.gb, "SEPB2") != 1) { if (check_marker(h->c.avctx, &h->gb, "SEPB2") != 1) {
return -1; return -1;
} }
} }
@ -1366,19 +1367,19 @@ int ff_h263_decode_picture_header(H263DecContext *const h)
ff_h263_show_pict_info(h, h263_plus); ff_h263_show_pict_info(h, h263_plus);
if (h->c.pict_type == AV_PICTURE_TYPE_I && h->c.codec_tag == AV_RL32("ZYGO") && get_bits_left(&h->c.gb) >= 85 + 13*3*16 + 50){ if (h->c.pict_type == AV_PICTURE_TYPE_I && h->c.codec_tag == AV_RL32("ZYGO") && get_bits_left(&h->gb) >= 85 + 13*3*16 + 50){
int i,j; int i,j;
for(i=0; i<85; i++) av_log(h->c.avctx, AV_LOG_DEBUG, "%d", get_bits1(&h->c.gb)); for(i=0; i<85; i++) av_log(h->c.avctx, AV_LOG_DEBUG, "%d", get_bits1(&h->gb));
av_log(h->c.avctx, AV_LOG_DEBUG, "\n"); av_log(h->c.avctx, AV_LOG_DEBUG, "\n");
for(i=0; i<13; i++){ for(i=0; i<13; i++){
for(j=0; j<3; j++){ for(j=0; j<3; j++){
int v= get_bits(&h->c.gb, 8); int v= get_bits(&h->gb, 8);
v |= get_sbits(&h->c.gb, 8) * (1 << 8); v |= get_sbits(&h->gb, 8) * (1 << 8);
av_log(h->c.avctx, AV_LOG_DEBUG, " %5d", v); av_log(h->c.avctx, AV_LOG_DEBUG, " %5d", v);
} }
av_log(h->c.avctx, AV_LOG_DEBUG, "\n"); av_log(h->c.avctx, AV_LOG_DEBUG, "\n");
} }
for(i=0; i<50; i++) av_log(h->c.avctx, AV_LOG_DEBUG, "%d", get_bits1(&h->c.gb)); for(i=0; i<50; i++) av_log(h->c.avctx, AV_LOG_DEBUG, "%d", get_bits1(&h->gb));
} }
return 0; return 0;

10
libavcodec/mpeg12dec.c
View File

@ -479,7 +479,7 @@ static int mpeg_decode_mb(MPVContext *const s)
s->interlaced_dct = get_bits1(&s->gb); s->interlaced_dct = get_bits1(&s->gb);
if (IS_QUANT(mb_type)) if (IS_QUANT(mb_type))
s->qscale = mpeg_get_qscale(s); s->qscale = mpeg_get_qscale(&s->gb, s->q_scale_type);
if (s->concealment_motion_vectors) { if (s->concealment_motion_vectors) {
/* just parse them */ /* just parse them */
@ -537,7 +537,7 @@ static int mpeg_decode_mb(MPVContext *const s)
} }
if (IS_QUANT(mb_type)) if (IS_QUANT(mb_type))
s->qscale = mpeg_get_qscale(s); s->qscale = mpeg_get_qscale(&s->gb, s->q_scale_type);
s->last_mv[0][0][0] = 0; s->last_mv[0][0][0] = 0;
s->last_mv[0][0][1] = 0; s->last_mv[0][0][1] = 0;
@ -558,7 +558,7 @@ static int mpeg_decode_mb(MPVContext *const s)
} }
if (IS_QUANT(mb_type)) if (IS_QUANT(mb_type))
s->qscale = mpeg_get_qscale(s); s->qscale = mpeg_get_qscale(&s->gb, s->q_scale_type);
/* motion vectors */ /* motion vectors */
s->mv_dir = MB_TYPE_MV_2_MV_DIR(mb_type); s->mv_dir = MB_TYPE_MV_2_MV_DIR(mb_type);
@ -1370,7 +1370,7 @@ static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
ff_mpeg1_clean_buffers(s); ff_mpeg1_clean_buffers(s);
s->interlaced_dct = 0; s->interlaced_dct = 0;
s->qscale = mpeg_get_qscale(s); s->qscale = mpeg_get_qscale(&s->gb, s->q_scale_type);
if (s->qscale == 0) { if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n"); av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
@ -2805,7 +2805,7 @@ static int ipu_decode_frame(AVCodecContext *avctx, AVFrame *frame,
skip_bits1(gb); skip_bits1(gb);
if (intraquant) if (intraquant)
m->qscale = mpeg_get_qscale(m); m->qscale = mpeg_get_qscale(&m->gb, m->q_scale_type);
memset(s->block, 0, sizeof(s->block)); memset(s->block, 0, sizeof(s->block));

320
libavcodec/mpeg4videodec.c
View File

@ -383,8 +383,8 @@ void ff_mpeg4_pred_ac(H263DecContext *const h, int16_t *block, int n, int dir)
static inline int mpeg4_is_resync(Mpeg4DecContext *ctx) static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
{ {
H263DecContext *const h = &ctx->h; H263DecContext *const h = &ctx->h;
int bits_count = get_bits_count(&h->c.gb); int bits_count = get_bits_count(&h->gb);
int v = show_bits(&h->c.gb, 16); int v = show_bits(&h->gb, 16);
if (h->c.workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker) if (h->c.workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker)
return 0; return 0;
@ -393,12 +393,12 @@ static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
if (h->c.pict_type == AV_PICTURE_TYPE_B || if (h->c.pict_type == AV_PICTURE_TYPE_B ||
(v >> (8 - h->c.pict_type) != 1) || h->c.partitioned_frame) (v >> (8 - h->c.pict_type) != 1) || h->c.partitioned_frame)
break; break;
skip_bits(&h->c.gb, 8 + h->c.pict_type); skip_bits(&h->gb, 8 + h->c.pict_type);
bits_count += 8 + h->c.pict_type; bits_count += 8 + h->c.pict_type;
v = show_bits(&h->c.gb, 16); v = show_bits(&h->gb, 16);
} }
if (bits_count + 8 >= h->c.gb.size_in_bits) { if (bits_count + 8 >= h->gb.size_in_bits) {
v >>= 8; v >>= 8;
v |= 0x7F >> (7 - (bits_count & 7)); v |= 0x7F >> (7 - (bits_count & 7));
@ -412,20 +412,20 @@ static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
if (v == mpeg4_resync_prefix[bits_count & 7]) { if (v == mpeg4_resync_prefix[bits_count & 7]) {
int len, mb_num; int len, mb_num;
int mb_num_bits = av_log2(h->c.mb_num - 1) + 1; int mb_num_bits = av_log2(h->c.mb_num - 1) + 1;
GetBitContext gb = h->c.gb; GetBitContext gb = h->gb;
skip_bits(&h->c.gb, 1); skip_bits(&h->gb, 1);
align_get_bits(&h->c.gb); align_get_bits(&h->gb);
for (len = 0; len < 32; len++) for (len = 0; len < 32; len++)
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
break; break;
mb_num = get_bits(&h->c.gb, mb_num_bits); mb_num = get_bits(&h->gb, mb_num_bits);
if (!mb_num || mb_num > h->c.mb_num || get_bits_count(&h->c.gb) + 6 > h->c.gb.size_in_bits) if (!mb_num || mb_num > h->c.mb_num || get_bits_count(&h->gb) + 6 > h->gb.size_in_bits)
mb_num= -1; mb_num= -1;
h->c.gb = gb; h->gb = gb;
if (len >= ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code)) if (len >= ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code))
return mb_num; return mb_num;
@ -713,11 +713,11 @@ int ff_mpeg4_decode_video_packet_header(H263DecContext *const h)
int header_extension = 0, mb_num, len; int header_extension = 0, mb_num, len;
/* is there enough space left for a video packet + header */ /* is there enough space left for a video packet + header */
if (get_bits_count(&h->c.gb) > h->c.gb.size_in_bits - 20) if (get_bits_count(&h->gb) > h->gb.size_in_bits - 20)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
for (len = 0; len < 32; len++) for (len = 0; len < 32; len++)
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
break; break;
if (len != ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code)) { if (len != ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code)) {
@ -726,11 +726,11 @@ int ff_mpeg4_decode_video_packet_header(H263DecContext *const h)
} }
if (ctx->shape != RECT_SHAPE) { if (ctx->shape != RECT_SHAPE) {
header_extension = get_bits1(&h->c.gb); header_extension = get_bits1(&h->gb);
// FIXME more stuff here // FIXME more stuff here
} }
mb_num = get_bits(&h->c.gb, mb_num_bits); mb_num = get_bits(&h->gb, mb_num_bits);
if (mb_num >= h->c.mb_num || !mb_num) { if (mb_num >= h->c.mb_num || !mb_num) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"illegal mb_num in video packet (%d %d) \n", mb_num, h->c.mb_num); "illegal mb_num in video packet (%d %d) \n", mb_num, h->c.mb_num);
@ -741,31 +741,31 @@ int ff_mpeg4_decode_video_packet_header(H263DecContext *const h)
h->c.mb_y = mb_num / h->c.mb_width; h->c.mb_y = mb_num / h->c.mb_width;
if (ctx->shape != BIN_ONLY_SHAPE) { if (ctx->shape != BIN_ONLY_SHAPE) {
int qscale = get_bits(&h->c.gb, ctx->quant_precision); int qscale = get_bits(&h->gb, ctx->quant_precision);
if (qscale) if (qscale)
h->c.chroma_qscale = h->c.qscale = qscale; h->c.chroma_qscale = h->c.qscale = qscale;
} }
if (ctx->shape == RECT_SHAPE) if (ctx->shape == RECT_SHAPE)
header_extension = get_bits1(&h->c.gb); header_extension = get_bits1(&h->gb);
if (header_extension) { if (header_extension) {
while (get_bits1(&h->c.gb) != 0) while (get_bits1(&h->gb) != 0)
; ;
check_marker(h->c.avctx, &h->c.gb, "before time_increment in video packed header"); check_marker(h->c.avctx, &h->gb, "before time_increment in video packed header");
skip_bits(&h->c.gb, ctx->time_increment_bits); /* time_increment */ skip_bits(&h->gb, ctx->time_increment_bits); /* time_increment */
check_marker(h->c.avctx, &h->c.gb, "before vop_coding_type in video packed header"); check_marker(h->c.avctx, &h->gb, "before vop_coding_type in video packed header");
skip_bits(&h->c.gb, 2); /* vop coding type */ skip_bits(&h->gb, 2); /* vop coding type */
// FIXME not rect stuff here // FIXME not rect stuff here
if (ctx->shape != BIN_ONLY_SHAPE) { if (ctx->shape != BIN_ONLY_SHAPE) {
skip_bits(&h->c.gb, 3); /* intra dc vlc threshold */ skip_bits(&h->gb, 3); /* intra dc vlc threshold */
// FIXME don't just ignore everything // FIXME don't just ignore everything
if (h->c.pict_type == AV_PICTURE_TYPE_S && if (h->c.pict_type == AV_PICTURE_TYPE_S &&
ctx->vol_sprite_usage == GMC_SPRITE) { ctx->vol_sprite_usage == GMC_SPRITE) {
if (mpeg4_decode_sprite_trajectory(ctx, &h->c.gb) < 0) if (mpeg4_decode_sprite_trajectory(ctx, &h->gb) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
av_log(h->c.avctx, AV_LOG_ERROR, "untested\n"); av_log(h->c.avctx, AV_LOG_ERROR, "untested\n");
} }
@ -773,13 +773,13 @@ int ff_mpeg4_decode_video_packet_header(H263DecContext *const h)
// FIXME reduced res stuff here // FIXME reduced res stuff here
if (h->c.pict_type != AV_PICTURE_TYPE_I) { if (h->c.pict_type != AV_PICTURE_TYPE_I) {
int f_code = get_bits(&h->c.gb, 3); /* fcode_for */ int f_code = get_bits(&h->gb, 3); /* fcode_for */
if (f_code == 0) if (f_code == 0)
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"Error, video packet header damaged (f_code=0)\n"); "Error, video packet header damaged (f_code=0)\n");
} }
if (h->c.pict_type == AV_PICTURE_TYPE_B) { if (h->c.pict_type == AV_PICTURE_TYPE_B) {
int b_code = get_bits(&h->c.gb, 3); int b_code = get_bits(&h->gb, 3);
if (b_code == 0) if (b_code == 0)
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"Error, video packet header damaged (b_code=0)\n"); "Error, video packet header damaged (b_code=0)\n");
@ -787,7 +787,7 @@ int ff_mpeg4_decode_video_packet_header(H263DecContext *const h)
} }
} }
if (ctx->new_pred) if (ctx->new_pred)
decode_new_pred(ctx, &h->c.gb); decode_new_pred(ctx, &h->gb);
return 0; return 0;
} }
@ -808,7 +808,7 @@ static void reset_studio_dc_predictors(Mpeg4DecContext *const ctx)
int ff_mpeg4_decode_studio_slice_header(H263DecContext *const h) int ff_mpeg4_decode_studio_slice_header(H263DecContext *const h)
{ {
Mpeg4DecContext *const ctx = h263_to_mpeg4(h); Mpeg4DecContext *const ctx = h263_to_mpeg4(h);
GetBitContext *gb = &h->c.gb; GetBitContext *gb = &h->gb;
unsigned vlc_len; unsigned vlc_len;
uint16_t mb_num; uint16_t mb_num;
@ -823,7 +823,7 @@ int ff_mpeg4_decode_studio_slice_header(H263DecContext *const h)
h->c.mb_y = mb_num / h->c.mb_width; h->c.mb_y = mb_num / h->c.mb_width;
if (ctx->shape != BIN_ONLY_SHAPE) if (ctx->shape != BIN_ONLY_SHAPE)
h->c.qscale = mpeg_get_qscale(&h->c); h->c.qscale = mpeg_get_qscale(&h->gb, h->c.q_scale_type);
if (get_bits1(gb)) { /* slice_extension_flag */ if (get_bits1(gb)) { /* slice_extension_flag */
skip_bits1(gb); /* intra_slice */ skip_bits1(gb); /* intra_slice */
@ -985,9 +985,9 @@ static inline int mpeg4_decode_dc(H263DecContext *const h, int n, int *dir_ptr)
int level, code, pred; int level, code, pred;
if (n < 4) if (n < 4)
code = get_vlc2(&h->c.gb, dc_lum, DC_VLC_BITS, 1); code = get_vlc2(&h->gb, dc_lum, DC_VLC_BITS, 1);
else else
code = get_vlc2(&h->c.gb, dc_chrom, DC_VLC_BITS, 1); code = get_vlc2(&h->gb, dc_chrom, DC_VLC_BITS, 1);
if (code < 0) { if (code < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n"); av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n");
@ -999,19 +999,19 @@ static inline int mpeg4_decode_dc(H263DecContext *const h, int n, int *dir_ptr)
} else { } else {
if (IS_3IV1) { if (IS_3IV1) {
if (code == 1) if (code == 1)
level = 2 * get_bits1(&h->c.gb) - 1; level = 2 * get_bits1(&h->gb) - 1;
else { else {
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
level = get_bits(&h->c.gb, code - 1) + (1 << (code - 1)); level = get_bits(&h->gb, code - 1) + (1 << (code - 1));
else else
level = -get_bits(&h->c.gb, code - 1) - (1 << (code - 1)); level = -get_bits(&h->gb, code - 1) - (1 << (code - 1));
} }
} else { } else {
level = get_xbits(&h->c.gb, code); level = get_xbits(&h->gb, code);
} }
if (code > 8) { if (code > 8) {
if (get_bits1(&h->c.gb) == 0) { /* marker */ if (get_bits1(&h->gb) == 0) { /* marker */
if (h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) { if (h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {
av_log(h->c.avctx, AV_LOG_ERROR, "dc marker bit missing\n"); av_log(h->c.avctx, AV_LOG_ERROR, "dc marker bit missing\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -1052,10 +1052,10 @@ static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
int i; int i;
do { do {
if (show_bits(&h->c.gb, 19) == DC_MARKER) if (show_bits(&h->gb, 19) == DC_MARKER)
return mb_num - 1; return mb_num - 1;
cbpc = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); cbpc = get_vlc2(&h->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
if (cbpc < 0) { if (cbpc < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"mcbpc corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); "mcbpc corrupted at %d %d\n", h->c.mb_x, h->c.mb_y);
@ -1068,7 +1068,7 @@ static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
h->c.mb_intra = 1; h->c.mb_intra = 1;
if (cbpc & 4) if (cbpc & 4)
ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->gb, 2)]);
h->c.cur_pic.qscale_table[xy] = h->c.qscale; h->c.cur_pic.qscale_table[xy] = h->c.qscale;
@ -1092,11 +1092,11 @@ static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
const int stride = h->c.b8_stride * 2; const int stride = h->c.b8_stride * 2;
try_again: try_again:
bits = show_bits(&h->c.gb, 17); bits = show_bits(&h->gb, 17);
if (bits == MOTION_MARKER) if (bits == MOTION_MARKER)
return mb_num - 1; return mb_num - 1;
skip_bits1(&h->c.gb); skip_bits1(&h->gb);
if (bits & 0x10000) { if (bits & 0x10000) {
/* skip mb */ /* skip mb */
if (h->c.pict_type == AV_PICTURE_TYPE_S && if (h->c.pict_type == AV_PICTURE_TYPE_S &&
@ -1126,7 +1126,7 @@ try_again:
continue; continue;
} }
cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); cbpc = get_vlc2(&h->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
if (cbpc < 0) { if (cbpc < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"mcbpc corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); "mcbpc corrupted at %d %d\n", h->c.mb_x, h->c.mb_y);
@ -1156,7 +1156,7 @@ try_again:
if (h->c.pict_type == AV_PICTURE_TYPE_S && if (h->c.pict_type == AV_PICTURE_TYPE_S &&
ctx->vol_sprite_usage == GMC_SPRITE && ctx->vol_sprite_usage == GMC_SPRITE &&
(cbpc & 16) == 0) (cbpc & 16) == 0)
h->c.mcsel = get_bits1(&h->c.gb); h->c.mcsel = get_bits1(&h->gb);
else else
h->c.mcsel = 0; h->c.mcsel = 0;
@ -1238,8 +1238,8 @@ static int mpeg4_decode_partition_b(H263DecContext *const h, int mb_count)
h->c.first_slice_line = 0; h->c.first_slice_line = 0;
if (h->c.pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
int ac_pred = get_bits1(&h->c.gb); int ac_pred = get_bits1(&h->gb);
int cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); int cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (cbpy < 0) { if (cbpy < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"cbpy corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); "cbpy corrupted at %d %d\n", h->c.mb_x, h->c.mb_y);
@ -1252,8 +1252,8 @@ static int mpeg4_decode_partition_b(H263DecContext *const h, int mb_count)
if (IS_INTRA(h->c.cur_pic.mb_type[xy])) { if (IS_INTRA(h->c.cur_pic.mb_type[xy])) {
int i; int i;
int dir = 0; int dir = 0;
int ac_pred = get_bits1(&h->c.gb); int ac_pred = get_bits1(&h->gb);
int cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); int cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (cbpy < 0) { if (cbpy < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
@ -1262,7 +1262,7 @@ static int mpeg4_decode_partition_b(H263DecContext *const h, int mb_count)
} }
if (h->c.cbp_table[xy] & 8) if (h->c.cbp_table[xy] & 8)
ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->gb, 2)]);
h->c.cur_pic.qscale_table[xy] = h->c.qscale; h->c.cur_pic.qscale_table[xy] = h->c.qscale;
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
@ -1285,7 +1285,7 @@ static int mpeg4_decode_partition_b(H263DecContext *const h, int mb_count)
h->c.cur_pic.qscale_table[xy] = h->c.qscale; h->c.cur_pic.qscale_table[xy] = h->c.qscale;
h->c.cbp_table[xy] = 0; h->c.cbp_table[xy] = 0;
} else { } else {
int cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); int cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (cbpy < 0) { if (cbpy < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
@ -1294,7 +1294,7 @@ static int mpeg4_decode_partition_b(H263DecContext *const h, int mb_count)
} }
if (h->c.cbp_table[xy] & 8) if (h->c.cbp_table[xy] & 8)
ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->gb, 2)]);
h->c.cur_pic.qscale_table[xy] = h->c.qscale; h->c.cur_pic.qscale_table[xy] = h->c.qscale;
h->c.cbp_table[xy] &= 3; // remove dquant h->c.cbp_table[xy] &= 3; // remove dquant
@ -1338,18 +1338,18 @@ int ff_mpeg4_decode_partitions(H263DecContext *const h)
h->c.mb_num_left = mb_num; h->c.mb_num_left = mb_num;
if (h->c.pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
while (show_bits(&h->c.gb, 9) == 1) while (show_bits(&h->gb, 9) == 1)
skip_bits(&h->c.gb, 9); skip_bits(&h->gb, 9);
if (get_bits(&h->c.gb, 19) != DC_MARKER) { if (get_bits(&h->gb, 19) != DC_MARKER) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"marker missing after first I partition at %d %d\n", "marker missing after first I partition at %d %d\n",
h->c.mb_x, h->c.mb_y); h->c.mb_x, h->c.mb_y);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
} else { } else {
while (show_bits(&h->c.gb, 10) == 1) while (show_bits(&h->gb, 10) == 1)
skip_bits(&h->c.gb, 10); skip_bits(&h->gb, 10);
if (get_bits(&h->c.gb, 17) != MOTION_MARKER) { if (get_bits(&h->gb, 17) != MOTION_MARKER) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"marker missing after first P partition at %d %d\n", "marker missing after first P partition at %d %d\n",
h->c.mb_x, h->c.mb_y); h->c.mb_x, h->c.mb_y);
@ -1463,52 +1463,52 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
} }
} }
{ {
OPEN_READER(re, &h->c.gb); OPEN_READER(re, &h->gb);
for (;;) { for (;;) {
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 0); GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
if (level == 0) { if (level == 0) {
/* escape */ /* escape */
if (rvlc) { if (rvlc) {
if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { if (SHOW_UBITS(re, &h->gb, 1) == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"1. marker bit missing in rvlc esc\n"); "1. marker bit missing in rvlc esc\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
SKIP_CACHE(re, &h->c.gb, 1); SKIP_CACHE(re, &h->gb, 1);
last = SHOW_UBITS(re, &h->c.gb, 1); last = SHOW_UBITS(re, &h->gb, 1);
SKIP_CACHE(re, &h->c.gb, 1); SKIP_CACHE(re, &h->gb, 1);
run = SHOW_UBITS(re, &h->c.gb, 6); run = SHOW_UBITS(re, &h->gb, 6);
SKIP_COUNTER(re, &h->c.gb, 1 + 1 + 6); SKIP_COUNTER(re, &h->gb, 1 + 1 + 6);
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { if (SHOW_UBITS(re, &h->gb, 1) == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"2. marker bit missing in rvlc esc\n"); "2. marker bit missing in rvlc esc\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
SKIP_CACHE(re, &h->c.gb, 1); SKIP_CACHE(re, &h->gb, 1);
level = SHOW_UBITS(re, &h->c.gb, 11); level = SHOW_UBITS(re, &h->gb, 11);
SKIP_CACHE(re, &h->c.gb, 11); SKIP_CACHE(re, &h->gb, 11);
if (SHOW_UBITS(re, &h->c.gb, 5) != 0x10) { if (SHOW_UBITS(re, &h->gb, 5) != 0x10) {
av_log(h->c.avctx, AV_LOG_ERROR, "reverse esc missing\n"); av_log(h->c.avctx, AV_LOG_ERROR, "reverse esc missing\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
SKIP_CACHE(re, &h->c.gb, 5); SKIP_CACHE(re, &h->gb, 5);
level = level * qmul + qadd; level = level * qmul + qadd;
level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1);
SKIP_COUNTER(re, &h->c.gb, 1 + 11 + 5 + 1); SKIP_COUNTER(re, &h->gb, 1 + 11 + 5 + 1);
i += run + 1; i += run + 1;
if (last) if (last)
i += 192; i += 192;
} else { } else {
int cache; int cache;
cache = GET_CACHE(re, &h->c.gb); cache = GET_CACHE(re, &h->gb);
if (IS_3IV1) if (IS_3IV1)
cache ^= 0xC0000000; cache ^= 0xC0000000;
@ -1516,36 +1516,36 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
if (cache & 0x80000000) { if (cache & 0x80000000) {
if (cache & 0x40000000) { if (cache & 0x40000000) {
/* third escape */ /* third escape */
SKIP_CACHE(re, &h->c.gb, 2); SKIP_CACHE(re, &h->gb, 2);
last = SHOW_UBITS(re, &h->c.gb, 1); last = SHOW_UBITS(re, &h->gb, 1);
SKIP_CACHE(re, &h->c.gb, 1); SKIP_CACHE(re, &h->gb, 1);
run = SHOW_UBITS(re, &h->c.gb, 6); run = SHOW_UBITS(re, &h->gb, 6);
SKIP_COUNTER(re, &h->c.gb, 2 + 1 + 6); SKIP_COUNTER(re, &h->gb, 2 + 1 + 6);
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
if (IS_3IV1) { if (IS_3IV1) {
level = SHOW_SBITS(re, &h->c.gb, 12); level = SHOW_SBITS(re, &h->gb, 12);
LAST_SKIP_BITS(re, &h->c.gb, 12); LAST_SKIP_BITS(re, &h->gb, 12);
} else { } else {
if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { if (SHOW_UBITS(re, &h->gb, 1) == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"1. marker bit missing in 3. esc\n"); "1. marker bit missing in 3. esc\n");
if (!(h->c.avctx->err_recognition & AV_EF_IGNORE_ERR) || get_bits_left(&h->c.gb) <= 0) if (!(h->c.avctx->err_recognition & AV_EF_IGNORE_ERR) || get_bits_left(&h->gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
SKIP_CACHE(re, &h->c.gb, 1); SKIP_CACHE(re, &h->gb, 1);
level = SHOW_SBITS(re, &h->c.gb, 12); level = SHOW_SBITS(re, &h->gb, 12);
SKIP_CACHE(re, &h->c.gb, 12); SKIP_CACHE(re, &h->gb, 12);
if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { if (SHOW_UBITS(re, &h->gb, 1) == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"2. marker bit missing in 3. esc\n"); "2. marker bit missing in 3. esc\n");
if (!(h->c.avctx->err_recognition & AV_EF_IGNORE_ERR) || get_bits_left(&h->c.gb) <= 0) if (!(h->c.avctx->err_recognition & AV_EF_IGNORE_ERR) || get_bits_left(&h->gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
SKIP_COUNTER(re, &h->c.gb, 1 + 12 + 1); SKIP_COUNTER(re, &h->gb, 1 + 12 + 1);
} }
#if 0 #if 0
@ -1592,26 +1592,26 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
i += 192; i += 192;
} else { } else {
/* second escape */ /* second escape */
SKIP_BITS(re, &h->c.gb, 2); SKIP_BITS(re, &h->gb, 2);
GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 1); GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i += run + rl->max_run[run >> 7][level / qmul] + 1; // FIXME opt indexing i += run + rl->max_run[run >> 7][level / qmul] + 1; // FIXME opt indexing
level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1);
LAST_SKIP_BITS(re, &h->c.gb, 1); LAST_SKIP_BITS(re, &h->gb, 1);
} }
} else { } else {
/* first escape */ /* first escape */
SKIP_BITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->gb, 1);
GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 1); GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i += run; i += run;
level = level + rl->max_level[run >> 7][(run - 1) & 63] * qmul; // FIXME opt indexing level = level + rl->max_level[run >> 7][(run - 1) & 63] * qmul; // FIXME opt indexing
level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1);
LAST_SKIP_BITS(re, &h->c.gb, 1); LAST_SKIP_BITS(re, &h->gb, 1);
} }
} }
} else { } else {
i += run; i += run;
level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1);
LAST_SKIP_BITS(re, &h->c.gb, 1); LAST_SKIP_BITS(re, &h->gb, 1);
} }
ff_tlog(h->c.avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62); ff_tlog(h->c.avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
if (i > 62) { if (i > 62) {
@ -1628,7 +1628,7 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
block[scan_table[i]] = level; block[scan_table[i]] = level;
} }
CLOSE_READER(re, &h->c.gb); CLOSE_READER(re, &h->gb);
} }
not_coded: not_coded:
@ -1751,7 +1751,7 @@ static int mpeg4_decode_mb(H263DecContext *const h)
if (h->c.pict_type == AV_PICTURE_TYPE_P || if (h->c.pict_type == AV_PICTURE_TYPE_P ||
h->c.pict_type == AV_PICTURE_TYPE_S) { h->c.pict_type == AV_PICTURE_TYPE_S) {
do { do {
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
/* skip mb */ /* skip mb */
h->c.mb_intra = 0; h->c.mb_intra = 0;
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
@ -1780,7 +1780,7 @@ static int mpeg4_decode_mb(H263DecContext *const h)
} }
goto end; goto end;
} }
cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); cbpc = get_vlc2(&h->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
if (cbpc < 0) { if (cbpc < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"mcbpc damaged at %d %d\n", h->c.mb_x, h->c.mb_y); "mcbpc damaged at %d %d\n", h->c.mb_x, h->c.mb_y);
@ -1796,10 +1796,10 @@ static int mpeg4_decode_mb(H263DecContext *const h)
if (h->c.pict_type == AV_PICTURE_TYPE_S && if (h->c.pict_type == AV_PICTURE_TYPE_S &&
ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0) ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0)
h->c.mcsel = get_bits1(&h->c.gb); h->c.mcsel = get_bits1(&h->gb);
else else
h->c.mcsel = 0; h->c.mcsel = 0;
cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1) ^ 0x0F; cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1) ^ 0x0F;
if (cbpy < 0) { if (cbpy < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"P cbpy damaged at %d %d\n", h->c.mb_x, h->c.mb_y); "P cbpy damaged at %d %d\n", h->c.mb_x, h->c.mb_y);
@ -1808,10 +1808,10 @@ static int mpeg4_decode_mb(H263DecContext *const h)
cbp = (cbpc & 3) | (cbpy << 2); cbp = (cbpc & 3) | (cbpy << 2);
if (dquant) if (dquant)
ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->gb, 2)]);
if ((!h->c.progressive_sequence) && if ((!h->c.progressive_sequence) &&
(cbp || (h->c.workaround_bugs & FF_BUG_XVID_ILACE))) (cbp || (h->c.workaround_bugs & FF_BUG_XVID_ILACE)))
h->c.interlaced_dct = get_bits1(&h->c.gb); h->c.interlaced_dct = get_bits1(&h->gb);
h->c.mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
if ((cbpc & 16) == 0) { if ((cbpc & 16) == 0) {
@ -1824,14 +1824,14 @@ static int mpeg4_decode_mb(H263DecContext *const h)
my = get_amv(ctx, 1); my = get_amv(ctx, 1);
h->c.mv[0][0][0] = mx; h->c.mv[0][0][0] = mx;
h->c.mv[0][0][1] = my; h->c.mv[0][0][1] = my;
} else if ((!h->c.progressive_sequence) && get_bits1(&h->c.gb)) { } else if ((!h->c.progressive_sequence) && get_bits1(&h->gb)) {
h->c.cur_pic.mb_type[xy] = MB_TYPE_16x8 | MB_TYPE_FORWARD_MV | h->c.cur_pic.mb_type[xy] = MB_TYPE_16x8 | MB_TYPE_FORWARD_MV |
MB_TYPE_INTERLACED; MB_TYPE_INTERLACED;
/* 16x8 field motion prediction */ /* 16x8 field motion prediction */
h->c.mv_type = MV_TYPE_FIELD; h->c.mv_type = MV_TYPE_FIELD;
h->c.field_select[0][0] = get_bits1(&h->c.gb); h->c.field_select[0][0] = get_bits1(&h->gb);
h->c.field_select[0][1] = get_bits1(&h->c.gb); h->c.field_select[0][1] = get_bits1(&h->gb);
ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y); ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y);
@ -1921,14 +1921,14 @@ static int mpeg4_decode_mb(H263DecContext *const h)
goto end; goto end;
} }
modb1 = get_bits1(&h->c.gb); modb1 = get_bits1(&h->gb);
if (modb1) { if (modb1) {
// like MB_TYPE_B_DIRECT but no vectors coded // like MB_TYPE_B_DIRECT but no vectors coded
mb_type = MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_BIDIR_MV; mb_type = MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_BIDIR_MV;
cbp = 0; cbp = 0;
} else { } else {
modb2 = get_bits1(&h->c.gb); modb2 = get_bits1(&h->gb);
mb_type = get_vlc2(&h->c.gb, mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 1); mb_type = get_vlc2(&h->gb, mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 1);
if (mb_type < 0) { if (mb_type < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "illegal MB_type\n"); av_log(h->c.avctx, AV_LOG_ERROR, "illegal MB_type\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -1937,29 +1937,29 @@ static int mpeg4_decode_mb(H263DecContext *const h)
cbp = 0; cbp = 0;
} else { } else {
h->c.bdsp.clear_blocks(h->block[0]); h->c.bdsp.clear_blocks(h->block[0]);
cbp = get_bits(&h->c.gb, 6); cbp = get_bits(&h->gb, 6);
} }
if ((!IS_DIRECT(mb_type)) && cbp) { if ((!IS_DIRECT(mb_type)) && cbp) {
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
ff_set_qscale(&h->c, h->c.qscale + get_bits1(&h->c.gb) * 4 - 2); ff_set_qscale(&h->c, h->c.qscale + get_bits1(&h->gb) * 4 - 2);
} }
if (!h->c.progressive_sequence) { if (!h->c.progressive_sequence) {
if (cbp) if (cbp)
h->c.interlaced_dct = get_bits1(&h->c.gb); h->c.interlaced_dct = get_bits1(&h->gb);
if (!IS_DIRECT(mb_type) && get_bits1(&h->c.gb)) { if (!IS_DIRECT(mb_type) && get_bits1(&h->gb)) {
mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
mb_type &= ~MB_TYPE_16x16; mb_type &= ~MB_TYPE_16x16;
if (HAS_FORWARD_MV(mb_type)) { if (HAS_FORWARD_MV(mb_type)) {
h->c.field_select[0][0] = get_bits1(&h->c.gb); h->c.field_select[0][0] = get_bits1(&h->gb);
h->c.field_select[0][1] = get_bits1(&h->c.gb); h->c.field_select[0][1] = get_bits1(&h->gb);
} }
if (HAS_BACKWARD_MV(mb_type)) { if (HAS_BACKWARD_MV(mb_type)) {
h->c.field_select[1][0] = get_bits1(&h->c.gb); h->c.field_select[1][0] = get_bits1(&h->gb);
h->c.field_select[1][1] = get_bits1(&h->c.gb); h->c.field_select[1][1] = get_bits1(&h->gb);
} }
} }
} }
@ -2039,7 +2039,7 @@ static int mpeg4_decode_mb(H263DecContext *const h)
int use_intra_dc_vlc; int use_intra_dc_vlc;
do { do {
cbpc = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); cbpc = get_vlc2(&h->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
if (cbpc < 0) { if (cbpc < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"I cbpc damaged at %d %d\n", h->c.mb_x, h->c.mb_y); "I cbpc damaged at %d %d\n", h->c.mb_x, h->c.mb_y);
@ -2051,13 +2051,13 @@ static int mpeg4_decode_mb(H263DecContext *const h)
h->c.mb_intra = 1; h->c.mb_intra = 1;
intra: intra:
h->c.ac_pred = get_bits1(&h->c.gb); h->c.ac_pred = get_bits1(&h->gb);
if (h->c.ac_pred) if (h->c.ac_pred)
h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
else else
h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA;
cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (cbpy < 0) { if (cbpy < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"I cbpy damaged at %d %d\n", h->c.mb_x, h->c.mb_y); "I cbpy damaged at %d %d\n", h->c.mb_x, h->c.mb_y);
@ -2068,10 +2068,10 @@ intra:
use_intra_dc_vlc = h->c.qscale < ctx->intra_dc_threshold; use_intra_dc_vlc = h->c.qscale < ctx->intra_dc_threshold;
if (dquant) if (dquant)
ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->gb, 2)]);
if (!h->c.progressive_sequence) if (!h->c.progressive_sequence)
h->c.interlaced_dct = get_bits1(&h->c.gb); h->c.interlaced_dct = get_bits1(&h->gb);
h->c.bdsp.clear_blocks(h->block[0]); h->c.bdsp.clear_blocks(h->block[0]);
/* decode each block */ /* decode each block */
@ -2173,24 +2173,24 @@ static int mpeg4_decode_studio_block(Mpeg4DecContext *const ctx, int32_t block[6
if (n < 4) { if (n < 4) {
cc = 0; cc = 0;
dct_dc_size = get_vlc2(&h->c.gb, studio_luma_dc, STUDIO_INTRA_BITS, 2); dct_dc_size = get_vlc2(&h->gb, studio_luma_dc, STUDIO_INTRA_BITS, 2);
quant_matrix = h->c.intra_matrix; quant_matrix = h->c.intra_matrix;
} else { } else {
cc = (n & 1) + 1; cc = (n & 1) + 1;
if (ctx->rgb) if (ctx->rgb)
dct_dc_size = get_vlc2(&h->c.gb, studio_luma_dc, STUDIO_INTRA_BITS, 2); dct_dc_size = get_vlc2(&h->gb, studio_luma_dc, STUDIO_INTRA_BITS, 2);
else else
dct_dc_size = get_vlc2(&h->c.gb, studio_chroma_dc, STUDIO_INTRA_BITS, 2); dct_dc_size = get_vlc2(&h->gb, studio_chroma_dc, STUDIO_INTRA_BITS, 2);
quant_matrix = h->c.chroma_intra_matrix; quant_matrix = h->c.chroma_intra_matrix;
} }
if (dct_dc_size == 0) { if (dct_dc_size == 0) {
dct_diff = 0; dct_diff = 0;
} else { } else {
dct_diff = get_xbits(&h->c.gb, dct_dc_size); dct_diff = get_xbits(&h->gb, dct_dc_size);
if (dct_dc_size > 8) { if (dct_dc_size > 8) {
if(!check_marker(h->c.avctx, &h->c.gb, "dct_dc_size > 8")) if(!check_marker(h->c.avctx, &h->gb, "dct_dc_size > 8"))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -2209,7 +2209,7 @@ static int mpeg4_decode_studio_block(Mpeg4DecContext *const ctx, int32_t block[6
/* AC Coefficients */ /* AC Coefficients */
while (1) { while (1) {
group = get_vlc2(&h->c.gb, cur_vlc, STUDIO_INTRA_BITS, 2); group = get_vlc2(&h->gb, cur_vlc, STUDIO_INTRA_BITS, 2);
if (group < 0) { if (group < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "illegal ac coefficient group vlc\n"); av_log(h->c.avctx, AV_LOG_ERROR, "illegal ac coefficient group vlc\n");
@ -2226,12 +2226,12 @@ static int mpeg4_decode_studio_block(Mpeg4DecContext *const ctx, int32_t block[6
/* Zero run length (Table B.47) */ /* Zero run length (Table B.47) */
run = 1 << additional_code_len; run = 1 << additional_code_len;
if (additional_code_len) if (additional_code_len)
run += get_bits(&h->c.gb, additional_code_len); run += get_bits(&h->gb, additional_code_len);
idx += run; idx += run;
continue; continue;
} else if (group >= 7 && group <= 12) { } else if (group >= 7 && group <= 12) {
/* Zero run length and +/-1 level (Table B.48) */ /* Zero run length and +/-1 level (Table B.48) */
code = get_bits(&h->c.gb, additional_code_len); code = get_bits(&h->gb, additional_code_len);
sign = code & 1; sign = code & 1;
code >>= 1; code >>= 1;
run = (1 << (additional_code_len - 1)) + code; run = (1 << (additional_code_len - 1)) + code;
@ -2245,14 +2245,14 @@ static int mpeg4_decode_studio_block(Mpeg4DecContext *const ctx, int32_t block[6
if (idx > 63) if (idx > 63)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
j = scantable[idx++]; j = scantable[idx++];
block[j] = get_xbits(&h->c.gb, additional_code_len); block[j] = get_xbits(&h->gb, additional_code_len);
} else if (group == 21) { } else if (group == 21) {
/* Escape */ /* Escape */
if (idx > 63) if (idx > 63)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
j = scantable[idx++]; j = scantable[idx++];
additional_code_len = h->c.avctx->bits_per_raw_sample + ctx->dct_precision + 4; additional_code_len = h->c.avctx->bits_per_raw_sample + ctx->dct_precision + 4;
flc = get_bits(&h->c.gb, additional_code_len); flc = get_bits(&h->gb, additional_code_len);
if (flc >> (additional_code_len-1)) if (flc >> (additional_code_len-1))
block[j] = -1 * (( flc ^ ((1 << additional_code_len) -1)) + 1); block[j] = -1 * (( flc ^ ((1 << additional_code_len) -1)) + 1);
else else
@ -2278,14 +2278,14 @@ static int mpeg4_decode_dpcm_macroblock(Mpeg4DecContext *const ctx,
height = 16 >> (n ? h->c.chroma_y_shift : 0); height = 16 >> (n ? h->c.chroma_y_shift : 0);
w = 16 >> (n ? h->c.chroma_x_shift : 0); w = 16 >> (n ? h->c.chroma_x_shift : 0);
block_mean = get_bits(&h->c.gb, h->c.avctx->bits_per_raw_sample); block_mean = get_bits(&h->gb, h->c.avctx->bits_per_raw_sample);
if (block_mean == 0){ if (block_mean == 0){
av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden block_mean\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden block_mean\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
h->c.last_dc[n] = block_mean * (1 << (ctx->dct_precision + h->c.intra_dc_precision)); h->c.last_dc[n] = block_mean * (1 << (ctx->dct_precision + h->c.intra_dc_precision));
rice_parameter = get_bits(&h->c.gb, 4); rice_parameter = get_bits(&h->gb, 4);
if (rice_parameter == 0) { if (rice_parameter == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -2307,17 +2307,17 @@ static int mpeg4_decode_dpcm_macroblock(Mpeg4DecContext *const ctx,
left = output; left = output;
topleft = top; topleft = top;
rice_prefix_code = get_unary(&h->c.gb, 1, 12); rice_prefix_code = get_unary(&h->gb, 1, 12);
/* Escape */ /* Escape */
if (rice_prefix_code == 11) if (rice_prefix_code == 11)
dpcm_residual = get_bits(&h->c.gb, h->c.avctx->bits_per_raw_sample); dpcm_residual = get_bits(&h->gb, h->c.avctx->bits_per_raw_sample);
else { else {
if (rice_prefix_code == 12) { if (rice_prefix_code == 12) {
av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden rice_prefix_code\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden rice_prefix_code\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
rice_suffix_code = get_bitsz(&h->c.gb, rice_parameter); rice_suffix_code = get_bitsz(&h->gb, rice_parameter);
dpcm_residual = (rice_prefix_code << rice_parameter) + rice_suffix_code; dpcm_residual = (rice_prefix_code << rice_parameter) + rice_suffix_code;
} }
@ -2363,12 +2363,12 @@ static int mpeg4_decode_studio_mb(H263DecContext *const h)
/* StudioMacroblock */ /* StudioMacroblock */
/* Assumes I-VOP */ /* Assumes I-VOP */
h->c.mb_intra = 1; h->c.mb_intra = 1;
if (get_bits1(&h->c.gb)) { /* compression_mode */ if (get_bits1(&h->gb)) { /* compression_mode */
/* DCT */ /* DCT */
/* macroblock_type, 1 or 2-bit VLC */ /* macroblock_type, 1 or 2-bit VLC */
if (!get_bits1(&h->c.gb)) { if (!get_bits1(&h->gb)) {
skip_bits1(&h->c.gb); skip_bits1(&h->gb);
h->c.qscale = mpeg_get_qscale(&h->c); h->c.qscale = mpeg_get_qscale(&h->gb, h->c.q_scale_type);
} }
for (i = 0; i < mpeg4_block_count[h->c.chroma_format]; i++) { for (i = 0; i < mpeg4_block_count[h->c.chroma_format]; i++) {
@ -2377,25 +2377,25 @@ static int mpeg4_decode_studio_mb(H263DecContext *const h)
} }
} else { } else {
/* DPCM */ /* DPCM */
check_marker(h->c.avctx, &h->c.gb, "DPCM block start"); check_marker(h->c.avctx, &h->gb, "DPCM block start");
ctx->dpcm_direction = get_bits1(&h->c.gb) ? -1 : 1; ctx->dpcm_direction = get_bits1(&h->gb) ? -1 : 1;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
if (mpeg4_decode_dpcm_macroblock(ctx, ctx->dpcm_macroblock[i], i) < 0) if (mpeg4_decode_dpcm_macroblock(ctx, ctx->dpcm_macroblock[i], i) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
} }
if (get_bits_left(&h->c.gb) >= 24 && show_bits(&h->c.gb, 23) == 0) { if (get_bits_left(&h->gb) >= 24 && show_bits(&h->gb, 23) == 0) {
next_start_code_studio(&h->c.gb); next_start_code_studio(&h->gb);
return SLICE_END; return SLICE_END;
} }
//vcon-stp9L1.bits (first frame) //vcon-stp9L1.bits (first frame)
if (get_bits_left(&h->c.gb) == 0) if (get_bits_left(&h->gb) == 0)
return SLICE_END; return SLICE_END;
//vcon-stp2L1.bits, vcon-stp3L1.bits, vcon-stp6L1.bits, vcon-stp7L1.bits, vcon-stp8L1.bits, vcon-stp10L1.bits (first frame) //vcon-stp2L1.bits, vcon-stp3L1.bits, vcon-stp6L1.bits, vcon-stp7L1.bits, vcon-stp8L1.bits, vcon-stp10L1.bits (first frame)
if (get_bits_left(&h->c.gb) < 8U && show_bits(&h->c.gb, get_bits_left(&h->c.gb)) == 0) if (get_bits_left(&h->gb) < 8U && show_bits(&h->gb, get_bits_left(&h->gb)) == 0)
return SLICE_END; return SLICE_END;
return SLICE_OK; return SLICE_OK;
@ -3743,9 +3743,9 @@ int ff_mpeg4_decode_picture_header(H263DecContext *const h)
h->c.skipped_last_frame = 0; h->c.skipped_last_frame = 0;
if (ctx->bitstream_buffer) { if (ctx->bitstream_buffer) {
int buf_size = get_bits_left(&h->c.gb) / 8U; int buf_size = get_bits_left(&h->gb) / 8U;
int bitstream_buffer_size = ctx->bitstream_buffer->size; int bitstream_buffer_size = ctx->bitstream_buffer->size;
const uint8_t *buf = h->c.gb.buffer; const uint8_t *buf = h->gb.buffer;
if (h->c.divx_packed) { if (h->c.divx_packed) {
for (int i = 0; i < buf_size - 3; i++) { for (int i = 0; i < buf_size - 3; i++) {
@ -3760,7 +3760,7 @@ int ff_mpeg4_decode_picture_header(H263DecContext *const h)
} }
ctx->bitstream_buffer->size = 0; ctx->bitstream_buffer->size = 0;
if (bitstream_buffer_size && (h->c.divx_packed || buf_size <= MAX_NVOP_SIZE)) {// divx 5.01+/xvid frame reorder if (bitstream_buffer_size && (h->c.divx_packed || buf_size <= MAX_NVOP_SIZE)) {// divx 5.01+/xvid frame reorder
int ret = init_get_bits8(&h->c.gb, ctx->bitstream_buffer->data, int ret = init_get_bits8(&h->gb, ctx->bitstream_buffer->data,
bitstream_buffer_size); bitstream_buffer_size);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -3768,7 +3768,7 @@ int ff_mpeg4_decode_picture_header(H263DecContext *const h)
av_buffer_unref(&ctx->bitstream_buffer); av_buffer_unref(&ctx->bitstream_buffer);
} }
return ff_mpeg4_parse_picture_header(ctx, &h->c.gb, 0, 0); return ff_mpeg4_parse_picture_header(ctx, &h->gb, 0, 0);
} }
int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt) int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt)
@ -3781,7 +3781,7 @@ int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt)
/* divx 5.01+ bitstream reorder stuff */ /* divx 5.01+ bitstream reorder stuff */
if (h->c.divx_packed) { if (h->c.divx_packed) {
int current_pos = ctx->bitstream_buffer && h->c.gb.buffer == ctx->bitstream_buffer->data ? 0 : (get_bits_count(&h->c.gb) >> 3); int current_pos = ctx->bitstream_buffer && h->gb.buffer == ctx->bitstream_buffer->data ? 0 : (get_bits_count(&h->gb) >> 3);
int startcode_found = 0; int startcode_found = 0;
uint8_t *buf = pkt->data; uint8_t *buf = pkt->data;
int buf_size = pkt->size; int buf_size = pkt->size;

1
libavcodec/mpegvideo.h
View File

@ -219,7 +219,6 @@ typedef struct MpegEncContext {
/* error concealment / resync */ /* error concealment / resync */
int resync_mb_x; ///< x position of last resync marker int resync_mb_x; ///< x position of last resync marker
int resync_mb_y; ///< y position of last resync marker int resync_mb_y; ///< y position of last resync marker
GetBitContext last_resync_gb; ///< used to search for the next resync marker
int mb_num_left; ///< number of MBs left in this video packet (for partitioned Slices only) int mb_num_left; ///< number of MBs left in this video packet (for partitioned Slices only)
/* H.263 specific */ /* H.263 specific */

6
libavcodec/mpegvideodec.h
View File

@ -77,10 +77,10 @@ int ff_mpv_decode_close(AVCodecContext *avctx);
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict); void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict);
static inline int mpeg_get_qscale(MpegEncContext *s) static inline int mpeg_get_qscale(GetBitContext *const gb, int q_scale_type)
{ {
int qscale = get_bits(&s->gb, 5); int qscale = get_bits(gb, 5);
if (s->q_scale_type) if (q_scale_type)
return ff_mpeg2_non_linear_qscale[qscale]; return ff_mpeg2_non_linear_qscale[qscale];
else else
return qscale << 1; return qscale << 1;

188
libavcodec/msmpeg4dec.c
View File

@ -78,7 +78,7 @@ static int msmpeg4v2_decode_motion(H263DecContext *const h, int pred, int f_code
{ {
int code, val, sign, shift; int code, val, sign, shift;
code = get_vlc2(&h->c.gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2); code = get_vlc2(&h->gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2);
ff_dlog(h->c.avctx, "MV code %d at %d %d pred: %d\n", ff_dlog(h->c.avctx, "MV code %d at %d %d pred: %d\n",
code, h->c.mb_x,h->c.mb_y, pred); code, h->c.mb_x,h->c.mb_y, pred);
if (code < 0) if (code < 0)
@ -86,12 +86,12 @@ static int msmpeg4v2_decode_motion(H263DecContext *const h, int pred, int f_code
if (code == 0) if (code == 0)
return pred; return pred;
sign = get_bits1(&h->c.gb); sign = get_bits1(&h->gb);
shift = f_code - 1; shift = f_code - 1;
val = code; val = code;
if (shift) { if (shift) {
val = (val - 1) << shift; val = (val - 1) << shift;
val |= get_bits(&h->c.gb, shift); val |= get_bits(&h->gb, shift);
val++; val++;
} }
if (sign) if (sign)
@ -114,7 +114,7 @@ static int msmpeg4v12_decode_mb(H263DecContext *const h)
if (h->c.pict_type == AV_PICTURE_TYPE_P) { if (h->c.pict_type == AV_PICTURE_TYPE_P) {
if (ms->use_skip_mb_code) { if (ms->use_skip_mb_code) {
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
/* skip mb */ /* skip mb */
h->c.mb_intra = 0; h->c.mb_intra = 0;
for(i=0;i<6;i++) for(i=0;i<6;i++)
@ -130,9 +130,9 @@ static int msmpeg4v12_decode_mb(H263DecContext *const h)
} }
if (h->c.msmpeg4_version == MSMP4_V2) if (h->c.msmpeg4_version == MSMP4_V2)
code = get_vlc2(&h->c.gb, v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 1); code = get_vlc2(&h->gb, v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 1);
else else
code = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); code = get_vlc2(&h->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
if(code<0 || code>7){ if(code<0 || code>7){
av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n",
code, h->c.mb_x, h->c.mb_y); code, h->c.mb_x, h->c.mb_y);
@ -145,9 +145,9 @@ static int msmpeg4v12_decode_mb(H263DecContext *const h)
} else { } else {
h->c.mb_intra = 1; h->c.mb_intra = 1;
if (h->c.msmpeg4_version == MSMP4_V2) if (h->c.msmpeg4_version == MSMP4_V2)
cbp = get_vlc2(&h->c.gb, v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 1); cbp = get_vlc2(&h->gb, v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 1);
else else
cbp = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); cbp = get_vlc2(&h->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
if(cbp<0 || cbp>3){ if(cbp<0 || cbp>3){
av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n",
cbp, h->c.mb_x, h->c.mb_y); cbp, h->c.mb_x, h->c.mb_y);
@ -158,7 +158,7 @@ static int msmpeg4v12_decode_mb(H263DecContext *const h)
if (!h->c.mb_intra) { if (!h->c.mb_intra) {
int mx, my, cbpy; int mx, my, cbpy;
cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); cbpy = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if(cbpy<0){ if(cbpy<0){
av_log(h->c.avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", av_log(h->c.avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n",
cbp, h->c.mb_x, h->c.mb_y); cbp, h->c.mb_x, h->c.mb_y);
@ -181,8 +181,8 @@ static int msmpeg4v12_decode_mb(H263DecContext *const h)
} else { } else {
int v; int v;
if (h->c.msmpeg4_version == MSMP4_V2) { if (h->c.msmpeg4_version == MSMP4_V2) {
h->c.ac_pred = get_bits1(&h->c.gb); h->c.ac_pred = get_bits1(&h->gb);
v = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); v = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (v < 0) { if (v < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
return -1; return -1;
@ -190,7 +190,7 @@ static int msmpeg4v12_decode_mb(H263DecContext *const h)
cbp|= v<<2; cbp|= v<<2;
} else{ } else{
h->c.ac_pred = 0; h->c.ac_pred = 0;
v = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); v = get_vlc2(&h->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (v < 0) { if (v < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
return -1; return -1;
@ -220,12 +220,12 @@ static int msmpeg4v34_decode_mb(H263DecContext *const h)
uint8_t *coded_val; uint8_t *coded_val;
uint32_t * const mb_type_ptr = &h->c.cur_pic.mb_type[h->c.mb_x + h->c.mb_y*h->c.mb_stride]; uint32_t * const mb_type_ptr = &h->c.cur_pic.mb_type[h->c.mb_x + h->c.mb_y*h->c.mb_stride];
if (get_bits_left(&h->c.gb) <= 0) if (get_bits_left(&h->gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (h->c.pict_type == AV_PICTURE_TYPE_P) { if (h->c.pict_type == AV_PICTURE_TYPE_P) {
if (ms->use_skip_mb_code) { if (ms->use_skip_mb_code) {
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
/* skip mb */ /* skip mb */
h->c.mb_intra = 0; h->c.mb_intra = 0;
for(i=0;i<6;i++) for(i=0;i<6;i++)
@ -241,14 +241,14 @@ static int msmpeg4v34_decode_mb(H263DecContext *const h)
} }
} }
code = get_vlc2(&h->c.gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX], MB_NON_INTRA_VLC_BITS, 3); code = get_vlc2(&h->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX], MB_NON_INTRA_VLC_BITS, 3);
//h->c.mb_intra = (code & 0x40) ? 0 : 1; //h->c.mb_intra = (code & 0x40) ? 0 : 1;
h->c.mb_intra = (~code & 0x40) >> 6; h->c.mb_intra = (~code & 0x40) >> 6;
cbp = code & 0x3f; cbp = code & 0x3f;
} else { } else {
h->c.mb_intra = 1; h->c.mb_intra = 1;
code = get_vlc2(&h->c.gb, ff_msmp4_mb_i_vlc, MSMP4_MB_INTRA_VLC_BITS, 2); code = get_vlc2(&h->gb, ff_msmp4_mb_i_vlc, MSMP4_MB_INTRA_VLC_BITS, 2);
/* predict coded block pattern */ /* predict coded block pattern */
cbp = 0; cbp = 0;
for(i=0;i<6;i++) { for(i=0;i<6;i++) {
@ -265,7 +265,7 @@ static int msmpeg4v34_decode_mb(H263DecContext *const h)
if (!h->c.mb_intra) { if (!h->c.mb_intra) {
int mx, my; int mx, my;
if (ms->per_mb_rl_table && cbp) { if (ms->per_mb_rl_table && cbp) {
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }
ff_h263_pred_motion(&h->c, 0, 0, &mx, &my); ff_h263_pred_motion(&h->c, 0, 0, &mx, &my);
@ -278,16 +278,16 @@ static int msmpeg4v34_decode_mb(H263DecContext *const h)
} else { } else {
ff_dlog(h->c.avctx, "I at %d %d %d %06X\n", h->c.mb_x, h->c.mb_y, ff_dlog(h->c.avctx, "I at %d %d %d %06X\n", h->c.mb_x, h->c.mb_y,
((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0), ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
show_bits(&h->c.gb, 24)); show_bits(&h->gb, 24));
h->c.ac_pred = get_bits1(&h->c.gb); h->c.ac_pred = get_bits1(&h->gb);
*mb_type_ptr = MB_TYPE_INTRA; *mb_type_ptr = MB_TYPE_INTRA;
if (h->c.inter_intra_pred) { if (h->c.inter_intra_pred) {
h->c.h263_aic_dir = get_vlc2(&h->c.gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1); h->c.h263_aic_dir = get_vlc2(&h->gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1);
ff_dlog(h->c.avctx, "%d%d %d %d/", ff_dlog(h->c.avctx, "%d%d %d %d/",
h->c.ac_pred, h->c.h263_aic_dir, h->c.mb_x, h->c.mb_y); h->c.ac_pred, h->c.h263_aic_dir, h->c.mb_x, h->c.mb_y);
} }
if (ms->per_mb_rl_table && cbp) { if (ms->per_mb_rl_table && cbp) {
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }
} }
@ -409,33 +409,33 @@ int ff_msmpeg4_decode_picture_header(H263DecContext *const h)
// smallest "black/skip" frame generally contain not much recoverable content // smallest "black/skip" frame generally contain not much recoverable content
// while at the same time they have the highest computational requirements // while at the same time they have the highest computational requirements
// per byte // per byte
if (get_bits_left(&h->c.gb) * 8LL < (h->c.width+15)/16 * ((h->c.height+15)/16)) if (get_bits_left(&h->gb) * 8LL < (h->c.width+15)/16 * ((h->c.height+15)/16))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (h->c.msmpeg4_version == MSMP4_V1) { if (h->c.msmpeg4_version == MSMP4_V1) {
int start_code = get_bits_long(&h->c.gb, 32); int start_code = get_bits_long(&h->gb, 32);
if(start_code!=0x00000100){ if(start_code!=0x00000100){
av_log(h->c.avctx, AV_LOG_ERROR, "invalid startcode\n"); av_log(h->c.avctx, AV_LOG_ERROR, "invalid startcode\n");
return -1; return -1;
} }
skip_bits(&h->c.gb, 5); // frame number */ skip_bits(&h->gb, 5); // frame number */
} }
h->c.pict_type = get_bits(&h->c.gb, 2) + 1; h->c.pict_type = get_bits(&h->gb, 2) + 1;
if (h->c.pict_type != AV_PICTURE_TYPE_I && if (h->c.pict_type != AV_PICTURE_TYPE_I &&
h->c.pict_type != AV_PICTURE_TYPE_P){ h->c.pict_type != AV_PICTURE_TYPE_P){
av_log(h->c.avctx, AV_LOG_ERROR, "invalid picture type\n"); av_log(h->c.avctx, AV_LOG_ERROR, "invalid picture type\n");
return -1; return -1;
} }
h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->gb, 5);
if (h->c.qscale == 0) { if (h->c.qscale == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "invalid qscale\n"); av_log(h->c.avctx, AV_LOG_ERROR, "invalid qscale\n");
return -1; return -1;
} }
if (h->c.pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
code = get_bits(&h->c.gb, 5); code = get_bits(&h->gb, 5);
if (h->c.msmpeg4_version == MSMP4_V1) { if (h->c.msmpeg4_version == MSMP4_V1) {
if(code==0 || code>h->c.mb_height) { if(code==0 || code>h->c.mb_height) {
av_log(h->c.avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); av_log(h->c.avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
@ -462,25 +462,25 @@ int ff_msmpeg4_decode_picture_header(H263DecContext *const h)
ms->dc_table_index = 0; //not used ms->dc_table_index = 0; //not used
break; break;
case MSMP4_V3: case MSMP4_V3:
ms->rl_chroma_table_index = decode012(&h->c.gb); ms->rl_chroma_table_index = decode012(&h->gb);
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
ms->dc_table_index = get_bits1(&h->c.gb); ms->dc_table_index = get_bits1(&h->gb);
break; break;
case MSMP4_WMV1: case MSMP4_WMV1:
ff_msmpeg4_decode_ext_header(h, (2+5+5+17+7)/8); ff_msmpeg4_decode_ext_header(h, (2+5+5+17+7)/8);
if (ms->bit_rate > MBAC_BITRATE) if (ms->bit_rate > MBAC_BITRATE)
ms->per_mb_rl_table = get_bits1(&h->c.gb); ms->per_mb_rl_table = get_bits1(&h->gb);
else else
ms->per_mb_rl_table = 0; ms->per_mb_rl_table = 0;
if (!ms->per_mb_rl_table) { if (!ms->per_mb_rl_table) {
ms->rl_chroma_table_index = decode012(&h->c.gb); ms->rl_chroma_table_index = decode012(&h->gb);
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
} }
ms->dc_table_index = get_bits1(&h->c.gb); ms->dc_table_index = get_bits1(&h->gb);
h->c.inter_intra_pred= 0; h->c.inter_intra_pred= 0;
break; break;
default: default:
@ -502,37 +502,37 @@ int ff_msmpeg4_decode_picture_header(H263DecContext *const h)
if (h->c.msmpeg4_version == MSMP4_V1) if (h->c.msmpeg4_version == MSMP4_V1)
ms->use_skip_mb_code = 1; ms->use_skip_mb_code = 1;
else else
ms->use_skip_mb_code = get_bits1(&h->c.gb); ms->use_skip_mb_code = get_bits1(&h->gb);
ms->rl_table_index = 2; ms->rl_table_index = 2;
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
ms->dc_table_index = 0; //not used ms->dc_table_index = 0; //not used
ms->mv_table_index = 0; ms->mv_table_index = 0;
break; break;
case MSMP4_V3: case MSMP4_V3:
ms->use_skip_mb_code = get_bits1(&h->c.gb); ms->use_skip_mb_code = get_bits1(&h->gb);
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
ms->dc_table_index = get_bits1(&h->c.gb); ms->dc_table_index = get_bits1(&h->gb);
ms->mv_table_index = get_bits1(&h->c.gb); ms->mv_table_index = get_bits1(&h->gb);
break; break;
case MSMP4_WMV1: case MSMP4_WMV1:
ms->use_skip_mb_code = get_bits1(&h->c.gb); ms->use_skip_mb_code = get_bits1(&h->gb);
if (ms->bit_rate > MBAC_BITRATE) if (ms->bit_rate > MBAC_BITRATE)
ms->per_mb_rl_table = get_bits1(&h->c.gb); ms->per_mb_rl_table = get_bits1(&h->gb);
else else
ms->per_mb_rl_table = 0; ms->per_mb_rl_table = 0;
if (!ms->per_mb_rl_table) { if (!ms->per_mb_rl_table) {
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }
ms->dc_table_index = get_bits1(&h->c.gb); ms->dc_table_index = get_bits1(&h->gb);
ms->mv_table_index = get_bits1(&h->c.gb); ms->mv_table_index = get_bits1(&h->gb);
h->c.inter_intra_pred = h->c.width*h->c.height < 320*240 && h->c.inter_intra_pred = h->c.width*h->c.height < 320*240 &&
ms->bit_rate <= II_BITRATE; ms->bit_rate <= II_BITRATE;
break; break;
@ -568,15 +568,15 @@ int ff_msmpeg4_decode_picture_header(H263DecContext *const h)
int ff_msmpeg4_decode_ext_header(H263DecContext *const h, int buf_size) int ff_msmpeg4_decode_ext_header(H263DecContext *const h, int buf_size)
{ {
MSMP4DecContext *const ms = mpv_to_msmpeg4(h); MSMP4DecContext *const ms = mpv_to_msmpeg4(h);
int left= buf_size*8 - get_bits_count(&h->c.gb); int left = buf_size*8 - get_bits_count(&h->gb);
int length = h->c.msmpeg4_version >= MSMP4_V3 ? 17 : 16; int length = h->c.msmpeg4_version >= MSMP4_V3 ? 17 : 16;
/* the alt_bitstream reader could read over the end so we need to check it */ /* the alt_bitstream reader could read over the end so we need to check it */
if(left>=length && left<length+8) if(left>=length && left<length+8)
{ {
skip_bits(&h->c.gb, 5); /* fps */ skip_bits(&h->gb, 5); /* fps */
ms->bit_rate = get_bits(&h->c.gb, 11) * 1024; ms->bit_rate = get_bits(&h->gb, 11) * 1024;
if (h->c.msmpeg4_version >= MSMP4_V3) if (h->c.msmpeg4_version >= MSMP4_V3)
ms->flipflop_rounding = get_bits1(&h->c.gb); ms->flipflop_rounding = get_bits1(&h->gb);
else else
ms->flipflop_rounding = 0; ms->flipflop_rounding = 0;
} }
@ -601,9 +601,9 @@ static int msmpeg4_decode_dc(MSMP4DecContext *const ms, int n, int *dir_ptr)
if (h->c.msmpeg4_version <= MSMP4_V2) { if (h->c.msmpeg4_version <= MSMP4_V2) {
if (n < 4) { if (n < 4) {
level = get_vlc2(&h->c.gb, v2_dc_lum_vlc, MSMP4_DC_VLC_BITS, 3); level = get_vlc2(&h->gb, v2_dc_lum_vlc, MSMP4_DC_VLC_BITS, 3);
} else { } else {
level = get_vlc2(&h->c.gb, v2_dc_chroma_vlc, MSMP4_DC_VLC_BITS, 3); level = get_vlc2(&h->gb, v2_dc_chroma_vlc, MSMP4_DC_VLC_BITS, 3);
} }
if (level < 0) { if (level < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n"); av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n");
@ -612,15 +612,15 @@ static int msmpeg4_decode_dc(MSMP4DecContext *const ms, int n, int *dir_ptr)
} }
level-=256; level-=256;
} else { } else {
level = get_vlc2(&h->c.gb, ff_msmp4_dc_vlc[ms->dc_table_index][n >= 4], level = get_vlc2(&h->gb, ff_msmp4_dc_vlc[ms->dc_table_index][n >= 4],
MSMP4_DC_VLC_BITS, 3); MSMP4_DC_VLC_BITS, 3);
if (level == DC_MAX) { if (level == DC_MAX) {
level = get_bits(&h->c.gb, 8); level = get_bits(&h->gb, 8);
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
level = -level; level = -level;
} else if (level != 0) { } else if (level != 0) {
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
level = -level; level = -level;
} }
} }
@ -721,58 +721,58 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block,
rl_vlc= rl->rl_vlc[h->c.qscale]; rl_vlc= rl->rl_vlc[h->c.qscale];
} }
{ {
OPEN_READER(re, &h->c.gb); OPEN_READER(re, &h->gb);
for(;;) { for(;;) {
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 0); GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
if (level==0) { if (level==0) {
int cache; int cache;
cache= GET_CACHE(re, &h->c.gb); cache= GET_CACHE(re, &h->gb);
/* escape */ /* escape */
if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x80000000)==0) { if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x80000000)==0) {
if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) { if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) {
/* third escape */ /* third escape */
if (h->c.msmpeg4_version != MSMP4_V1) if (h->c.msmpeg4_version != MSMP4_V1)
LAST_SKIP_BITS(re, &h->c.gb, 2); LAST_SKIP_BITS(re, &h->gb, 2);
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
if (h->c.msmpeg4_version <= MSMP4_V3) { if (h->c.msmpeg4_version <= MSMP4_V3) {
last = SHOW_UBITS(re, &h->c.gb, 1); SKIP_CACHE(re, &h->c.gb, 1); last = SHOW_UBITS(re, &h->gb, 1); SKIP_CACHE(re, &h->gb, 1);
run = SHOW_UBITS(re, &h->c.gb, 6); SKIP_CACHE(re, &h->c.gb, 6); run = SHOW_UBITS(re, &h->gb, 6); SKIP_CACHE(re, &h->gb, 6);
level = SHOW_SBITS(re, &h->c.gb, 8); level = SHOW_SBITS(re, &h->gb, 8);
SKIP_COUNTER(re, &h->c.gb, 1 + 6 + 8); SKIP_COUNTER(re, &h->gb, 1 + 6 + 8);
}else{ }else{
int sign; int sign;
last = SHOW_UBITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->c.gb, 1); last = SHOW_UBITS(re, &h->gb, 1); SKIP_BITS(re, &h->gb, 1);
if (!ms->esc3_level_length) { if (!ms->esc3_level_length) {
int ll; int ll;
ff_dlog(h->c.avctx, "ESC-3 %X at %d %d\n", ff_dlog(h->c.avctx, "ESC-3 %X at %d %d\n",
show_bits(&h->c.gb, 24), h->c.mb_x, h->c.mb_y); show_bits(&h->gb, 24), h->c.mb_x, h->c.mb_y);
if (h->c.qscale < 8) { if (h->c.qscale < 8) {
ll = SHOW_UBITS(re, &h->c.gb, 3); SKIP_BITS(re, &h->c.gb, 3); ll = SHOW_UBITS(re, &h->gb, 3); SKIP_BITS(re, &h->gb, 3);
if(ll==0){ if(ll==0){
ll = 8+SHOW_UBITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->c.gb, 1); ll = 8+SHOW_UBITS(re, &h->gb, 1); SKIP_BITS(re, &h->gb, 1);
} }
}else{ }else{
ll=2; ll=2;
while (ll < 8 && SHOW_UBITS(re, &h->c.gb, 1) == 0) { while (ll < 8 && SHOW_UBITS(re, &h->gb, 1) == 0) {
ll++; ll++;
SKIP_BITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->gb, 1);
} }
if (ll<8) SKIP_BITS(re, &h->c.gb, 1); if (ll<8) SKIP_BITS(re, &h->gb, 1);
} }
ms->esc3_level_length = ll; ms->esc3_level_length = ll;
ms->esc3_run_length = SHOW_UBITS(re, &h->c.gb, 2) + 3; SKIP_BITS(re, &h->c.gb, 2); ms->esc3_run_length = SHOW_UBITS(re, &h->gb, 2) + 3; SKIP_BITS(re, &h->gb, 2);
UPDATE_CACHE(re, &h->c.gb); UPDATE_CACHE(re, &h->gb);
} }
run = SHOW_UBITS(re, &h->c.gb, ms->esc3_run_length); run = SHOW_UBITS(re, &h->gb, ms->esc3_run_length);
SKIP_BITS(re, &h->c.gb, ms->esc3_run_length); SKIP_BITS(re, &h->gb, ms->esc3_run_length);
sign= SHOW_UBITS(re, &h->c.gb, 1); sign= SHOW_UBITS(re, &h->gb, 1);
SKIP_BITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->gb, 1);
level = SHOW_UBITS(re, &h->c.gb, ms->esc3_level_length); level = SHOW_UBITS(re, &h->gb, ms->esc3_level_length);
SKIP_BITS(re, &h->c.gb, ms->esc3_level_length); SKIP_BITS(re, &h->gb, ms->esc3_level_length);
if(sign) level= -level; if(sign) level= -level;
} }
@ -783,30 +783,30 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block,
if(last) i+=192; if(last) i+=192;
} else { } else {
/* second escape */ /* second escape */
SKIP_BITS(re, &h->c.gb, 2); SKIP_BITS(re, &h->gb, 2);
GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 1); GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1);
LAST_SKIP_BITS(re, &h->c.gb, 1); LAST_SKIP_BITS(re, &h->gb, 1);
} }
} else { } else {
/* first escape */ /* first escape */
SKIP_BITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->gb, 1);
GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 1); GET_RL_VLC(level, run, re, &h->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i+= run; i+= run;
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1);
LAST_SKIP_BITS(re, &h->c.gb, 1); LAST_SKIP_BITS(re, &h->gb, 1);
} }
} else { } else {
i+= run; i+= run;
level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); level = (level ^ SHOW_SBITS(re, &h->gb, 1)) - SHOW_SBITS(re, &h->gb, 1);
LAST_SKIP_BITS(re, &h->c.gb, 1); LAST_SKIP_BITS(re, &h->gb, 1);
} }
if (i > 62){ if (i > 62){
i-= 192; i-= 192;
if(i&(~63)){ if(i&(~63)){
const int left = get_bits_left(&h->c.gb); const int left = get_bits_left(&h->gb);
if (((i + 192 == 64 && level / qmul == -1) || if (((i + 192 == 64 && level / qmul == -1) ||
!(h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && !(h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
left >= 0) { left >= 0) {
@ -827,7 +827,7 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block,
block[scan_table[i]] = level; block[scan_table[i]] = level;
} }
CLOSE_READER(re, &h->c.gb); CLOSE_READER(re, &h->gb);
} }
if (h->c.mb_intra) { if (h->c.mb_intra) {
not_coded: not_coded:
@ -844,14 +844,14 @@ void ff_msmpeg4_decode_motion(MSMP4DecContext *const ms, int *mx_ptr, int *my_pt
H263DecContext *const h = &ms->h; H263DecContext *const h = &ms->h;
int sym, mx, my; int sym, mx, my;
sym = get_vlc2(&h->c.gb, mv_vlc, MV_VLC_BITS, 2); sym = get_vlc2(&h->gb, mv_vlc, MV_VLC_BITS, 2);
if (sym) { if (sym) {
mx = sym >> 8; mx = sym >> 8;
my = sym & 0xFF; my = sym & 0xFF;
} else { } else {
/* Escape */ /* Escape */
mx = get_bits(&h->c.gb, 6); mx = get_bits(&h->gb, 6);
my = get_bits(&h->c.gb, 6); my = get_bits(&h->gb, 6);
} }
mx += *mx_ptr - 32; mx += *mx_ptr - 32;

62
libavcodec/rv10.c
View File

@ -85,9 +85,9 @@ int ff_rv_decode_dc(H263DecContext *const h, int n)
int code; int code;
if (n < 4) { if (n < 4) {
code = get_vlc2(&h->c.gb, rv_dc_lum, DC_VLC_BITS, 2); code = get_vlc2(&h->gb, rv_dc_lum, DC_VLC_BITS, 2);
} else { } else {
code = get_vlc2(&h->c.gb, rv_dc_chrom, DC_VLC_BITS, 2); code = get_vlc2(&h->gb, rv_dc_chrom, DC_VLC_BITS, 2);
if (code < 0) { if (code < 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "chroma dc error\n"); av_log(h->c.avctx, AV_LOG_ERROR, "chroma dc error\n");
return -1; return -1;
@ -101,9 +101,9 @@ static int rv10_decode_picture_header(H263DecContext *const h)
{ {
int mb_count, pb_frame, marker, mb_xy; int mb_count, pb_frame, marker, mb_xy;
marker = get_bits1(&h->c.gb); marker = get_bits1(&h->gb);
if (get_bits1(&h->c.gb)) if (get_bits1(&h->gb))
h->c.pict_type = AV_PICTURE_TYPE_P; h->c.pict_type = AV_PICTURE_TYPE_P;
else else
h->c.pict_type = AV_PICTURE_TYPE_I; h->c.pict_type = AV_PICTURE_TYPE_I;
@ -111,7 +111,7 @@ static int rv10_decode_picture_header(H263DecContext *const h)
if (!marker) if (!marker)
av_log(h->c.avctx, AV_LOG_ERROR, "marker missing\n"); av_log(h->c.avctx, AV_LOG_ERROR, "marker missing\n");
pb_frame = get_bits1(&h->c.gb); pb_frame = get_bits1(&h->gb);
ff_dlog(h->c.avctx, "pict_type=%d pb_frame=%d\n", h->c.pict_type, pb_frame); ff_dlog(h->c.avctx, "pict_type=%d pb_frame=%d\n", h->c.pict_type, pb_frame);
@ -120,7 +120,7 @@ static int rv10_decode_picture_header(H263DecContext *const h)
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
h->c.qscale = get_bits(&h->c.gb, 5); h->c.qscale = get_bits(&h->gb, 5);
if (h->c.qscale == 0) { if (h->c.qscale == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -129,9 +129,9 @@ static int rv10_decode_picture_header(H263DecContext *const h)
if (h->c.pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
if (h->c.rv10_version == 3) { if (h->c.rv10_version == 3) {
/* specific MPEG like DC coding not used */ /* specific MPEG like DC coding not used */
h->c.last_dc[0] = get_bits(&h->c.gb, 8); h->c.last_dc[0] = get_bits(&h->gb, 8);
h->c.last_dc[1] = get_bits(&h->c.gb, 8); h->c.last_dc[1] = get_bits(&h->gb, 8);
h->c.last_dc[2] = get_bits(&h->c.gb, 8); h->c.last_dc[2] = get_bits(&h->gb, 8);
ff_dlog(h->c.avctx, "DC:%d %d %d\n", h->c.last_dc[0], ff_dlog(h->c.avctx, "DC:%d %d %d\n", h->c.last_dc[0],
h->c.last_dc[1], h->c.last_dc[2]); h->c.last_dc[1], h->c.last_dc[2]);
} }
@ -140,16 +140,16 @@ static int rv10_decode_picture_header(H263DecContext *const h)
* to display the macroblocks is coded here */ * to display the macroblocks is coded here */
mb_xy = h->c.mb_x + h->c.mb_y * h->c.mb_width; mb_xy = h->c.mb_x + h->c.mb_y * h->c.mb_width;
if (show_bits(&h->c.gb, 12) == 0 || (mb_xy && mb_xy < h->c.mb_num)) { if (show_bits(&h->gb, 12) == 0 || (mb_xy && mb_xy < h->c.mb_num)) {
h->c.mb_x = get_bits(&h->c.gb, 6); /* mb_x */ h->c.mb_x = get_bits(&h->gb, 6); /* mb_x */
h->c.mb_y = get_bits(&h->c.gb, 6); /* mb_y */ h->c.mb_y = get_bits(&h->gb, 6); /* mb_y */
mb_count = get_bits(&h->c.gb, 12); mb_count = get_bits(&h->gb, 12);
} else { } else {
h->c.mb_x = 0; h->c.mb_x = 0;
h->c.mb_y = 0; h->c.mb_y = 0;
mb_count = h->c.mb_width * h->c.mb_height; mb_count = h->c.mb_width * h->c.mb_height;
} }
skip_bits(&h->c.gb, 3); /* ignored */ skip_bits(&h->gb, 3); /* ignored */
return mb_count; return mb_count;
} }
@ -163,7 +163,7 @@ static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)
int seq, mb_pos, ret; int seq, mb_pos, ret;
int rpr_max; int rpr_max;
h->c.pict_type = pict_types[get_bits(&h->c.gb, 2)]; h->c.pict_type = pict_types[get_bits(&h->gb, 2)];
if (h->c.low_delay && h->c.pict_type == AV_PICTURE_TYPE_B) { if (h->c.low_delay && h->c.pict_type == AV_PICTURE_TYPE_B) {
av_log(h->c.avctx, AV_LOG_ERROR, "low delay B\n"); av_log(h->c.avctx, AV_LOG_ERROR, "low delay B\n");
@ -174,31 +174,31 @@ static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
av_log(h->c.avctx, AV_LOG_ERROR, "reserved bit set\n"); av_log(h->c.avctx, AV_LOG_ERROR, "reserved bit set\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
h->c.qscale = get_bits(&h->c.gb, 5); h->c.qscale = get_bits(&h->gb, 5);
if (h->c.qscale == 0) { if (h->c.qscale == 0) {
av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (RV_GET_MINOR_VER(rv->sub_id) >= 2) if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
h->c.loop_filter = get_bits1(&h->c.gb) && !h->c.avctx->lowres; h->c.loop_filter = get_bits1(&h->gb) && !h->c.avctx->lowres;
if (RV_GET_MINOR_VER(rv->sub_id) <= 1) if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
seq = get_bits(&h->c.gb, 8) << 7; seq = get_bits(&h->gb, 8) << 7;
else else
seq = get_bits(&h->c.gb, 13) << 2; seq = get_bits(&h->gb, 13) << 2;
rpr_max = h->c.avctx->extradata[1] & 7; rpr_max = h->c.avctx->extradata[1] & 7;
if (rpr_max) { if (rpr_max) {
int f, new_w, new_h; int f, new_w, new_h;
int rpr_bits = av_log2(rpr_max) + 1; int rpr_bits = av_log2(rpr_max) + 1;
f = get_bits(&h->c.gb, rpr_bits); f = get_bits(&h->gb, rpr_bits);
if (f) { if (f) {
if (h->c.avctx->extradata_size < 8 + 2 * f) { if (h->c.avctx->extradata_size < 8 + 2 * f) {
@ -277,11 +277,11 @@ static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)
ff_mpeg4_init_direct_mv(&h->c); ff_mpeg4_init_direct_mv(&h->c);
} }
h->c.no_rounding = get_bits1(&h->c.gb); h->c.no_rounding = get_bits1(&h->gb);
if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && h->c.pict_type == AV_PICTURE_TYPE_B) if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && h->c.pict_type == AV_PICTURE_TYPE_B)
// binary decoder reads 3+2 bits here but they don't seem to be used // binary decoder reads 3+2 bits here but they don't seem to be used
skip_bits(&h->c.gb, 5); skip_bits(&h->gb, 5);
h->c.h263_aic = h->c.pict_type == AV_PICTURE_TYPE_I; h->c.h263_aic = h->c.pict_type == AV_PICTURE_TYPE_I;
if (h->c.h263_aic) { if (h->c.h263_aic) {
@ -416,7 +416,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret; int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
active_bits_size = buf_size * 8; active_bits_size = buf_size * 8;
init_get_bits(&h->c.gb, buf, FFMAX(buf_size, buf_size2) * 8); init_get_bits(&h->gb, buf, FFMAX(buf_size, buf_size2) * 8);
if (h->c.codec_id == AV_CODEC_ID_RV10) if (h->c.codec_id == AV_CODEC_ID_RV10)
mb_count = rv10_decode_picture_header(h); mb_count = rv10_decode_picture_header(h);
else else
@ -492,24 +492,24 @@ static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
// Repeat the slice end check from ff_h263_decode_mb with our active // Repeat the slice end check from ff_h263_decode_mb with our active
// bitstream size // bitstream size
if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&h->c.gb)) { if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&h->gb)) {
int v = show_bits(&h->c.gb, 16); int v = show_bits(&h->gb, 16);
if (get_bits_count(&h->c.gb) + 16 > active_bits_size) if (get_bits_count(&h->gb) + 16 > active_bits_size)
v >>= get_bits_count(&h->c.gb) + 16 - active_bits_size; v >>= get_bits_count(&h->gb) + 16 - active_bits_size;
if (!v) if (!v)
ret = SLICE_END; ret = SLICE_END;
} }
if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&h->c.gb) && if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&h->gb) &&
8 * buf_size2 >= get_bits_count(&h->c.gb)) { 8 * buf_size2 >= get_bits_count(&h->gb)) {
active_bits_size = buf_size2 * 8; active_bits_size = buf_size2 * 8;
av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
8 * buf_size, active_bits_size); 8 * buf_size, active_bits_size);
ret = SLICE_OK; ret = SLICE_OK;
} }
if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&h->c.gb)) { if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&h->gb)) {
av_log(h->c.avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", h->c.mb_x, av_log(h->c.avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", h->c.mb_x,
h->c.mb_y); h->c.mb_y);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;

8
libavcodec/vaapi_mpeg4.c
View File

@ -157,8 +157,8 @@ fail:
static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
{ {
MpegEncContext *s = avctx->priv_data; H263DecContext *const h = avctx->priv_data;
VAAPIDecodePicture *pic = s->cur_pic.ptr->hwaccel_picture_private; VAAPIDecodePicture *pic = h->c.cur_pic.ptr->hwaccel_picture_private;
VASliceParameterBufferMPEG4 slice_param; VASliceParameterBufferMPEG4 slice_param;
int err; int err;
@ -166,9 +166,9 @@ static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer
.slice_data_size = size, .slice_data_size = size,
.slice_data_offset = 0, .slice_data_offset = 0,
.slice_data_flag = VA_SLICE_DATA_FLAG_ALL, .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
.macroblock_offset = get_bits_count(&s->gb) % 8, .macroblock_offset = get_bits_count(&h->gb) % 8,
.macroblock_number = 0, .macroblock_number = 0,
.quant_scale = s->qscale, .quant_scale = h->c.qscale,
}; };
err = ff_vaapi_decode_make_slice_buffer(avctx, pic, err = ff_vaapi_decode_make_slice_buffer(avctx, pic,

92
libavcodec/wmv2dec.c
View File

@ -105,7 +105,7 @@ static int parse_mb_skip(WMV2DecContext *w)
int coded_mb_count = 0; int coded_mb_count = 0;
uint32_t *const mb_type = h->c.cur_pic.mb_type; uint32_t *const mb_type = h->c.cur_pic.mb_type;
w->skip_type = get_bits(&h->c.gb, 2); w->skip_type = get_bits(&h->gb, 2);
switch (w->skip_type) { switch (w->skip_type) {
case SKIP_TYPE_NONE: case SKIP_TYPE_NONE:
for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
@ -114,40 +114,40 @@ static int parse_mb_skip(WMV2DecContext *w)
MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
break; break;
case SKIP_TYPE_MPEG: case SKIP_TYPE_MPEG:
if (get_bits_left(&h->c.gb) < h->c.mb_height * h->c.mb_width) if (get_bits_left(&h->gb) < h->c.mb_height * h->c.mb_width)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
mb_type[mb_y * h->c.mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
(get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; (get_bits1(&h->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
break; break;
case SKIP_TYPE_ROW: case SKIP_TYPE_ROW:
for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) { for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) {
if (get_bits_left(&h->c.gb) < 1) if (get_bits_left(&h->gb) < 1)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
mb_type[mb_y * h->c.mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
} else { } else {
for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
mb_type[mb_y * h->c.mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
(get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; (get_bits1(&h->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
} }
} }
break; break;
case SKIP_TYPE_COL: case SKIP_TYPE_COL:
for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) { for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) {
if (get_bits_left(&h->c.gb) < 1) if (get_bits_left(&h->gb) < 1)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (get_bits1(&h->c.gb)) { if (get_bits1(&h->gb)) {
for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
mb_type[mb_y * h->c.mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
} else { } else {
for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
mb_type[mb_y * h->c.mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
(get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; (get_bits1(&h->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
} }
} }
break; break;
@ -157,7 +157,7 @@ static int parse_mb_skip(WMV2DecContext *w)
for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
coded_mb_count += !IS_SKIP(mb_type[mb_y * h->c.mb_stride + mb_x]); coded_mb_count += !IS_SKIP(mb_type[mb_y * h->c.mb_stride + mb_x]);
if (coded_mb_count > get_bits_left(&h->c.gb)) if (coded_mb_count > get_bits_left(&h->gb))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
return 0; return 0;
@ -205,17 +205,17 @@ int ff_wmv2_decode_picture_header(H263DecContext *const h)
{ {
int code; int code;
h->c.pict_type = get_bits1(&h->c.gb) + 1; h->c.pict_type = get_bits1(&h->gb) + 1;
if (h->c.pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
code = get_bits(&h->c.gb, 7); code = get_bits(&h->gb, 7);
av_log(h->c.avctx, AV_LOG_DEBUG, "I7:%X/\n", code); av_log(h->c.avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
} }
h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->gb, 5);
if (h->c.qscale <= 0) if (h->c.qscale <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (h->c.pict_type != AV_PICTURE_TYPE_I && show_bits(&h->c.gb, 1)) { if (h->c.pict_type != AV_PICTURE_TYPE_I && show_bits(&h->gb, 1)) {
GetBitContext gb = h->c.gb; GetBitContext gb = h->gb;
int skip_type = get_bits(&gb, 2); int skip_type = get_bits(&gb, 2);
int run = skip_type == SKIP_TYPE_COL ? h->c.mb_width : h->c.mb_height; int run = skip_type == SKIP_TYPE_COL ? h->c.mb_width : h->c.mb_height;
@ -241,29 +241,29 @@ int ff_wmv2_decode_secondary_picture_header(H263DecContext *const h)
memset(h->c.cur_pic.mb_type, 0, memset(h->c.cur_pic.mb_type, 0,
sizeof(*h->c.cur_pic.mb_type) * h->c.mb_height * h->c.mb_stride); sizeof(*h->c.cur_pic.mb_type) * h->c.mb_height * h->c.mb_stride);
if (w->j_type_bit) if (w->j_type_bit)
w->j_type = get_bits1(&h->c.gb); w->j_type = get_bits1(&h->gb);
else else
w->j_type = 0; // FIXME check w->j_type = 0; // FIXME check
if (!w->j_type) { if (!w->j_type) {
if (w->per_mb_rl_bit) if (w->per_mb_rl_bit)
w->ms.per_mb_rl_table = get_bits1(&h->c.gb); w->ms.per_mb_rl_table = get_bits1(&h->gb);
else else
w->ms.per_mb_rl_table = 0; w->ms.per_mb_rl_table = 0;
if (!w->ms.per_mb_rl_table) { if (!w->ms.per_mb_rl_table) {
w->ms.rl_chroma_table_index = decode012(&h->c.gb); w->ms.rl_chroma_table_index = decode012(&h->gb);
w->ms.rl_table_index = decode012(&h->c.gb); w->ms.rl_table_index = decode012(&h->gb);
} }
w->ms.dc_table_index = get_bits1(&h->c.gb); w->ms.dc_table_index = get_bits1(&h->gb);
// at minimum one bit per macroblock is required at least in a valid frame, // at minimum one bit per macroblock is required at least in a valid frame,
// we discard frames much smaller than this. Frames smaller than 1/8 of the // we discard frames much smaller than this. Frames smaller than 1/8 of the
// smallest "black/skip" frame generally contain not much recoverable content // smallest "black/skip" frame generally contain not much recoverable content
// while at the same time they have the highest computational requirements // while at the same time they have the highest computational requirements
// per byte // per byte
if (get_bits_left(&h->c.gb) * 8LL < (h->c.width+15)/16 * ((h->c.height+15)/16)) if (get_bits_left(&h->gb) * 8LL < (h->c.width+15)/16 * ((h->c.height+15)/16))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
h->c.inter_intra_pred = 0; h->c.inter_intra_pred = 0;
@ -282,35 +282,35 @@ int ff_wmv2_decode_secondary_picture_header(H263DecContext *const h)
ret = parse_mb_skip(w); ret = parse_mb_skip(w);
if (ret < 0) if (ret < 0)
return ret; return ret;
cbp_index = decode012(&h->c.gb); cbp_index = decode012(&h->gb);
w->cbp_table_index = wmv2_get_cbp_table_index(h->c.qscale, cbp_index); w->cbp_table_index = wmv2_get_cbp_table_index(h->c.qscale, cbp_index);
if (w->mspel_bit) if (w->mspel_bit)
h->c.mspel = get_bits1(&h->c.gb); h->c.mspel = get_bits1(&h->gb);
else else
h->c.mspel = 0; // FIXME check h->c.mspel = 0; // FIXME check
if (w->abt_flag) { if (w->abt_flag) {
w->per_mb_abt = get_bits1(&h->c.gb) ^ 1; w->per_mb_abt = get_bits1(&h->gb) ^ 1;
if (!w->per_mb_abt) if (!w->per_mb_abt)
w->abt_type = decode012(&h->c.gb); w->abt_type = decode012(&h->gb);
} }
if (w->per_mb_rl_bit) if (w->per_mb_rl_bit)
w->ms.per_mb_rl_table = get_bits1(&h->c.gb); w->ms.per_mb_rl_table = get_bits1(&h->gb);
else else
w->ms.per_mb_rl_table = 0; w->ms.per_mb_rl_table = 0;
if (!w->ms.per_mb_rl_table) { if (!w->ms.per_mb_rl_table) {
w->ms.rl_table_index = decode012(&h->c.gb); w->ms.rl_table_index = decode012(&h->gb);
w->ms.rl_chroma_table_index = w->ms.rl_table_index; w->ms.rl_chroma_table_index = w->ms.rl_table_index;
} }
if (get_bits_left(&h->c.gb) < 2) if (get_bits_left(&h->gb) < 2)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
w->ms.dc_table_index = get_bits1(&h->c.gb); w->ms.dc_table_index = get_bits1(&h->gb);
w->ms.mv_table_index = get_bits1(&h->c.gb); w->ms.mv_table_index = get_bits1(&h->gb);
h->c.inter_intra_pred = 0; // (h->c.width * h->c.height < 320 * 240 && w->ms.bit_rate <= II_BITRATE); h->c.inter_intra_pred = 0; // (h->c.width * h->c.height < 320 * 240 && w->ms.bit_rate <= II_BITRATE);
h->c.no_rounding ^= 1; h->c.no_rounding ^= 1;
@ -331,7 +331,7 @@ int ff_wmv2_decode_secondary_picture_header(H263DecContext *const h)
if (w->j_type) { if (w->j_type) {
ff_intrax8_decode_picture(&w->x8, h->c.cur_pic.ptr, ff_intrax8_decode_picture(&w->x8, h->c.cur_pic.ptr,
&h->c.gb, &h->c.mb_x, &h->c.mb_y, &h->gb, &h->c.mb_x, &h->c.mb_y,
2 * h->c.qscale, (h->c.qscale - 1) | 1, 2 * h->c.qscale, (h->c.qscale - 1) | 1,
h->c.loop_filter, h->c.low_delay); h->c.loop_filter, h->c.low_delay);
@ -351,7 +351,7 @@ static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_pt
ff_msmpeg4_decode_motion(&w->ms, mx_ptr, my_ptr); ff_msmpeg4_decode_motion(&w->ms, mx_ptr, my_ptr);
if ((((*mx_ptr) | (*my_ptr)) & 1) && h->c.mspel) if ((((*mx_ptr) | (*my_ptr)) & 1) && h->c.mspel)
w->common.hshift = get_bits1(&h->c.gb); w->common.hshift = get_bits1(&h->gb);
else else
w->common.hshift = 0; w->common.hshift = 0;
} }
@ -376,7 +376,7 @@ static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
diff = 0; diff = 0;
if (diff >= 8) if (diff >= 8)
type = get_bits1(&h->c.gb); type = get_bits1(&h->gb);
else else
type = 2; type = 2;
@ -413,13 +413,13 @@ static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
} }
if (w->per_block_abt) if (w->per_block_abt)
w->abt_type = decode012(&h->c.gb); w->abt_type = decode012(&h->gb);
w->abt_type_table[n] = w->abt_type; w->abt_type_table[n] = w->abt_type;
if (w->abt_type) { if (w->abt_type) {
const uint8_t *scantable = w->abt_type == 1 ? ff_wmv2_scantableA : ff_wmv2_scantableB; const uint8_t *scantable = w->abt_type == 1 ? ff_wmv2_scantableA : ff_wmv2_scantableB;
sub_cbp = sub_cbp_table[decode012(&h->c.gb)]; sub_cbp = sub_cbp_table[decode012(&h->gb)];
if (sub_cbp & 1) { if (sub_cbp & 1) {
ret = ff_msmpeg4_decode_block(&w->ms, block, n, 1, scantable); ret = ff_msmpeg4_decode_block(&w->ms, block, n, 1, scantable);
@ -468,19 +468,19 @@ static int wmv2_decode_mb(H263DecContext *const h)
w->common.hshift = 0; w->common.hshift = 0;
return 0; return 0;
} }
if (get_bits_left(&h->c.gb) <= 0) if (get_bits_left(&h->gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
code = get_vlc2(&h->c.gb, ff_mb_non_intra_vlc[w->cbp_table_index], code = get_vlc2(&h->gb, ff_mb_non_intra_vlc[w->cbp_table_index],
MB_NON_INTRA_VLC_BITS, 3); MB_NON_INTRA_VLC_BITS, 3);
h->c.mb_intra = (~code & 0x40) >> 6; h->c.mb_intra = (~code & 0x40) >> 6;
cbp = code & 0x3f; cbp = code & 0x3f;
} else { } else {
h->c.mb_intra = 1; h->c.mb_intra = 1;
if (get_bits_left(&h->c.gb) <= 0) if (get_bits_left(&h->gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
code = get_vlc2(&h->c.gb, ff_msmp4_mb_i_vlc, code = get_vlc2(&h->gb, ff_msmp4_mb_i_vlc,
MSMP4_MB_INTRA_VLC_BITS, 2); MSMP4_MB_INTRA_VLC_BITS, 2);
/* predict coded block pattern */ /* predict coded block pattern */
cbp = 0; cbp = 0;
@ -502,14 +502,14 @@ static int wmv2_decode_mb(H263DecContext *const h)
if (cbp) { if (cbp) {
h->c.bdsp.clear_blocks(h->block[0]); h->c.bdsp.clear_blocks(h->block[0]);
if (ms->per_mb_rl_table) { if (ms->per_mb_rl_table) {
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }
if (w->abt_flag && w->per_mb_abt) { if (w->abt_flag && w->per_mb_abt) {
w->per_block_abt = get_bits1(&h->c.gb); w->per_block_abt = get_bits1(&h->gb);
if (!w->per_block_abt) if (!w->per_block_abt)
w->abt_type = decode012(&h->c.gb); w->abt_type = decode012(&h->gb);
} else } else
w->per_block_abt = 0; w->per_block_abt = 0;
} }
@ -534,16 +534,16 @@ static int wmv2_decode_mb(H263DecContext *const h)
ff_dlog(h->c.avctx, "%d%d ", h->c.inter_intra_pred, cbp); ff_dlog(h->c.avctx, "%d%d ", h->c.inter_intra_pred, cbp);
ff_dlog(h->c.avctx, "I at %d %d %d %06X\n", h->c.mb_x, h->c.mb_y, ff_dlog(h->c.avctx, "I at %d %d %d %06X\n", h->c.mb_x, h->c.mb_y,
((cbp & 3) ? 1 : 0) + ((cbp & 0x3C) ? 2 : 0), ((cbp & 3) ? 1 : 0) + ((cbp & 0x3C) ? 2 : 0),
show_bits(&h->c.gb, 24)); show_bits(&h->gb, 24));
h->c.ac_pred = get_bits1(&h->c.gb); h->c.ac_pred = get_bits1(&h->gb);
if (h->c.inter_intra_pred) { if (h->c.inter_intra_pred) {
h->c.h263_aic_dir = get_vlc2(&h->c.gb, ff_inter_intra_vlc, h->c.h263_aic_dir = get_vlc2(&h->gb, ff_inter_intra_vlc,
INTER_INTRA_VLC_BITS, 1); INTER_INTRA_VLC_BITS, 1);
ff_dlog(h->c.avctx, "%d%d %d %d/", ff_dlog(h->c.avctx, "%d%d %d %d/",
h->c.ac_pred, h->c.h263_aic_dir, h->c.mb_x, h->c.mb_y); h->c.ac_pred, h->c.h263_aic_dir, h->c.mb_x, h->c.mb_y);
} }
if (ms->per_mb_rl_table && cbp) { if (ms->per_mb_rl_table && cbp) {
ms->rl_table_index = decode012(&h->c.gb); ms->rl_table_index = decode012(&h->gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }