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: Add H263DecContext

Browse Source 
This is in preparation for moving the fields only used
by H.263-based decoders from MPVContext to H263DecContext.
For now only the decode_mb function pointer has been moved
(to be able to switch said callback to use an H263DecContext*).

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt
2025-06-19 19:24:35 +02:00
parent 3f5c2043cc
commit 584d50c5f3
21 changed files with 2244 additions and 2216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
libavcodec/flvdec.c
View File

@ -26,31 +26,31 @@
#include "mpegvideo.h" #include "mpegvideo.h"
#include "mpegvideodec.h" #include "mpegvideodec.h"
int ff_flv_decode_picture_header(MpegEncContext *s) int ff_flv_decode_picture_header(H263DecContext *const h)
{ {
int format, width, height; int format, width, height;
/* picture header */ /* picture header */
if (get_bits(&s->gb, 17) != 1) { if (get_bits(&h->c.gb, 17) != 1) {
av_log(s->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(&s->gb, 5); format = get_bits(&h->c.gb, 5);
if (format != 0 && format != 1) { if (format != 0 && format != 1) {
av_log(s->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;
} }
s->h263_flv = format + 1; h->c.h263_flv = format + 1;
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ h->c.picture_number = get_bits(&h->c.gb, 8); /* picture timestamp */
format = get_bits(&s->gb, 3); format = get_bits(&h->c.gb, 3);
switch (format) { switch (format) {
case 0: case 0:
width = get_bits(&s->gb, 8); width = get_bits(&h->c.gb, 8);
height = get_bits(&s->gb, 8); height = get_bits(&h->c.gb, 8);
break; break;
case 1: case 1:
width = get_bits(&s->gb, 16); width = get_bits(&h->c.gb, 16);
height = get_bits(&s->gb, 16); height = get_bits(&h->c.gb, 16);
break; break;
case 2: case 2:
width = 352; width = 352;
@ -76,32 +76,32 @@ int ff_flv_decode_picture_header(MpegEncContext *s)
width = height = 0; width = height = 0;
break; break;
} }
if (av_image_check_size(width, height, 0, s->avctx)) if (av_image_check_size(width, height, 0, h->c.avctx))
return AVERROR(EINVAL); return AVERROR(EINVAL);
s->width = width; h->c.width = width;
s->height = height; h->c.height = height;
s->pict_type = AV_PICTURE_TYPE_I + get_bits(&s->gb, 2); h->c.pict_type = AV_PICTURE_TYPE_I + get_bits(&h->c.gb, 2);
s->droppable = s->pict_type > AV_PICTURE_TYPE_P; h->c.droppable = h->c.pict_type > AV_PICTURE_TYPE_P;
if (s->droppable) if (h->c.droppable)
s->pict_type = AV_PICTURE_TYPE_P; h->c.pict_type = AV_PICTURE_TYPE_P;
skip_bits1(&s->gb); /* deblocking flag */ skip_bits1(&h->c.gb); /* deblocking flag */
s->chroma_qscale = s->qscale = get_bits(&s->gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5);
s->h263_long_vectors = 0; h->c.h263_long_vectors = 0;
/* PEI */ /* PEI */
if (skip_1stop_8data_bits(&s->gb) < 0) if (skip_1stop_8data_bits(&h->c.gb) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (s->ehc_mode) if (h->c.ehc_mode)
s->avctx->sample_aspect_ratio= (AVRational){1,2}; h->c.avctx->sample_aspect_ratio= (AVRational){1,2};
if (s->avctx->debug & FF_DEBUG_PICT_INFO) { if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", av_log(h->c.avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
s->droppable ? 'D' : av_get_picture_type_char(s->pict_type), h->c.droppable ? 'D' : av_get_picture_type_char(h->c.pict_type),
s->h263_flv - 1, s->qscale, s->picture_number); h->c.h263_flv - 1, h->c.qscale, h->c.picture_number);
} }
return 0; return 0;
@ -112,7 +112,7 @@ const FFCodec ff_flv_decoder = {
CODEC_LONG_NAME("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"), CODEC_LONG_NAME("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"),
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_FLV1, .p.id = AV_CODEC_ID_FLV1,
.priv_data_size = sizeof(MpegEncContext), .priv_data_size = sizeof(H263DecContext),
.init = ff_h263_decode_init, .init = ff_h263_decode_init,
FF_CODEC_DECODE_CB(ff_h263_decode_frame), FF_CODEC_DECODE_CB(ff_h263_decode_frame),
.close = ff_mpv_decode_close, .close = ff_mpv_decode_close,

4
libavcodec/flvdec.h
View File

@ -21,8 +21,8 @@
#ifndef AVCODEC_FLVDEC_H #ifndef AVCODEC_FLVDEC_H
#define AVCODEC_FLVDEC_H #define AVCODEC_FLVDEC_H
#include "mpegvideo.h" struct H263DecContext;
int ff_flv_decode_picture_header(MpegEncContext *s); int ff_flv_decode_picture_header(struct H263DecContext *const h);
#endif /* AVCODEC_FLVDEC_H */ #endif /* AVCODEC_FLVDEC_H */

410
libavcodec/h263dec.c
View File

@ -90,7 +90,8 @@ static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)
av_cold int ff_h263_decode_init(AVCodecContext *avctx) av_cold int ff_h263_decode_init(AVCodecContext *avctx)
{ {
MpegEncContext *s = avctx->priv_data; H263DecContext *const h = avctx->priv_data;
MPVContext *const s = &h->c;
MPVUnquantDSPContext unquant_dsp_ctx; MPVUnquantDSPContext unquant_dsp_ctx;
int ret; int ret;
@ -101,7 +102,7 @@ av_cold int ff_h263_decode_init(AVCodecContext *avctx)
if (ret < 0) if (ret < 0)
return ret; return ret;
s->decode_mb = ff_h263_decode_mb; h->decode_mb = ff_h263_decode_mb;
s->low_delay = 1; s->low_delay = 1;
s->y_dc_scale_table = s->y_dc_scale_table =
@ -179,239 +180,239 @@ static void report_decode_progress(MpegEncContext *s)
ff_thread_progress_report(&s->cur_pic.ptr->progress, s->mb_y); ff_thread_progress_report(&s->cur_pic.ptr->progress, s->mb_y);
} }
static int decode_slice(MpegEncContext *s) static int decode_slice(H263DecContext *const h)
{ {
const int part_mask = s->partitioned_frame const int part_mask = h->c.partitioned_frame
? (ER_AC_END | ER_AC_ERROR) : 0x7F; ? (ER_AC_END | ER_AC_ERROR) : 0x7F;
const int mb_size = 16 >> s->avctx->lowres; const int mb_size = 16 >> h->c.avctx->lowres;
int ret; int ret;
s->last_resync_gb = s->gb; h->c.last_resync_gb = h->c.gb;
s->first_slice_line = 1; h->c.first_slice_line = 1;
s->resync_mb_x = s->mb_x; h->c.resync_mb_x = h->c.mb_x;
s->resync_mb_y = s->mb_y; h->c.resync_mb_y = h->c.mb_y;
ff_set_qscale(s, s->qscale); ff_set_qscale(&h->c, h->c.qscale);
if (s->studio_profile) { if (h->c.studio_profile) {
if ((ret = ff_mpeg4_decode_studio_slice_header(s)) < 0) if ((ret = ff_mpeg4_decode_studio_slice_header(h)) < 0)
return ret; return ret;
} }
if (s->avctx->hwaccel) { if (h->c.avctx->hwaccel) {
const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8; const uint8_t *start = h->c.gb.buffer + get_bits_count(&h->c.gb) / 8;
ret = FF_HW_CALL(s->avctx, decode_slice, start, s->gb.buffer_end - start); ret = FF_HW_CALL(h->c.avctx, decode_slice, start, h->c.gb.buffer_end - start);
// ensure we exit decode loop // ensure we exit decode loop
s->mb_y = s->mb_height; h->c.mb_y = h->c.mb_height;
return ret; return ret;
} }
if (s->partitioned_frame) { if (h->c.partitioned_frame) {
const int qscale = s->qscale; const int qscale = h->c.qscale;
if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) if (CONFIG_MPEG4_DECODER && h->c.codec_id == AV_CODEC_ID_MPEG4)
if ((ret = ff_mpeg4_decode_partitions(s)) < 0) if ((ret = ff_mpeg4_decode_partitions(h)) < 0)
return ret; return ret;
/* restore variables which were modified */ /* restore variables which were modified */
s->first_slice_line = 1; h->c.first_slice_line = 1;
s->mb_x = s->resync_mb_x; h->c.mb_x = h->c.resync_mb_x;
s->mb_y = s->resync_mb_y; h->c.mb_y = h->c.resync_mb_y;
ff_set_qscale(s, qscale); ff_set_qscale(&h->c, qscale);
} }
for (; s->mb_y < s->mb_height; s->mb_y++) { for (; h->c.mb_y < h->c.mb_height; h->c.mb_y++) {
/* per-row end of slice checks */ /* per-row end of slice checks */
if (s->msmpeg4_version != MSMP4_UNUSED) { if (h->c.msmpeg4_version != MSMP4_UNUSED) {
if (s->resync_mb_y + s->slice_height == s->mb_y) { if (h->c.resync_mb_y + h->c.slice_height == h->c.mb_y) {
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y,
s->mb_x - 1, s->mb_y, ER_MB_END); h->c.mb_x - 1, h->c.mb_y, ER_MB_END);
return 0; return 0;
} }
} }
if (s->msmpeg4_version == MSMP4_V1) { if (h->c.msmpeg4_version == MSMP4_V1) {
s->last_dc[0] = h->c.last_dc[0] =
s->last_dc[1] = h->c.last_dc[1] =
s->last_dc[2] = 128; h->c.last_dc[2] = 128;
} }
ff_init_block_index(s); ff_init_block_index(&h->c);
for (; s->mb_x < s->mb_width; s->mb_x++) { for (; h->c.mb_x < h->c.mb_width; h->c.mb_x++) {
int ret; int ret;
ff_update_block_index(s, s->avctx->bits_per_raw_sample, ff_update_block_index(&h->c, h->c.avctx->bits_per_raw_sample,
s->avctx->lowres, s->chroma_x_shift); h->c.avctx->lowres, h->c.chroma_x_shift);
if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y) if (h->c.resync_mb_x == h->c.mb_x && h->c.resync_mb_y + 1 == h->c.mb_y)
s->first_slice_line = 0; h->c.first_slice_line = 0;
/* DCT & quantize */ /* DCT & quantize */
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
ff_dlog(s->avctx, "%d %06X\n", ff_dlog(h->c.avctx, "%d %06X\n",
get_bits_count(&s->gb), show_bits(&s->gb, 24)); get_bits_count(&h->c.gb), show_bits(&h->c.gb, 24));
ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y); ff_tlog(NULL, "Decoding MB at %dx%d\n", h->c.mb_x, h->c.mb_y);
ret = s->decode_mb(s, s->block); ret = h->decode_mb(h, h->c.block);
if (s->h263_pred || s->h263_aic) { if (h->c.h263_pred || h->c.h263_aic) {
int mb_xy = s->mb_y * s->mb_stride + s->mb_x; int mb_xy = h->c.mb_y * h->c.mb_stride + h->c.mb_x;
if (!s->mb_intra) { if (!h->c.mb_intra) {
ff_h263_clean_intra_table_entries(s, mb_xy); ff_h263_clean_intra_table_entries(&h->c, mb_xy);
} else } else
s->mbintra_table[mb_xy] = 1; h->c.mbintra_table[mb_xy] = 1;
} }
if (s->pict_type != AV_PICTURE_TYPE_B) if (h->c.pict_type != AV_PICTURE_TYPE_B)
ff_h263_update_motion_val(s); ff_h263_update_motion_val(&h->c);
if (ret < 0) { if (ret < 0) {
const int xy = s->mb_x + s->mb_y * s->mb_stride; const int xy = h->c.mb_x + h->c.mb_y * h->c.mb_stride;
if (ret == SLICE_END) { if (ret == SLICE_END) {
ff_mpv_reconstruct_mb(s, s->block); ff_mpv_reconstruct_mb(&h->c, h->c.block);
if (s->loop_filter) if (h->c.loop_filter)
ff_h263_loop_filter(s); ff_h263_loop_filter(&h->c);
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y,
s->mb_x, s->mb_y, ER_MB_END & part_mask); h->c.mb_x, h->c.mb_y, ER_MB_END & part_mask);
s->padding_bug_score--; h->c.padding_bug_score--;
if (++s->mb_x >= s->mb_width) { if (++h->c.mb_x >= h->c.mb_width) {
s->mb_x = 0; h->c.mb_x = 0;
report_decode_progress(s); report_decode_progress(&h->c);
ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); ff_mpeg_draw_horiz_band(&h->c, h->c.mb_y * mb_size, mb_size);
s->mb_y++; h->c.mb_y++;
} }
return 0; return 0;
} else if (ret == SLICE_NOEND) { } else if (ret == SLICE_NOEND) {
av_log(s->avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"Slice mismatch at MB: %d\n", xy); "Slice mismatch at MB: %d\n", xy);
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y,
s->mb_x + 1, s->mb_y, h->c.mb_x + 1, h->c.mb_y,
ER_MB_END & part_mask); ER_MB_END & part_mask);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); av_log(h->c.avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y,
s->mb_x, s->mb_y, ER_MB_ERROR & part_mask); h->c.mb_x, h->c.mb_y, ER_MB_ERROR & part_mask);
if ((s->avctx->err_recognition & AV_EF_IGNORE_ERR) && get_bits_left(&s->gb) > 0) if ((h->c.avctx->err_recognition & AV_EF_IGNORE_ERR) && get_bits_left(&h->c.gb) > 0)
continue; continue;
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
ff_mpv_reconstruct_mb(s, s->block); ff_mpv_reconstruct_mb(&h->c, h->c.block);
if (s->loop_filter) if (h->c.loop_filter)
ff_h263_loop_filter(s); ff_h263_loop_filter(&h->c);
} }
report_decode_progress(s); report_decode_progress(&h->c);
ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); ff_mpeg_draw_horiz_band(&h->c, h->c.mb_y * mb_size, mb_size);
s->mb_x = 0; h->c.mb_x = 0;
} }
av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height); av_assert1(h->c.mb_x == 0 && h->c.mb_y == h->c.mb_height);
// 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 (s->codec_id == AV_CODEC_ID_MPEG4 && if (h->c.codec_id == AV_CODEC_ID_MPEG4 &&
(s->workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&s->gb) >= 48 && get_bits_left(&h->c.gb) >= 48 &&
show_bits(&s->gb, 24) == 0x4010 && show_bits(&h->c.gb, 24) == 0x4010 &&
!s->data_partitioning) !h->c.data_partitioning)
s->padding_bug_score += 32; h->c.padding_bug_score += 32;
/* try to detect the padding bug */ /* try to detect the padding bug */
if (s->codec_id == AV_CODEC_ID_MPEG4 && if (h->c.codec_id == AV_CODEC_ID_MPEG4 &&
(s->workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&s->gb) >= 0 && get_bits_left(&h->c.gb) >= 0 &&
get_bits_left(&s->gb) < 137 && get_bits_left(&h->c.gb) < 137 &&
!s->data_partitioning) { !h->c.data_partitioning) {
const int bits_count = get_bits_count(&s->gb); const int bits_count = get_bits_count(&h->c.gb);
const int bits_left = s->gb.size_in_bits - bits_count; const int bits_left = h->c.gb.size_in_bits - bits_count;
if (bits_left == 0) { if (bits_left == 0) {
s->padding_bug_score += 16; h->c.padding_bug_score += 16;
} else if (bits_left != 1) { } else if (bits_left != 1) {
int v = show_bits(&s->gb, 8); int v = show_bits(&h->c.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)
s->padding_bug_score--; h->c.padding_bug_score--;
else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) && else if (v == 0x7F && ((get_bits_count(&h->c.gb) + 8) & 8) &&
bits_left <= 16) bits_left <= 16)
s->padding_bug_score += 4; h->c.padding_bug_score += 4;
else else
s->padding_bug_score++; h->c.padding_bug_score++;
} }
} }
if (s->codec_id == AV_CODEC_ID_H263 && if (h->c.codec_id == AV_CODEC_ID_H263 &&
(s->workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&s->gb) >= 8 && get_bits_left(&h->c.gb) >= 8 &&
get_bits_left(&s->gb) < 300 && get_bits_left(&h->c.gb) < 300 &&
s->pict_type == AV_PICTURE_TYPE_I && h->c.pict_type == AV_PICTURE_TYPE_I &&
show_bits(&s->gb, 8) == 0 && show_bits(&h->c.gb, 8) == 0 &&
!s->data_partitioning) { !h->c.data_partitioning) {
s->padding_bug_score += 32; h->c.padding_bug_score += 32;
} }
if (s->codec_id == AV_CODEC_ID_H263 && if (h->c.codec_id == AV_CODEC_ID_H263 &&
(s->workaround_bugs & FF_BUG_AUTODETECT) && (h->c.workaround_bugs & FF_BUG_AUTODETECT) &&
get_bits_left(&s->gb) >= 64 && get_bits_left(&h->c.gb) >= 64 &&
AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) { AV_RB64(h->c.gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) {
s->padding_bug_score += 32; h->c.padding_bug_score += 32;
} }
if (s->workaround_bugs & FF_BUG_AUTODETECT) { if (h->c.workaround_bugs & FF_BUG_AUTODETECT) {
if ( if (
(s->padding_bug_score > -2 && !s->data_partitioning)) (h->c.padding_bug_score > -2 && !h->c.data_partitioning))
s->workaround_bugs |= FF_BUG_NO_PADDING; h->c.workaround_bugs |= FF_BUG_NO_PADDING;
else else
s->workaround_bugs &= ~FF_BUG_NO_PADDING; h->c.workaround_bugs &= ~FF_BUG_NO_PADDING;
} }
// handle formats which don't have unique end markers // handle formats which don't have unique end markers
if (s->msmpeg4_version != MSMP4_UNUSED || (s->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(&s->gb); int left = get_bits_left(&h->c.gb);
int max_extra = 7; int max_extra = 7;
/* no markers in M$ crap */ /* no markers in M$ crap */
if (s->msmpeg4_version != MSMP4_UNUSED && s->pict_type == AV_PICTURE_TYPE_I) if (h->c.msmpeg4_version != MSMP4_UNUSED && h->c.pict_type == AV_PICTURE_TYPE_I)
max_extra += 17; max_extra += 17;
/* buggy padding but the frame should still end approximately at /* buggy padding but the frame should still end approximately at
* the bitstream end */ * the bitstream end */
if ((s->workaround_bugs & FF_BUG_NO_PADDING) && if ((h->c.workaround_bugs & FF_BUG_NO_PADDING) &&
(s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) (h->c.avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE)))
max_extra += 48; max_extra += 48;
else if ((s->workaround_bugs & FF_BUG_NO_PADDING)) else if ((h->c.workaround_bugs & FF_BUG_NO_PADDING))
max_extra += 256 * 256 * 256 * 64; max_extra += 256 * 256 * 256 * 64;
if (left > max_extra) if (left > max_extra)
av_log(s->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(&s->gb, 24)); left, show_bits(&h->c.gb, 24));
else if (left < 0) else if (left < 0)
av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left); av_log(h->c.avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
else else
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y,
s->mb_x - 1, s->mb_y, ER_MB_END); h->c.mb_x - 1, h->c.mb_y, ER_MB_END);
return 0; return 0;
} }
av_log(s->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(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score); get_bits_left(&h->c.gb), show_bits(&h->c.gb, 24), h->c.padding_bug_score);
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->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);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -420,9 +421,10 @@ static int decode_slice(MpegEncContext *s)
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
int *got_frame, AVPacket *avpkt) int *got_frame, AVPacket *avpkt)
{ {
H263DecContext *const h = avctx->priv_data;
MPVContext *const s = &h->c;
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
MpegEncContext *s = avctx->priv_data;
int ret; int ret;
int slice_ret = 0; int slice_ret = 0;
int bak_width, bak_height; int bak_width, bak_height;
@ -430,10 +432,10 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
/* no supplementary picture */ /* no supplementary picture */
if (buf_size == 0) { if (buf_size == 0) {
/* special case for last picture */ /* special case for last picture */
if ((!s->low_delay || s->skipped_last_frame) && s->next_pic.ptr) { if ((!h->c.low_delay || h->c.skipped_last_frame) && h->c.next_pic.ptr) {
if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0) if ((ret = av_frame_ref(pict, h->c.next_pic.ptr->f)) < 0)
return ret; return ret;
if (s->skipped_last_frame) { if (h->c.skipped_last_frame) {
/* If the stream ended with an NVOP, we output the last frame /* If the stream ended with an NVOP, we output the last frame
* in display order, but with the props from the last input * in display order, but with the props from the last input
* packet so that the stream's end time is correct. */ * packet so that the stream's end time is correct. */
@ -442,7 +444,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
return ret; return ret;
} }
ff_mpv_unref_picture(&s->next_pic); ff_mpv_unref_picture(&h->c.next_pic);
*got_frame = 1; *got_frame = 1;
} }
@ -450,37 +452,37 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
return 0; return 0;
} }
// s->gb might be overridden in ff_mpeg4_decode_picture_header() below. // h->c.gb might be overridden in ff_mpeg4_decode_picture_header() below.
ret = init_get_bits8(&s->gb, buf, buf_size); ret = init_get_bits8(&h->c.gb, buf, buf_size);
if (ret < 0) if (ret < 0)
return ret; return ret;
bak_width = s->width; bak_width = h->c.width;
bak_height = s->height; bak_height = h->c.height;
/* let's go :-) */ /* let's go :-) */
if (CONFIG_WMV2_DECODER && s->msmpeg4_version == MSMP4_WMV2) { if (CONFIG_WMV2_DECODER && h->c.msmpeg4_version == MSMP4_WMV2) {
ret = ff_wmv2_decode_picture_header(s); ret = ff_wmv2_decode_picture_header(h);
#if CONFIG_MSMPEG4DEC #if CONFIG_MSMPEG4DEC
} else if (s->msmpeg4_version != MSMP4_UNUSED) { } else if (h->c.msmpeg4_version != MSMP4_UNUSED) {
ret = ff_msmpeg4_decode_picture_header(s); ret = ff_msmpeg4_decode_picture_header(h);
#endif #endif
} else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) { } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
ret = ff_mpeg4_decode_picture_header(s); ret = ff_mpeg4_decode_picture_header(h);
} else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) { } else if (CONFIG_H263I_DECODER && h->c.codec_id == AV_CODEC_ID_H263I) {
ret = ff_intel_h263_decode_picture_header(s); ret = ff_intel_h263_decode_picture_header(h);
} else if (CONFIG_FLV_DECODER && s->h263_flv) { } else if (CONFIG_FLV_DECODER && h->c.h263_flv) {
ret = ff_flv_decode_picture_header(s); ret = ff_flv_decode_picture_header(h);
} else { } else {
ret = ff_h263_decode_picture_header(s); ret = ff_h263_decode_picture_header(h);
} }
if (ret < 0 || ret == FRAME_SKIPPED) { if (ret < 0 || ret == FRAME_SKIPPED) {
if ( s->width != bak_width if ( h->c.width != bak_width
|| s->height != bak_height) { || h->c.height != bak_height) {
av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n"); av_log(h->c.avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");
s->width = bak_width; h->c.width = bak_width;
s->height= bak_height; h->c.height= bak_height;
} }
} }
@ -489,37 +491,35 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
/* skip if the header was thrashed */ /* skip if the header was thrashed */
if (ret < 0) { if (ret < 0) {
av_log(s->avctx, AV_LOG_ERROR, "header damaged\n"); av_log(h->c.avctx, AV_LOG_ERROR, "header damaged\n");
return ret; return ret;
} }
if (!s->context_initialized) { if (!h->c.context_initialized) {
avctx->pix_fmt = h263_get_format(avctx); avctx->pix_fmt = h263_get_format(avctx);
if ((ret = ff_mpv_common_init(s)) < 0) if ((ret = ff_mpv_common_init(s)) < 0)
return ret; return ret;
} }
avctx->has_b_frames = !s->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 (s->pict_type != AV_PICTURE_TYPE_B && s->mb_num/2 > get_bits_left(&s->gb)) if (h->c.pict_type != AV_PICTURE_TYPE_B && h->c.mb_num/2 > get_bits_left(&h->c.gb))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ff_mpeg4_workaround_bugs(avctx); ff_mpeg4_workaround_bugs(avctx);
if (s->studio_profile != (s->idsp.idct == NULL)) if (h->c.studio_profile != (h->c.idsp.idct == NULL))
ff_mpv_idct_init(s); ff_mpv_idct_init(s);
} }
/* After H.263 & MPEG-4 header decode we have the height, width, /* After H.263 & MPEG-4 header decode we have the height, width,
* and other parameters. So then we could init the picture. * and other parameters. So then we could init the picture. */
* FIXME: By the way H.263 decoder is evolving it should have if (h->c.width != avctx->coded_width ||
* an H263EncContext */ h->c.height != avctx->coded_height ||
if (s->width != avctx->coded_width || h->c.context_reinit) {
s->height != avctx->coded_height ||
s->context_reinit) {
/* H.263 could change picture size any time */ /* H.263 could change picture size any time */
s->context_reinit = 0; h->c.context_reinit = 0;
ret = ff_set_dimensions(avctx, s->width, s->height); ret = ff_set_dimensions(avctx, h->c.width, h->c.height);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -536,25 +536,25 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
} }
/* skip B-frames if we don't have reference frames */ /* skip B-frames if we don't have reference frames */
if (!s->last_pic.ptr && if (!h->c.last_pic.ptr &&
(s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) (h->c.pict_type == AV_PICTURE_TYPE_B || h->c.droppable))
return buf_size; return buf_size;
if ((avctx->skip_frame >= AVDISCARD_NONREF && if ((avctx->skip_frame >= AVDISCARD_NONREF &&
s->pict_type == AV_PICTURE_TYPE_B) || h->c.pict_type == AV_PICTURE_TYPE_B) ||
(avctx->skip_frame >= AVDISCARD_NONKEY && (avctx->skip_frame >= AVDISCARD_NONKEY &&
s->pict_type != AV_PICTURE_TYPE_I) || h->c.pict_type != AV_PICTURE_TYPE_I) ||
avctx->skip_frame >= AVDISCARD_ALL) avctx->skip_frame >= AVDISCARD_ALL)
return buf_size; return buf_size;
if ((ret = ff_mpv_frame_start(s, avctx)) < 0) if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
return ret; return ret;
if (!s->divx_packed) if (!h->c.divx_packed)
ff_thread_finish_setup(avctx); ff_thread_finish_setup(avctx);
if (avctx->hwaccel) { if (avctx->hwaccel) {
ret = FF_HW_CALL(avctx, start_frame, NULL, ret = FF_HW_CALL(avctx, start_frame, NULL,
s->gb.buffer, s->gb.buffer_end - s->gb.buffer); h->c.gb.buffer, h->c.gb.buffer_end - h->c.gb.buffer);
if (ret < 0 ) if (ret < 0 )
return ret; return ret;
} }
@ -565,8 +565,8 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
* are stored in current_picture->mb_type which is not available before * are stored in current_picture->mb_type which is not available before
* ff_mpv_frame_start() */ * ff_mpv_frame_start() */
#if CONFIG_WMV2_DECODER #if CONFIG_WMV2_DECODER
if (s->msmpeg4_version == MSMP4_WMV2) { if (h->c.msmpeg4_version == MSMP4_WMV2) {
ret = ff_wmv2_decode_secondary_picture_header(s); ret = ff_wmv2_decode_secondary_picture_header(h);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (ret == 1) if (ret == 1)
@ -575,39 +575,39 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
#endif #endif
/* decode each macroblock */ /* decode each macroblock */
s->mb_x = 0; h->c.mb_x = 0;
s->mb_y = 0; h->c.mb_y = 0;
slice_ret = decode_slice(s); slice_ret = decode_slice(h);
while (s->mb_y < s->mb_height) { while (h->c.mb_y < h->c.mb_height) {
if (s->msmpeg4_version != MSMP4_UNUSED) { if (h->c.msmpeg4_version != MSMP4_UNUSED) {
if (s->slice_height == 0 || s->mb_x != 0 || slice_ret < 0 || if (h->c.slice_height == 0 || h->c.mb_x != 0 || slice_ret < 0 ||
(s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0) (h->c.mb_y % h->c.slice_height) != 0 || get_bits_left(&h->c.gb) < 0)
break; break;
} else { } else {
int prev_x = s->mb_x, prev_y = s->mb_y; int prev_x = h->c.mb_x, prev_y = h->c.mb_y;
if (ff_h263_resync(s) < 0) if (ff_h263_resync(h) < 0)
break; break;
if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x) if (prev_y * h->c.mb_width + prev_x < h->c.mb_y * h->c.mb_width + h->c.mb_x)
s->er.error_occurred = 1; h->c.er.error_occurred = 1;
} }
if (s->msmpeg4_version < MSMP4_WMV1 && s->h263_pred) if (h->c.msmpeg4_version < MSMP4_WMV1 && h->c.h263_pred)
ff_mpeg4_clean_buffers(s); ff_mpeg4_clean_buffers(s);
if (decode_slice(s) < 0) if (decode_slice(h) < 0)
slice_ret = AVERROR_INVALIDDATA; slice_ret = AVERROR_INVALIDDATA;
} }
if (s->msmpeg4_version != MSMP4_UNUSED && s->msmpeg4_version < MSMP4_WMV1 && if (h->c.msmpeg4_version != MSMP4_UNUSED && h->c.msmpeg4_version < MSMP4_WMV1 &&
s->pict_type == AV_PICTURE_TYPE_I) h->c.pict_type == AV_PICTURE_TYPE_I)
if (!CONFIG_MSMPEG4DEC || if (!CONFIG_MSMPEG4DEC ||
ff_msmpeg4_decode_ext_header(s, buf_size) < 0) ff_msmpeg4_decode_ext_header(h, buf_size) < 0)
s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR; h->c.er.error_status_table[h->c.mb_num - 1] = ER_MB_ERROR;
frame_end: frame_end:
if (!s->studio_profile) if (!h->c.studio_profile)
ff_er_frame_end(&s->er, NULL); ff_er_frame_end(&h->c.er, NULL);
if (avctx->hwaccel) { if (avctx->hwaccel) {
ret = FF_HW_SIMPLE_CALL(avctx, end_frame); ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
@ -620,22 +620,22 @@ frame_end:
if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4)
ff_mpeg4_frame_end(avctx, avpkt); ff_mpeg4_frame_end(avctx, avpkt);
av_assert1(s->pict_type == s->cur_pic.ptr->f->pict_type); av_assert1(h->c.pict_type == h->c.cur_pic.ptr->f->pict_type);
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if (h->c.pict_type == AV_PICTURE_TYPE_B || h->c.low_delay) {
if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0) if ((ret = av_frame_ref(pict, h->c.cur_pic.ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->cur_pic.ptr, pict); ff_print_debug_info(s, h->c.cur_pic.ptr, pict);
ff_mpv_export_qp_table(s, pict, s->cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict, h->c.cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1);
} else if (s->last_pic.ptr) { } else if (h->c.last_pic.ptr) {
if ((ret = av_frame_ref(pict, s->last_pic.ptr->f)) < 0) if ((ret = av_frame_ref(pict, h->c.last_pic.ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->last_pic.ptr, pict); ff_print_debug_info(s, h->c.last_pic.ptr, pict);
ff_mpv_export_qp_table(s, pict, s->last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict, h->c.last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1);
} }
if (s->last_pic.ptr || s->low_delay) { if (h->c.last_pic.ptr || h->c.low_delay) {
if ( pict->format == AV_PIX_FMT_YUV420P if ( pict->format == AV_PIX_FMT_YUV420P
&& (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) { && (h->c.codec_tag == AV_RL32("GEOV") || h->c.codec_tag == AV_RL32("GEOX"))) {
for (int p = 0; p < 3; p++) { for (int p = 0; p < 3; p++) {
int h = AV_CEIL_RSHIFT(pict->height, !!p); int h = AV_CEIL_RSHIFT(pict->height, !!p);
@ -673,7 +673,7 @@ const FFCodec ff_h263_decoder = {
CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_H263, .p.id = AV_CODEC_ID_H263,
.priv_data_size = sizeof(MpegEncContext), .priv_data_size = sizeof(H263DecContext),
.init = ff_h263_decode_init, .init = ff_h263_decode_init,
FF_CODEC_DECODE_CB(ff_h263_decode_frame), FF_CODEC_DECODE_CB(ff_h263_decode_frame),
.close = ff_mpv_decode_close, .close = ff_mpv_decode_close,
@ -691,7 +691,7 @@ const FFCodec ff_h263p_decoder = {
CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_H263P, .p.id = AV_CODEC_ID_H263P,
.priv_data_size = sizeof(MpegEncContext), .priv_data_size = sizeof(H263DecContext),
.init = ff_h263_decode_init, .init = ff_h263_decode_init,
FF_CODEC_DECODE_CB(ff_h263_decode_frame), FF_CODEC_DECODE_CB(ff_h263_decode_frame),
.close = ff_mpv_decode_close, .close = ff_mpv_decode_close,

22
libavcodec/h263dec.h
View File

@ -43,24 +43,30 @@ extern VLCElem ff_h263_inter_MCBPC_vlc[];
extern VLCElem ff_h263_cbpy_vlc[]; extern VLCElem ff_h263_cbpy_vlc[];
extern VLCElem ff_h263_mv_vlc[]; extern VLCElem ff_h263_mv_vlc[];
int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code); typedef struct H263DecContext {
MPVContext c;
int (*decode_mb)(struct H263DecContext *h, int16_t block[6][64]);
} H263DecContext;
int ff_h263_decode_motion(H263DecContext *const h, int pred, int f_code);
int ff_h263_decode_init(AVCodecContext *avctx); int ff_h263_decode_init(AVCodecContext *avctx);
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *frame, int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *frame,
int *got_frame, AVPacket *avpkt); int *got_frame, AVPacket *avpkt);
void ff_h263_decode_init_vlc(void); void ff_h263_decode_init_vlc(void);
int ff_h263_decode_picture_header(MpegEncContext *s); int ff_h263_decode_picture_header(H263DecContext *const h);
int ff_h263_decode_gob_header(MpegEncContext *s); int ff_h263_decode_gob_header(H263DecContext *const h);
int ff_h263_decode_mba(MpegEncContext *s); int ff_h263_decode_mba(H263DecContext *const h);
/** /**
* Print picture info if FF_DEBUG_PICT_INFO is set. * Print picture info if FF_DEBUG_PICT_INFO is set.
*/ */
void ff_h263_show_pict_info(MpegEncContext *s, int h263_plus); void ff_h263_show_pict_info(H263DecContext *const h, int h263_plus);
int ff_intel_h263_decode_picture_header(MpegEncContext *s); int ff_intel_h263_decode_picture_header(H263DecContext *const h);
int ff_h263_decode_mb(MpegEncContext *s, int ff_h263_decode_mb(H263DecContext *const h,
int16_t block[6][64]); int16_t block[6][64]);
int ff_h263_resync(MpegEncContext *s); int ff_h263_resync(H263DecContext *const h);
#endif #endif

110
libavcodec/intelh263dec.c
View File

@ -26,102 +26,102 @@
#include "h263dec.h" #include "h263dec.h"
/* don't understand why they choose a different header ! */ /* don't understand why they choose a different header ! */
int ff_intel_h263_decode_picture_header(MpegEncContext *s) int ff_intel_h263_decode_picture_header(H263DecContext *const h)
{ {
int format; int format;
if (get_bits_left(&s->gb) == 64) { /* special dummy frames */ if (get_bits_left(&h->c.gb) == 64) { /* special dummy frames */
return FRAME_SKIPPED; return FRAME_SKIPPED;
} }
/* picture header */ /* picture header */
if (get_bits(&s->gb, 22) != 0x20) { if (get_bits(&h->c.gb, 22) != 0x20) {
av_log(s->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;
} }
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ h->c.picture_number = get_bits(&h->c.gb, 8); /* picture timestamp */
if (check_marker(s->avctx, &s->gb, "after picture_number") != 1) { if (check_marker(h->c.avctx, &h->c.gb, "after picture_number") != 1) {
return -1; /* marker */ return -1; /* marker */
} }
if (get_bits1(&s->gb) != 0) { if (get_bits1(&h->c.gb) != 0) {
av_log(s->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(&s->gb); /* split screen off */ skip_bits1(&h->c.gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */ skip_bits1(&h->c.gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */ skip_bits1(&h->c.gb); /* freeze picture release off */
format = get_bits(&s->gb, 3); format = get_bits(&h->c.gb, 3);
if (format == 0 || format == 6) { if (format == 0 || format == 6) {
av_log(s->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;
} }
s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb); h->c.pict_type = AV_PICTURE_TYPE_I + get_bits1(&h->c.gb);
s->h263_long_vectors = get_bits1(&s->gb); h->c.h263_long_vectors = get_bits1(&h->c.gb);
if (get_bits1(&s->gb) != 0) { if (get_bits1(&h->c.gb) != 0) {
av_log(s->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 */
} }
s->obmc= get_bits1(&s->gb); h->c.obmc = get_bits1(&h->c.gb);
s->pb_frame = get_bits1(&s->gb); h->c.pb_frame = get_bits1(&h->c.gb);
if (format < 6) { if (format < 6) {
s->width = ff_h263_format[format][0]; h->c.width = ff_h263_format[format][0];
s->height = ff_h263_format[format][1]; h->c.height = ff_h263_format[format][1];
s->avctx->sample_aspect_ratio.num = 12; h->c.avctx->sample_aspect_ratio.num = 12;
s->avctx->sample_aspect_ratio.den = 11; h->c.avctx->sample_aspect_ratio.den = 11;
} else { } else {
format = get_bits(&s->gb, 3); format = get_bits(&h->c.gb, 3);
if(format == 0 || format == 7){ if(format == 0 || format == 7){
av_log(s->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(&s->gb, 2)) if (get_bits(&h->c.gb, 2))
av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
s->loop_filter = get_bits1(&s->gb) * !s->avctx->lowres; h->c.loop_filter = get_bits1(&h->c.gb) * !h->c.avctx->lowres;
if(get_bits1(&s->gb)) if (get_bits1(&h->c.gb))
av_log(s->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(&s->gb)) if (get_bits1(&h->c.gb))
s->pb_frame = 2; h->c.pb_frame = 2;
if(get_bits(&s->gb, 5)) if (get_bits(&h->c.gb, 5))
av_log(s->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(&s->gb, 5) != 1) if (get_bits(&h->c.gb, 5) != 1)
av_log(s->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(&s->gb, 4); int ar = get_bits(&h->c.gb, 4);
skip_bits(&s->gb, 9); // display width skip_bits(&h->c.gb, 9); // display width
check_marker(s->avctx, &s->gb, "in dimensions"); check_marker(h->c.avctx, &h->c.gb, "in dimensions");
skip_bits(&s->gb, 9); // display height skip_bits(&h->c.gb, 9); // display height
if(ar == 15){ if (ar == 15) {
s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 8); // aspect ratio - width h->c.avctx->sample_aspect_ratio.num = get_bits(&h->c.gb, 8); // aspect ratio - width
s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 8); // aspect ratio - height h->c.avctx->sample_aspect_ratio.den = get_bits(&h->c.gb, 8); // aspect ratio - height
} else { } else {
s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[ar]; h->c.avctx->sample_aspect_ratio = ff_h263_pixel_aspect[ar];
} }
if (s->avctx->sample_aspect_ratio.num == 0) if (h->c.avctx->sample_aspect_ratio.num == 0)
av_log(s->avctx, AV_LOG_ERROR, "Invalid aspect ratio.\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Invalid aspect ratio.\n");
} }
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5);
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ skip_bits1(&h->c.gb); /* Continuous Presence Multipoint mode: off */
if(s->pb_frame){ if (h->c.pb_frame) {
skip_bits(&s->gb, 3); //temporal reference for B-frame skip_bits(&h->c.gb, 3); //temporal reference for B-frame
skip_bits(&s->gb, 2); //dbquant skip_bits(&h->c.gb, 2); //dbquant
} }
/* PEI */ /* PEI */
if (skip_1stop_8data_bits(&s->gb) < 0) if (skip_1stop_8data_bits(&h->c.gb) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
s->gob_index = H263_GOB_HEIGHT(s->height); h->c.gob_index = H263_GOB_HEIGHT(h->c.height);
ff_h263_show_pict_info(s, 0); ff_h263_show_pict_info(h, 0);
return 0; return 0;
} }
@ -131,7 +131,7 @@ const FFCodec ff_h263i_decoder = {
CODEC_LONG_NAME("Intel H.263"), CODEC_LONG_NAME("Intel H.263"),
.p.type = AVMEDIA_TYPE_VIDEO, .p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_H263I, .p.id = AV_CODEC_ID_H263I,
.priv_data_size = sizeof(MpegEncContext), .priv_data_size = sizeof(H263DecContext),
.init = ff_h263_decode_init, .init = ff_h263_decode_init,
FF_CODEC_DECODE_CB(ff_h263_decode_frame), FF_CODEC_DECODE_CB(ff_h263_decode_frame),
.close = ff_mpv_decode_close, .close = ff_mpv_decode_close,

943
libavcodec/ituh263dec.c
View File

File diff suppressed because it is too large Load Diff

4
libavcodec/mpeg4video_parser.c
View File

@ -84,7 +84,7 @@ static int mpeg4_decode_header(AVCodecParserContext *s1, AVCodecContext *avctx,
{ {
struct Mp4vParseContext *pc = s1->priv_data; struct Mp4vParseContext *pc = s1->priv_data;
Mpeg4DecContext *dec_ctx = &pc->dec_ctx; Mpeg4DecContext *dec_ctx = &pc->dec_ctx;
MpegEncContext *s = &dec_ctx->m; MPVContext *const s = &dec_ctx->h.c;
GetBitContext gb1, *gb = &gb1; GetBitContext gb1, *gb = &gb1;
int ret; int ret;
@ -124,7 +124,7 @@ static av_cold int mpeg4video_parse_init(AVCodecParserContext *s)
pc->first_picture = 1; pc->first_picture = 1;
pc->dec_ctx.quant_precision = 5; pc->dec_ctx.quant_precision = 5;
pc->dec_ctx.m.slice_context_count = 1; pc->dec_ctx.h.c.slice_context_count = 1;
pc->dec_ctx.showed_packed_warning = 1; pc->dec_ctx.showed_packed_warning = 1;
return 0; return 0;
} }

1697
libavcodec/mpeg4videodec.c
View File

File diff suppressed because it is too large Load Diff

13
libavcodec/mpeg4videodec.h
View File

@ -26,13 +26,14 @@
#include <stdint.h> #include <stdint.h>
#include "get_bits.h" #include "get_bits.h"
#include "h263dec.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "mpeg4videodsp.h" #include "mpeg4videodsp.h"
#include "libavutil/mem_internal.h" #include "libavutil/mem_internal.h"
typedef struct Mpeg4DecContext { typedef struct Mpeg4DecContext {
MpegEncContext m; H263DecContext h;
int f_code; ///< forward MV resolution int f_code; ///< forward MV resolution
int b_code; ///< backward MV resolution for B-frames int b_code; ///< backward MV resolution for B-frames
@ -108,7 +109,7 @@ typedef struct Mpeg4DecContext {
int dct_precision; int dct_precision;
} Mpeg4DecContext; } Mpeg4DecContext;
int ff_mpeg4_decode_picture_header(MpegEncContext *s); int ff_mpeg4_decode_picture_header(H263DecContext *const h);
int ff_mpeg4_parse_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int ff_mpeg4_parse_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb,
int header, int parse_only); int header, int parse_only);
void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,
@ -117,11 +118,11 @@ void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb
void ff_mpeg4_mcsel_motion(MpegEncContext *s, void ff_mpeg4_mcsel_motion(MpegEncContext *s,
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
uint8_t *const *ref_picture); uint8_t *const *ref_picture);
int ff_mpeg4_decode_partitions(MPVContext *const s); int ff_mpeg4_decode_partitions(H263DecContext *const h);
int ff_mpeg4_decode_video_packet_header(MPVContext *const s); int ff_mpeg4_decode_video_packet_header(H263DecContext *const h);
int ff_mpeg4_decode_studio_slice_header(MPVContext *const s); int ff_mpeg4_decode_studio_slice_header(H263DecContext *const h);
void ff_mpeg4_workaround_bugs(AVCodecContext *avctx); void ff_mpeg4_workaround_bugs(AVCodecContext *avctx);
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, void ff_mpeg4_pred_ac(H263DecContext *const h, int16_t *block, int n,
int dir); int dir);
int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt); int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt);

1
libavcodec/mpegvideo.h
View File

@ -307,7 +307,6 @@ typedef struct MpegEncContext {
int first_field; ///< is 1 for the first field of a field picture 0 otherwise int first_field; ///< is 1 for the first field of a field picture 0 otherwise
int16_t (*block)[64]; int16_t (*block)[64];
int (*decode_mb)(struct MpegEncContext *s, int16_t block[12][64]); // used by some codecs to avoid a switch()
#define SLICE_OK 0 #define SLICE_OK 0
#define SLICE_ERROR -1 #define SLICE_ERROR -1

505
libavcodec/msmpeg4dec.c
View File

@ -74,23 +74,24 @@ static VLCElem v2_mb_type_vlc[128];
VLCElem ff_inter_intra_vlc[8]; VLCElem ff_inter_intra_vlc[8];
/* This is identical to H.263 except that its range is multiplied by 2. */ /* This is identical to H.263 except that its range is multiplied by 2. */
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) 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(&s->gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2); code = get_vlc2(&h->c.gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2);
ff_dlog(s->avctx, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred); ff_dlog(h->c.avctx, "MV code %d at %d %d pred: %d\n",
code, h->c.mb_x,h->c.mb_y, pred);
if (code < 0) if (code < 0)
return 0xffff; return 0xffff;
if (code == 0) if (code == 0)
return pred; return pred;
sign = get_bits1(&s->gb); sign = get_bits1(&h->c.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(&s->gb, shift); val |= get_bits(&h->c.gb, shift);
val++; val++;
} }
if (sign) if (sign)
@ -105,151 +106,155 @@ static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
return val; return val;
} }
static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64]) static int msmpeg4v12_decode_mb(H263DecContext *const h, int16_t block[6][64])
{ {
MSMP4DecContext *const ms = mpv_to_msmpeg4(s); MSMP4DecContext *const ms = mpv_to_msmpeg4(h);
int cbp, code, i; int cbp, code, i;
uint32_t * const mb_type_ptr = &s->cur_pic.mb_type[s->mb_x + s->mb_y*s->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 (s->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(&s->gb)) { if (get_bits1(&h->c.gb)) {
/* skip mb */ /* skip mb */
s->mb_intra = 0; h->c.mb_intra = 0;
for(i=0;i<6;i++) for(i=0;i<6;i++)
s->block_last_index[i] = -1; h->c.block_last_index[i] = -1;
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
s->mv[0][0][0] = 0; h->c.mv[0][0][0] = 0;
s->mv[0][0][1] = 0; h->c.mv[0][0][1] = 0;
s->mb_skipped = 1; h->c.mb_skipped = 1;
*mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16; *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
return 0; return 0;
} }
} }
if (s->msmpeg4_version == MSMP4_V2) if (h->c.msmpeg4_version == MSMP4_V2)
code = get_vlc2(&s->gb, v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 1); code = get_vlc2(&h->c.gb, v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 1);
else else
code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); code = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
if(code<0 || code>7){ if(code<0 || code>7){
av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y); av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n",
code, h->c.mb_x, h->c.mb_y);
return -1; return -1;
} }
s->mb_intra = code >>2; h->c.mb_intra = code >>2;
cbp = code & 0x3; cbp = code & 0x3;
} else { } else {
s->mb_intra = 1; h->c.mb_intra = 1;
if (s->msmpeg4_version == MSMP4_V2) if (h->c.msmpeg4_version == MSMP4_V2)
cbp = get_vlc2(&s->gb, v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 1); cbp = get_vlc2(&h->c.gb, v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 1);
else else
cbp = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); cbp = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
if(cbp<0 || cbp>3){ if(cbp<0 || cbp>3){
av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); av_log(h->c.avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n",
cbp, h->c.mb_x, h->c.mb_y);
return -1; return -1;
} }
} }
if (!s->mb_intra) { if (!h->c.mb_intra) {
int mx, my, cbpy; int mx, my, cbpy;
cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if(cbpy<0){ if(cbpy<0){
av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); av_log(h->c.avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n",
cbp, h->c.mb_x, h->c.mb_y);
return -1; return -1;
} }
cbp|= cbpy<<2; cbp|= cbpy<<2;
if (s->msmpeg4_version == MSMP4_V1 || (cbp&3) != 3) if (h->c.msmpeg4_version == MSMP4_V1 || (cbp&3) != 3)
cbp ^= 0x3C; cbp ^= 0x3C;
ff_h263_pred_motion(s, 0, 0, &mx, &my); ff_h263_pred_motion(&h->c, 0, 0, &mx, &my);
mx= msmpeg4v2_decode_motion(s, mx, 1); mx = msmpeg4v2_decode_motion(h, mx, 1);
my= msmpeg4v2_decode_motion(s, my, 1); my = msmpeg4v2_decode_motion(h, my, 1);
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
s->mv[0][0][0] = mx; h->c.mv[0][0][0] = mx;
s->mv[0][0][1] = my; h->c.mv[0][0][1] = my;
*mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16; *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
} else { } else {
int v; int v;
if (s->msmpeg4_version == MSMP4_V2) { if (h->c.msmpeg4_version == MSMP4_V2) {
s->ac_pred = get_bits1(&s->gb); h->c.ac_pred = get_bits1(&h->c.gb);
v = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); v = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (v < 0) { if (v < 0) {
av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
return -1; return -1;
} }
cbp|= v<<2; cbp|= v<<2;
} else{ } else{
s->ac_pred = 0; h->c.ac_pred = 0;
v = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); v = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
if (v < 0) { if (v < 0) {
av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); av_log(h->c.avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
return -1; return -1;
} }
cbp|= v<<2; cbp|= v<<2;
if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C; if (h->c.pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
} }
*mb_type_ptr = MB_TYPE_INTRA; *mb_type_ptr = MB_TYPE_INTRA;
} }
s->bdsp.clear_blocks(s->block[0]); h->c.bdsp.clear_blocks(h->c.block[0]);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
if (ff_msmpeg4_decode_block(ms, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) if (ff_msmpeg4_decode_block(ms, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
{ {
av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); av_log(h->c.avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n",
h->c.mb_x, h->c.mb_y, i);
return -1; return -1;
} }
} }
return 0; return 0;
} }
static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64]) static int msmpeg4v34_decode_mb(H263DecContext *const h, int16_t block[6][64])
{ {
MSMP4DecContext *const ms = mpv_to_msmpeg4(s); MSMP4DecContext *const ms = mpv_to_msmpeg4(h);
int cbp, code, i; int cbp, code, i;
uint8_t *coded_val; uint8_t *coded_val;
uint32_t * const mb_type_ptr = &s->cur_pic.mb_type[s->mb_x + s->mb_y*s->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(&s->gb) <= 0) if (get_bits_left(&h->c.gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (s->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(&s->gb)) { if (get_bits1(&h->c.gb)) {
/* skip mb */ /* skip mb */
s->mb_intra = 0; h->c.mb_intra = 0;
for(i=0;i<6;i++) for(i=0;i<6;i++)
s->block_last_index[i] = -1; h->c.block_last_index[i] = -1;
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
s->mv[0][0][0] = 0; h->c.mv[0][0][0] = 0;
s->mv[0][0][1] = 0; h->c.mv[0][0][1] = 0;
s->mb_skipped = 1; h->c.mb_skipped = 1;
*mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16; *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
return 0; return 0;
} }
} }
code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX], MB_NON_INTRA_VLC_BITS, 3); code = get_vlc2(&h->c.gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX], MB_NON_INTRA_VLC_BITS, 3);
//s->mb_intra = (code & 0x40) ? 0 : 1; //h->c.mb_intra = (code & 0x40) ? 0 : 1;
s->mb_intra = (~code & 0x40) >> 6; h->c.mb_intra = (~code & 0x40) >> 6;
cbp = code & 0x3f; cbp = code & 0x3f;
} else { } else {
s->mb_intra = 1; h->c.mb_intra = 1;
code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc, MSMP4_MB_INTRA_VLC_BITS, 2); code = get_vlc2(&h->c.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++) {
int val = ((code >> (5 - i)) & 1); int val = ((code >> (5 - i)) & 1);
if (i < 4) { if (i < 4) {
int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val); int pred = ff_msmpeg4_coded_block_pred(&h->c, i, &coded_val);
val = val ^ pred; val = val ^ pred;
*coded_val = val; *coded_val = val;
} }
@ -257,41 +262,42 @@ static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
} }
} }
if (!s->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(&s->gb); ms->rl_table_index = decode012(&h->c.gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }
ff_h263_pred_motion(s, 0, 0, &mx, &my); ff_h263_pred_motion(&h->c, 0, 0, &mx, &my);
ff_msmpeg4_decode_motion(ms, &mx, &my); ff_msmpeg4_decode_motion(ms, &mx, &my);
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
s->mv[0][0][0] = mx; h->c.mv[0][0][0] = mx;
s->mv[0][0][1] = my; h->c.mv[0][0][1] = my;
*mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16; *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
} else { } else {
ff_dlog(s->avctx, "I at %d %d %d %06X\n", s->mb_x, s->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(&s->gb, 24)); show_bits(&h->c.gb, 24));
s->ac_pred = get_bits1(&s->gb); h->c.ac_pred = get_bits1(&h->c.gb);
*mb_type_ptr = MB_TYPE_INTRA; *mb_type_ptr = MB_TYPE_INTRA;
if(s->inter_intra_pred){ if (h->c.inter_intra_pred) {
s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1); h->c.h263_aic_dir = get_vlc2(&h->c.gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1);
ff_dlog(s->avctx, "%d%d %d %d/", ff_dlog(h->c.avctx, "%d%d %d %d/",
s->ac_pred, s->h263_aic_dir, s->mb_x, s->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(&s->gb); ms->rl_table_index = decode012(&h->c.gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }
} }
s->bdsp.clear_blocks(s->block[0]); h->c.bdsp.clear_blocks(h->c.block[0]);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
if (ff_msmpeg4_decode_block(ms, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) if (ff_msmpeg4_decode_block(ms, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
{ {
av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); av_log(h->c.avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n",
h->c.mb_x, h->c.mb_y, i);
return -1; return -1;
} }
} }
@ -357,7 +363,7 @@ static av_cold void msmpeg4_decode_init_static(void)
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx) av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
{ {
static AVOnce init_static_once = AV_ONCE_INIT; static AVOnce init_static_once = AV_ONCE_INIT;
MpegEncContext *s = avctx->priv_data; H263DecContext *const h = avctx->priv_data;
int ret; int ret;
if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0) if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
@ -367,18 +373,18 @@ av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
return -1; return -1;
// We unquantize inter blocks as we parse them. // We unquantize inter blocks as we parse them.
s->dct_unquantize_inter = NULL; h->c.dct_unquantize_inter = NULL;
ff_msmpeg4_common_init(s); ff_msmpeg4_common_init(&h->c);
switch (s->msmpeg4_version) { switch (h->c.msmpeg4_version) {
case MSMP4_V1: case MSMP4_V1:
case MSMP4_V2: case MSMP4_V2:
s->decode_mb= msmpeg4v12_decode_mb; h->decode_mb = msmpeg4v12_decode_mb;
break; break;
case MSMP4_V3: case MSMP4_V3:
case MSMP4_WMV1: case MSMP4_WMV1:
s->decode_mb= msmpeg4v34_decode_mb; h->decode_mb = msmpeg4v34_decode_mb;
break; break;
case MSMP4_WMV2: case MSMP4_WMV2:
break; break;
@ -386,16 +392,16 @@ av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
av_unreachable("List contains all cases using ff_msmpeg4_decode_init()"); av_unreachable("List contains all cases using ff_msmpeg4_decode_init()");
} }
s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe h->c.slice_height = h->c.mb_height; //to avoid 1/0 if the first frame is not a keyframe
ff_thread_once(&init_static_once, msmpeg4_decode_init_static); ff_thread_once(&init_static_once, msmpeg4_decode_init_static);
return 0; return 0;
} }
int ff_msmpeg4_decode_picture_header(MpegEncContext * s) int ff_msmpeg4_decode_picture_header(H263DecContext *const h)
{ {
MSMP4DecContext *const ms = mpv_to_msmpeg4(s); MSMP4DecContext *const ms = mpv_to_msmpeg4(h);
int code; int code;
// 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,
@ -403,51 +409,51 @@ int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
// 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(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16)) if (get_bits_left(&h->c.gb) * 8LL < (h->c.width+15)/16 * ((h->c.height+15)/16))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (s->msmpeg4_version == MSMP4_V1) { if (h->c.msmpeg4_version == MSMP4_V1) {
int start_code = get_bits_long(&s->gb, 32); int start_code = get_bits_long(&h->c.gb, 32);
if(start_code!=0x00000100){ if(start_code!=0x00000100){
av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n"); av_log(h->c.avctx, AV_LOG_ERROR, "invalid startcode\n");
return -1; return -1;
} }
skip_bits(&s->gb, 5); // frame number */ skip_bits(&h->c.gb, 5); // frame number */
} }
s->pict_type = get_bits(&s->gb, 2) + 1; h->c.pict_type = get_bits(&h->c.gb, 2) + 1;
if (s->pict_type != AV_PICTURE_TYPE_I && if (h->c.pict_type != AV_PICTURE_TYPE_I &&
s->pict_type != AV_PICTURE_TYPE_P){ h->c.pict_type != AV_PICTURE_TYPE_P){
av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n"); av_log(h->c.avctx, AV_LOG_ERROR, "invalid picture type\n");
return -1; return -1;
} }
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5);
if(s->qscale==0){ if (h->c.qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n"); av_log(h->c.avctx, AV_LOG_ERROR, "invalid qscale\n");
return -1; return -1;
} }
if (s->pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
code = get_bits(&s->gb, 5); code = get_bits(&h->c.gb, 5);
if (s->msmpeg4_version == MSMP4_V1) { if (h->c.msmpeg4_version == MSMP4_V1) {
if(code==0 || code>s->mb_height){ if(code==0 || code>h->c.mb_height) {
av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); av_log(h->c.avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
return -1; return -1;
} }
s->slice_height = code; h->c.slice_height = code;
}else{ }else{
/* 0x17: one slice, 0x18: two slices, ... */ /* 0x17: one slice, 0x18: two slices, ... */
if (code < 0x17){ if (code < 0x17){
av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code); av_log(h->c.avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
return -1; return -1;
} }
s->slice_height = s->mb_height / (code - 0x16); h->c.slice_height = h->c.mb_height / (code - 0x16);
} }
switch(s->msmpeg4_version){ switch (h->c.msmpeg4_version) {
case MSMP4_V1: case MSMP4_V1:
case MSMP4_V2: case MSMP4_V2:
ms->rl_chroma_table_index = 2; ms->rl_chroma_table_index = 2;
@ -456,102 +462,102 @@ int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
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(&s->gb); ms->rl_chroma_table_index = decode012(&h->c.gb);
ms->rl_table_index = decode012(&s->gb); ms->rl_table_index = decode012(&h->c.gb);
ms->dc_table_index = get_bits1(&s->gb); ms->dc_table_index = get_bits1(&h->c.gb);
break; break;
case MSMP4_WMV1: case MSMP4_WMV1:
ff_msmpeg4_decode_ext_header(s, (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(&s->gb); ms->per_mb_rl_table = get_bits1(&h->c.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(&s->gb); ms->rl_chroma_table_index = decode012(&h->c.gb);
ms->rl_table_index = decode012(&s->gb); ms->rl_table_index = decode012(&h->c.gb);
} }
ms->dc_table_index = get_bits1(&s->gb); ms->dc_table_index = get_bits1(&h->c.gb);
s->inter_intra_pred= 0; h->c.inter_intra_pred= 0;
break; break;
default: default:
av_unreachable("ff_msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1"); av_unreachable("ff_msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1");
} }
s->no_rounding = 1; h->c.no_rounding = 1;
if(s->avctx->debug&FF_DEBUG_PICT_INFO) if (h->c.avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n", av_log(h->c.avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
s->qscale, h->c.qscale,
ms->rl_chroma_table_index, ms->rl_chroma_table_index,
ms->rl_table_index, ms->rl_table_index,
ms->dc_table_index, ms->dc_table_index,
ms->per_mb_rl_table, ms->per_mb_rl_table,
s->slice_height); h->c.slice_height);
} else { } else {
switch(s->msmpeg4_version){ switch (h->c.msmpeg4_version) {
case MSMP4_V1: case MSMP4_V1:
case MSMP4_V2: case MSMP4_V2:
if (s->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(&s->gb); ms->use_skip_mb_code = get_bits1(&h->c.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(&s->gb); ms->use_skip_mb_code = get_bits1(&h->c.gb);
ms->rl_table_index = decode012(&s->gb); ms->rl_table_index = decode012(&h->c.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(&s->gb); ms->dc_table_index = get_bits1(&h->c.gb);
ms->mv_table_index = get_bits1(&s->gb); ms->mv_table_index = get_bits1(&h->c.gb);
break; break;
case MSMP4_WMV1: case MSMP4_WMV1:
ms->use_skip_mb_code = get_bits1(&s->gb); ms->use_skip_mb_code = get_bits1(&h->c.gb);
if (ms->bit_rate > MBAC_BITRATE) if (ms->bit_rate > MBAC_BITRATE)
ms->per_mb_rl_table = get_bits1(&s->gb); ms->per_mb_rl_table = get_bits1(&h->c.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(&s->gb); ms->rl_table_index = decode012(&h->c.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(&s->gb); ms->dc_table_index = get_bits1(&h->c.gb);
ms->mv_table_index = get_bits1(&s->gb); ms->mv_table_index = get_bits1(&h->c.gb);
s->inter_intra_pred = s->width*s->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;
default: default:
av_unreachable("ff_msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1"); av_unreachable("ff_msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1");
} }
if(s->avctx->debug&FF_DEBUG_PICT_INFO) if (h->c.avctx->debug&FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n", av_log(h->c.avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
ms->use_skip_mb_code, ms->use_skip_mb_code,
ms->rl_table_index, ms->rl_table_index,
ms->rl_chroma_table_index, ms->rl_chroma_table_index,
ms->dc_table_index, ms->dc_table_index,
ms->mv_table_index, ms->mv_table_index,
ms->per_mb_rl_table, ms->per_mb_rl_table,
s->qscale); h->c.qscale);
if (ms->flipflop_rounding) { if (ms->flipflop_rounding) {
s->no_rounding ^= 1; h->c.no_rounding ^= 1;
}else{ }else{
s->no_rounding = 0; h->c.no_rounding = 0;
} }
} }
ff_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, ms->bit_rate, ff_dlog(h->c.avctx, "%d %d %d %d %d\n", h->c.pict_type, ms->bit_rate,
s->inter_intra_pred, s->width, s->height); h->c.inter_intra_pred, h->c.width, h->c.height);
ms->esc3_level_length = 0; ms->esc3_level_length = 0;
ms->esc3_run_length = 0; ms->esc3_run_length = 0;
@ -559,30 +565,30 @@ int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
return 0; return 0;
} }
int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) int ff_msmpeg4_decode_ext_header(H263DecContext *const h, int buf_size)
{ {
MSMP4DecContext *const ms = mpv_to_msmpeg4(s); MSMP4DecContext *const ms = mpv_to_msmpeg4(h);
int left= buf_size*8 - get_bits_count(&s->gb); int left= buf_size*8 - get_bits_count(&h->c.gb);
int length = s->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(&s->gb, 5); /* fps */ skip_bits(&h->c.gb, 5); /* fps */
ms->bit_rate = get_bits(&s->gb, 11) * 1024; ms->bit_rate = get_bits(&h->c.gb, 11) * 1024;
if (s->msmpeg4_version >= MSMP4_V3) if (h->c.msmpeg4_version >= MSMP4_V3)
ms->flipflop_rounding = get_bits1(&s->gb); ms->flipflop_rounding = get_bits1(&h->c.gb);
else else
ms->flipflop_rounding = 0; ms->flipflop_rounding = 0;
} }
else if(left<length+8) else if(left<length+8)
{ {
ms->flipflop_rounding = 0; ms->flipflop_rounding = 0;
if (s->msmpeg4_version != MSMP4_V2) if (h->c.msmpeg4_version != MSMP4_V2)
av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); av_log(h->c.avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
} }
else else
{ {
av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n"); av_log(h->c.avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
} }
return 0; return 0;
@ -590,52 +596,52 @@ int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
static int msmpeg4_decode_dc(MSMP4DecContext *const ms, int n, int *dir_ptr) static int msmpeg4_decode_dc(MSMP4DecContext *const ms, int n, int *dir_ptr)
{ {
MpegEncContext *const s = &ms->m; H263DecContext *const h = &ms->h;
int level, pred; int level, pred;
if (s->msmpeg4_version <= MSMP4_V2) { if (h->c.msmpeg4_version <= MSMP4_V2) {
if (n < 4) { if (n < 4) {
level = get_vlc2(&s->gb, v2_dc_lum_vlc, MSMP4_DC_VLC_BITS, 3); level = get_vlc2(&h->c.gb, v2_dc_lum_vlc, MSMP4_DC_VLC_BITS, 3);
} else { } else {
level = get_vlc2(&s->gb, v2_dc_chroma_vlc, MSMP4_DC_VLC_BITS, 3); level = get_vlc2(&h->c.gb, v2_dc_chroma_vlc, MSMP4_DC_VLC_BITS, 3);
} }
if (level < 0) { if (level < 0) {
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n");
*dir_ptr = 0; *dir_ptr = 0;
return -1; return -1;
} }
level-=256; level-=256;
} else { } else {
level = get_vlc2(&s->gb, ff_msmp4_dc_vlc[ms->dc_table_index][n >= 4], level = get_vlc2(&h->c.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(&s->gb, 8); level = get_bits(&h->c.gb, 8);
if (get_bits1(&s->gb)) if (get_bits1(&h->c.gb))
level = -level; level = -level;
} else if (level != 0) { } else if (level != 0) {
if (get_bits1(&s->gb)) if (get_bits1(&h->c.gb))
level = -level; level = -level;
} }
} }
if (s->msmpeg4_version == MSMP4_V1) { if (h->c.msmpeg4_version == MSMP4_V1) {
int32_t *dc_val; int32_t *dc_val;
pred = msmpeg4v1_pred_dc(s, n, &dc_val); pred = msmpeg4v1_pred_dc(&h->c, n, &dc_val);
level += pred; level += pred;
/* update predictor */ /* update predictor */
*dc_val= level; *dc_val= level;
}else{ }else{
int16_t *dc_val; int16_t *dc_val;
pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); pred = ff_msmpeg4_pred_dc(&h->c, n, &dc_val, dir_ptr);
level += pred; level += pred;
/* update predictor */ /* update predictor */
if (n < 4) { if (n < 4) {
*dc_val = level * s->y_dc_scale; *dc_val = level * h->c.y_dc_scale;
} else { } else {
*dc_val = level * s->c_dc_scale; *dc_val = level * h->c.c_dc_scale;
} }
} }
@ -645,14 +651,14 @@ static int msmpeg4_decode_dc(MSMP4DecContext *const ms, int n, int *dir_ptr)
int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block, int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block,
int n, int coded, const uint8_t *scan_table) int n, int coded, const uint8_t *scan_table)
{ {
MpegEncContext *const s = &ms->m; H263DecContext *const h = &ms->h;
int level, i, last, run, run_diff; int level, i, last, run, run_diff;
int dc_pred_dir = -1; //unused but its passed around, so it needs to be initialized int dc_pred_dir = -1; //unused but its passed around, so it needs to be initialized
const RLTable *rl; const RLTable *rl;
const RL_VLC_ELEM *rl_vlc; const RL_VLC_ELEM *rl_vlc;
int qmul, qadd; int qmul, qadd;
if (s->mb_intra) { if (h->c.mb_intra) {
qmul=1; qmul=1;
qadd=0; qadd=0;
@ -660,110 +666,113 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block,
level = msmpeg4_decode_dc(ms, n, &dc_pred_dir); level = msmpeg4_decode_dc(ms, n, &dc_pred_dir);
if (level < 0){ if (level < 0){
av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale); av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, h->c.qscale);
if(s->inter_intra_pred) level=0; if (h->c.inter_intra_pred)
level = 0;
} }
if (n < 4) { if (n < 4) {
rl = &ff_rl_table[ms->rl_table_index]; rl = &ff_rl_table[ms->rl_table_index];
if(level > 256*s->y_dc_scale){ if (level > 256 * h->c.y_dc_scale) {
av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale); av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", h->c.qscale);
if(!s->inter_intra_pred) return -1; if (!h->c.inter_intra_pred)
return -1;
} }
} else { } else {
rl = &ff_rl_table[3 + ms->rl_chroma_table_index]; rl = &ff_rl_table[3 + ms->rl_chroma_table_index];
if(level > 256*s->c_dc_scale){ if (level > 256 * h->c.c_dc_scale) {
av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale); av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", h->c.qscale);
if(!s->inter_intra_pred) return -1; if (!h->c.inter_intra_pred)
return -1;
} }
} }
block[0] = level; block[0] = level;
run_diff = s->msmpeg4_version >= MSMP4_WMV1; run_diff = h->c.msmpeg4_version >= MSMP4_WMV1;
i = 0; i = 0;
if (!coded) { if (!coded) {
goto not_coded; goto not_coded;
} }
if (s->ac_pred) { if (h->c.ac_pred) {
if (dc_pred_dir == 0) if (dc_pred_dir == 0)
scan_table = s->permutated_intra_v_scantable; /* left */ scan_table = h->c.permutated_intra_v_scantable; /* left */
else else
scan_table = s->permutated_intra_h_scantable; /* top */ scan_table = h->c.permutated_intra_h_scantable; /* top */
} else { } else {
scan_table = s->intra_scantable.permutated; scan_table = h->c.intra_scantable.permutated;
} }
rl_vlc= rl->rl_vlc[0]; rl_vlc= rl->rl_vlc[0];
} else { } else {
qmul = s->qscale << 1; qmul = h->c.qscale << 1;
qadd = (s->qscale - 1) | 1; qadd = (h->c.qscale - 1) | 1;
i = -1; i = -1;
rl = &ff_rl_table[3 + ms->rl_table_index]; rl = &ff_rl_table[3 + ms->rl_table_index];
if (s->msmpeg4_version == MSMP4_V2) if (h->c.msmpeg4_version == MSMP4_V2)
run_diff = 0; run_diff = 0;
else else
run_diff = 1; run_diff = 1;
if (!coded) { if (!coded) {
s->block_last_index[n] = i; h->c.block_last_index[n] = i;
return 0; return 0;
} }
if(!scan_table) if(!scan_table)
scan_table = s->inter_scantable.permutated; scan_table = h->c.inter_scantable.permutated;
rl_vlc= rl->rl_vlc[s->qscale]; rl_vlc= rl->rl_vlc[h->c.qscale];
} }
{ {
OPEN_READER(re, &s->gb); OPEN_READER(re, &h->c.gb);
for(;;) { for(;;) {
UPDATE_CACHE(re, &s->gb); UPDATE_CACHE(re, &h->c.gb);
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 0);
if (level==0) { if (level==0) {
int cache; int cache;
cache= GET_CACHE(re, &s->gb); cache= GET_CACHE(re, &h->c.gb);
/* escape */ /* escape */
if (s->msmpeg4_version == MSMP4_V1 || (cache&0x80000000)==0) { if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x80000000)==0) {
if (s->msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) { if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) {
/* third escape */ /* third escape */
if (s->msmpeg4_version != MSMP4_V1) if (h->c.msmpeg4_version != MSMP4_V1)
LAST_SKIP_BITS(re, &s->gb, 2); LAST_SKIP_BITS(re, &h->c.gb, 2);
UPDATE_CACHE(re, &s->gb); UPDATE_CACHE(re, &h->c.gb);
if (s->msmpeg4_version <= MSMP4_V3) { if (h->c.msmpeg4_version <= MSMP4_V3) {
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); last = SHOW_UBITS(re, &h->c.gb, 1); SKIP_CACHE(re, &h->c.gb, 1);
run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6); run = SHOW_UBITS(re, &h->c.gb, 6); SKIP_CACHE(re, &h->c.gb, 6);
level= SHOW_SBITS(re, &s->gb, 8); level = SHOW_SBITS(re, &h->c.gb, 8);
SKIP_COUNTER(re, &s->gb, 1+6+8); SKIP_COUNTER(re, &h->c.gb, 1 + 6 + 8);
}else{ }else{
int sign; int sign;
last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); last = SHOW_UBITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->c.gb, 1);
if (!ms->esc3_level_length) { if (!ms->esc3_level_length) {
int ll; int ll;
ff_dlog(s->avctx, "ESC-3 %X at %d %d\n", ff_dlog(h->c.avctx, "ESC-3 %X at %d %d\n",
show_bits(&s->gb, 24), s->mb_x, s->mb_y); show_bits(&h->c.gb, 24), h->c.mb_x, h->c.mb_y);
if(s->qscale<8){ if (h->c.qscale < 8) {
ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3); ll = SHOW_UBITS(re, &h->c.gb, 3); SKIP_BITS(re, &h->c.gb, 3);
if(ll==0){ if(ll==0){
ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); ll = 8+SHOW_UBITS(re, &h->c.gb, 1); SKIP_BITS(re, &h->c.gb, 1);
} }
}else{ }else{
ll=2; ll=2;
while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){ while (ll < 8 && SHOW_UBITS(re, &h->c.gb, 1) == 0) {
ll++; ll++;
SKIP_BITS(re, &s->gb, 1); SKIP_BITS(re, &h->c.gb, 1);
} }
if(ll<8) SKIP_BITS(re, &s->gb, 1); if (ll<8) SKIP_BITS(re, &h->c.gb, 1);
} }
ms->esc3_level_length = ll; ms->esc3_level_length = ll;
ms->esc3_run_length = SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2); ms->esc3_run_length = SHOW_UBITS(re, &h->c.gb, 2) + 3; SKIP_BITS(re, &h->c.gb, 2);
UPDATE_CACHE(re, &s->gb); UPDATE_CACHE(re, &h->c.gb);
} }
run = SHOW_UBITS(re, &s->gb, ms->esc3_run_length); run = SHOW_UBITS(re, &h->c.gb, ms->esc3_run_length);
SKIP_BITS(re, &s->gb, ms->esc3_run_length); SKIP_BITS(re, &h->c.gb, ms->esc3_run_length);
sign= SHOW_UBITS(re, &s->gb, 1); sign= SHOW_UBITS(re, &h->c.gb, 1);
SKIP_BITS(re, &s->gb, 1); SKIP_BITS(re, &h->c.gb, 1);
level = SHOW_UBITS(re, &s->gb, ms->esc3_level_length); level = SHOW_UBITS(re, &h->c.gb, ms->esc3_level_length);
SKIP_BITS(re, &s->gb, ms->esc3_level_length); SKIP_BITS(re, &h->c.gb, ms->esc3_level_length);
if(sign) level= -level; if(sign) level= -level;
} }
@ -774,38 +783,40 @@ 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, &s->gb, 2); SKIP_BITS(re, &h->c.gb, 2);
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); GET_RL_VLC(level, run, re, &h->c.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, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1); LAST_SKIP_BITS(re, &h->c.gb, 1);
} }
} else { } else {
/* first escape */ /* first escape */
SKIP_BITS(re, &s->gb, 1); SKIP_BITS(re, &h->c.gb, 1);
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); GET_RL_VLC(level, run, re, &h->c.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, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1); LAST_SKIP_BITS(re, &h->c.gb, 1);
} }
} else { } else {
i+= run; i+= run;
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1); LAST_SKIP_BITS(re, &h->c.gb, 1);
} }
if (i > 62){ if (i > 62){
i-= 192; i-= 192;
if(i&(~63)){ if(i&(~63)){
const int left= get_bits_left(&s->gb); const int left = get_bits_left(&h->c.gb);
if (((i + 192 == 64 && level / qmul == -1) || if (((i + 192 == 64 && level / qmul == -1) ||
!(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && !(h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
left >= 0) { left >= 0) {
av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y); av_log(h->c.avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n",
h->c.mb_x, h->c.mb_y);
i = 63; i = 63;
break; break;
}else{ }else{
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); av_log(h->c.avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",
h->c.mb_x, h->c.mb_y);
return -1; return -1;
} }
} }
@ -816,13 +827,13 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block,
block[scan_table[i]] = level; block[scan_table[i]] = level;
} }
CLOSE_READER(re, &s->gb); CLOSE_READER(re, &h->c.gb);
} }
if (s->mb_intra) { if (h->c.mb_intra) {
not_coded: not_coded:
ff_mpeg4_pred_ac(s, block, n, dc_pred_dir); ff_mpeg4_pred_ac(h, block, n, dc_pred_dir);
} }
s->block_last_index[n] = i; h->c.block_last_index[n] = i;
return 0; return 0;
} }
@ -830,17 +841,17 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block,
void ff_msmpeg4_decode_motion(MSMP4DecContext *const ms, int *mx_ptr, int *my_ptr) void ff_msmpeg4_decode_motion(MSMP4DecContext *const ms, int *mx_ptr, int *my_ptr)
{ {
const VLCElem *const mv_vlc = mv_tables[ms->mv_table_index]; const VLCElem *const mv_vlc = mv_tables[ms->mv_table_index];
MpegEncContext *const s = &ms->m; H263DecContext *const h = &ms->h;
int sym, mx, my; int sym, mx, my;
sym = get_vlc2(&s->gb, mv_vlc, MV_VLC_BITS, 2); sym = get_vlc2(&h->c.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(&s->gb, 6); mx = get_bits(&h->c.gb, 6);
my = get_bits(&s->gb, 6); my = get_bits(&h->c.gb, 6);
} }
mx += *mx_ptr - 32; mx += *mx_ptr - 32;

11
libavcodec/msmpeg4dec.h
View File

@ -23,13 +23,14 @@
#define AVCODEC_MSMPEG4DEC_H #define AVCODEC_MSMPEG4DEC_H
#include "avcodec.h" #include "avcodec.h"
#include "h263dec.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#define INTER_INTRA_VLC_BITS 3 #define INTER_INTRA_VLC_BITS 3
#define MB_NON_INTRA_VLC_BITS 9 #define MB_NON_INTRA_VLC_BITS 9
typedef struct MSMP4DecContext { typedef struct MSMP4DecContext {
MpegEncContext m; H263DecContext h;
int bit_rate; int bit_rate;
int flipflop_rounding; int flipflop_rounding;
int mv_table_index; int mv_table_index;
@ -42,18 +43,18 @@ typedef struct MSMP4DecContext {
int esc3_run_length; int esc3_run_length;
} MSMP4DecContext; } MSMP4DecContext;
static inline MSMP4DecContext *mpv_to_msmpeg4(MpegEncContext *s) static inline MSMP4DecContext *mpv_to_msmpeg4(H263DecContext *const h)
{ {
// Only legal because no MSMPEG-4 decoder uses slice-threading. // Only legal because no MSMPEG-4 decoder uses slice-threading.
return (MSMP4DecContext*)s; return (MSMP4DecContext*)h;
} }
extern const VLCElem *ff_mb_non_intra_vlc[4]; extern const VLCElem *ff_mb_non_intra_vlc[4];
extern VLCElem ff_inter_intra_vlc[8]; extern VLCElem ff_inter_intra_vlc[8];
int ff_msmpeg4_decode_init(AVCodecContext *avctx); int ff_msmpeg4_decode_init(AVCodecContext *avctx);
int ff_msmpeg4_decode_picture_header(MpegEncContext *s); int ff_msmpeg4_decode_picture_header(H263DecContext *const h);
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size); int ff_msmpeg4_decode_ext_header(H263DecContext *const h, int buf_size);
void ff_msmpeg4_decode_motion(MSMP4DecContext *ms, int *mx_ptr, int *my_ptr); void ff_msmpeg4_decode_motion(MSMP4DecContext *ms, int *mx_ptr, int *my_ptr);
int ff_msmpeg4_decode_block(MSMP4DecContext *ms, int16_t * block, int ff_msmpeg4_decode_block(MSMP4DecContext *ms, int16_t * block,
int n, int coded, const uint8_t *scan_table); int n, int coded, const uint8_t *scan_table);

2
libavcodec/nvdec_mpeg4.c
View File

@ -33,7 +33,7 @@ static int nvdec_mpeg4_start_frame(AVCodecContext *avctx,
const uint8_t *buffer, uint32_t size) const uint8_t *buffer, uint32_t size)
{ {
Mpeg4DecContext *m = avctx->priv_data; Mpeg4DecContext *m = avctx->priv_data;
MpegEncContext *s = &m->m; MPVContext *const s = &m->h.c;
NVDECContext *ctx = avctx->internal->hwaccel_priv_data; NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
CUVIDPICPARAMS *pp = &ctx->pic_params; CUVIDPICPARAMS *pp = &ctx->pic_params;

338
libavcodec/rv10.c
View File

@ -52,7 +52,7 @@
#define DC_VLC_BITS 9 #define DC_VLC_BITS 9
typedef struct RVDecContext { typedef struct RVDecContext {
MpegEncContext m; H263DecContext h;
int sub_id; int sub_id;
int orig_width, orig_height; int orig_width, orig_height;
} RVDecContext; } RVDecContext;
@ -80,16 +80,16 @@ static const uint16_t rv_chrom_len_count[15] = {
static VLCElem rv_dc_lum[1472], rv_dc_chrom[992]; static VLCElem rv_dc_lum[1472], rv_dc_chrom[992];
int ff_rv_decode_dc(MpegEncContext *s, int n) int ff_rv_decode_dc(H263DecContext *const h, int n)
{ {
int code; int code;
if (n < 4) { if (n < 4) {
code = get_vlc2(&s->gb, rv_dc_lum, DC_VLC_BITS, 2); code = get_vlc2(&h->c.gb, rv_dc_lum, DC_VLC_BITS, 2);
} else { } else {
code = get_vlc2(&s->gb, rv_dc_chrom, DC_VLC_BITS, 2); code = get_vlc2(&h->c.gb, rv_dc_chrom, DC_VLC_BITS, 2);
if (code < 0) { if (code < 0) {
av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n"); av_log(h->c.avctx, AV_LOG_ERROR, "chroma dc error\n");
return -1; return -1;
} }
} }
@ -97,59 +97,59 @@ int ff_rv_decode_dc(MpegEncContext *s, int n)
} }
/* read RV 1.0 compatible frame header */ /* read RV 1.0 compatible frame header */
static int rv10_decode_picture_header(MpegEncContext *s) 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(&s->gb); marker = get_bits1(&h->c.gb);
if (get_bits1(&s->gb)) if (get_bits1(&h->c.gb))
s->pict_type = AV_PICTURE_TYPE_P; h->c.pict_type = AV_PICTURE_TYPE_P;
else else
s->pict_type = AV_PICTURE_TYPE_I; h->c.pict_type = AV_PICTURE_TYPE_I;
if (!marker) if (!marker)
av_log(s->avctx, AV_LOG_ERROR, "marker missing\n"); av_log(h->c.avctx, AV_LOG_ERROR, "marker missing\n");
pb_frame = get_bits1(&s->gb); pb_frame = get_bits1(&h->c.gb);
ff_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame); ff_dlog(h->c.avctx, "pict_type=%d pb_frame=%d\n", h->c.pict_type, pb_frame);
if (pb_frame) { if (pb_frame) {
avpriv_request_sample(s->avctx, "PB-frame"); avpriv_request_sample(h->c.avctx, "PB-frame");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
s->qscale = get_bits(&s->gb, 5); h->c.qscale = get_bits(&h->c.gb, 5);
if (s->qscale == 0) { if (h->c.qscale == 0) {
av_log(s->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 (s->pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
if (s->rv10_version == 3) { if (h->c.rv10_version == 3) {
/* specific MPEG like DC coding not used */ /* specific MPEG like DC coding not used */
s->last_dc[0] = get_bits(&s->gb, 8); h->c.last_dc[0] = get_bits(&h->c.gb, 8);
s->last_dc[1] = get_bits(&s->gb, 8); h->c.last_dc[1] = get_bits(&h->c.gb, 8);
s->last_dc[2] = get_bits(&s->gb, 8); h->c.last_dc[2] = get_bits(&h->c.gb, 8);
ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0], ff_dlog(h->c.avctx, "DC:%d %d %d\n", h->c.last_dc[0],
s->last_dc[1], s->last_dc[2]); h->c.last_dc[1], h->c.last_dc[2]);
} }
} }
/* if multiple packets per frame are sent, the position at which /* if multiple packets per frame are sent, the position at which
* to display the macroblocks is coded here */ * to display the macroblocks is coded here */
mb_xy = s->mb_x + s->mb_y * s->mb_width; mb_xy = h->c.mb_x + h->c.mb_y * h->c.mb_width;
if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) { if (show_bits(&h->c.gb, 12) == 0 || (mb_xy && mb_xy < h->c.mb_num)) {
s->mb_x = get_bits(&s->gb, 6); /* mb_x */ h->c.mb_x = get_bits(&h->c.gb, 6); /* mb_x */
s->mb_y = get_bits(&s->gb, 6); /* mb_y */ h->c.mb_y = get_bits(&h->c.gb, 6); /* mb_y */
mb_count = get_bits(&s->gb, 12); mb_count = get_bits(&h->c.gb, 12);
} else { } else {
s->mb_x = 0; h->c.mb_x = 0;
s->mb_y = 0; h->c.mb_y = 0;
mb_count = s->mb_width * s->mb_height; mb_count = h->c.mb_width * h->c.mb_height;
} }
skip_bits(&s->gb, 3); /* ignored */ skip_bits(&h->c.gb, 3); /* ignored */
return mb_count; return mb_count;
} }
@ -159,151 +159,151 @@ static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)
static const enum AVPictureType pict_types[] = static const enum AVPictureType pict_types[] =
{ AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_I /* hmm ... */, { AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_I /* hmm ... */,
AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B }; AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B };
MpegEncContext *s = &rv->m; H263DecContext *const h = &rv->h;
int seq, mb_pos, ret; int seq, mb_pos, ret;
int rpr_max; int rpr_max;
s->pict_type = pict_types[get_bits(&s->gb, 2)]; h->c.pict_type = pict_types[get_bits(&h->c.gb, 2)];
if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) { if (h->c.low_delay && h->c.pict_type == AV_PICTURE_TYPE_B) {
av_log(s->avctx, AV_LOG_ERROR, "low delay B\n"); av_log(h->c.avctx, AV_LOG_ERROR, "low delay B\n");
return -1; return -1;
} }
if (!s->last_pic.ptr && s->pict_type == AV_PICTURE_TYPE_B) { if (!h->c.last_pic.ptr && h->c.pict_type == AV_PICTURE_TYPE_B) {
av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n"); av_log(h->c.avctx, AV_LOG_ERROR, "early B-frame\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (get_bits1(&s->gb)) { if (get_bits1(&h->c.gb)) {
av_log(s->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;
} }
s->qscale = get_bits(&s->gb, 5); h->c.qscale = get_bits(&h->c.gb, 5);
if (s->qscale == 0) { if (h->c.qscale == 0) {
av_log(s->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)
s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres; h->c.loop_filter = get_bits1(&h->c.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(&s->gb, 8) << 7; seq = get_bits(&h->c.gb, 8) << 7;
else else
seq = get_bits(&s->gb, 13) << 2; seq = get_bits(&h->c.gb, 13) << 2;
rpr_max = s->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(&s->gb, rpr_bits); f = get_bits(&h->c.gb, rpr_bits);
if (f) { if (f) {
if (s->avctx->extradata_size < 8 + 2 * f) { if (h->c.avctx->extradata_size < 8 + 2 * f) {
av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Extradata too small.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
new_w = 4 * s->avctx->extradata[6 + 2 * f]; new_w = 4 * h->c.avctx->extradata[6 + 2 * f];
new_h = 4 * s->avctx->extradata[7 + 2 * f]; new_h = 4 * h->c.avctx->extradata[7 + 2 * f];
} else { } else {
new_w = rv->orig_width; new_w = rv->orig_width;
new_h = rv->orig_height; new_h = rv->orig_height;
} }
if (new_w != s->width || new_h != s->height || !s->context_initialized) { if (new_w != h->c.width || new_h != h->c.height || !h->c.context_initialized) {
AVRational old_aspect = s->avctx->sample_aspect_ratio; AVRational old_aspect = h->c.avctx->sample_aspect_ratio;
av_log(s->avctx, AV_LOG_DEBUG, av_log(h->c.avctx, AV_LOG_DEBUG,
"attempting to change resolution to %dx%d\n", new_w, new_h); "attempting to change resolution to %dx%d\n", new_w, new_h);
if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0) if (av_image_check_size(new_w, new_h, 0, h->c.avctx) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (whole_size < (new_w + 15)/16 * ((new_h + 15)/16) / 8) if (whole_size < (new_w + 15)/16 * ((new_h + 15)/16) / 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ff_mpv_common_end(s); ff_mpv_common_end(&h->c);
// attempt to keep aspect during typical resolution switches // attempt to keep aspect during typical resolution switches
if (!old_aspect.num) if (!old_aspect.num)
old_aspect = (AVRational){1, 1}; old_aspect = (AVRational){1, 1};
if (2 * (int64_t)new_w * s->height == (int64_t)new_h * s->width) if (2 * (int64_t)new_w * h->c.height == (int64_t)new_h * h->c.width)
s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1}); h->c.avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
if ((int64_t)new_w * s->height == 2 * (int64_t)new_h * s->width) if ((int64_t)new_w * h->c.height == 2 * (int64_t)new_h * h->c.width)
s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2}); h->c.avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
ret = ff_set_dimensions(s->avctx, new_w, new_h); ret = ff_set_dimensions(h->c.avctx, new_w, new_h);
if (ret < 0) if (ret < 0)
return ret; return ret;
s->width = new_w; h->c.width = new_w;
s->height = new_h; h->c.height = new_h;
if ((ret = ff_mpv_common_init(s)) < 0) if ((ret = ff_mpv_common_init(&h->c)) < 0)
return ret; return ret;
} }
if (s->avctx->debug & FF_DEBUG_PICT_INFO) { if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max); av_log(h->c.avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
} }
} }
if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0) if (av_image_check_size(h->c.width, h->c.height, 0, h->c.avctx) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
mb_pos = ff_h263_decode_mba(s); mb_pos = ff_h263_decode_mba(h);
seq |= s->time & ~0x7FFF; seq |= h->c.time & ~0x7FFF;
if (seq - s->time > 0x4000) if (seq - h->c.time > 0x4000)
seq -= 0x8000; seq -= 0x8000;
if (seq - s->time < -0x4000) if (seq - h->c.time < -0x4000)
seq += 0x8000; seq += 0x8000;
if (seq != s->time) { if (seq != h->c.time) {
if (s->pict_type != AV_PICTURE_TYPE_B) { if (h->c.pict_type != AV_PICTURE_TYPE_B) {
s->time = seq; h->c.time = seq;
s->pp_time = s->time - s->last_non_b_time; h->c.pp_time = h->c.time - h->c.last_non_b_time;
s->last_non_b_time = s->time; h->c.last_non_b_time = h->c.time;
} else { } else {
s->time = seq; h->c.time = seq;
s->pb_time = s->pp_time - (s->last_non_b_time - s->time); h->c.pb_time = h->c.pp_time - (h->c.last_non_b_time - h->c.time);
} }
} }
if (s->pict_type == AV_PICTURE_TYPE_B) { if (h->c.pict_type == AV_PICTURE_TYPE_B) {
if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) { if (h->c.pp_time <=h->c.pb_time || h->c.pp_time <= h->c.pp_time - h->c.pb_time || h->c.pp_time<=0) {
av_log(s->avctx, AV_LOG_DEBUG, av_log(h->c.avctx, AV_LOG_DEBUG,
"messed up order, possible from seeking? skipping current B-frame\n"); "messed up order, possible from seeking? skipping current B-frame\n");
#define ERROR_SKIP_FRAME -123 #define ERROR_SKIP_FRAME -123
return ERROR_SKIP_FRAME; return ERROR_SKIP_FRAME;
} }
ff_mpeg4_init_direct_mv(s); ff_mpeg4_init_direct_mv(&h->c);
} }
s->no_rounding = get_bits1(&s->gb); h->c.no_rounding = get_bits1(&h->c.gb);
if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->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(&s->gb, 5); skip_bits(&h->c.gb, 5);
s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I; h->c.h263_aic = h->c.pict_type == AV_PICTURE_TYPE_I;
if (s->h263_aic) { if (h->c.h263_aic) {
s->y_dc_scale_table = h->c.y_dc_scale_table =
s->c_dc_scale_table = ff_aic_dc_scale_table; h->c.c_dc_scale_table = ff_aic_dc_scale_table;
} else { } else {
s->y_dc_scale_table = h->c.y_dc_scale_table =
s->c_dc_scale_table = ff_mpeg1_dc_scale_table; h->c.c_dc_scale_table = ff_mpeg1_dc_scale_table;
} }
if (!s->avctx->lowres) if (!h->c.avctx->lowres)
s->loop_filter = 1; h->c.loop_filter = 1;
if (s->avctx->debug & FF_DEBUG_PICT_INFO) { if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_INFO, av_log(h->c.avctx, AV_LOG_INFO,
"num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, seq, h->c.mb_x, h->c.mb_y, h->c.pict_type, h->c.qscale,
s->no_rounding); h->c.no_rounding);
} }
av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay); av_assert0(h->c.pict_type != AV_PICTURE_TYPE_B || !h->c.low_delay);
return s->mb_width * s->mb_height - mb_pos; return h->c.mb_width * h->c.mb_height - mb_pos;
} }
static av_cold void rv10_build_vlc(VLCElem vlc[], int table_size, static av_cold void rv10_build_vlc(VLCElem vlc[], int table_size,
@ -351,7 +351,7 @@ static av_cold int rv10_decode_init(AVCodecContext *avctx)
{ {
static AVOnce init_static_once = AV_ONCE_INIT; static AVOnce init_static_once = AV_ONCE_INIT;
RVDecContext *rv = avctx->priv_data; RVDecContext *rv = avctx->priv_data;
MpegEncContext *s = &rv->m; H263DecContext *const h = &rv->h;
int major_ver, minor_ver, micro_ver, ret; int major_ver, minor_ver, micro_ver, ret;
if (avctx->extradata_size < 8) { if (avctx->extradata_size < 8) {
@ -369,11 +369,11 @@ static av_cold int rv10_decode_init(AVCodecContext *avctx)
rv->orig_width = avctx->coded_width; rv->orig_width = avctx->coded_width;
rv->orig_height = avctx->coded_height; rv->orig_height = avctx->coded_height;
s->h263_long_vectors = avctx->extradata[3] & 1; h->c.h263_long_vectors = avctx->extradata[3] & 1;
rv->sub_id = AV_RB32A(avctx->extradata + 4); rv->sub_id = AV_RB32A(avctx->extradata + 4);
if (avctx->codec_id == AV_CODEC_ID_RV20) { if (avctx->codec_id == AV_CODEC_ID_RV20) {
s->modified_quant = 1; h->c.modified_quant = 1;
s->chroma_qscale_table = ff_h263_chroma_qscale_table; h->c.chroma_qscale_table = ff_h263_chroma_qscale_table;
} }
major_ver = RV_GET_MAJOR_VER(rv->sub_id); major_ver = RV_GET_MAJOR_VER(rv->sub_id);
@ -382,12 +382,12 @@ static av_cold int rv10_decode_init(AVCodecContext *avctx)
switch (major_ver) { switch (major_ver) {
case 1: case 1:
s->rv10_version = micro_ver ? 3 : 1; h->c.rv10_version = micro_ver ? 3 : 1;
s->obmc = micro_ver == 2; h->c.obmc = micro_ver == 2;
break; break;
case 2: case 2:
if (minor_ver >= 2) { if (minor_ver >= 2) {
s->low_delay = 0; h->c.low_delay = 0;
avctx->has_b_frames = 1; avctx->has_b_frames = 1;
} }
break; break;
@ -412,126 +412,126 @@ static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
int buf_size, int buf_size2, int whole_size) int buf_size, int buf_size2, int whole_size)
{ {
RVDecContext *rv = avctx->priv_data; RVDecContext *rv = avctx->priv_data;
MpegEncContext *s = &rv->m; H263DecContext *const h = &rv->h;
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(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8); init_get_bits(&h->c.gb, buf, FFMAX(buf_size, buf_size2) * 8);
if (s->codec_id == AV_CODEC_ID_RV10) if (h->c.codec_id == AV_CODEC_ID_RV10)
mb_count = rv10_decode_picture_header(s); mb_count = rv10_decode_picture_header(h);
else else
mb_count = rv20_decode_picture_header(rv, whole_size); mb_count = rv20_decode_picture_header(rv, whole_size);
if (mb_count < 0) { if (mb_count < 0) {
if (mb_count != ERROR_SKIP_FRAME) if (mb_count != ERROR_SKIP_FRAME)
av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n"); av_log(h->c.avctx, AV_LOG_ERROR, "HEADER ERROR\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (s->mb_x >= s->mb_width || if (h->c.mb_x >= h->c.mb_width ||
s->mb_y >= s->mb_height) { h->c.mb_y >= h->c.mb_height) {
av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y); av_log(h->c.avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", h->c.mb_x, h->c.mb_y);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
mb_pos = s->mb_y * s->mb_width + s->mb_x; mb_pos = h->c.mb_y * h->c.mb_width + h->c.mb_x;
left = s->mb_width * s->mb_height - mb_pos; left = h->c.mb_width * h->c.mb_height - mb_pos;
if (mb_count > left) { if (mb_count > left) {
av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n"); av_log(h->c.avctx, AV_LOG_ERROR, "COUNT ERROR\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (whole_size < s->mb_width * s->mb_height / 8) if (whole_size < h->c.mb_width * h->c.mb_height / 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if ((s->mb_x == 0 && s->mb_y == 0) || !s->cur_pic.ptr) { if ((h->c.mb_x == 0 && h->c.mb_y == 0) || !h->c.cur_pic.ptr) {
// FIXME write parser so we always have complete frames? // FIXME write parser so we always have complete frames?
if (s->cur_pic.ptr) { if (h->c.cur_pic.ptr) {
ff_er_frame_end(&s->er, NULL); ff_er_frame_end(&h->c.er, NULL);
ff_mpv_frame_end(s); ff_mpv_frame_end(&h->c);
s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0; h->c.mb_x = h->c.mb_y = h->c.resync_mb_x = h->c.resync_mb_y = 0;
} }
if ((ret = ff_mpv_frame_start(s, avctx)) < 0) if ((ret = ff_mpv_frame_start(&h->c, avctx)) < 0)
return ret; return ret;
ff_mpeg_er_frame_start(s); ff_mpeg_er_frame_start(&h->c);
} else { } else {
if (s->cur_pic.ptr->f->pict_type != s->pict_type) { if (h->c.cur_pic.ptr->f->pict_type != h->c.pict_type) {
av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n"); av_log(h->c.avctx, AV_LOG_ERROR, "Slice type mismatch\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
} }
ff_dlog(avctx, "qscale=%d\n", s->qscale); ff_dlog(avctx, "qscale=%d\n", h->c.qscale);
/* default quantization values */ /* default quantization values */
if (s->codec_id == AV_CODEC_ID_RV10) { if (h->c.codec_id == AV_CODEC_ID_RV10) {
if (s->mb_y == 0) if (h->c.mb_y == 0)
s->first_slice_line = 1; h->c.first_slice_line = 1;
} else { } else {
s->first_slice_line = 1; h->c.first_slice_line = 1;
s->resync_mb_x = s->mb_x; h->c.resync_mb_x = h->c.mb_x;
} }
start_mb_x = s->mb_x; start_mb_x = h->c.mb_x;
s->resync_mb_y = s->mb_y; h->c.resync_mb_y = h->c.mb_y;
ff_set_qscale(s, s->qscale); ff_set_qscale(&h->c, h->c.qscale);
s->rv10_first_dc_coded[0] = 0; h->c.rv10_first_dc_coded[0] = 0;
s->rv10_first_dc_coded[1] = 0; h->c.rv10_first_dc_coded[1] = 0;
s->rv10_first_dc_coded[2] = 0; h->c.rv10_first_dc_coded[2] = 0;
ff_init_block_index(s); ff_init_block_index(&h->c);
/* decode each macroblock */ /* decode each macroblock */
for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) { for (h->c.mb_num_left = mb_count; h->c.mb_num_left > 0; h->c.mb_num_left--) {
int ret; int ret;
ff_update_block_index(s, 8, s->avctx->lowres, 1); ff_update_block_index(&h->c, 8, h->c.avctx->lowres, 1);
ff_tlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y); ff_tlog(avctx, "**mb x=%d y=%d\n", h->c.mb_x, h->c.mb_y);
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
ret = ff_h263_decode_mb(s, s->block); ret = ff_h263_decode_mb(h, h->c.block);
// 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(&s->gb)) { if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&h->c.gb)) {
int v = show_bits(&s->gb, 16); int v = show_bits(&h->c.gb, 16);
if (get_bits_count(&s->gb) + 16 > active_bits_size) if (get_bits_count(&h->c.gb) + 16 > active_bits_size)
v >>= get_bits_count(&s->gb) + 16 - active_bits_size; v >>= get_bits_count(&h->c.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(&s->gb) && if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&h->c.gb) &&
8 * buf_size2 >= get_bits_count(&s->gb)) { 8 * buf_size2 >= get_bits_count(&h->c.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(&s->gb)) { if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&h->c.gb)) {
av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, av_log(h->c.avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", h->c.mb_x,
s->mb_y); h->c.mb_y);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (s->pict_type != AV_PICTURE_TYPE_B) if (h->c.pict_type != AV_PICTURE_TYPE_B)
ff_h263_update_motion_val(s); ff_h263_update_motion_val(&h->c);
ff_mpv_reconstruct_mb(s, s->block); ff_mpv_reconstruct_mb(&h->c, h->c.block);
if (s->loop_filter) if (h->c.loop_filter)
ff_h263_loop_filter(s); ff_h263_loop_filter(&h->c);
if (++s->mb_x == s->mb_width) { if (++h->c.mb_x == h->c.mb_width) {
s->mb_x = 0; h->c.mb_x = 0;
s->mb_y++; h->c.mb_y++;
ff_init_block_index(s); ff_init_block_index(&h->c);
} }
if (s->mb_x == s->resync_mb_x) if (h->c.mb_x == h->c.resync_mb_x)
s->first_slice_line = 0; h->c.first_slice_line = 0;
if (ret == SLICE_END) if (ret == SLICE_END)
break; break;
} }
ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y, ff_er_add_slice(&h->c.er, start_mb_x, h->c.resync_mb_y, h->c.mb_x - 1, h->c.mb_y,
ER_MB_END); ER_MB_END);
return active_bits_size; return active_bits_size;

4
libavcodec/rv10dec.h
View File

@ -21,8 +21,8 @@
#ifndef AVCODEC_RV10DEC_H #ifndef AVCODEC_RV10DEC_H
#define AVCODEC_RV10DEC_H #define AVCODEC_RV10DEC_H
#include "mpegvideo.h" struct H263DecContext;
int ff_rv_decode_dc(MpegEncContext *s, int n); int ff_rv_decode_dc(struct H263DecContext *const h, int n);
#endif /* AVCODEC_RV10DEC_H */ #endif /* AVCODEC_RV10DEC_H */

2
libavcodec/vaapi_mpeg4.c
View File

@ -51,7 +51,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx,
av_unused uint32_t size) av_unused uint32_t size)
{ {
Mpeg4DecContext *ctx = avctx->priv_data; Mpeg4DecContext *ctx = avctx->priv_data;
MpegEncContext *s = &ctx->m; MPVContext *const s = &ctx->h.c;
VAAPIDecodePicture *pic = s->cur_pic.ptr->hwaccel_picture_private; VAAPIDecodePicture *pic = s->cur_pic.ptr->hwaccel_picture_private;
VAPictureParameterBufferMPEG4 pic_param; VAPictureParameterBufferMPEG4 pic_param;
int i, err; int i, err;

2
libavcodec/vdpau_mpeg4.c
View File

@ -34,7 +34,7 @@ static int vdpau_mpeg4_start_frame(AVCodecContext *avctx,
const uint8_t *buffer, uint32_t size) const uint8_t *buffer, uint32_t size)
{ {
Mpeg4DecContext *ctx = avctx->priv_data; Mpeg4DecContext *ctx = avctx->priv_data;
MpegEncContext * const s = &ctx->m; MPVContext *const s = &ctx->h.c;
MPVPicture *pic = s->cur_pic.ptr; MPVPicture *pic = s->cur_pic.ptr;
struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private; struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
VdpPictureInfoMPEG4Part2 *info = &pic_ctx->info.mpeg4; VdpPictureInfoMPEG4Part2 *info = &pic_ctx->info.mpeg4;

4
libavcodec/wmv2.h
View File

@ -44,7 +44,7 @@ void ff_mspel_motion(MpegEncContext *s,
int motion_x, int motion_y, int h); int motion_x, int motion_y, int h);
static av_always_inline int wmv2_get_cbp_table_index(MpegEncContext *s, int cbp_index) static av_always_inline int wmv2_get_cbp_table_index(int qscale, int cbp_index)
{ {
static const uint8_t map[3][3] = { static const uint8_t map[3][3] = {
{ 0, 2, 1 }, { 0, 2, 1 },
@ -52,7 +52,7 @@ static av_always_inline int wmv2_get_cbp_table_index(MpegEncContext *s, int cbp_
{ 2, 1, 0 }, { 2, 1, 0 },
}; };
return map[(s->qscale > 10) + (s->qscale > 20)][cbp_index]; return map[(qscale > 10) + (qscale > 20)][cbp_index];
} }
#endif /* AVCODEC_WMV2_H */ #endif /* AVCODEC_WMV2_H */

321
libavcodec/wmv2dec.c
View File

@ -59,9 +59,9 @@ typedef struct WMV2DecContext {
static void wmv2_add_block(WMV2DecContext *w, int16_t *block1, static void wmv2_add_block(WMV2DecContext *w, int16_t *block1,
uint8_t *dst, int stride, int n) uint8_t *dst, int stride, int n)
{ {
MpegEncContext *const s = &w->ms.m; H263DecContext *const h = &w->ms.h;
if (s->block_last_index[n] >= 0) { if (h->c.block_last_index[n] >= 0) {
switch (w->abt_type_table[n]) { switch (w->abt_type_table[n]) {
case 0: case 0:
w->common.wdsp.idct_add(dst, stride, block1); w->common.wdsp.idct_add(dst, stride, block1);
@ -69,15 +69,15 @@ static void wmv2_add_block(WMV2DecContext *w, int16_t *block1,
case 1: case 1:
ff_simple_idct84_add(dst, stride, block1); ff_simple_idct84_add(dst, stride, block1);
ff_simple_idct84_add(dst + 4 * stride, stride, w->abt_block2[n]); ff_simple_idct84_add(dst + 4 * stride, stride, w->abt_block2[n]);
s->bdsp.clear_block(w->abt_block2[n]); h->c.bdsp.clear_block(w->abt_block2[n]);
break; break;
case 2: case 2:
ff_simple_idct48_add(dst, stride, block1); ff_simple_idct48_add(dst, stride, block1);
ff_simple_idct48_add(dst + 4, stride, w->abt_block2[n]); ff_simple_idct48_add(dst + 4, stride, w->abt_block2[n]);
s->bdsp.clear_block(w->abt_block2[n]); h->c.bdsp.clear_block(w->abt_block2[n]);
break; break;
default: default:
av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n"); av_log(h->c.avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n");
} }
} }
} }
@ -101,64 +101,63 @@ void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64],
static int parse_mb_skip(WMV2DecContext *w) static int parse_mb_skip(WMV2DecContext *w)
{ {
int mb_x, mb_y; H263DecContext *const h = &w->ms.h;
int coded_mb_count = 0; int coded_mb_count = 0;
MpegEncContext *const s = &w->ms.m; uint32_t *const mb_type = h->c.cur_pic.mb_type;
uint32_t *const mb_type = s->cur_pic.mb_type;
w->skip_type = get_bits(&s->gb, 2); w->skip_type = get_bits(&h->c.gb, 2);
switch (w->skip_type) { switch (w->skip_type) {
case SKIP_TYPE_NONE: case SKIP_TYPE_NONE:
for (mb_y = 0; mb_y < s->mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
for (mb_x = 0; mb_x < s->mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
mb_type[mb_y * s->mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
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(&s->gb) < s->mb_height * s->mb_width) if (get_bits_left(&h->c.gb) < h->c.mb_height * h->c.mb_width)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
for (mb_y = 0; mb_y < s->mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
for (mb_x = 0; mb_x < s->mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
mb_type[mb_y * s->mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
(get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; (get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
break; break;
case SKIP_TYPE_ROW: case SKIP_TYPE_ROW:
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) {
if (get_bits_left(&s->gb) < 1) if (get_bits_left(&h->c.gb) < 1)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (get_bits1(&s->gb)) { if (get_bits1(&h->c.gb)) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
mb_type[mb_y * s->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 (mb_x = 0; mb_x < s->mb_width; mb_x++) for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++)
mb_type[mb_y * s->mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
(get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; (get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
} }
} }
break; break;
case SKIP_TYPE_COL: case SKIP_TYPE_COL:
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) {
if (get_bits_left(&s->gb) < 1) if (get_bits_left(&h->c.gb) < 1)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (get_bits1(&s->gb)) { if (get_bits1(&h->c.gb)) {
for (mb_y = 0; mb_y < s->mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
mb_type[mb_y * s->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 (mb_y = 0; mb_y < s->mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
mb_type[mb_y * s->mb_stride + mb_x] = mb_type[mb_y * h->c.mb_stride + mb_x] =
(get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; (get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
} }
} }
break; break;
} }
for (mb_y = 0; mb_y < s->mb_height; mb_y++) for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++)
for (mb_x = 0; mb_x < s->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 * s->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(&s->gb)) if (coded_mb_count > get_bits_left(&h->c.gb))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
return 0; return 0;
@ -166,20 +165,20 @@ static int parse_mb_skip(WMV2DecContext *w)
static int decode_ext_header(WMV2DecContext *w) static int decode_ext_header(WMV2DecContext *w)
{ {
MpegEncContext *const s = &w->ms.m; H263DecContext *const h = &w->ms.h;
GetBitContext gb; GetBitContext gb;
int fps; int fps;
int code; int code;
if (s->avctx->extradata_size < 4) if (h->c.avctx->extradata_size < 4)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
init_get_bits(&gb, s->avctx->extradata, 32); init_get_bits(&gb, h->c.avctx->extradata, 32);
fps = get_bits(&gb, 5); fps = get_bits(&gb, 5);
w->ms.bit_rate = get_bits(&gb, 11) * 1024; w->ms.bit_rate = get_bits(&gb, 11) * 1024;
w->mspel_bit = get_bits1(&gb); w->mspel_bit = get_bits1(&gb);
s->loop_filter = get_bits1(&gb); h->c.loop_filter = get_bits1(&gb);
w->abt_flag = get_bits1(&gb); w->abt_flag = get_bits1(&gb);
w->j_type_bit = get_bits1(&gb); w->j_type_bit = get_bits1(&gb);
w->top_left_mv_flag = get_bits1(&gb); w->top_left_mv_flag = get_bits1(&gb);
@ -189,36 +188,36 @@ static int decode_ext_header(WMV2DecContext *w)
if (code == 0) if (code == 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
s->slice_height = s->mb_height / code; h->c.slice_height = h->c.mb_height / code;
if (s->avctx->debug & FF_DEBUG_PICT_INFO) if (h->c.avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG, av_log(h->c.avctx, AV_LOG_DEBUG,
"fps:%d, br:%d, qpbit:%d, abt_flag:%d, j_type_bit:%d, " "fps:%d, br:%d, qpbit:%d, abt_flag:%d, j_type_bit:%d, "
"tl_mv_flag:%d, mbrl_bit:%d, code:%d, loop_filter:%d, " "tl_mv_flag:%d, mbrl_bit:%d, code:%d, loop_filter:%d, "
"slices:%d\n", "slices:%d\n",
fps, w->ms.bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit, fps, w->ms.bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit,
w->top_left_mv_flag, w->per_mb_rl_bit, code, s->loop_filter, w->top_left_mv_flag, w->per_mb_rl_bit, code, h->c.loop_filter,
code); code);
return 0; return 0;
} }
int ff_wmv2_decode_picture_header(MpegEncContext *s) int ff_wmv2_decode_picture_header(H263DecContext *const h)
{ {
int code; int code;
s->pict_type = get_bits1(&s->gb) + 1; h->c.pict_type = get_bits1(&h->c.gb) + 1;
if (s->pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
code = get_bits(&s->gb, 7); code = get_bits(&h->c.gb, 7);
av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code); av_log(h->c.avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
} }
s->chroma_qscale = s->qscale = get_bits(&s->gb, 5); h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5);
if (s->qscale <= 0) if (h->c.qscale <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (s->pict_type != AV_PICTURE_TYPE_I && show_bits(&s->gb, 1)) { if (h->c.pict_type != AV_PICTURE_TYPE_I && show_bits(&h->c.gb, 1)) {
GetBitContext gb = s->gb; GetBitContext gb = h->c.gb;
int skip_type = get_bits(&gb, 2); int skip_type = get_bits(&gb, 2);
int run = skip_type == SKIP_TYPE_COL ? s->mb_width : s->mb_height; int run = skip_type == SKIP_TYPE_COL ? h->c.mb_width : h->c.mb_height;
while (run > 0) { while (run > 0) {
int block = FFMIN(run, 25); int block = FFMIN(run, 25);
@ -233,46 +232,46 @@ int ff_wmv2_decode_picture_header(MpegEncContext *s)
return 0; return 0;
} }
int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s) int ff_wmv2_decode_secondary_picture_header(H263DecContext *const h)
{ {
WMV2DecContext *const w = (WMV2DecContext *) s; WMV2DecContext *const w = (WMV2DecContext *)h;
if (s->pict_type == AV_PICTURE_TYPE_I) { if (h->c.pict_type == AV_PICTURE_TYPE_I) {
/* Is filling with zeroes really the right thing to do? */ /* Is filling with zeroes really the right thing to do? */
memset(s->cur_pic.mb_type, 0, memset(h->c.cur_pic.mb_type, 0,
sizeof(*s->cur_pic.mb_type) * s->mb_height * s->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(&s->gb); w->j_type = get_bits1(&h->c.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(&s->gb); w->ms.per_mb_rl_table = get_bits1(&h->c.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(&s->gb); w->ms.rl_chroma_table_index = decode012(&h->c.gb);
w->ms.rl_table_index = decode012(&s->gb); w->ms.rl_table_index = decode012(&h->c.gb);
} }
w->ms.dc_table_index = get_bits1(&s->gb); w->ms.dc_table_index = get_bits1(&h->c.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(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16)) if (get_bits_left(&h->c.gb) * 8LL < (h->c.width+15)/16 * ((h->c.height+15)/16))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
s->inter_intra_pred = 0; h->c.inter_intra_pred = 0;
s->no_rounding = 1; h->c.no_rounding = 1;
if (s->avctx->debug & FF_DEBUG_PICT_INFO) { if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG, av_log(h->c.avctx, AV_LOG_DEBUG,
"qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n", "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n",
s->qscale, w->ms.rl_chroma_table_index, w->ms.rl_table_index, h->c.qscale, w->ms.rl_chroma_table_index, w->ms.rl_table_index,
w->ms.dc_table_index, w->ms.per_mb_rl_table, w->j_type); w->ms.dc_table_index, w->ms.per_mb_rl_table, w->j_type);
} }
} else { } else {
@ -283,61 +282,61 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
ret = parse_mb_skip(w); ret = parse_mb_skip(w);
if (ret < 0) if (ret < 0)
return ret; return ret;
cbp_index = decode012(&s->gb); cbp_index = decode012(&h->c.gb);
w->cbp_table_index = wmv2_get_cbp_table_index(s, cbp_index); w->cbp_table_index = wmv2_get_cbp_table_index(h->c.qscale, cbp_index);
if (w->mspel_bit) if (w->mspel_bit)
s->mspel = get_bits1(&s->gb); h->c.mspel = get_bits1(&h->c.gb);
else else
s->mspel = 0; // FIXME check h->c.mspel = 0; // FIXME check
if (w->abt_flag) { if (w->abt_flag) {
w->per_mb_abt = get_bits1(&s->gb) ^ 1; w->per_mb_abt = get_bits1(&h->c.gb) ^ 1;
if (!w->per_mb_abt) if (!w->per_mb_abt)
w->abt_type = decode012(&s->gb); w->abt_type = decode012(&h->c.gb);
} }
if (w->per_mb_rl_bit) if (w->per_mb_rl_bit)
w->ms.per_mb_rl_table = get_bits1(&s->gb); w->ms.per_mb_rl_table = get_bits1(&h->c.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(&s->gb); w->ms.rl_table_index = decode012(&h->c.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(&s->gb) < 2) if (get_bits_left(&h->c.gb) < 2)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
w->ms.dc_table_index = get_bits1(&s->gb); w->ms.dc_table_index = get_bits1(&h->c.gb);
w->ms.mv_table_index = get_bits1(&s->gb); w->ms.mv_table_index = get_bits1(&h->c.gb);
s->inter_intra_pred = 0; // (s->width * s->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);
s->no_rounding ^= 1; h->c.no_rounding ^= 1;
if (s->avctx->debug & FF_DEBUG_PICT_INFO) { if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG, av_log(h->c.avctx, AV_LOG_DEBUG,
"rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d " "rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d "
"per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n", "per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n",
w->ms.rl_table_index, w->ms.rl_chroma_table_index, w->ms.rl_table_index, w->ms.rl_chroma_table_index,
w->ms.dc_table_index, w->ms.mv_table_index, w->ms.dc_table_index, w->ms.mv_table_index,
w->ms.per_mb_rl_table, s->qscale, s->mspel, w->ms.per_mb_rl_table, h->c.qscale, h->c.mspel,
w->per_mb_abt, w->abt_type, w->cbp_table_index, w->per_mb_abt, w->abt_type, w->cbp_table_index,
s->inter_intra_pred); h->c.inter_intra_pred);
} }
} }
w->ms.esc3_level_length = 0; w->ms.esc3_level_length = 0;
w->ms.esc3_run_length = 0; w->ms.esc3_run_length = 0;
if (w->j_type) { if (w->j_type) {
ff_intrax8_decode_picture(&w->x8, s->cur_pic.ptr, ff_intrax8_decode_picture(&w->x8, h->c.cur_pic.ptr,
&s->gb, &s->mb_x, &s->mb_y, &h->c.gb, &h->c.mb_x, &h->c.mb_y,
2 * s->qscale, (s->qscale - 1) | 1, 2 * h->c.qscale, (h->c.qscale - 1) | 1,
s->loop_filter, s->low_delay); h->c.loop_filter, h->c.low_delay);
ff_er_add_slice(&s->er, 0, 0, ff_er_add_slice(&h->c.er, 0, 0,
(s->mb_x >> 1) - 1, (s->mb_y >> 1) - 1, (h->c.mb_x >> 1) - 1, (h->c.mb_y >> 1) - 1,
ER_MB_END); ER_MB_END);
return 1; return 1;
} }
@ -347,38 +346,37 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_ptr) static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_ptr)
{ {
MpegEncContext *const s = &w->ms.m; H263DecContext *const h = &w->ms.h;
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) && s->mspel) if ((((*mx_ptr) | (*my_ptr)) & 1) && h->c.mspel)
w->common.hshift = get_bits1(&s->gb); w->common.hshift = get_bits1(&h->c.gb);
else else
w->common.hshift = 0; w->common.hshift = 0;
} }
static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py) static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
{ {
MpegEncContext *const s = &w->ms.m; H263DecContext *const h = &w->ms.h;
int xy, wrap, diff, type; int diff, type;
int16_t *A, *B, *C, *mot_val;
wrap = s->b8_stride; int wrap = h->c.b8_stride;
xy = s->block_index[0]; int xy = h->c.block_index[0];
mot_val = s->cur_pic.motion_val[0][xy]; int16_t *mot_val = h->c.cur_pic.motion_val[0][xy];
A = s->cur_pic.motion_val[0][xy - 1]; const int16_t *A = h->c.cur_pic.motion_val[0][xy - 1];
B = s->cur_pic.motion_val[0][xy - wrap]; const int16_t *B = h->c.cur_pic.motion_val[0][xy - wrap];
C = s->cur_pic.motion_val[0][xy + 2 - wrap]; const int16_t *C = h->c.cur_pic.motion_val[0][xy + 2 - wrap];
if (s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag) if (h->c.mb_x && !h->c.first_slice_line && !h->c.mspel && w->top_left_mv_flag)
diff = FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1])); diff = FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));
else else
diff = 0; diff = 0;
if (diff >= 8) if (diff >= 8)
type = get_bits1(&s->gb); type = get_bits1(&h->c.gb);
else else
type = 2; type = 2;
@ -390,7 +388,7 @@ static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
*py = B[1]; *py = B[1];
} else { } else {
/* special case for first (slice) line */ /* special case for first (slice) line */
if (s->first_slice_line) { if (h->c.first_slice_line) {
*px = A[0]; *px = A[0];
*py = A[1]; *py = A[1];
} else { } else {
@ -405,23 +403,23 @@ static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block, static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
int n, int cbp) int n, int cbp)
{ {
MpegEncContext *const s = &w->ms.m; H263DecContext *const h = &w->ms.h;
static const int sub_cbp_table[3] = { 2, 3, 1 }; static const int sub_cbp_table[3] = { 2, 3, 1 };
int sub_cbp, ret; int sub_cbp, ret;
if (!cbp) { if (!cbp) {
s->block_last_index[n] = -1; h->c.block_last_index[n] = -1;
return 0; return 0;
} }
if (w->per_block_abt) if (w->per_block_abt)
w->abt_type = decode012(&s->gb); w->abt_type = decode012(&h->c.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(&s->gb)]; sub_cbp = sub_cbp_table[decode012(&h->c.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);
@ -435,20 +433,20 @@ static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
return ret; return ret;
} }
s->block_last_index[n] = 63; h->c.block_last_index[n] = 63;
return 0; return 0;
} else { } else {
return ff_msmpeg4_decode_block(&w->ms, block, n, 1, return ff_msmpeg4_decode_block(&w->ms, block, n, 1,
s->inter_scantable.permutated); h->c.inter_scantable.permutated);
} }
} }
static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64]) static int wmv2_decode_mb(H263DecContext *const h, int16_t block[6][64])
{ {
/* The following is only allowed because this encoder /* The following is only allowed because this decoder
* does not use slice threading. */ * does not use slice threading. */
WMV2DecContext *const w = (WMV2DecContext *) s; WMV2DecContext *const w = (WMV2DecContext *) h;
MSMP4DecContext *const ms = &w->ms; MSMP4DecContext *const ms = &w->ms;
int cbp, code, i, ret; int cbp, code, i, ret;
uint8_t *coded_val; uint8_t *coded_val;
@ -456,40 +454,40 @@ static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
if (w->j_type) if (w->j_type)
return 0; return 0;
if (s->pict_type == AV_PICTURE_TYPE_P) { if (h->c.pict_type == AV_PICTURE_TYPE_P) {
if (IS_SKIP(s->cur_pic.mb_type[s->mb_y * s->mb_stride + s->mb_x])) { if (IS_SKIP(h->c.cur_pic.mb_type[h->c.mb_y * h->c.mb_stride + h->c.mb_x])) {
/* skip mb */ /* skip mb */
s->mb_intra = 0; h->c.mb_intra = 0;
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
s->block_last_index[i] = -1; h->c.block_last_index[i] = -1;
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
s->mv[0][0][0] = 0; h->c.mv[0][0][0] = 0;
s->mv[0][0][1] = 0; h->c.mv[0][0][1] = 0;
s->mb_skipped = 1; h->c.mb_skipped = 1;
w->common.hshift = 0; w->common.hshift = 0;
return 0; return 0;
} }
if (get_bits_left(&s->gb) <= 0) if (get_bits_left(&h->c.gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[w->cbp_table_index], code = get_vlc2(&h->c.gb, ff_mb_non_intra_vlc[w->cbp_table_index],
MB_NON_INTRA_VLC_BITS, 3); MB_NON_INTRA_VLC_BITS, 3);
s->mb_intra = (~code & 0x40) >> 6; h->c.mb_intra = (~code & 0x40) >> 6;
cbp = code & 0x3f; cbp = code & 0x3f;
} else { } else {
s->mb_intra = 1; h->c.mb_intra = 1;
if (get_bits_left(&s->gb) <= 0) if (get_bits_left(&h->c.gb) <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc, code = get_vlc2(&h->c.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;
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
int val = ((code >> (5 - i)) & 1); int val = ((code >> (5 - i)) & 1);
if (i < 4) { if (i < 4) {
int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val); int pred = ff_msmpeg4_coded_block_pred(&h->c, i, &coded_val);
val = val ^ pred; val = val ^ pred;
*coded_val = val; *coded_val = val;
} }
@ -497,65 +495,65 @@ static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
} }
} }
if (!s->mb_intra) { if (!h->c.mb_intra) {
int mx, my; int mx, my;
wmv2_pred_motion(w, &mx, &my); wmv2_pred_motion(w, &mx, &my);
if (cbp) { if (cbp) {
s->bdsp.clear_blocks(s->block[0]); h->c.bdsp.clear_blocks(h->c.block[0]);
if (ms->per_mb_rl_table) { if (ms->per_mb_rl_table) {
ms->rl_table_index = decode012(&s->gb); ms->rl_table_index = decode012(&h->c.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(&s->gb); w->per_block_abt = get_bits1(&h->c.gb);
if (!w->per_block_abt) if (!w->per_block_abt)
w->abt_type = decode012(&s->gb); w->abt_type = decode012(&h->c.gb);
} else } else
w->per_block_abt = 0; w->per_block_abt = 0;
} }
wmv2_decode_motion(w, &mx, &my); wmv2_decode_motion(w, &mx, &my);
s->mv_dir = MV_DIR_FORWARD; h->c.mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; h->c.mv_type = MV_TYPE_16X16;
s->mv[0][0][0] = mx; h->c.mv[0][0][0] = mx;
s->mv[0][0][1] = my; h->c.mv[0][0][1] = my;
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
if ((ret = wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1)) < 0) { if ((ret = wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1)) < 0) {
av_log(s->avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"\nerror while decoding inter block: %d x %d (%d)\n", "\nerror while decoding inter block: %d x %d (%d)\n",
s->mb_x, s->mb_y, i); h->c.mb_x, h->c.mb_y, i);
return ret; return ret;
} }
} }
} else { } else {
if (s->pict_type == AV_PICTURE_TYPE_P) if (h->c.pict_type == AV_PICTURE_TYPE_P)
ff_dlog(s->avctx, "%d%d ", s->inter_intra_pred, cbp); ff_dlog(h->c.avctx, "%d%d ", h->c.inter_intra_pred, cbp);
ff_dlog(s->avctx, "I at %d %d %d %06X\n", s->mb_x, s->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(&s->gb, 24)); show_bits(&h->c.gb, 24));
s->ac_pred = get_bits1(&s->gb); h->c.ac_pred = get_bits1(&h->c.gb);
if (s->inter_intra_pred) { if (h->c.inter_intra_pred) {
s->h263_aic_dir = get_vlc2(&s->gb, ff_inter_intra_vlc, h->c.h263_aic_dir = get_vlc2(&h->c.gb, ff_inter_intra_vlc,
INTER_INTRA_VLC_BITS, 1); INTER_INTRA_VLC_BITS, 1);
ff_dlog(s->avctx, "%d%d %d %d/", ff_dlog(h->c.avctx, "%d%d %d %d/",
s->ac_pred, s->h263_aic_dir, s->mb_x, s->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(&s->gb); ms->rl_table_index = decode012(&h->c.gb);
ms->rl_chroma_table_index = ms->rl_table_index; ms->rl_chroma_table_index = ms->rl_table_index;
} }
s->bdsp.clear_blocks(s->block[0]); h->c.bdsp.clear_blocks(h->c.block[0]);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
ret = ff_msmpeg4_decode_block(ms, block[i], i, (cbp >> (5 - i)) & 1, NULL); ret = ff_msmpeg4_decode_block(ms, block[i], i, (cbp >> (5 - i)) & 1, NULL);
if (ret < 0) { if (ret < 0) {
av_log(s->avctx, AV_LOG_ERROR, av_log(h->c.avctx, AV_LOG_ERROR,
"\nerror while decoding intra block: %d x %d (%d)\n", "\nerror while decoding intra block: %d x %d (%d)\n",
s->mb_x, s->mb_y, i); h->c.mb_x, h->c.mb_y, i);
return ret; return ret;
} }
} }
@ -567,7 +565,8 @@ static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
static av_cold int wmv2_decode_init(AVCodecContext *avctx) static av_cold int wmv2_decode_init(AVCodecContext *avctx)
{ {
WMV2DecContext *const w = avctx->priv_data; WMV2DecContext *const w = avctx->priv_data;
MpegEncContext *const s = &w->ms.m; H263DecContext *const h = &w->ms.h;
MpegEncContext *const s = &h->c;
int ret; int ret;
s->private_ctx = &w->common; s->private_ctx = &w->common;
@ -575,13 +574,13 @@ static av_cold int wmv2_decode_init(AVCodecContext *avctx)
if ((ret = ff_msmpeg4_decode_init(avctx)) < 0) if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
return ret; return ret;
s->decode_mb = wmv2_decode_mb; h->decode_mb = wmv2_decode_mb;
ff_wmv2_common_init(s); ff_wmv2_common_init(s);
decode_ext_header(w); decode_ext_header(w);
return ff_intrax8_common_init(avctx, &w->x8, s->block[0], return ff_intrax8_common_init(avctx, &w->x8, h->c.block[0],
s->mb_width, s->mb_height); s->mb_width, s->mb_height);
} }

5
libavcodec/wmv2dec.h
View File

@ -22,9 +22,10 @@
#define AVCODEC_WMV2DEC_H #define AVCODEC_WMV2DEC_H
#include "mpegvideo.h" #include "mpegvideo.h"
struct H263DecContext;
int ff_wmv2_decode_picture_header(MpegEncContext * s); int ff_wmv2_decode_picture_header(struct H263DecContext *const h);
int ff_wmv2_decode_secondary_picture_header(MpegEncContext * s); int ff_wmv2_decode_secondary_picture_header(struct H263DecContext *const h);
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block[6][64], void ff_wmv2_add_mb(MpegEncContext *s, int16_t block[6][64],
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr); uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr);

2
libavcodec/wmv2enc.c
View File

@ -118,7 +118,7 @@ static int wmv2_encode_picture_header(MPVMainEncContext *const m)
put_bits(&s->pb, 2, SKIP_TYPE_NONE); put_bits(&s->pb, 2, SKIP_TYPE_NONE);
ff_msmpeg4_code012(&s->pb, cbp_index = 0); ff_msmpeg4_code012(&s->pb, cbp_index = 0);
w->cbp_table_index = wmv2_get_cbp_table_index(&s->c, cbp_index); w->cbp_table_index = wmv2_get_cbp_table_index(s->c.qscale, cbp_index);
if (w->mspel_bit) if (w->mspel_bit)
put_bits(&s->pb, 1, s->c.mspel); put_bits(&s->pb, 1, s->c.mspel);