From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from ffbox0-bg.ffmpeg.org (ffbox0-bg.ffmpeg.org [79.124.17.100]) by master.gitmailbox.com (Postfix) with ESMTPS id 59DAB4F7F5 for ; Mon, 23 Jun 2025 13:42:28 +0000 (UTC) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.ffmpeg.org (Postfix) with ESMTP id 3FFD068E29F; Mon, 23 Jun 2025 16:39:30 +0300 (EEST) Received: from mail-pl1-f173.google.com (mail-pl1-f173.google.com [209.85.214.173]) by ffbox0-bg.ffmpeg.org (Postfix) with ESMTPS id 1419B68E254 for ; Mon, 23 Jun 2025 16:39:23 +0300 (EEST) Received: by mail-pl1-f173.google.com with SMTP id d9443c01a7336-235ef62066eso55900195ad.3 for ; Mon, 23 Jun 2025 06:39:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1750685961; x=1751290761; darn=ffmpeg.org; h=cc:to:mime-version:content-transfer-encoding:fcc:subject:date :references:in-reply-to:message-id:from:from:to:cc:subject:date :message-id:reply-to; bh=fEaBcmUloFCvXu1mo5v0a4d3D10eRj9RrNb8eiwK2tI=; b=AtnfE619oXs48xpZxUxE9ZKKfTK0VT6G4sSxBMJQj6DGmcQxgOrOfXwyBvLddnscgU Rlan6V0mOveH7FN5GKDruebvzGAi1ZpNL3K4BhHu0vc3SFAxS9eoIBOxkpgMsHUxO0Lv RYI7xYvjRSrDiVsi1gtuaLh9Y1UYAxK6QvDRmv3jGDZJv8/2ZGK24EjEv+Qb1WIs4u0p EJ1eFr2ctW1vcx1gH8XQ4Ragn4Qr3FjcDEw2eXmovRmWGxUkrRvqGElI3ppgDxbaUeIR +Y4zEWb2vuCsgE/nOLCrNDXQDT6GzZy9cKDl/2FdGtUWG0g4L1mD6gimKWJbQF/HbBee GHmQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750685961; x=1751290761; h=cc:to:mime-version:content-transfer-encoding:fcc:subject:date :references:in-reply-to:message-id:from:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=fEaBcmUloFCvXu1mo5v0a4d3D10eRj9RrNb8eiwK2tI=; b=c0csPtmaE6Ix54DOifrQpqdkVd4dJp64DBXilEtOzY8x/H8D9JytbR/IxcuUjWK2Of K/YTVMf6EqGBlgl+v1Yuex1oFbLK0rkopFCSJy/TQIGp6AnnSsCRwZce96Q/9SThjvVv Lb87f95CCi6aoz7mvf9yxENihkl/Sh2UBO1xXpBbLNF/H/c85PZ8rMZXk/90BfwCMcuS +z/xRXo6QJ1vnYDOfLX3YAP3IImVICZnXULp1ul50LTnbuJTIucpOVsrPhCgy5NHN8RK deR5EW1dbLhdzjz62OryrPtOH2jq4VQYstC3J3aIpqGFby8w3GSTTqBU0u/E4bjMpvGO 0fQg== X-Gm-Message-State: AOJu0YxY7FzbZBXaJOuaLsYfhr++0v1KHUHqMMyXIJ+nbiy3sV9uiWEU 9UIyTGDJTGvR64B3Omz7MQl2dCuthiIDe2zR/NCqW+yGkzgvlCrrxK0rf+mBKw== X-Gm-Gg: ASbGncvEmzqdWSjPUk7wxCQETKw/bu6RZ6h0tABHknCHorvamXkj03Z23Ev1hs3hr/h qNhfEaeF3fvjiPgi5F0OcznPg9KH5pTGv4VcUDqopT2DNWdTKFNzguPlHR4IPESRNq1QhxNXYHi 95sETbS2jXvmSftzO0E339w9sSQN5YOOzYxlzKcTBYmCrQv6VMQ7Sos4keC0HObYEYFO8AIZsFW mIzCjCOZbQadxFxJ6Mgk1EkYx15D6Y9VFizSdw0cKhCgxQXfWpP4YOkBhZ/Hjkfg8x+tPCWQGq2 ZeO1quoZ5UWg45KBffTnTQpDV2DV9ez3kN3lk/JeF3smVTyZSRJXDykNK85/kNJS79WCehOnOPb OzWRIbOc6a+iQl2JA X-Google-Smtp-Source: AGHT+IGJhWAYnOZ8oXGRg7Sr4bur4TMUn60pm9tWrpxRhfSv1IywtJPOQ/gqtE5ymXZv890Xp89tTQ== X-Received: by 2002:a17:902:cf41:b0:235:5a9:976f with SMTP id d9443c01a7336-237d9852fcfmr241801735ad.24.1750685960423; Mon, 23 Jun 2025 06:39:20 -0700 (PDT) Received: from [127.0.0.1] (master.gitmailbox.com. [34.83.118.50]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-237d860a861sm83917555ad.101.2025.06.23.06.39.19 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 23 Jun 2025 06:39:19 -0700 (PDT) From: Andreas Rheinhardt X-Google-Original-From: Andreas Rheinhardt Message-Id: <41d88c2ba4d2adeaddcd12099cfb6f66710785f1.1750685809.git.ffmpegagent@gmail.com> In-Reply-To: References: Date: Mon, 23 Jun 2025 13:36:26 +0000 Fcc: Sent MIME-Version: 1.0 To: ffmpeg-devel@ffmpeg.org Subject: [FFmpeg-devel] [PATCH 26/48] avcodec/h263dec: Add H263DecContext X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Andreas Rheinhardt Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Archived-At: List-Archive: List-Post: From: Andreas Rheinhardt 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 --- libavcodec/flvdec.c | 60 +- libavcodec/flvdec.h | 4 +- libavcodec/h263dec.c | 408 ++++---- libavcodec/h263dec.h | 22 +- libavcodec/intelh263dec.c | 110 +-- libavcodec/ituh263dec.c | 947 +++++++++--------- libavcodec/mpeg4video_parser.c | 4 +- libavcodec/mpeg4videodec.c | 1703 ++++++++++++++++---------------- libavcodec/mpeg4videodec.h | 13 +- libavcodec/mpegvideo.h | 1 - libavcodec/msmpeg4dec.c | 505 +++++----- libavcodec/msmpeg4dec.h | 11 +- libavcodec/nvdec_mpeg4.c | 2 +- libavcodec/rv10.c | 340 +++---- libavcodec/rv10dec.h | 4 +- libavcodec/vaapi_mpeg4.c | 2 +- libavcodec/vdpau_mpeg4.c | 2 +- libavcodec/wmv2.h | 4 +- libavcodec/wmv2dec.c | 321 +++--- libavcodec/wmv2dec.h | 5 +- libavcodec/wmv2enc.c | 2 +- 21 files changed, 2250 insertions(+), 2220 deletions(-) diff --git a/libavcodec/flvdec.c b/libavcodec/flvdec.c index e8c1595639..a5d96584f1 100644 --- a/libavcodec/flvdec.c +++ b/libavcodec/flvdec.c @@ -26,31 +26,31 @@ #include "mpegvideo.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; /* picture header */ - if (get_bits(&s->gb, 17) != 1) { - av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); + if (get_bits(&h->c.gb, 17) != 1) { + av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture start code\n"); return AVERROR_INVALIDDATA; } - format = get_bits(&s->gb, 5); + format = get_bits(&h->c.gb, 5); 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; } - s->h263_flv = format + 1; - s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ - format = get_bits(&s->gb, 3); + h->c.h263_flv = format + 1; + h->c.picture_number = get_bits(&h->c.gb, 8); /* picture timestamp */ + format = get_bits(&h->c.gb, 3); switch (format) { case 0: - width = get_bits(&s->gb, 8); - height = get_bits(&s->gb, 8); + width = get_bits(&h->c.gb, 8); + height = get_bits(&h->c.gb, 8); break; case 1: - width = get_bits(&s->gb, 16); - height = get_bits(&s->gb, 16); + width = get_bits(&h->c.gb, 16); + height = get_bits(&h->c.gb, 16); break; case 2: width = 352; @@ -76,32 +76,32 @@ int ff_flv_decode_picture_header(MpegEncContext *s) width = height = 0; 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); - s->width = width; - s->height = height; + h->c.width = width; + h->c.height = height; - s->pict_type = AV_PICTURE_TYPE_I + get_bits(&s->gb, 2); - s->droppable = s->pict_type > AV_PICTURE_TYPE_P; - if (s->droppable) - s->pict_type = AV_PICTURE_TYPE_P; + h->c.pict_type = AV_PICTURE_TYPE_I + get_bits(&h->c.gb, 2); + h->c.droppable = h->c.pict_type > AV_PICTURE_TYPE_P; + if (h->c.droppable) + h->c.pict_type = AV_PICTURE_TYPE_P; - skip_bits1(&s->gb); /* deblocking flag */ - s->chroma_qscale = s->qscale = get_bits(&s->gb, 5); + skip_bits1(&h->c.gb); /* deblocking flag */ + 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 */ - if (skip_1stop_8data_bits(&s->gb) < 0) + if (skip_1stop_8data_bits(&h->c.gb) < 0) return AVERROR_INVALIDDATA; - if (s->ehc_mode) - s->avctx->sample_aspect_ratio= (AVRational){1,2}; + if (h->c.ehc_mode) + h->c.avctx->sample_aspect_ratio= (AVRational){1,2}; - if (s->avctx->debug & FF_DEBUG_PICT_INFO) { - av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", - s->droppable ? 'D' : av_get_picture_type_char(s->pict_type), - s->h263_flv - 1, s->qscale, s->picture_number); + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) { + av_log(h->c.avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", + h->c.droppable ? 'D' : av_get_picture_type_char(h->c.pict_type), + h->c.h263_flv - 1, h->c.qscale, h->c.picture_number); } return 0; @@ -112,7 +112,7 @@ const FFCodec ff_flv_decoder = { CODEC_LONG_NAME("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"), .p.type = AVMEDIA_TYPE_VIDEO, .p.id = AV_CODEC_ID_FLV1, - .priv_data_size = sizeof(MpegEncContext), + .priv_data_size = sizeof(H263DecContext), .init = ff_h263_decode_init, FF_CODEC_DECODE_CB(ff_h263_decode_frame), .close = ff_mpv_decode_close, diff --git a/libavcodec/flvdec.h b/libavcodec/flvdec.h index d5aff74a98..e0f6d299ca 100644 --- a/libavcodec/flvdec.h +++ b/libavcodec/flvdec.h @@ -21,8 +21,8 @@ #ifndef 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 */ diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c index 7e454e3406..22bcf40681 100644 --- a/libavcodec/h263dec.c +++ b/libavcodec/h263dec.c @@ -90,7 +90,8 @@ static enum AVPixelFormat h263_get_format(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; int ret; @@ -101,7 +102,7 @@ av_cold int ff_h263_decode_init(AVCodecContext *avctx) if (ret < 0) return ret; - s->decode_mb = ff_h263_decode_mb; + h->decode_mb = ff_h263_decode_mb; s->low_delay = 1; 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); } -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; - const int mb_size = 16 >> s->avctx->lowres; + const int mb_size = 16 >> h->c.avctx->lowres; int ret; - s->last_resync_gb = s->gb; - s->first_slice_line = 1; - s->resync_mb_x = s->mb_x; - s->resync_mb_y = s->mb_y; + h->c.last_resync_gb = h->c.gb; + h->c.first_slice_line = 1; + h->c.resync_mb_x = h->c.mb_x; + 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 ((ret = ff_mpeg4_decode_studio_slice_header(s)) < 0) + if (h->c.studio_profile) { + if ((ret = ff_mpeg4_decode_studio_slice_header(h)) < 0) return ret; } - if (s->avctx->hwaccel) { - const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8; - ret = FF_HW_CALL(s->avctx, decode_slice, start, s->gb.buffer_end - start); + if (h->c.avctx->hwaccel) { + const uint8_t *start = h->c.gb.buffer + get_bits_count(&h->c.gb) / 8; + ret = FF_HW_CALL(h->c.avctx, decode_slice, start, h->c.gb.buffer_end - start); // ensure we exit decode loop - s->mb_y = s->mb_height; + h->c.mb_y = h->c.mb_height; return ret; } - if (s->partitioned_frame) { - const int qscale = s->qscale; + if (h->c.partitioned_frame) { + const int qscale = h->c.qscale; - if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) - if ((ret = ff_mpeg4_decode_partitions(s)) < 0) + if (CONFIG_MPEG4_DECODER && h->c.codec_id == AV_CODEC_ID_MPEG4) + if ((ret = ff_mpeg4_decode_partitions(h)) < 0) return ret; /* restore variables which were modified */ - s->first_slice_line = 1; - s->mb_x = s->resync_mb_x; - s->mb_y = s->resync_mb_y; - ff_set_qscale(s, qscale); + h->c.first_slice_line = 1; + h->c.mb_x = h->c.resync_mb_x; + h->c.mb_y = h->c.resync_mb_y; + 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 */ - if (s->msmpeg4_version != MSMP4_UNUSED) { - if (s->resync_mb_y + s->slice_height == s->mb_y) { - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x - 1, s->mb_y, ER_MB_END); + if (h->c.msmpeg4_version != MSMP4_UNUSED) { + if (h->c.resync_mb_y + h->c.slice_height == h->c.mb_y) { + ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, + h->c.mb_x - 1, h->c.mb_y, ER_MB_END); return 0; } } - if (s->msmpeg4_version == MSMP4_V1) { - s->last_dc[0] = - s->last_dc[1] = - s->last_dc[2] = 128; + if (h->c.msmpeg4_version == MSMP4_V1) { + h->c.last_dc[0] = + h->c.last_dc[1] = + h->c.last_dc[2] = 128; } - ff_init_block_index(s); - for (; s->mb_x < s->mb_width; s->mb_x++) { + ff_init_block_index(&h->c); + for (; h->c.mb_x < h->c.mb_width; h->c.mb_x++) { int ret; - ff_update_block_index(s, s->avctx->bits_per_raw_sample, - s->avctx->lowres, s->chroma_x_shift); + ff_update_block_index(&h->c, h->c.avctx->bits_per_raw_sample, + 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) - s->first_slice_line = 0; + if (h->c.resync_mb_x == h->c.mb_x && h->c.resync_mb_y + 1 == h->c.mb_y) + h->c.first_slice_line = 0; /* DCT & quantize */ - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - ff_dlog(s->avctx, "%d %06X\n", - get_bits_count(&s->gb), show_bits(&s->gb, 24)); + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + ff_dlog(h->c.avctx, "%d %06X\n", + 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); - ret = s->decode_mb(s, s->block); + ff_tlog(NULL, "Decoding MB at %dx%d\n", h->c.mb_x, h->c.mb_y); + ret = h->decode_mb(h, h->c.block); - if (s->h263_pred || s->h263_aic) { - int mb_xy = s->mb_y * s->mb_stride + s->mb_x; - if (!s->mb_intra) { - ff_h263_clean_intra_table_entries(s, mb_xy); + if (h->c.h263_pred || h->c.h263_aic) { + int mb_xy = h->c.mb_y * h->c.mb_stride + h->c.mb_x; + if (!h->c.mb_intra) { + ff_h263_clean_intra_table_entries(&h->c, mb_xy); } else - s->mbintra_table[mb_xy] = 1; + h->c.mbintra_table[mb_xy] = 1; } - if (s->pict_type != AV_PICTURE_TYPE_B) - ff_h263_update_motion_val(s); + if (h->c.pict_type != AV_PICTURE_TYPE_B) + ff_h263_update_motion_val(&h->c); 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) { - ff_mpv_reconstruct_mb(s, s->block); - if (s->loop_filter) - ff_h263_loop_filter(s); + ff_mpv_reconstruct_mb(&h->c, h->c.block); + if (h->c.loop_filter) + ff_h263_loop_filter(&h->c); - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x, s->mb_y, ER_MB_END & part_mask); + 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); - s->padding_bug_score--; + h->c.padding_bug_score--; - if (++s->mb_x >= s->mb_width) { - s->mb_x = 0; - report_decode_progress(s); - ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); - s->mb_y++; + if (++h->c.mb_x >= h->c.mb_width) { + h->c.mb_x = 0; + report_decode_progress(&h->c); + ff_mpeg_draw_horiz_band(&h->c, h->c.mb_y * mb_size, mb_size); + h->c.mb_y++; } return 0; } 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); - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x + 1, s->mb_y, + ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, + h->c.mb_x + 1, h->c.mb_y, ER_MB_END & part_mask); return AVERROR_INVALIDDATA; } - av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x, s->mb_y, ER_MB_ERROR & part_mask); + av_log(h->c.avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); + ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, + h->c.mb_x, h->c.mb_y, ER_MB_ERROR & part_mask); - 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; return AVERROR_INVALIDDATA; } - ff_mpv_reconstruct_mb(s, s->block); - if (s->loop_filter) - ff_h263_loop_filter(s); + ff_mpv_reconstruct_mb(&h->c, h->c.block); + if (h->c.loop_filter) + ff_h263_loop_filter(&h->c); } - report_decode_progress(s); - ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); + report_decode_progress(&h->c); + 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 - if (s->codec_id == AV_CODEC_ID_MPEG4 && - (s->workaround_bugs & FF_BUG_AUTODETECT) && - get_bits_left(&s->gb) >= 48 && - show_bits(&s->gb, 24) == 0x4010 && - !s->data_partitioning) - s->padding_bug_score += 32; + if (h->c.codec_id == AV_CODEC_ID_MPEG4 && + (h->c.workaround_bugs & FF_BUG_AUTODETECT) && + get_bits_left(&h->c.gb) >= 48 && + show_bits(&h->c.gb, 24) == 0x4010 && + !h->c.data_partitioning) + h->c.padding_bug_score += 32; /* try to detect the padding bug */ - if (s->codec_id == AV_CODEC_ID_MPEG4 && - (s->workaround_bugs & FF_BUG_AUTODETECT) && - get_bits_left(&s->gb) >= 0 && - get_bits_left(&s->gb) < 137 && - !s->data_partitioning) { - const int bits_count = get_bits_count(&s->gb); - const int bits_left = s->gb.size_in_bits - bits_count; + if (h->c.codec_id == AV_CODEC_ID_MPEG4 && + (h->c.workaround_bugs & FF_BUG_AUTODETECT) && + get_bits_left(&h->c.gb) >= 0 && + get_bits_left(&h->c.gb) < 137 && + !h->c.data_partitioning) { + const int bits_count = get_bits_count(&h->c.gb); + const int bits_left = h->c.gb.size_in_bits - bits_count; if (bits_left == 0) { - s->padding_bug_score += 16; + h->c.padding_bug_score += 16; } 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)); if (v == 0x7F && bits_left <= 8) - s->padding_bug_score--; - else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) && + h->c.padding_bug_score--; + else if (v == 0x7F && ((get_bits_count(&h->c.gb) + 8) & 8) && bits_left <= 16) - s->padding_bug_score += 4; + h->c.padding_bug_score += 4; else - s->padding_bug_score++; + h->c.padding_bug_score++; } } - if (s->codec_id == AV_CODEC_ID_H263 && - (s->workaround_bugs & FF_BUG_AUTODETECT) && - get_bits_left(&s->gb) >= 8 && - get_bits_left(&s->gb) < 300 && - s->pict_type == AV_PICTURE_TYPE_I && - show_bits(&s->gb, 8) == 0 && - !s->data_partitioning) { + if (h->c.codec_id == AV_CODEC_ID_H263 && + (h->c.workaround_bugs & FF_BUG_AUTODETECT) && + get_bits_left(&h->c.gb) >= 8 && + get_bits_left(&h->c.gb) < 300 && + h->c.pict_type == AV_PICTURE_TYPE_I && + show_bits(&h->c.gb, 8) == 0 && + !h->c.data_partitioning) { - s->padding_bug_score += 32; + h->c.padding_bug_score += 32; } - if (s->codec_id == AV_CODEC_ID_H263 && - (s->workaround_bugs & FF_BUG_AUTODETECT) && - get_bits_left(&s->gb) >= 64 && - AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) { + if (h->c.codec_id == AV_CODEC_ID_H263 && + (h->c.workaround_bugs & FF_BUG_AUTODETECT) && + get_bits_left(&h->c.gb) >= 64 && + 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 ( - (s->padding_bug_score > -2 && !s->data_partitioning)) - s->workaround_bugs |= FF_BUG_NO_PADDING; + (h->c.padding_bug_score > -2 && !h->c.data_partitioning)) + h->c.workaround_bugs |= FF_BUG_NO_PADDING; 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 - if (s->msmpeg4_version != MSMP4_UNUSED || (s->workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly - int left = get_bits_left(&s->gb); + if (h->c.msmpeg4_version != MSMP4_UNUSED || (h->c.workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly + int left = get_bits_left(&h->c.gb); int max_extra = 7; /* 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; /* buggy padding but the frame should still end approximately at * the bitstream end */ - if ((s->workaround_bugs & FF_BUG_NO_PADDING) && - (s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) + if ((h->c.workaround_bugs & FF_BUG_NO_PADDING) && + (h->c.avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) 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; 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", - left, show_bits(&s->gb, 24)); + left, show_bits(&h->c.gb, 24)); 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 - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x - 1, s->mb_y, ER_MB_END); + ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, + h->c.mb_x - 1, h->c.mb_y, ER_MB_END); 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", - 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); return AVERROR_INVALIDDATA; @@ -420,9 +421,10 @@ static int decode_slice(MpegEncContext *s) int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt) { + H263DecContext *const h = avctx->priv_data; + MPVContext *const s = &h->c; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; - MpegEncContext *s = avctx->priv_data; int ret; int slice_ret = 0; int bak_width, bak_height; @@ -430,10 +432,10 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, /* no supplementary picture */ if (buf_size == 0) { /* special case for last picture */ - if ((!s->low_delay || s->skipped_last_frame) && s->next_pic.ptr) { - if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0) + if ((!h->c.low_delay || h->c.skipped_last_frame) && h->c.next_pic.ptr) { + if ((ret = av_frame_ref(pict, h->c.next_pic.ptr->f)) < 0) 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 * in display order, but with the props from the last input * 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; } - ff_mpv_unref_picture(&s->next_pic); + ff_mpv_unref_picture(&h->c.next_pic); *got_frame = 1; } @@ -450,37 +452,37 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, return 0; } - // s->gb might be overridden in ff_mpeg4_decode_picture_header() below. - ret = init_get_bits8(&s->gb, buf, buf_size); + // h->c.gb might be overridden in ff_mpeg4_decode_picture_header() below. + ret = init_get_bits8(&h->c.gb, buf, buf_size); if (ret < 0) return ret; - bak_width = s->width; - bak_height = s->height; + bak_width = h->c.width; + bak_height = h->c.height; /* let's go :-) */ - if (CONFIG_WMV2_DECODER && s->msmpeg4_version == MSMP4_WMV2) { - ret = ff_wmv2_decode_picture_header(s); + if (CONFIG_WMV2_DECODER && h->c.msmpeg4_version == MSMP4_WMV2) { + ret = ff_wmv2_decode_picture_header(h); #if CONFIG_MSMPEG4DEC - } else if (s->msmpeg4_version != MSMP4_UNUSED) { - ret = ff_msmpeg4_decode_picture_header(s); + } else if (h->c.msmpeg4_version != MSMP4_UNUSED) { + ret = ff_msmpeg4_decode_picture_header(h); #endif } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) { - ret = ff_mpeg4_decode_picture_header(s); - } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) { - ret = ff_intel_h263_decode_picture_header(s); - } else if (CONFIG_FLV_DECODER && s->h263_flv) { - ret = ff_flv_decode_picture_header(s); + ret = ff_mpeg4_decode_picture_header(h); + } else if (CONFIG_H263I_DECODER && h->c.codec_id == AV_CODEC_ID_H263I) { + ret = ff_intel_h263_decode_picture_header(h); + } else if (CONFIG_FLV_DECODER && h->c.h263_flv) { + ret = ff_flv_decode_picture_header(h); } else { - ret = ff_h263_decode_picture_header(s); + ret = ff_h263_decode_picture_header(h); } if (ret < 0 || ret == FRAME_SKIPPED) { - if ( s->width != bak_width - || s->height != bak_height) { - av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n"); - s->width = bak_width; - s->height= bak_height; + if ( h->c.width != bak_width + || h->c.height != bak_height) { + av_log(h->c.avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n"); + h->c.width = bak_width; + h->c.height= bak_height; } } @@ -489,23 +491,23 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, /* skip if the header was thrashed */ 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; } - if (!s->context_initialized) { + if (!h->c.context_initialized) { avctx->pix_fmt = h263_get_format(avctx); if ((ret = ff_mpv_common_init(s)) < 0) 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 (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; 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); } @@ -513,13 +515,13 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, * and other parameters. So then we could init the picture. * FIXME: By the way H.263 decoder is evolving it should have * an H263EncContext */ - if (s->width != avctx->coded_width || - s->height != avctx->coded_height || - s->context_reinit) { + if (h->c.width != avctx->coded_width || + h->c.height != avctx->coded_height || + h->c.context_reinit) { /* 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) return ret; @@ -536,25 +538,25 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, } /* skip B-frames if we don't have reference frames */ - if (!s->last_pic.ptr && - (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) + if (!h->c.last_pic.ptr && + (h->c.pict_type == AV_PICTURE_TYPE_B || h->c.droppable)) return buf_size; 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 && - s->pict_type != AV_PICTURE_TYPE_I) || + h->c.pict_type != AV_PICTURE_TYPE_I) || avctx->skip_frame >= AVDISCARD_ALL) return buf_size; if ((ret = ff_mpv_frame_start(s, avctx)) < 0) return ret; - if (!s->divx_packed) + if (!h->c.divx_packed) ff_thread_finish_setup(avctx); if (avctx->hwaccel) { 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 ) return ret; } @@ -565,8 +567,8 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, * are stored in current_picture->mb_type which is not available before * ff_mpv_frame_start() */ #if CONFIG_WMV2_DECODER - if (s->msmpeg4_version == MSMP4_WMV2) { - ret = ff_wmv2_decode_secondary_picture_header(s); + if (h->c.msmpeg4_version == MSMP4_WMV2) { + ret = ff_wmv2_decode_secondary_picture_header(h); if (ret < 0) return ret; if (ret == 1) @@ -575,39 +577,39 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, #endif /* decode each macroblock */ - s->mb_x = 0; - s->mb_y = 0; - - slice_ret = decode_slice(s); - while (s->mb_y < s->mb_height) { - if (s->msmpeg4_version != MSMP4_UNUSED) { - if (s->slice_height == 0 || s->mb_x != 0 || slice_ret < 0 || - (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0) + h->c.mb_x = 0; + h->c.mb_y = 0; + + slice_ret = decode_slice(h); + while (h->c.mb_y < h->c.mb_height) { + if (h->c.msmpeg4_version != MSMP4_UNUSED) { + if (h->c.slice_height == 0 || h->c.mb_x != 0 || slice_ret < 0 || + (h->c.mb_y % h->c.slice_height) != 0 || get_bits_left(&h->c.gb) < 0) break; } else { - int prev_x = s->mb_x, prev_y = s->mb_y; - if (ff_h263_resync(s) < 0) + int prev_x = h->c.mb_x, prev_y = h->c.mb_y; + if (ff_h263_resync(h) < 0) break; - if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x) - s->er.error_occurred = 1; + if (prev_y * h->c.mb_width + prev_x < h->c.mb_y * h->c.mb_width + h->c.mb_x) + 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); - if (decode_slice(s) < 0) + if (decode_slice(h) < 0) slice_ret = AVERROR_INVALIDDATA; } - if (s->msmpeg4_version != MSMP4_UNUSED && s->msmpeg4_version < MSMP4_WMV1 && - s->pict_type == AV_PICTURE_TYPE_I) + if (h->c.msmpeg4_version != MSMP4_UNUSED && h->c.msmpeg4_version < MSMP4_WMV1 && + h->c.pict_type == AV_PICTURE_TYPE_I) if (!CONFIG_MSMPEG4DEC || - ff_msmpeg4_decode_ext_header(s, buf_size) < 0) - s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR; + ff_msmpeg4_decode_ext_header(h, buf_size) < 0) + h->c.er.error_status_table[h->c.mb_num - 1] = ER_MB_ERROR; frame_end: - if (!s->studio_profile) - ff_er_frame_end(&s->er, NULL); + if (!h->c.studio_profile) + ff_er_frame_end(&h->c.er, NULL); if (avctx->hwaccel) { ret = FF_HW_SIMPLE_CALL(avctx, end_frame); @@ -620,22 +622,22 @@ frame_end: if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) ff_mpeg4_frame_end(avctx, avpkt); - av_assert1(s->pict_type == s->cur_pic.ptr->f->pict_type); - if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { - if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0) + av_assert1(h->c.pict_type == h->c.cur_pic.ptr->f->pict_type); + if (h->c.pict_type == AV_PICTURE_TYPE_B || h->c.low_delay) { + if ((ret = av_frame_ref(pict, h->c.cur_pic.ptr->f)) < 0) return ret; - ff_print_debug_info(s, s->cur_pic.ptr, pict); - ff_mpv_export_qp_table(s, pict, s->cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1); - } else if (s->last_pic.ptr) { - if ((ret = av_frame_ref(pict, s->last_pic.ptr->f)) < 0) + ff_print_debug_info(s, h->c.cur_pic.ptr, pict); + ff_mpv_export_qp_table(s, pict, h->c.cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1); + } else if (h->c.last_pic.ptr) { + if ((ret = av_frame_ref(pict, h->c.last_pic.ptr->f)) < 0) return ret; - ff_print_debug_info(s, s->last_pic.ptr, pict); - ff_mpv_export_qp_table(s, pict, s->last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1); + ff_print_debug_info(s, h->c.last_pic.ptr, pict); + 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 - && (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++) { int h = AV_CEIL_RSHIFT(pict->height, !!p); @@ -673,7 +675,7 @@ const FFCodec ff_h263_decoder = { CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), .p.type = AVMEDIA_TYPE_VIDEO, .p.id = AV_CODEC_ID_H263, - .priv_data_size = sizeof(MpegEncContext), + .priv_data_size = sizeof(H263DecContext), .init = ff_h263_decode_init, FF_CODEC_DECODE_CB(ff_h263_decode_frame), .close = ff_mpv_decode_close, @@ -691,7 +693,7 @@ const FFCodec ff_h263p_decoder = { CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), .p.type = AVMEDIA_TYPE_VIDEO, .p.id = AV_CODEC_ID_H263P, - .priv_data_size = sizeof(MpegEncContext), + .priv_data_size = sizeof(H263DecContext), .init = ff_h263_decode_init, FF_CODEC_DECODE_CB(ff_h263_decode_frame), .close = ff_mpv_decode_close, diff --git a/libavcodec/h263dec.h b/libavcodec/h263dec.h index c1306c7ec5..0600e0bcb0 100644 --- a/libavcodec/h263dec.h +++ b/libavcodec/h263dec.h @@ -43,24 +43,30 @@ extern VLCElem ff_h263_inter_MCBPC_vlc[]; extern VLCElem ff_h263_cbpy_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_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt); void ff_h263_decode_init_vlc(void); -int ff_h263_decode_picture_header(MpegEncContext *s); -int ff_h263_decode_gob_header(MpegEncContext *s); -int ff_h263_decode_mba(MpegEncContext *s); +int ff_h263_decode_picture_header(H263DecContext *const h); +int ff_h263_decode_gob_header(H263DecContext *const h); +int ff_h263_decode_mba(H263DecContext *const h); /** * 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_h263_decode_mb(MpegEncContext *s, +int ff_intel_h263_decode_picture_header(H263DecContext *const h); +int ff_h263_decode_mb(H263DecContext *const h, int16_t block[6][64]); -int ff_h263_resync(MpegEncContext *s); +int ff_h263_resync(H263DecContext *const h); #endif diff --git a/libavcodec/intelh263dec.c b/libavcodec/intelh263dec.c index 02016e93bf..d7242f4922 100644 --- a/libavcodec/intelh263dec.c +++ b/libavcodec/intelh263dec.c @@ -26,102 +26,102 @@ #include "h263dec.h" /* 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; - if (get_bits_left(&s->gb) == 64) { /* special dummy frames */ + if (get_bits_left(&h->c.gb) == 64) { /* special dummy frames */ return FRAME_SKIPPED; } /* picture header */ - if (get_bits(&s->gb, 22) != 0x20) { - av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); + if (get_bits(&h->c.gb, 22) != 0x20) { + av_log(h->c.avctx, AV_LOG_ERROR, "Bad picture start code\n"); 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 */ } - if (get_bits1(&s->gb) != 0) { - av_log(s->avctx, AV_LOG_ERROR, "Bad H.263 id\n"); + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Bad H.263 id\n"); return -1; /* H.263 id */ } - skip_bits1(&s->gb); /* split screen off */ - skip_bits1(&s->gb); /* camera off */ - skip_bits1(&s->gb); /* freeze picture release off */ + skip_bits1(&h->c.gb); /* split screen off */ + skip_bits1(&h->c.gb); /* camera 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) { - 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; } - 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) { - av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "SAC not supported\n"); return -1; /* SAC: off */ } - s->obmc= get_bits1(&s->gb); - s->pb_frame = get_bits1(&s->gb); + h->c.obmc = get_bits1(&h->c.gb); + h->c.pb_frame = get_bits1(&h->c.gb); if (format < 6) { - s->width = ff_h263_format[format][0]; - s->height = ff_h263_format[format][1]; - s->avctx->sample_aspect_ratio.num = 12; - s->avctx->sample_aspect_ratio.den = 11; + h->c.width = ff_h263_format[format][0]; + h->c.height = ff_h263_format[format][1]; + h->c.avctx->sample_aspect_ratio.num = 12; + h->c.avctx->sample_aspect_ratio.den = 11; } else { - format = get_bits(&s->gb, 3); + format = get_bits(&h->c.gb, 3); 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; } - if(get_bits(&s->gb, 2)) - av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); - s->loop_filter = get_bits1(&s->gb) * !s->avctx->lowres; - if(get_bits1(&s->gb)) - av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); - if(get_bits1(&s->gb)) - s->pb_frame = 2; - if(get_bits(&s->gb, 5)) - av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); - if(get_bits(&s->gb, 5) != 1) - av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n"); + if (get_bits(&h->c.gb, 2)) + av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); + h->c.loop_filter = get_bits1(&h->c.gb) * !h->c.avctx->lowres; + if (get_bits1(&h->c.gb)) + av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); + if (get_bits1(&h->c.gb)) + h->c.pb_frame = 2; + if (get_bits(&h->c.gb, 5)) + av_log(h->c.avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); + if (get_bits(&h->c.gb, 5) != 1) + av_log(h->c.avctx, AV_LOG_ERROR, "Invalid marker\n"); } if(format == 6){ - int ar = get_bits(&s->gb, 4); - skip_bits(&s->gb, 9); // display width - check_marker(s->avctx, &s->gb, "in dimensions"); - skip_bits(&s->gb, 9); // display height - if(ar == 15){ - s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 8); // aspect ratio - width - s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 8); // aspect ratio - height + int ar = get_bits(&h->c.gb, 4); + skip_bits(&h->c.gb, 9); // display width + check_marker(h->c.avctx, &h->c.gb, "in dimensions"); + skip_bits(&h->c.gb, 9); // display height + if (ar == 15) { + h->c.avctx->sample_aspect_ratio.num = get_bits(&h->c.gb, 8); // aspect ratio - width + h->c.avctx->sample_aspect_ratio.den = get_bits(&h->c.gb, 8); // aspect ratio - height } 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) - av_log(s->avctx, AV_LOG_ERROR, "Invalid aspect ratio.\n"); + if (h->c.avctx->sample_aspect_ratio.num == 0) + av_log(h->c.avctx, AV_LOG_ERROR, "Invalid aspect ratio.\n"); } - s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); - skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ + h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); + skip_bits1(&h->c.gb); /* Continuous Presence Multipoint mode: off */ - if(s->pb_frame){ - skip_bits(&s->gb, 3); //temporal reference for B-frame - skip_bits(&s->gb, 2); //dbquant + if (h->c.pb_frame) { + skip_bits(&h->c.gb, 3); //temporal reference for B-frame + skip_bits(&h->c.gb, 2); //dbquant } /* PEI */ - if (skip_1stop_8data_bits(&s->gb) < 0) + if (skip_1stop_8data_bits(&h->c.gb) < 0) 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; } @@ -131,7 +131,7 @@ const FFCodec ff_h263i_decoder = { CODEC_LONG_NAME("Intel H.263"), .p.type = AVMEDIA_TYPE_VIDEO, .p.id = AV_CODEC_ID_H263I, - .priv_data_size = sizeof(MpegEncContext), + .priv_data_size = sizeof(H263DecContext), .init = ff_h263_decode_init, FF_CODEC_DECODE_CB(ff_h263_decode_frame), .close = ff_mpv_decode_close, diff --git a/libavcodec/ituh263dec.c b/libavcodec/ituh263dec.c index f5001200fe..d37ebaeb0b 100644 --- a/libavcodec/ituh263dec.c +++ b/libavcodec/ituh263dec.c @@ -77,23 +77,22 @@ static const int16_t h263_mb_type_b_map[15]= { MB_TYPE_INTRA4x4 | MB_TYPE_CBP | MB_TYPE_QUANT, }; -void ff_h263_show_pict_info(MpegEncContext *s, int h263_plus) +void ff_h263_show_pict_info(H263DecContext *const h, int h263_plus) { - if(s->avctx->debug&FF_DEBUG_PICT_INFO){ - av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", - s->qscale, av_get_picture_type_char(s->pict_type), - s->gb.size_in_bits, 1-s->no_rounding, - s->obmc ? " AP" : "", - s->umvplus ? " UMV" : "", - s->h263_long_vectors ? " LONG" : "", - h263_plus ? " +" : "", - s->h263_aic ? " AIC" : "", - s->alt_inter_vlc ? " AIV" : "", - s->modified_quant ? " MQ" : "", - s->loop_filter ? " LOOP" : "", - s->h263_slice_structured ? " SS" : "", - s->avctx->framerate.num, s->avctx->framerate.den - ); + if (h->c.avctx->debug&FF_DEBUG_PICT_INFO) { + av_log(h->c.avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", + h->c.qscale, av_get_picture_type_char(h->c.pict_type), + h->c.gb.size_in_bits, 1-h->c.no_rounding, + h->c.obmc ? " AP" : "", + h->c.umvplus ? " UMV" : "", + h->c.h263_long_vectors ? " LONG" : "", + h263_plus ? " +" : "", + h->c.h263_aic ? " AIC" : "", + h->c.alt_inter_vlc ? " AIV" : "", + h->c.modified_quant ? " MQ" : "", + h->c.loop_filter ? " LOOP" : "", + h->c.h263_slice_structured ? " SS" : "", + h->c.avctx->framerate.num, h->c.avctx->framerate.den); } } @@ -140,16 +139,16 @@ av_cold void ff_h263_decode_init_vlc(void) ff_thread_once(&init_static_once, h263_decode_init_vlc); } -int ff_h263_decode_mba(MpegEncContext *s) +int ff_h263_decode_mba(H263DecContext *const h) { int i, mb_pos; for (i = 0; i < 6; i++) - if (s->mb_num - 1 <= ff_mba_max[i]) + if (h->c.mb_num - 1 <= ff_mba_max[i]) break; - mb_pos = get_bits(&s->gb, ff_mba_length[i]); - s->mb_x = mb_pos % s->mb_width; - s->mb_y = mb_pos / s->mb_width; + mb_pos = get_bits(&h->c.gb, ff_mba_length[i]); + h->c.mb_x = mb_pos % h->c.mb_width; + h->c.mb_y = mb_pos / h->c.mb_width; return mb_pos; } @@ -158,53 +157,53 @@ int ff_h263_decode_mba(MpegEncContext *s) * Decode the group of blocks header or slice header. * @return <0 if an error occurred */ -static int h263_decode_gob_header(MpegEncContext *s) +static int h263_decode_gob_header(H263DecContext *const h) { unsigned int val, gob_number; int left; /* Check for GOB Start Code */ - val = show_bits(&s->gb, 16); + val = show_bits(&h->c.gb, 16); if(val) return -1; /* We have a GBSC probably with GSTUFF */ - skip_bits(&s->gb, 16); /* Drop the zeros */ - left= get_bits_left(&s->gb); + skip_bits(&h->c.gb, 16); /* Drop the zeros */ + left = get_bits_left(&h->c.gb); left = FFMIN(left, 32); //MN: we must check the bits left or we might end in an infinite loop (or segfault) for(;left>13; left--){ - if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ + if (get_bits1(&h->c.gb)) break; /* Seek the '1' bit */ } if(left<=13) return -1; - if(s->h263_slice_structured){ - if(check_marker(s->avctx, &s->gb, "before MBA")==0) + if (h->c.h263_slice_structured) { + if (check_marker(h->c.avctx, &h->c.gb, "before MBA")==0) return -1; - ff_h263_decode_mba(s); + ff_h263_decode_mba(h); - if(s->mb_num > 1583) - if(check_marker(s->avctx, &s->gb, "after MBA")==0) + if (h->c.mb_num > 1583) + if (check_marker(h->c.avctx, &h->c.gb, "after MBA")==0) return -1; - s->qscale = get_bits(&s->gb, 5); /* SQUANT */ - if(check_marker(s->avctx, &s->gb, "after SQUANT")==0) + h->c.qscale = get_bits(&h->c.gb, 5); /* SQUANT */ + if (check_marker(h->c.avctx, &h->c.gb, "after SQUANT")==0) return -1; - skip_bits(&s->gb, 2); /* GFID */ + skip_bits(&h->c.gb, 2); /* GFID */ }else{ - gob_number = get_bits(&s->gb, 5); /* GN */ - s->mb_x= 0; - s->mb_y= s->gob_index* gob_number; - skip_bits(&s->gb, 2); /* GFID */ - s->qscale = get_bits(&s->gb, 5); /* GQUANT */ + gob_number = get_bits(&h->c.gb, 5); /* GN */ + h->c.mb_x = 0; + h->c.mb_y = h->c.gob_index* gob_number; + skip_bits(&h->c.gb, 2); /* GFID */ + h->c.qscale = get_bits(&h->c.gb, 5); /* GQUANT */ } - if(s->mb_y >= s->mb_height) + if (h->c.mb_y >= h->c.mb_height) return -1; - if(s->qscale==0) + if (h->c.qscale==0) return -1; return 0; @@ -214,79 +213,80 @@ static int h263_decode_gob_header(MpegEncContext *s) * Decode the group of blocks / video packet header / slice header (MPEG-4 Studio). * @return bit position of the resync_marker, or <0 if none was found */ -int ff_h263_resync(MpegEncContext *s){ +int ff_h263_resync(H263DecContext *const h) +{ int left, pos, ret; /* In MPEG-4 studio mode look for a new slice startcode * and decode slice header */ - if(s->codec_id==AV_CODEC_ID_MPEG4 && s->studio_profile) { - align_get_bits(&s->gb); + if (h->c.codec_id==AV_CODEC_ID_MPEG4 && h->c.studio_profile) { + align_get_bits(&h->c.gb); - while (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) != SLICE_STARTCODE) { - get_bits(&s->gb, 8); + while (get_bits_left(&h->c.gb) >= 32 && show_bits_long(&h->c.gb, 32) != SLICE_STARTCODE) { + get_bits(&h->c.gb, 8); } - if (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) == SLICE_STARTCODE) - return get_bits_count(&s->gb); + if (get_bits_left(&h->c.gb) >= 32 && show_bits_long(&h->c.gb, 32) == SLICE_STARTCODE) + return get_bits_count(&h->c.gb); else return -1; } - if(s->codec_id==AV_CODEC_ID_MPEG4){ - skip_bits1(&s->gb); - align_get_bits(&s->gb); + if (h->c.codec_id==AV_CODEC_ID_MPEG4){ + skip_bits1(&h->c.gb); + align_get_bits(&h->c.gb); } - if(show_bits(&s->gb, 16)==0){ - pos= get_bits_count(&s->gb); - if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) - ret = ff_mpeg4_decode_video_packet_header(s); + if (show_bits(&h->c.gb, 16) ==0) { + pos = get_bits_count(&h->c.gb); + if(CONFIG_MPEG4_DECODER && h->c.codec_id==AV_CODEC_ID_MPEG4) + ret = ff_mpeg4_decode_video_packet_header(h); else - ret= h263_decode_gob_header(s); + ret = h263_decode_gob_header(h); if(ret>=0) return pos; } //OK, it's not where it is supposed to be ... - s->gb= s->last_resync_gb; - align_get_bits(&s->gb); - left= get_bits_left(&s->gb); + h->c.gb = h->c.last_resync_gb; + align_get_bits(&h->c.gb); + left = get_bits_left(&h->c.gb); for(;left>16+1+5+5; left-=8){ - if(show_bits(&s->gb, 16)==0){ - GetBitContext bak= s->gb; + if (show_bits(&h->c.gb, 16) == 0){ + GetBitContext bak = h->c.gb; - pos= get_bits_count(&s->gb); - if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) - ret = ff_mpeg4_decode_video_packet_header(s); + pos = get_bits_count(&h->c.gb); + if(CONFIG_MPEG4_DECODER && h->c.codec_id==AV_CODEC_ID_MPEG4) + ret = ff_mpeg4_decode_video_packet_header(h); else - ret= h263_decode_gob_header(s); + ret = h263_decode_gob_header(h); if(ret>=0) return pos; - s->gb= bak; + h->c.gb = bak; } - skip_bits(&s->gb, 8); + skip_bits(&h->c.gb, 8); } return -1; } -int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code) +int ff_h263_decode_motion(H263DecContext *const h, int pred, int f_code) { 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); if (code == 0) return pred; if (code < 0) return 0xffff; - sign = get_bits1(&s->gb); + sign = get_bits1(&h->c.gb); shift = f_code - 1; val = code; if (shift) { val = (val - 1) << shift; - val |= get_bits(&s->gb, shift); + val |= get_bits(&h->c.gb, shift); val++; } if (sign) @@ -294,7 +294,7 @@ int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code) val += pred; /* modulo decoding */ - if (!s->h263_long_vectors) { + if (!h->c.h263_long_vectors) { val = sign_extend(val, 5 + f_code); } else { /* horrible H.263 long vector mode */ @@ -309,21 +309,21 @@ int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code) /* Decode RVLC of H.263+ UMV */ -static int h263p_decode_umotion(MpegEncContext * s, int pred) +static int h263p_decode_umotion(H263DecContext *const h, int pred) { int code = 0, sign; - if (get_bits1(&s->gb)) /* Motion difference = 0 */ + if (get_bits1(&h->c.gb)) /* Motion difference = 0 */ return pred; - code = 2 + get_bits1(&s->gb); + code = 2 + get_bits1(&h->c.gb); - while (get_bits1(&s->gb)) + while (get_bits1(&h->c.gb)) { code <<= 1; - code += get_bits1(&s->gb); + code += get_bits1(&h->c.gb); if (code >= 32768) { - avpriv_request_sample(s->avctx, "Huge DMV"); + avpriv_request_sample(h->c.avctx, "Huge DMV"); return 0xffff; } } @@ -331,7 +331,7 @@ static int h263p_decode_umotion(MpegEncContext * s, int pred) code >>= 1; code = (sign) ? (pred - code) : (pred + code); - ff_tlog(s->avctx,"H.263+ UMV Motion = %d\n", code); + ff_tlog(h->c.avctx,"H.263+ UMV Motion = %d\n", code); return code; } @@ -339,82 +339,79 @@ static int h263p_decode_umotion(MpegEncContext * s, int pred) /** * read the next MVs for OBMC. yes this is an ugly hack, feel free to send a patch :) */ -static void preview_obmc(MpegEncContext *s){ - GetBitContext gb= s->gb; +static void preview_obmc(H263DecContext *const h) +{ + GetBitContext gb = h->c.gb; int cbpc, i, pred_x, pred_y, mx, my; int16_t *mot_val; - const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; - const int stride= s->b8_stride*2; + const int xy = h->c.mb_x + 1 + h->c.mb_y * h->c.mb_stride; + const int stride = h->c.b8_stride * 2; for(i=0; i<4; i++) - s->block_index[i]+= 2; + h->c.block_index[i] += 2; for(i=4; i<6; i++) - s->block_index[i]+= 1; - s->mb_x++; + h->c.block_index[i] += 1; + h->c.mb_x++; - av_assert2(s->pict_type == AV_PICTURE_TYPE_P); + av_assert2(h->c.pict_type == AV_PICTURE_TYPE_P); do{ - if (get_bits1(&s->gb)) { + if (get_bits1(&h->c.gb)) { /* skip mb */ - mot_val = s->cur_pic.motion_val[0][s->block_index[0]]; + mot_val = h->c.cur_pic.motion_val[0][h->c.block_index[0]]; mot_val[0 ]= mot_val[2 ]= mot_val[0+stride]= mot_val[2+stride]= 0; mot_val[1 ]= mot_val[3 ]= mot_val[1+stride]= mot_val[3+stride]= 0; - s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; goto end; } - cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); + cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); }while(cbpc == 20); if(cbpc & 4){ - s->cur_pic.mb_type[xy] = MB_TYPE_INTRA; + h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; }else{ - get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); if (cbpc & 8) { - if(s->modified_quant){ - if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); - else skip_bits(&s->gb, 5); - }else - skip_bits(&s->gb, 2); + skip_bits(&h->c.gb, h->c.modified_quant ? (get_bits1(&h->c.gb) ? 1 : 5) : 2); } if ((cbpc & 16) == 0) { - s->cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + h->c.cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; /* 16x16 motion prediction */ - mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); - if (s->umvplus) - mx = h263p_decode_umotion(s, pred_x); + mot_val= ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y); + if (h->c.umvplus) + mx = h263p_decode_umotion(h, pred_x); else - mx = ff_h263_decode_motion(s, pred_x, 1); + mx = ff_h263_decode_motion(h, pred_x, 1); - if (s->umvplus) - my = h263p_decode_umotion(s, pred_y); + if (h->c.umvplus) + my = h263p_decode_umotion(h, pred_y); else - my = ff_h263_decode_motion(s, pred_y, 1); + my = ff_h263_decode_motion(h, pred_y, 1); mot_val[0 ]= mot_val[2 ]= mot_val[0+stride]= mot_val[2+stride]= mx; mot_val[1 ]= mot_val[3 ]= mot_val[1+stride]= mot_val[3+stride]= my; } else { - s->cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; + h->c.cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; for(i=0;i<4;i++) { - mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); - if (s->umvplus) - mx = h263p_decode_umotion(s, pred_x); + mot_val = ff_h263_pred_motion(&h->c, i, 0, &pred_x, &pred_y); + if (h->c.umvplus) + mx = h263p_decode_umotion(h, pred_x); else - mx = ff_h263_decode_motion(s, pred_x, 1); + mx = ff_h263_decode_motion(h, pred_x, 1); - if (s->umvplus) - my = h263p_decode_umotion(s, pred_y); + if (h->c.umvplus) + my = h263p_decode_umotion(h, pred_y); else - my = ff_h263_decode_motion(s, pred_y, 1); - if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) - skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ + my = ff_h263_decode_motion(h, pred_y, 1); + if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) + skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ mot_val[0] = mx; mot_val[1] = my; } @@ -423,26 +420,27 @@ static void preview_obmc(MpegEncContext *s){ end: for(i=0; i<4; i++) - s->block_index[i]-= 2; + h->c.block_index[i] -= 2; for(i=4; i<6; i++) - s->block_index[i]-= 1; - s->mb_x--; + h->c.block_index[i] -= 1; + h->c.mb_x--; - s->gb= gb; + h->c.gb = gb; } -static void h263_decode_dquant(MpegEncContext *s){ +static void h263_decode_dquant(H263DecContext *const h) +{ static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; int qscale; - if(s->modified_quant){ - if(get_bits1(&s->gb)) - qscale = ff_modified_quant_tab[get_bits1(&s->gb)][s->qscale]; + if (h->c.modified_quant) { + if (get_bits1(&h->c.gb)) + qscale = ff_modified_quant_tab[get_bits1(&h->c.gb)][h->c.qscale]; else - qscale = get_bits(&s->gb, 5); + qscale = get_bits(&h->c.gb, 5); }else - qscale = s->qscale + quant_tab[get_bits(&s->gb, 2)]; - ff_set_qscale(s, qscale); + qscale = h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]; + ff_set_qscale(&h->c, qscale); } static void h263_pred_acdc(MpegEncContext * s, int16_t *block, int n) @@ -523,52 +521,53 @@ static void h263_pred_acdc(MpegEncContext * s, int16_t *block, int n) ac_val[8 + i] = block[s->idsp.idct_permutation[i]]; } -static int h263_decode_block(MpegEncContext * s, int16_t * block, +static int h263_decode_block(H263DecContext *const h, int16_t block[64], int n, int coded) { int level, i, j, run; const RLTable *rl = &ff_h263_rl_inter; const uint8_t *scan_table; - GetBitContext gb= s->gb; + GetBitContext gb = h->c.gb; - scan_table = s->intra_scantable.permutated; - if (s->h263_aic && s->mb_intra) { + scan_table = h->c.intra_scantable.permutated; + if (h->c.h263_aic && h->c.mb_intra) { i = 0; if (!coded) goto not_coded; rl = &ff_rl_intra_aic; - if (s->ac_pred) { - if (s->h263_aic_dir) - scan_table = s->permutated_intra_v_scantable; /* left */ + if (h->c.ac_pred) { + if (h->c.h263_aic_dir) + scan_table = h->c.permutated_intra_v_scantable; /* left */ else - scan_table = s->permutated_intra_h_scantable; /* top */ + scan_table = h->c.permutated_intra_h_scantable; /* top */ } - } else if (s->mb_intra) { + } else if (h->c.mb_intra) { /* DC coef */ - if (CONFIG_RV10_DECODER && s->codec_id == AV_CODEC_ID_RV10) { - if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) { + if (CONFIG_RV10_DECODER && h->c.codec_id == AV_CODEC_ID_RV10) { + if (h->c.rv10_version == 3 && h->c.pict_type == AV_PICTURE_TYPE_I) { int component = (n <= 3 ? 0 : n - 4 + 1); - level = s->last_dc[component]; - if (s->rv10_first_dc_coded[component]) { - int diff = ff_rv_decode_dc(s, n); + level = h->c.last_dc[component]; + if (h->c.rv10_first_dc_coded[component]) { + int diff = ff_rv_decode_dc(h, n); if (diff < 0) return -1; level += diff; level = level & 0xff; /* handle wrap round */ - s->last_dc[component] = level; + h->c.last_dc[component] = level; } else { - s->rv10_first_dc_coded[component] = 1; + h->c.rv10_first_dc_coded[component] = 1; } } else { - level = get_bits(&s->gb, 8); + level = get_bits(&h->c.gb, 8); if (level == 255) level = 128; } }else{ - level = get_bits(&s->gb, 8); + level = get_bits(&h->c.gb, 8); if((level&0x7F) == 0){ - av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); - if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) + av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", + level, h->c.mb_x, h->c.mb_y); + if (h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) return -1; } if (level == 255) @@ -580,64 +579,65 @@ static int h263_decode_block(MpegEncContext * s, int16_t * block, i = 0; } if (!coded) { - s->block_last_index[n] = i - 1; + h->c.block_last_index[n] = i - 1; return 0; } retry: { - OPEN_READER(re, &s->gb); + OPEN_READER(re, &h->c.gb); i--; // offset by -1 to allow direct indexing of scan_table for(;;) { - UPDATE_CACHE(re, &s->gb); - GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); + UPDATE_CACHE(re, &h->c.gb); + GET_RL_VLC(level, run, re, &h->c.gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); if (run == 66) { if (level){ - CLOSE_READER(re, &s->gb); - av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); + CLOSE_READER(re, &h->c.gb); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", + h->c.mb_x, h->c.mb_y); return -1; } /* escape */ - if (CONFIG_FLV_DECODER && s->h263_flv > 1) { - int is11 = SHOW_UBITS(re, &s->gb, 1); - SKIP_CACHE(re, &s->gb, 1); - run = SHOW_UBITS(re, &s->gb, 7) + 1; + if (CONFIG_FLV_DECODER && h->c.h263_flv > 1) { + int is11 = SHOW_UBITS(re, &h->c.gb, 1); + SKIP_CACHE(re, &h->c.gb, 1); + run = SHOW_UBITS(re, &h->c.gb, 7) + 1; if (is11) { - SKIP_COUNTER(re, &s->gb, 1 + 7); - UPDATE_CACHE(re, &s->gb); - level = SHOW_SBITS(re, &s->gb, 11); - SKIP_COUNTER(re, &s->gb, 11); + SKIP_COUNTER(re, &h->c.gb, 1 + 7); + UPDATE_CACHE(re, &h->c.gb); + level = SHOW_SBITS(re, &h->c.gb, 11); + SKIP_COUNTER(re, &h->c.gb, 11); } else { - SKIP_CACHE(re, &s->gb, 7); - level = SHOW_SBITS(re, &s->gb, 7); - SKIP_COUNTER(re, &s->gb, 1 + 7 + 7); + SKIP_CACHE(re, &h->c.gb, 7); + level = SHOW_SBITS(re, &h->c.gb, 7); + SKIP_COUNTER(re, &h->c.gb, 1 + 7 + 7); } } else { - run = SHOW_UBITS(re, &s->gb, 7) + 1; - SKIP_CACHE(re, &s->gb, 7); - level = (int8_t)SHOW_UBITS(re, &s->gb, 8); - SKIP_COUNTER(re, &s->gb, 7 + 8); + run = SHOW_UBITS(re, &h->c.gb, 7) + 1; + SKIP_CACHE(re, &h->c.gb, 7); + level = (int8_t)SHOW_UBITS(re, &h->c.gb, 8); + SKIP_COUNTER(re, &h->c.gb, 7 + 8); if(level == -128){ - UPDATE_CACHE(re, &s->gb); - if (s->codec_id == AV_CODEC_ID_RV10) { + UPDATE_CACHE(re, &h->c.gb); + if (h->c.codec_id == AV_CODEC_ID_RV10) { /* XXX: should patch encoder too */ - level = SHOW_SBITS(re, &s->gb, 12); - SKIP_COUNTER(re, &s->gb, 12); + level = SHOW_SBITS(re, &h->c.gb, 12); + SKIP_COUNTER(re, &h->c.gb, 12); }else{ - level = SHOW_UBITS(re, &s->gb, 5); - SKIP_CACHE(re, &s->gb, 5); - level |= SHOW_SBITS(re, &s->gb, 6) * (1<<5); - SKIP_COUNTER(re, &s->gb, 5 + 6); + level = SHOW_UBITS(re, &h->c.gb, 5); + SKIP_CACHE(re, &h->c.gb, 5); + level |= SHOW_SBITS(re, &h->c.gb, 6) * (1<<5); + SKIP_COUNTER(re, &h->c.gb, 5 + 6); } } } } else { - if (SHOW_UBITS(re, &s->gb, 1)) + if (SHOW_UBITS(re, &h->c.gb, 1)) level = -level; - SKIP_COUNTER(re, &s->gb, 1); + SKIP_COUNTER(re, &h->c.gb, 1); } i += run; if (i >= 64){ - CLOSE_READER(re, &s->gb); + CLOSE_READER(re, &h->c.gb); // redo update without last flag, revert -1 offset i = i - run + ((run-1)&63) + 1; if (i < 64) { @@ -645,48 +645,49 @@ retry: block[scan_table[i]] = level; break; } - if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){ + if(h->c.alt_inter_vlc && rl == &ff_h263_rl_inter && !h->c.mb_intra){ //Looks like a hack but no, it's the way it is supposed to work ... rl = &ff_rl_intra_aic; i = 0; - s->gb= gb; - s->bdsp.clear_block(block); + h->c.gb = gb; + h->c.bdsp.clear_block(block); goto retry; } - av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); + av_log(h->c.avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", + h->c.mb_x, h->c.mb_y, h->c.mb_intra); return -1; } j = scan_table[i]; block[j] = level; } } - if (s->mb_intra && s->h263_aic) { + if (h->c.mb_intra && h->c.h263_aic) { not_coded: - h263_pred_acdc(s, block, n); + h263_pred_acdc(&h->c, block, n); } - s->block_last_index[n] = i; + h->c.block_last_index[n] = i; return 0; } -static int h263_skip_b_part(MpegEncContext *s, int cbp) +static int h263_skip_b_part(H263DecContext *const h, int cbp) { LOCAL_ALIGNED_32(int16_t, dblock, [64]); int i, mbi; int bli[6]; - /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly + /* we have to set h->c.mb_intra to zero to decode B-part of PB-frame correctly * but real value should be restored in order to be used later (in OBMC condition) */ - mbi = s->mb_intra; - memcpy(bli, s->block_last_index, sizeof(bli)); - s->mb_intra = 0; + mbi = h->c.mb_intra; + memcpy(bli, h->c.block_last_index, sizeof(bli)); + h->c.mb_intra = 0; for (i = 0; i < 6; i++) { - if (h263_decode_block(s, dblock, i, cbp&32) < 0) + if (h263_decode_block(h, dblock, i, cbp&32) < 0) return -1; cbp+=cbp; } - s->mb_intra = mbi; - memcpy(s->block_last_index, bli, sizeof(bli)); + h->c.mb_intra = mbi; + memcpy(h->c.block_last_index, bli, sizeof(bli)); return 0; } @@ -775,119 +776,121 @@ static int set_direct_mv(MpegEncContext *s) } } -int ff_h263_decode_mb(MpegEncContext *s, - int16_t block[6][64]) +int ff_h263_decode_mb(H263DecContext *const h, int16_t block[6][64]) { int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; int16_t *mot_val; - 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; int cbpb = 0, pb_mv_count = 0; - av_assert2(!s->h263_pred); + av_assert2(!h->c.h263_pred); - if (s->pict_type == AV_PICTURE_TYPE_P) { + if (h->c.pict_type == AV_PICTURE_TYPE_P) { do{ - if (get_bits1(&s->gb)) { + if (get_bits1(&h->c.gb)) { /* skip mb */ - s->mb_intra = 0; + h->c.mb_intra = 0; for(i=0;i<6;i++) - s->block_last_index[i] = -1; - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; - s->mv[0][0][0] = 0; - s->mv[0][0][1] = 0; - s->mb_skipped = !(s->obmc | s->loop_filter); + h->c.block_last_index[i] = -1; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + h->c.mv[0][0][0] = 0; + h->c.mv[0][0][1] = 0; + h->c.mb_skipped = !(h->c.obmc | h->c.loop_filter); goto end; } - cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); + cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); if (cbpc < 0){ - av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", + h->c.mb_x, h->c.mb_y); return SLICE_ERROR; } }while(cbpc == 20); - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); dquant = cbpc & 8; - s->mb_intra = ((cbpc & 4) != 0); - if (s->mb_intra) goto intra; + h->c.mb_intra = ((cbpc & 4) != 0); + if (h->c.mb_intra) + goto intra; - if(s->pb_frame && get_bits1(&s->gb)) - pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); - cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + if(h->c.pb_frame && get_bits1(&h->c.gb)) + pb_mv_count = h263_get_modb(&h->c.gb, h->c.pb_frame, &cbpb); + cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); if (cbpy < 0) { - av_log(s->avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n", + h->c.mb_x, h->c.mb_y); return SLICE_ERROR; } - if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) + if (!h->c.alt_inter_vlc|| (cbpc & 3)!=3) cbpy ^= 0xF; cbp = (cbpc & 3) | (cbpy << 2); if (dquant) { - h263_decode_dquant(s); + h263_decode_dquant(h); } - s->mv_dir = MV_DIR_FORWARD; + h->c.mv_dir = MV_DIR_FORWARD; if ((cbpc & 16) == 0) { - s->cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + h->c.cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; /* 16x16 motion prediction */ - s->mv_type = MV_TYPE_16X16; - ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); - if (s->umvplus) - mx = h263p_decode_umotion(s, pred_x); + h->c.mv_type = MV_TYPE_16X16; + ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y); + if (h->c.umvplus) + mx = h263p_decode_umotion(h, pred_x); else - mx = ff_h263_decode_motion(s, pred_x, 1); + mx = ff_h263_decode_motion(h, pred_x, 1); if (mx >= 0xffff) return SLICE_ERROR; - if (s->umvplus) - my = h263p_decode_umotion(s, pred_y); + if (h->c.umvplus) + my = h263p_decode_umotion(h, pred_y); else - my = ff_h263_decode_motion(s, pred_y, 1); + my = ff_h263_decode_motion(h, pred_y, 1); if (my >= 0xffff) return SLICE_ERROR; - s->mv[0][0][0] = mx; - s->mv[0][0][1] = my; + h->c.mv[0][0][0] = mx; + h->c.mv[0][0][1] = my; - if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) - skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ + if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) + skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ } else { - s->cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; - s->mv_type = MV_TYPE_8X8; + h->c.cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; + h->c.mv_type = MV_TYPE_8X8; for(i=0;i<4;i++) { - mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); - if (s->umvplus) - mx = h263p_decode_umotion(s, pred_x); + mot_val = ff_h263_pred_motion(&h->c, i, 0, &pred_x, &pred_y); + if (h->c.umvplus) + mx = h263p_decode_umotion(h, pred_x); else - mx = ff_h263_decode_motion(s, pred_x, 1); + mx = ff_h263_decode_motion(h, pred_x, 1); if (mx >= 0xffff) return SLICE_ERROR; - if (s->umvplus) - my = h263p_decode_umotion(s, pred_y); + if (h->c.umvplus) + my = h263p_decode_umotion(h, pred_y); else - my = ff_h263_decode_motion(s, pred_y, 1); + my = ff_h263_decode_motion(h, pred_y, 1); if (my >= 0xffff) return SLICE_ERROR; - s->mv[0][i][0] = mx; - s->mv[0][i][1] = my; - if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) - skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ + h->c.mv[0][i][0] = mx; + h->c.mv[0][i][1] = my; + if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) + skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ mot_val[0] = mx; mot_val[1] = my; } } - } else if(s->pict_type==AV_PICTURE_TYPE_B) { + } else if (h->c.pict_type==AV_PICTURE_TYPE_B) { int mb_type; - const int stride= s->b8_stride; - int16_t *mot_val0 = s->cur_pic.motion_val[0][2 * (s->mb_x + s->mb_y * stride)]; - int16_t *mot_val1 = s->cur_pic.motion_val[1][2 * (s->mb_x + s->mb_y * stride)]; -// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; + const int stride = h->c.b8_stride; + int16_t *mot_val0 = h->c.cur_pic.motion_val[0][2 * (h->c.mb_x + h->c.mb_y * stride)]; + int16_t *mot_val1 = h->c.cur_pic.motion_val[1][2 * (h->c.mb_x + h->c.mb_y * stride)]; +// const int mv_xy = h->c.mb_x + 1 + h->c.mb_y * h->c.mb_stride; //FIXME ugly mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= @@ -896,176 +899,181 @@ int ff_h263_decode_mb(MpegEncContext *s, mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; do{ - mb_type = get_vlc2(&s->gb, h263_mbtype_b_vlc, + mb_type = get_vlc2(&h->c.gb, h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 2); if (mb_type < 0){ - av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", + h->c.mb_x, h->c.mb_y); return SLICE_ERROR; } }while(!mb_type); - s->mb_intra = IS_INTRA(mb_type); + h->c.mb_intra = IS_INTRA(mb_type); if(HAS_CBP(mb_type)){ - s->bdsp.clear_blocks(s->block[0]); - cbpc = get_vlc2(&s->gb, cbpc_b_vlc, CBPC_B_VLC_BITS, 1); - if(s->mb_intra){ + h->c.bdsp.clear_blocks(h->c.block[0]); + cbpc = get_vlc2(&h->c.gb, cbpc_b_vlc, CBPC_B_VLC_BITS, 1); + if (h->c.mb_intra) { dquant = IS_QUANT(mb_type); goto intra; } - 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){ - av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", + h->c.mb_x, h->c.mb_y); return SLICE_ERROR; } - if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) + if (!h->c.alt_inter_vlc || (cbpc & 3)!=3) cbpy ^= 0xF; cbp = (cbpc & 3) | (cbpy << 2); }else cbp=0; - av_assert2(!s->mb_intra); + av_assert2(!h->c.mb_intra); if(IS_QUANT(mb_type)){ - h263_decode_dquant(s); + h263_decode_dquant(h); } if(IS_DIRECT(mb_type)){ - s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; - mb_type |= set_direct_mv(s); + h->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; + mb_type |= set_direct_mv(&h->c); }else{ - s->mv_dir = 0; - s->mv_type= MV_TYPE_16X16; + h->c.mv_dir = 0; + h->c.mv_type = MV_TYPE_16X16; //FIXME UMV if (HAS_FORWARD_MV(mb_type)) { - int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); - s->mv_dir = MV_DIR_FORWARD; + int16_t *mot_val= ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y); + h->c.mv_dir = MV_DIR_FORWARD; - if (s->umvplus) - mx = h263p_decode_umotion(s, pred_x); + if (h->c.umvplus) + mx = h263p_decode_umotion(h, pred_x); else - mx = ff_h263_decode_motion(s, pred_x, 1); + mx = ff_h263_decode_motion(h, pred_x, 1); if (mx >= 0xffff) return SLICE_ERROR; - if (s->umvplus) - my = h263p_decode_umotion(s, pred_y); + if (h->c.umvplus) + my = h263p_decode_umotion(h, pred_y); else - my = ff_h263_decode_motion(s, pred_y, 1); + my = ff_h263_decode_motion(h, pred_y, 1); if (my >= 0xffff) return SLICE_ERROR; - if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) - skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ + if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) + skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ - s->mv[0][0][0] = mx; - s->mv[0][0][1] = my; + h->c.mv[0][0][0] = mx; + h->c.mv[0][0][1] = my; mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; } if (HAS_BACKWARD_MV(mb_type)) { - int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &pred_x, &pred_y); - s->mv_dir |= MV_DIR_BACKWARD; + int16_t *mot_val= ff_h263_pred_motion(&h->c, 0, 1, &pred_x, &pred_y); + h->c.mv_dir |= MV_DIR_BACKWARD; - if (s->umvplus) - mx = h263p_decode_umotion(s, pred_x); + if (h->c.umvplus) + mx = h263p_decode_umotion(h, pred_x); else - mx = ff_h263_decode_motion(s, pred_x, 1); + mx = ff_h263_decode_motion(h, pred_x, 1); if (mx >= 0xffff) return SLICE_ERROR; - if (s->umvplus) - my = h263p_decode_umotion(s, pred_y); + if (h->c.umvplus) + my = h263p_decode_umotion(h, pred_y); else - my = ff_h263_decode_motion(s, pred_y, 1); + my = ff_h263_decode_motion(h, pred_y, 1); if (my >= 0xffff) return SLICE_ERROR; - if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) - skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ + if (h->c.umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) + skip_bits1(&h->c.gb); /* Bit stuffing to prevent PSC */ - s->mv[1][0][0] = mx; - s->mv[1][0][1] = my; + h->c.mv[1][0][0] = mx; + h->c.mv[1][0][1] = my; mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; } } - s->cur_pic.mb_type[xy] = mb_type; + h->c.cur_pic.mb_type[xy] = mb_type; } else { /* I-Frame */ do{ - cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); + cbpc = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); if (cbpc < 0){ - av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", + h->c.mb_x, h->c.mb_y); return SLICE_ERROR; } }while(cbpc == 8); - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); dquant = cbpc & 4; - s->mb_intra = 1; + h->c.mb_intra = 1; intra: - s->cur_pic.mb_type[xy] = MB_TYPE_INTRA; - if (s->h263_aic) { - s->ac_pred = get_bits1(&s->gb); - if(s->ac_pred){ - s->cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; + h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; + if (h->c.h263_aic) { + h->c.ac_pred = get_bits1(&h->c.gb); + if (h->c.ac_pred) { + h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; - s->h263_aic_dir = get_bits1(&s->gb); + h->c.h263_aic_dir = get_bits1(&h->c.gb); } }else - s->ac_pred = 0; + h->c.ac_pred = 0; - if(s->pb_frame && get_bits1(&s->gb)) - pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); - cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + if (h->c.pb_frame && get_bits1(&h->c.gb)) + pb_mv_count = h263_get_modb(&h->c.gb, h->c.pb_frame, &cbpb); + cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); if(cbpy<0){ - av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", + h->c.mb_x, h->c.mb_y); return SLICE_ERROR; } cbp = (cbpc & 3) | (cbpy << 2); if (dquant) { - h263_decode_dquant(s); + h263_decode_dquant(h); } - pb_mv_count += !!s->pb_frame; + pb_mv_count += !!h->c.pb_frame; } while(pb_mv_count--){ - ff_h263_decode_motion(s, 0, 1); - ff_h263_decode_motion(s, 0, 1); + ff_h263_decode_motion(h, 0, 1); + ff_h263_decode_motion(h, 0, 1); } /* decode each block */ for (i = 0; i < 6; i++) { - if (h263_decode_block(s, block[i], i, cbp&32) < 0) + if (h263_decode_block(h, block[i], i, cbp&32) < 0) return -1; cbp+=cbp; } - if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) + if (h->c.pb_frame && h263_skip_b_part(h, cbpb) < 0) return -1; - if(s->obmc && !s->mb_intra){ - if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1mb_width && s->mb_num_left != 1) - preview_obmc(s); + if (h->c.obmc && !h->c.mb_intra) { + if (h->c.pict_type == AV_PICTURE_TYPE_P && + h->c.mb_x + 1 < h->c.mb_width && h->c.mb_num_left != 1) + preview_obmc(h); } end: - if (get_bits_left(&s->gb) < 0) + if (get_bits_left(&h->c.gb) < 0) return AVERROR_INVALIDDATA; /* per-MB end of slice check */ { - int v= show_bits(&s->gb, 16); + int v = show_bits(&h->c.gb, 16); - if (get_bits_left(&s->gb) < 16) { - v >>= 16 - get_bits_left(&s->gb); + if (get_bits_left(&h->c.gb) < 16) { + v >>= 16 - get_bits_left(&h->c.gb); } if(v==0) @@ -1076,51 +1084,50 @@ end: } /* Most is hardcoded; should extend to handle all H.263 streams. */ -int ff_h263_decode_picture_header(MpegEncContext *s) +int ff_h263_decode_picture_header(H263DecContext *const h) { - int format, width, height, i, ret; - uint32_t startcode; + int width, height, i, ret; int h263_plus; - align_get_bits(&s->gb); + align_get_bits(&h->c.gb); - if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_num == 0) { - av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n"); + if (show_bits(&h->c.gb, 2) == 2 && h->c.avctx->frame_num == 0) { + av_log(h->c.avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n"); } - startcode= get_bits(&s->gb, 22-8); + uint32_t startcode = get_bits(&h->c.gb, 22-8); - for(i= get_bits_left(&s->gb); i>24; i-=8) { - startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; + for (i = get_bits_left(&h->c.gb); i>24; i -= 8) { + startcode = ((startcode << 8) | get_bits(&h->c.gb, 8)) & 0x003FFFFF; if(startcode == 0x20) break; } if (startcode != 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; } /* temporal reference */ - i = get_bits(&s->gb, 8); /* picture timestamp */ + i = get_bits(&h->c.gb, 8); /* picture timestamp */ - i -= (i - (s->picture_number & 0xFF) + 128) & ~0xFF; + i -= (i - (h->c.picture_number & 0xFF) + 128) & ~0xFF; - s->picture_number= (s->picture_number&~0xFF) + i; + h->c.picture_number = (h->c.picture_number&~0xFF) + i; /* PTYPE starts here */ - if (check_marker(s->avctx, &s->gb, "in PTYPE") != 1) { + if (check_marker(h->c.avctx, &h->c.gb, "in PTYPE") != 1) { return -1; } - if (get_bits1(&s->gb) != 0) { - av_log(s->avctx, AV_LOG_ERROR, "Bad H.263 id\n"); + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Bad H.263 id\n"); return -1; /* H.263 id */ } - skip_bits1(&s->gb); /* split screen off */ - skip_bits1(&s->gb); /* camera off */ - skip_bits1(&s->gb); /* freeze picture release off */ + skip_bits1(&h->c.gb); /* split screen off */ + skip_bits1(&h->c.gb); /* camera off */ + skip_bits1(&h->c.gb); /* freeze picture release off */ - format = get_bits(&s->gb, 3); + int format = get_bits(&h->c.gb, 3); /* 0 forbidden 1 sub-QCIF @@ -1136,88 +1143,88 @@ int ff_h263_decode_picture_header(MpegEncContext *s) if (!width) 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) { - av_log(s->avctx, AV_LOG_ERROR, "H.263 SAC not supported\n"); + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "H.263 SAC not supported\n"); return -1; /* SAC: off */ } - s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ + h->c.obmc = get_bits1(&h->c.gb); /* Advanced prediction mode */ - s->pb_frame = get_bits1(&s->gb); - s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); - skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ + h->c.pb_frame = get_bits1(&h->c.gb); + h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); + skip_bits1(&h->c.gb); /* Continuous Presence Multipoint mode: off */ - s->width = width; - s->height = height; - s->avctx->sample_aspect_ratio= (AVRational){12,11}; - s->avctx->framerate = (AVRational){ 30000, 1001 }; + h->c.width = width; + h->c.height = height; + h->c.avctx->sample_aspect_ratio= (AVRational){12,11}; + h->c.avctx->framerate = (AVRational){ 30000, 1001 }; } else { int ufep; /* H.263v2 */ h263_plus = 1; - ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ + ufep = get_bits(&h->c.gb, 3); /* Update Full Extended PTYPE */ /* ufep other than 0 and 1 are reserved */ if (ufep == 1) { /* OPPTYPE */ - format = get_bits(&s->gb, 3); - ff_dlog(s->avctx, "ufep=1, format: %d\n", format); - s->custom_pcf= get_bits1(&s->gb); - s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ - if (get_bits1(&s->gb) != 0) { - av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); + format = get_bits(&h->c.gb, 3); + ff_dlog(h->c.avctx, "ufep=1, format: %d\n", format); + h->c.custom_pcf = get_bits1(&h->c.gb); + h->c.umvplus = get_bits1(&h->c.gb); /* Unrestricted Motion Vector */ + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); } - s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ - s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ - s->loop_filter= get_bits1(&s->gb); - if(s->avctx->lowres) - s->loop_filter = 0; - - s->h263_slice_structured= get_bits1(&s->gb); - if (get_bits1(&s->gb) != 0) { - av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); + h->c.obmc = get_bits1(&h->c.gb); /* Advanced prediction mode */ + h->c.h263_aic = get_bits1(&h->c.gb); /* Advanced Intra Coding (AIC) */ + h->c.loop_filter = get_bits1(&h->c.gb); + if (h->c.avctx->lowres) + h->c.loop_filter = 0; + + h->c.h263_slice_structured= get_bits1(&h->c.gb); + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); } - if (get_bits1(&s->gb) != 0) { - av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); } - s->alt_inter_vlc= get_bits1(&s->gb); - s->modified_quant= get_bits1(&s->gb); - if(s->modified_quant) - s->chroma_qscale_table= ff_h263_chroma_qscale_table; + h->c.alt_inter_vlc = get_bits1(&h->c.gb); + h->c.modified_quant = get_bits1(&h->c.gb); + if (h->c.modified_quant) + h->c.chroma_qscale_table= ff_h263_chroma_qscale_table; - skip_bits(&s->gb, 1); /* Prevent start code emulation */ + skip_bits(&h->c.gb, 1); /* Prevent start code emulation */ - skip_bits(&s->gb, 3); /* Reserved */ + skip_bits(&h->c.gb, 3); /* Reserved */ } else if (ufep != 0) { - av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); + av_log(h->c.avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); return -1; } /* MPPTYPE */ - s->pict_type = get_bits(&s->gb, 3); - switch(s->pict_type){ - case 0: s->pict_type= AV_PICTURE_TYPE_I;break; - case 1: s->pict_type= AV_PICTURE_TYPE_P;break; - case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break; - case 3: s->pict_type= AV_PICTURE_TYPE_B;break; - case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO + h->c.pict_type = get_bits(&h->c.gb, 3); + switch (h->c.pict_type) { + case 0: h->c.pict_type = AV_PICTURE_TYPE_I; break; + case 1: h->c.pict_type = AV_PICTURE_TYPE_P; break; + case 2: h->c.pict_type = AV_PICTURE_TYPE_P; h->c.pb_frame = 3; break; + case 3: h->c.pict_type = AV_PICTURE_TYPE_B; break; + case 7: h->c.pict_type = AV_PICTURE_TYPE_I; break; //ZYGO default: return -1; } - skip_bits(&s->gb, 2); - s->no_rounding = get_bits1(&s->gb); - skip_bits(&s->gb, 4); + skip_bits(&h->c.gb, 2); + h->c.no_rounding = get_bits1(&h->c.gb); + skip_bits(&h->c.gb, 4); /* Get the picture dimensions */ if (ufep) { if (format == 6) { /* Custom Picture Format (CPFMT) */ - int aspect_ratio_info = get_bits(&s->gb, 4); - ff_dlog(s->avctx, "aspect: %d\n", aspect_ratio_info); + int aspect_ratio_info = get_bits(&h->c.gb, 4); + ff_dlog(h->c.avctx, "aspect: %d\n", aspect_ratio_info); /* aspect ratios: 0 - forbidden 1 - 1:1 @@ -1227,153 +1234,151 @@ int ff_h263_decode_picture_header(MpegEncContext *s) 5 - 40:33 (525-type 16:9) 6-14 - reserved */ - width = (get_bits(&s->gb, 9) + 1) * 4; - check_marker(s->avctx, &s->gb, "in dimensions"); - height = get_bits(&s->gb, 9) * 4; - ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); + width = (get_bits(&h->c.gb, 9) + 1) * 4; + check_marker(h->c.avctx, &h->c.gb, "in dimensions"); + height = get_bits(&h->c.gb, 9) * 4; + ff_dlog(h->c.avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); if (aspect_ratio_info == FF_ASPECT_EXTENDED) { /* expected dimensions */ - s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); - s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); + h->c.avctx->sample_aspect_ratio.num = get_bits(&h->c.gb, 8); + h->c.avctx->sample_aspect_ratio.den = get_bits(&h->c.gb, 8); }else{ - s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info]; + h->c.avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info]; } } else { width = ff_h263_format[format][0]; height = ff_h263_format[format][1]; - s->avctx->sample_aspect_ratio= (AVRational){12,11}; + h->c.avctx->sample_aspect_ratio = (AVRational){12,11}; } - s->avctx->sample_aspect_ratio.den <<= s->ehc_mode; + h->c.avctx->sample_aspect_ratio.den <<= h->c.ehc_mode; if ((width == 0) || (height == 0)) return -1; - s->width = width; - s->height = height; - - if(s->custom_pcf){ - int gcd; - s->avctx->framerate.num = 1800000; - s->avctx->framerate.den = 1000 + get_bits1(&s->gb); - s->avctx->framerate.den *= get_bits(&s->gb, 7); - if(s->avctx->framerate.den == 0){ - av_log(s->avctx, AV_LOG_ERROR, "zero framerate\n"); + h->c.width = width; + h->c.height = height; + + if (h->c.custom_pcf) { + h->c.avctx->framerate.num = 1800000; + h->c.avctx->framerate.den = 1000 + get_bits1(&h->c.gb); + h->c.avctx->framerate.den *= get_bits(&h->c.gb, 7); + if (h->c.avctx->framerate.den == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "zero framerate\n"); return -1; } - gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num); - s->avctx->framerate.den /= gcd; - s->avctx->framerate.num /= gcd; + int gcd = av_gcd(h->c.avctx->framerate.den, h->c.avctx->framerate.num); + h->c.avctx->framerate.den /= gcd; + h->c.avctx->framerate.num /= gcd; }else{ - s->avctx->framerate = (AVRational){ 30000, 1001 }; + h->c.avctx->framerate = (AVRational){ 30000, 1001 }; } } - if(s->custom_pcf){ - skip_bits(&s->gb, 2); //extended Temporal reference - } + if (h->c.custom_pcf) + skip_bits(&h->c.gb, 2); //extended Temporal reference if (ufep) { - if (s->umvplus) { - if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ - skip_bits1(&s->gb); + if (h->c.umvplus) { + if(get_bits1(&h->c.gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ + skip_bits1(&h->c.gb); } - if(s->h263_slice_structured){ - if (get_bits1(&s->gb) != 0) { - av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); + if (h->c.h263_slice_structured) { + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); } - if (get_bits1(&s->gb) != 0) { - av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); + if (get_bits1(&h->c.gb) != 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "unordered slices not supported\n"); } } - if (s->pict_type == AV_PICTURE_TYPE_B) { - skip_bits(&s->gb, 4); //ELNUM + if (h->c.pict_type == AV_PICTURE_TYPE_B) { + skip_bits(&h->c.gb, 4); //ELNUM if (ufep == 1) { - skip_bits(&s->gb, 4); // RLNUM + skip_bits(&h->c.gb, 4); // RLNUM } } } - s->qscale = get_bits(&s->gb, 5); + h->c.qscale = get_bits(&h->c.gb, 5); } - ret = av_image_check_size(s->width, s->height, 0, s->avctx); + ret = av_image_check_size(h->c.width, h->c.height, 0, h->c.avctx); if (ret < 0) return ret; - if (!(s->avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) { - if ((s->width * s->height / 256 / 8) > get_bits_left(&s->gb)) + if (!(h->c.avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) { + if ((h->c.width * h->c.height / 256 / 8) > get_bits_left(&h->c.gb)) return AVERROR_INVALIDDATA; } - s->mb_width = (s->width + 15) / 16; - s->mb_height = (s->height + 15) / 16; - s->mb_num = s->mb_width * s->mb_height; + h->c.mb_width = (h->c.width + 15U) / 16; + h->c.mb_height = (h->c.height + 15U) / 16; + h->c.mb_num = h->c.mb_width * h->c.mb_height; - s->gob_index = H263_GOB_HEIGHT(s->height); + h->c.gob_index = H263_GOB_HEIGHT(h->c.height); - if (s->pb_frame) { - skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ - if (s->custom_pcf) - skip_bits(&s->gb, 2); //extended Temporal reference - skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ + if (h->c.pb_frame) { + skip_bits(&h->c.gb, 3); /* Temporal reference for B-pictures */ + if (h->c.custom_pcf) + skip_bits(&h->c.gb, 2); //extended Temporal reference + skip_bits(&h->c.gb, 2); /* Quantization information for B-pictures */ } - if (s->pict_type!=AV_PICTURE_TYPE_B) { - s->time = s->picture_number; - s->pp_time = s->time - s->last_non_b_time; - s->last_non_b_time = s->time; + if (h->c.pict_type!=AV_PICTURE_TYPE_B) { + h->c.time = h->c.picture_number; + h->c.pp_time = h->c.time - h->c.last_non_b_time; + h->c.last_non_b_time = h->c.time; }else{ - s->time = s->picture_number; - s->pb_time = s->pp_time - (s->last_non_b_time - s->time); - if (s->pp_time <=s->pb_time || - s->pp_time <= s->pp_time - s->pb_time || - s->pp_time <= 0){ - s->pp_time = 2; - s->pb_time = 1; + h->c.time = h->c.picture_number; + h->c.pb_time = h->c.pp_time - (h->c.last_non_b_time - h->c.time); + 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) { + h->c.pp_time = 2; + h->c.pb_time = 1; } - ff_mpeg4_init_direct_mv(s); + ff_mpeg4_init_direct_mv(&h->c); } /* PEI */ - if (skip_1stop_8data_bits(&s->gb) < 0) + if (skip_1stop_8data_bits(&h->c.gb) < 0) return AVERROR_INVALIDDATA; - if(s->h263_slice_structured){ - if (check_marker(s->avctx, &s->gb, "SEPB1") != 1) { + if (h->c.h263_slice_structured) { + if (check_marker(h->c.avctx, &h->c.gb, "SEPB1") != 1) { return -1; } - ff_h263_decode_mba(s); + ff_h263_decode_mba(h); - if (check_marker(s->avctx, &s->gb, "SEPB2") != 1) { + if (check_marker(h->c.avctx, &h->c.gb, "SEPB2") != 1) { return -1; } } - if (s->pict_type == AV_PICTURE_TYPE_B) - s->low_delay = 0; + if (h->c.pict_type == AV_PICTURE_TYPE_B) + h->c.low_delay = 0; - if(s->h263_aic){ - s->y_dc_scale_table= - s->c_dc_scale_table= ff_aic_dc_scale_table; + if (h->c.h263_aic) { + h->c.y_dc_scale_table = + h->c.c_dc_scale_table = ff_aic_dc_scale_table; }else{ - s->y_dc_scale_table= - s->c_dc_scale_table= ff_mpeg1_dc_scale_table; + h->c.y_dc_scale_table = + h->c.c_dc_scale_table = ff_mpeg1_dc_scale_table; } - ff_h263_show_pict_info(s, h263_plus); + ff_h263_show_pict_info(h, h263_plus); - if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){ + if (h->c.pict_type == AV_PICTURE_TYPE_I && h->c.codec_tag == AV_RL32("ZYGO") && get_bits_left(&h->c.gb) >= 85 + 13*3*16 + 50){ int i,j; - for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); - av_log(s->avctx, AV_LOG_DEBUG, "\n"); + for(i=0; i<85; i++) av_log(h->c.avctx, AV_LOG_DEBUG, "%d", get_bits1(&h->c.gb)); + av_log(h->c.avctx, AV_LOG_DEBUG, "\n"); for(i=0; i<13; i++){ for(j=0; j<3; j++){ - int v= get_bits(&s->gb, 8); - v |= get_sbits(&s->gb, 8) * (1 << 8); - av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); + int v= get_bits(&h->c.gb, 8); + v |= get_sbits(&h->c.gb, 8) * (1 << 8); + av_log(h->c.avctx, AV_LOG_DEBUG, " %5d", v); } - av_log(s->avctx, AV_LOG_DEBUG, "\n"); + av_log(h->c.avctx, AV_LOG_DEBUG, "\n"); } - for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); + for(i=0; i<50; i++) av_log(h->c.avctx, AV_LOG_DEBUG, "%d", get_bits1(&h->c.gb)); } return 0; diff --git a/libavcodec/mpeg4video_parser.c b/libavcodec/mpeg4video_parser.c index de92f1b1dc..a2a22234f2 100644 --- a/libavcodec/mpeg4video_parser.c +++ b/libavcodec/mpeg4video_parser.c @@ -84,7 +84,7 @@ static int mpeg4_decode_header(AVCodecParserContext *s1, AVCodecContext *avctx, { struct Mp4vParseContext *pc = s1->priv_data; Mpeg4DecContext *dec_ctx = &pc->dec_ctx; - MpegEncContext *s = &dec_ctx->m; + MPVContext *const s = &dec_ctx->h.c; GetBitContext gb1, *gb = &gb1; int ret; @@ -124,7 +124,7 @@ static av_cold int mpeg4video_parse_init(AVCodecParserContext *s) pc->first_picture = 1; 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; return 0; } diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c index 677b372fee..e3503b1aca 100644 --- a/libavcodec/mpeg4videodec.c +++ b/libavcodec/mpeg4videodec.c @@ -81,6 +81,12 @@ static const int16_t mb_type_b_map[4] = { MB_TYPE_FORWARD_MV | MB_TYPE_16x16, }; +static inline Mpeg4DecContext *h263_to_mpeg4(H263DecContext *h) +{ + av_assert2(h->c.codec_id == AV_CODEC_ID_MPEG4 && h->c.avctx->priv_data == h); + return (Mpeg4DecContext*)h; +} + static void gmc1_motion(MpegEncContext *s, const Mpeg4DecContext *ctx, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture) @@ -319,55 +325,55 @@ void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb * @param n block index (0-3 are luma, 4-5 are chroma) * @param dir the ac prediction direction */ -void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir) +void ff_mpeg4_pred_ac(H263DecContext *const h, int16_t *block, int n, int dir) { int i; int16_t *ac_val, *ac_val1; - int8_t *const qscale_table = s->cur_pic.qscale_table; + int8_t *const qscale_table = h->c.cur_pic.qscale_table; /* find prediction */ - ac_val = &s->ac_val[0][0] + s->block_index[n] * 16; + ac_val = &h->c.ac_val[0][0] + h->c.block_index[n] * 16; ac_val1 = ac_val; - if (s->ac_pred) { + if (h->c.ac_pred) { if (dir == 0) { - const int xy = s->mb_x - 1 + s->mb_y * s->mb_stride; + const int xy = h->c.mb_x - 1 + h->c.mb_y * h->c.mb_stride; /* left prediction */ ac_val -= 16; - if (s->mb_x == 0 || s->qscale == qscale_table[xy] || + if (h->c.mb_x == 0 || h->c.qscale == qscale_table[xy] || n == 1 || n == 3) { /* same qscale */ for (i = 1; i < 8; i++) - block[s->idsp.idct_permutation[i << 3]] += ac_val[i]; + block[h->c.idsp.idct_permutation[i << 3]] += ac_val[i]; } else { /* different qscale, we must rescale */ for (i = 1; i < 8; i++) - block[s->idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale); + block[h->c.idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], h->c.qscale); } } else { - const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride; + const int xy = h->c.mb_x + h->c.mb_y * h->c.mb_stride - h->c.mb_stride; /* top prediction */ - ac_val -= 16 * s->block_wrap[n]; + ac_val -= 16 * h->c.block_wrap[n]; - if (s->mb_y == 0 || s->qscale == qscale_table[xy] || + if (h->c.mb_y == 0 || h->c.qscale == qscale_table[xy] || n == 2 || n == 3) { /* same qscale */ for (i = 1; i < 8; i++) - block[s->idsp.idct_permutation[i]] += ac_val[i + 8]; + block[h->c.idsp.idct_permutation[i]] += ac_val[i + 8]; } else { /* different qscale, we must rescale */ for (i = 1; i < 8; i++) - block[s->idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale); + block[h->c.idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], h->c.qscale); } } } /* left copy */ for (i = 1; i < 8; i++) - ac_val1[i] = block[s->idsp.idct_permutation[i << 3]]; + ac_val1[i] = block[h->c.idsp.idct_permutation[i << 3]]; /* top copy */ for (i = 1; i < 8; i++) - ac_val1[8 + i] = block[s->idsp.idct_permutation[i]]; + ac_val1[8 + i] = block[h->c.idsp.idct_permutation[i]]; } /** @@ -376,28 +382,28 @@ void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir) */ static inline int mpeg4_is_resync(Mpeg4DecContext *ctx) { - MpegEncContext *s = &ctx->m; - int bits_count = get_bits_count(&s->gb); - int v = show_bits(&s->gb, 16); + H263DecContext *const h = &ctx->h; + int bits_count = get_bits_count(&h->c.gb); + int v = show_bits(&h->c.gb, 16); - if (s->workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker) + if (h->c.workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker) return 0; while (v <= 0xFF) { - if (s->pict_type == AV_PICTURE_TYPE_B || - (v >> (8 - s->pict_type) != 1) || s->partitioned_frame) + if (h->c.pict_type == AV_PICTURE_TYPE_B || + (v >> (8 - h->c.pict_type) != 1) || h->c.partitioned_frame) break; - skip_bits(&s->gb, 8 + s->pict_type); - bits_count += 8 + s->pict_type; - v = show_bits(&s->gb, 16); + skip_bits(&h->c.gb, 8 + h->c.pict_type); + bits_count += 8 + h->c.pict_type; + v = show_bits(&h->c.gb, 16); } - if (bits_count + 8 >= s->gb.size_in_bits) { + if (bits_count + 8 >= h->c.gb.size_in_bits) { v >>= 8; v |= 0x7F >> (7 - (bits_count & 7)); if (v == 0x7F) - return s->mb_num; + return h->c.mb_num; } else { static const uint16_t mpeg4_resync_prefix[8] = { 0x7F00, 0x7E00, 0x7C00, 0x7800, 0x7000, 0x6000, 0x4000, 0x0000 @@ -405,23 +411,23 @@ static inline int mpeg4_is_resync(Mpeg4DecContext *ctx) if (v == mpeg4_resync_prefix[bits_count & 7]) { int len, mb_num; - int mb_num_bits = av_log2(s->mb_num - 1) + 1; - GetBitContext gb = s->gb; + int mb_num_bits = av_log2(h->c.mb_num - 1) + 1; + GetBitContext gb = h->c.gb; - skip_bits(&s->gb, 1); - align_get_bits(&s->gb); + skip_bits(&h->c.gb, 1); + align_get_bits(&h->c.gb); for (len = 0; len < 32; len++) - if (get_bits1(&s->gb)) + if (get_bits1(&h->c.gb)) break; - mb_num = get_bits(&s->gb, mb_num_bits); - if (!mb_num || mb_num > s->mb_num || get_bits_count(&s->gb)+6 > s->gb.size_in_bits) + mb_num = get_bits(&h->c.gb, mb_num_bits); + if (!mb_num || mb_num > h->c.mb_num || get_bits_count(&h->c.gb) + 6 > h->c.gb.size_in_bits) mb_num= -1; - s->gb = gb; + h->c.gb = gb; - if (len >= ff_mpeg4_get_video_packet_prefix_length(s->pict_type, ctx->f_code, ctx->b_code)) + if (len >= ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code)) return mb_num; } } @@ -430,7 +436,7 @@ static inline int mpeg4_is_resync(Mpeg4DecContext *ctx) static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; + MpegEncContext *s = &ctx->h.c; int a = 2 << ctx->sprite_warping_accuracy; int rho = 3 - ctx->sprite_warping_accuracy; int r = 16 / a; @@ -685,13 +691,12 @@ overflow: } static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; int len = FFMIN(ctx->time_increment_bits + 3, 15); get_bits(gb, len); if (get_bits1(gb)) get_bits(gb, len); - check_marker(s->avctx, gb, "after new_pred"); + check_marker(ctx->h.c.avctx, gb, "after new_pred"); return 0; } @@ -700,96 +705,96 @@ static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) { * Decode the next video packet. * @return <0 if something went wrong */ -int ff_mpeg4_decode_video_packet_header(MPVContext *const s) +int ff_mpeg4_decode_video_packet_header(H263DecContext *const h) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; + Mpeg4DecContext *const ctx = h263_to_mpeg4(h); - int mb_num_bits = av_log2(s->mb_num - 1) + 1; + int mb_num_bits = av_log2(h->c.mb_num - 1) + 1; int header_extension = 0, mb_num, len; /* is there enough space left for a video packet + header */ - if (get_bits_count(&s->gb) > s->gb.size_in_bits - 20) + if (get_bits_count(&h->c.gb) > h->c.gb.size_in_bits - 20) return AVERROR_INVALIDDATA; for (len = 0; len < 32; len++) - if (get_bits1(&s->gb)) + if (get_bits1(&h->c.gb)) break; - if (len != ff_mpeg4_get_video_packet_prefix_length(s->pict_type, ctx->f_code, ctx->b_code)) { - av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); + if (len != ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code)) { + av_log(h->c.avctx, AV_LOG_ERROR, "marker does not match f_code\n"); return AVERROR_INVALIDDATA; } if (ctx->shape != RECT_SHAPE) { - header_extension = get_bits1(&s->gb); + header_extension = get_bits1(&h->c.gb); // FIXME more stuff here } - mb_num = get_bits(&s->gb, mb_num_bits); - if (mb_num >= s->mb_num || !mb_num) { - av_log(s->avctx, AV_LOG_ERROR, - "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); + mb_num = get_bits(&h->c.gb, mb_num_bits); + if (mb_num >= h->c.mb_num || !mb_num) { + av_log(h->c.avctx, AV_LOG_ERROR, + "illegal mb_num in video packet (%d %d) \n", mb_num, h->c.mb_num); return AVERROR_INVALIDDATA; } - s->mb_x = mb_num % s->mb_width; - s->mb_y = mb_num / s->mb_width; + h->c.mb_x = mb_num % h->c.mb_width; + h->c.mb_y = mb_num / h->c.mb_width; if (ctx->shape != BIN_ONLY_SHAPE) { - int qscale = get_bits(&s->gb, ctx->quant_precision); + int qscale = get_bits(&h->c.gb, ctx->quant_precision); if (qscale) - s->chroma_qscale = s->qscale = qscale; + h->c.chroma_qscale = h->c.qscale = qscale; } if (ctx->shape == RECT_SHAPE) - header_extension = get_bits1(&s->gb); + header_extension = get_bits1(&h->c.gb); if (header_extension) { - while (get_bits1(&s->gb) != 0) + while (get_bits1(&h->c.gb) != 0) ; - check_marker(s->avctx, &s->gb, "before time_increment in video packed header"); - skip_bits(&s->gb, ctx->time_increment_bits); /* time_increment */ - check_marker(s->avctx, &s->gb, "before vop_coding_type in video packed header"); + check_marker(h->c.avctx, &h->c.gb, "before time_increment in video packed header"); + skip_bits(&h->c.gb, ctx->time_increment_bits); /* time_increment */ + check_marker(h->c.avctx, &h->c.gb, "before vop_coding_type in video packed header"); - skip_bits(&s->gb, 2); /* vop coding type */ + skip_bits(&h->c.gb, 2); /* vop coding type */ // FIXME not rect stuff here if (ctx->shape != BIN_ONLY_SHAPE) { - skip_bits(&s->gb, 3); /* intra dc vlc threshold */ + skip_bits(&h->c.gb, 3); /* intra dc vlc threshold */ // FIXME don't just ignore everything - if (s->pict_type == AV_PICTURE_TYPE_S && + if (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE) { - if (mpeg4_decode_sprite_trajectory(ctx, &s->gb) < 0) + if (mpeg4_decode_sprite_trajectory(ctx, &h->c.gb) < 0) return AVERROR_INVALIDDATA; - av_log(s->avctx, AV_LOG_ERROR, "untested\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "untested\n"); } // FIXME reduced res stuff here - if (s->pict_type != AV_PICTURE_TYPE_I) { - int f_code = get_bits(&s->gb, 3); /* fcode_for */ + if (h->c.pict_type != AV_PICTURE_TYPE_I) { + int f_code = get_bits(&h->c.gb, 3); /* fcode_for */ if (f_code == 0) - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); } - if (s->pict_type == AV_PICTURE_TYPE_B) { - int b_code = get_bits(&s->gb, 3); + if (h->c.pict_type == AV_PICTURE_TYPE_B) { + int b_code = get_bits(&h->c.gb, 3); if (b_code == 0) - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); } } } if (ctx->new_pred) - decode_new_pred(ctx, &s->gb); + decode_new_pred(ctx, &h->c.gb); return 0; } static void reset_studio_dc_predictors(Mpeg4DecContext *const ctx) { - MPVContext *const s = &ctx->m; + MPVContext *const s = &ctx->h.c; /* Reset DC Predictors */ s->last_dc[0] = s->last_dc[1] = @@ -800,25 +805,25 @@ static void reset_studio_dc_predictors(Mpeg4DecContext *const ctx) * Decode the next video packet. * @return <0 if something went wrong */ -int ff_mpeg4_decode_studio_slice_header(MPVContext *const s) +int ff_mpeg4_decode_studio_slice_header(H263DecContext *const h) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; - GetBitContext *gb = &s->gb; + Mpeg4DecContext *const ctx = h263_to_mpeg4(h); + GetBitContext *gb = &h->c.gb; unsigned vlc_len; uint16_t mb_num; if (get_bits_left(gb) >= 32 && get_bits_long(gb, 32) == SLICE_STARTCODE) { - vlc_len = av_log2(s->mb_width * s->mb_height) + 1; + vlc_len = av_log2(h->c.mb_width * h->c.mb_height) + 1; mb_num = get_bits(gb, vlc_len); - if (mb_num >= s->mb_num) + if (mb_num >= h->c.mb_num) return AVERROR_INVALIDDATA; - s->mb_x = mb_num % s->mb_width; - s->mb_y = mb_num / s->mb_width; + h->c.mb_x = mb_num % h->c.mb_width; + h->c.mb_y = mb_num / h->c.mb_width; if (ctx->shape != BIN_ONLY_SHAPE) - s->qscale = mpeg_get_qscale(s); + h->c.qscale = mpeg_get_qscale(&h->c); if (get_bits1(gb)) { /* slice_extension_flag */ skip_bits1(gb); /* intra_slice */ @@ -844,7 +849,7 @@ int ff_mpeg4_decode_studio_slice_header(MPVContext *const s) */ static inline int get_amv(Mpeg4DecContext *ctx, int n) { - MpegEncContext *s = &ctx->m; + MPVContext *const s = &ctx->h.c; int x, y, mb_v, sum, dx, dy, shift; int len = 1 << (ctx->f_code + 4); const int a = ctx->sprite_warping_accuracy; @@ -975,17 +980,17 @@ static inline int mpeg4_get_level_dc(MpegEncContext *s, int n, int pred, int lev * @param dir_ptr the prediction direction will be stored here * @return the quantized dc */ -static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr) +static inline int mpeg4_decode_dc(H263DecContext *const h, int n, int *dir_ptr) { int level, code, pred; if (n < 4) - code = get_vlc2(&s->gb, dc_lum, DC_VLC_BITS, 1); + code = get_vlc2(&h->c.gb, dc_lum, DC_VLC_BITS, 1); else - code = get_vlc2(&s->gb, dc_chrom, DC_VLC_BITS, 1); + code = get_vlc2(&h->c.gb, dc_chrom, DC_VLC_BITS, 1); if (code < 0) { - av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n"); return AVERROR_INVALIDDATA; } @@ -994,29 +999,29 @@ static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr) } else { if (IS_3IV1) { if (code == 1) - level = 2 * get_bits1(&s->gb) - 1; + level = 2 * get_bits1(&h->c.gb) - 1; else { - if (get_bits1(&s->gb)) - level = get_bits(&s->gb, code - 1) + (1 << (code - 1)); + if (get_bits1(&h->c.gb)) + level = get_bits(&h->c.gb, code - 1) + (1 << (code - 1)); else - level = -get_bits(&s->gb, code - 1) - (1 << (code - 1)); + level = -get_bits(&h->c.gb, code - 1) - (1 << (code - 1)); } } else { - level = get_xbits(&s->gb, code); + level = get_xbits(&h->c.gb, code); } if (code > 8) { - if (get_bits1(&s->gb) == 0) { /* marker */ - if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) { - av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); + if (get_bits1(&h->c.gb) == 0) { /* marker */ + if (h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) { + av_log(h->c.avctx, AV_LOG_ERROR, "dc marker bit missing\n"); return AVERROR_INVALIDDATA; } } } } - pred = mpeg4_pred_dc(s, n, dir_ptr); - return mpeg4_get_level_dc(s, n, pred, level); + pred = mpeg4_pred_dc(&h->c, n, dir_ptr); + return mpeg4_get_level_dc(&h->c, n, pred, level); } /** @@ -1025,85 +1030,85 @@ static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr) */ static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx) { - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; int mb_num = 0; static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; /* decode first partition */ - s->first_slice_line = 1; - for (; s->mb_y < s->mb_height; s->mb_y++) { - ff_init_block_index(s); - for (; s->mb_x < s->mb_width; s->mb_x++) { - const int xy = s->mb_x + s->mb_y * s->mb_stride; + h->c.first_slice_line = 1; + for (; h->c.mb_y < h->c.mb_height; h->c.mb_y++) { + ff_init_block_index(&h->c); + for (; h->c.mb_x < h->c.mb_width; h->c.mb_x++) { + const int xy = h->c.mb_x + h->c.mb_y * h->c.mb_stride; int cbpc; int dir = 0; mb_num++; - ff_update_block_index(s, 8, s->avctx->lowres, 1); - if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1) - s->first_slice_line = 0; + ff_update_block_index(&h->c, 8, h->c.avctx->lowres, 1); + if (h->c.mb_x == h->c.resync_mb_x && h->c.mb_y == h->c.resync_mb_y + 1) + h->c.first_slice_line = 0; - if (s->pict_type == AV_PICTURE_TYPE_I) { + if (h->c.pict_type == AV_PICTURE_TYPE_I) { int i; do { - if (show_bits(&s->gb, 19) == DC_MARKER) + if (show_bits(&h->c.gb, 19) == DC_MARKER) return mb_num - 1; - cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); + cbpc = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); if (cbpc < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "mcbpc corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } } while (cbpc == 8); - s->cbp_table[xy] = cbpc & 3; - s->cur_pic.mb_type[xy] = MB_TYPE_INTRA; - s->mb_intra = 1; + h->c.cbp_table[xy] = cbpc & 3; + h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; + h->c.mb_intra = 1; if (cbpc & 4) - ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); + ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); - s->cur_pic.qscale_table[xy] = s->qscale; + h->c.cur_pic.qscale_table[xy] = h->c.qscale; - s->mbintra_table[xy] = 1; + h->c.mbintra_table[xy] = 1; for (i = 0; i < 6; i++) { int dc_pred_dir; - int dc = mpeg4_decode_dc(s, i, &dc_pred_dir); + int dc = mpeg4_decode_dc(h, i, &dc_pred_dir); if (dc < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "DC corrupted at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "DC corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); return dc; } dir <<= 1; if (dc_pred_dir) dir |= 1; } - s->pred_dir_table[xy] = dir; + h->c.pred_dir_table[xy] = dir; } else { /* P/S_TYPE */ int mx, my, pred_x, pred_y, bits; - int16_t *const mot_val = s->cur_pic.motion_val[0][s->block_index[0]]; - const int stride = s->b8_stride * 2; + int16_t *const mot_val = h->c.cur_pic.motion_val[0][h->c.block_index[0]]; + const int stride = h->c.b8_stride * 2; try_again: - bits = show_bits(&s->gb, 17); + bits = show_bits(&h->c.gb, 17); if (bits == MOTION_MARKER) return mb_num - 1; - skip_bits1(&s->gb); + skip_bits1(&h->c.gb); if (bits & 0x10000) { /* skip mb */ - if (s->pict_type == AV_PICTURE_TYPE_S && + if (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE) { - s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | + h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_FORWARD_MV; mx = get_amv(ctx, 0); my = get_amv(ctx, 1); } else { - s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | + h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; mx = my = 0; @@ -1117,26 +1122,26 @@ try_again: mot_val[1 + stride] = mot_val[3 + stride] = my; - ff_h263_clean_intra_table_entries(s, xy); + ff_h263_clean_intra_table_entries(&h->c, xy); continue; } - cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); + cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); if (cbpc < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "mcbpc corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } if (cbpc == 20) goto try_again; - s->cbp_table[xy] = cbpc & (8 + 3); // 8 is dquant + h->c.cbp_table[xy] = cbpc & (8 + 3); // 8 is dquant - s->mb_intra = ((cbpc & 4) != 0); + h->c.mb_intra = ((cbpc & 4) != 0); - if (s->mb_intra) { - s->cur_pic.mb_type[xy] = MB_TYPE_INTRA; - s->mbintra_table[xy] = 1; + if (h->c.mb_intra) { + h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; + h->c.mbintra_table[xy] = 1; mot_val[0] = mot_val[2] = mot_val[0 + stride] = @@ -1146,33 +1151,33 @@ try_again: mot_val[1 + stride] = mot_val[3 + stride] = 0; } else { - ff_h263_clean_intra_table_entries(s, xy); + ff_h263_clean_intra_table_entries(&h->c, xy); - if (s->pict_type == AV_PICTURE_TYPE_S && + if (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0) - s->mcsel = get_bits1(&s->gb); + h->c.mcsel = get_bits1(&h->c.gb); else - s->mcsel = 0; + h->c.mcsel = 0; if ((cbpc & 16) == 0) { /* 16x16 motion prediction */ - ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); - if (!s->mcsel) { - mx = ff_h263_decode_motion(s, pred_x, ctx->f_code); + ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y); + if (!h->c.mcsel) { + mx = ff_h263_decode_motion(h, pred_x, ctx->f_code); if (mx >= 0xffff) return AVERROR_INVALIDDATA; - my = ff_h263_decode_motion(s, pred_y, ctx->f_code); + my = ff_h263_decode_motion(h, pred_y, ctx->f_code); if (my >= 0xffff) return AVERROR_INVALIDDATA; - s->cur_pic.mb_type[xy] = MB_TYPE_16x16 | + h->c.cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; } else { mx = get_amv(ctx, 0); my = get_amv(ctx, 1); - s->cur_pic.mb_type[xy] = MB_TYPE_16x16 | + h->c.cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_FORWARD_MV; } @@ -1187,15 +1192,15 @@ try_again: mot_val[3 + stride] = my; } else { int i; - s->cur_pic.mb_type[xy] = MB_TYPE_8x8 | + h->c.cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; for (i = 0; i < 4; i++) { - int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); - mx = ff_h263_decode_motion(s, pred_x, ctx->f_code); + int16_t *mot_val = ff_h263_pred_motion(&h->c, i, 0, &pred_x, &pred_y); + mx = ff_h263_decode_motion(h, pred_x, ctx->f_code); if (mx >= 0xffff) return AVERROR_INVALIDDATA; - my = ff_h263_decode_motion(s, pred_y, ctx->f_code); + my = ff_h263_decode_motion(h, pred_y, ctx->f_code); if (my >= 0xffff) return AVERROR_INVALIDDATA; mot_val[0] = mx; @@ -1205,7 +1210,7 @@ try_again: } } } - s->mb_x = 0; + h->c.mb_x = 0; } return mb_num; @@ -1215,91 +1220,91 @@ try_again: * decode second partition. * @return <0 if an error occurred */ -static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count) +static int mpeg4_decode_partition_b(H263DecContext *const h, int mb_count) { int mb_num = 0; static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; - s->mb_x = s->resync_mb_x; - s->first_slice_line = 1; - for (s->mb_y = s->resync_mb_y; mb_num < mb_count; s->mb_y++) { - ff_init_block_index(s); - for (; mb_num < mb_count && s->mb_x < s->mb_width; s->mb_x++) { - const int xy = s->mb_x + s->mb_y * s->mb_stride; + h->c.mb_x = h->c.resync_mb_x; + h->c.first_slice_line = 1; + for (h->c.mb_y = h->c.resync_mb_y; mb_num < mb_count; h->c.mb_y++) { + ff_init_block_index(&h->c); + for (; mb_num < mb_count && h->c.mb_x < h->c.mb_width; h->c.mb_x++) { + const int xy = h->c.mb_x + h->c.mb_y * h->c.mb_stride; mb_num++; - ff_update_block_index(s, 8, s->avctx->lowres, 1); - if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1) - s->first_slice_line = 0; + ff_update_block_index(&h->c, 8, h->c.avctx->lowres, 1); + if (h->c.mb_x == h->c.resync_mb_x && h->c.mb_y == h->c.resync_mb_y + 1) + h->c.first_slice_line = 0; - if (s->pict_type == AV_PICTURE_TYPE_I) { - int ac_pred = get_bits1(&s->gb); - int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + if (h->c.pict_type == AV_PICTURE_TYPE_I) { + int ac_pred = get_bits1(&h->c.gb); + int cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); if (cbpy < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "cbpy corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } - s->cbp_table[xy] |= cbpy << 2; - s->cur_pic.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED; + h->c.cbp_table[xy] |= cbpy << 2; + h->c.cur_pic.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED; } else { /* P || S_TYPE */ - if (IS_INTRA(s->cur_pic.mb_type[xy])) { + if (IS_INTRA(h->c.cur_pic.mb_type[xy])) { int i; int dir = 0; - int ac_pred = get_bits1(&s->gb); - int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + int ac_pred = get_bits1(&h->c.gb); + int cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); if (cbpy < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "I cbpy corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } - if (s->cbp_table[xy] & 8) - ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); - s->cur_pic.qscale_table[xy] = s->qscale; + if (h->c.cbp_table[xy] & 8) + ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); + h->c.cur_pic.qscale_table[xy] = h->c.qscale; for (i = 0; i < 6; i++) { int dc_pred_dir; - int dc = mpeg4_decode_dc(s, i, &dc_pred_dir); + int dc = mpeg4_decode_dc(h, i, &dc_pred_dir); if (dc < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "DC corrupted at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "DC corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); return dc; } dir <<= 1; if (dc_pred_dir) dir |= 1; } - s->cbp_table[xy] &= 3; // remove dquant - s->cbp_table[xy] |= cbpy << 2; - s->cur_pic.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED; - s->pred_dir_table[xy] = dir; - } else if (IS_SKIP(s->cur_pic.mb_type[xy])) { - s->cur_pic.qscale_table[xy] = s->qscale; - s->cbp_table[xy] = 0; + h->c.cbp_table[xy] &= 3; // remove dquant + h->c.cbp_table[xy] |= cbpy << 2; + h->c.cur_pic.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED; + h->c.pred_dir_table[xy] = dir; + } else if (IS_SKIP(h->c.cur_pic.mb_type[xy])) { + h->c.cur_pic.qscale_table[xy] = h->c.qscale; + h->c.cbp_table[xy] = 0; } else { - int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + int cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); if (cbpy < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "P cbpy corrupted at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } - if (s->cbp_table[xy] & 8) - ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); - s->cur_pic.qscale_table[xy] = s->qscale; + if (h->c.cbp_table[xy] & 8) + ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); + h->c.cur_pic.qscale_table[xy] = h->c.qscale; - s->cbp_table[xy] &= 3; // remove dquant - s->cbp_table[xy] |= (cbpy ^ 0xf) << 2; + h->c.cbp_table[xy] &= 3; // remove dquant + h->c.cbp_table[xy] |= (cbpy ^ 0xf) << 2; } } } if (mb_num >= mb_count) return 0; - s->mb_x = 0; + h->c.mb_x = 0; } return 0; } @@ -1308,62 +1313,62 @@ static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count) * Decode the first and second partition. * @return <0 if error (and sets error type in the error_status_table) */ -int ff_mpeg4_decode_partitions(MPVContext *const s) +int ff_mpeg4_decode_partitions(H263DecContext *const h) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; + Mpeg4DecContext *const ctx = h263_to_mpeg4(h); int mb_num; int ret; - const int part_a_error = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_ERROR | ER_MV_ERROR) : ER_MV_ERROR; - const int part_a_end = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_END | ER_MV_END) : ER_MV_END; + const int part_a_error = h->c.pict_type == AV_PICTURE_TYPE_I ? (ER_DC_ERROR | ER_MV_ERROR) : ER_MV_ERROR; + const int part_a_end = h->c.pict_type == AV_PICTURE_TYPE_I ? (ER_DC_END | ER_MV_END) : ER_MV_END; mb_num = mpeg4_decode_partition_a(ctx); if (mb_num <= 0) { - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x, s->mb_y, part_a_error); + 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, part_a_error); return mb_num ? mb_num : AVERROR_INVALIDDATA; } - if (s->resync_mb_x + s->resync_mb_y * s->mb_width + mb_num > s->mb_num) { - av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x, s->mb_y, part_a_error); + if (h->c.resync_mb_x + h->c.resync_mb_y * h->c.mb_width + mb_num > h->c.mb_num) { + av_log(h->c.avctx, AV_LOG_ERROR, "slice below monitor ...\n"); + 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, part_a_error); return AVERROR_INVALIDDATA; } - s->mb_num_left = mb_num; + h->c.mb_num_left = mb_num; - if (s->pict_type == AV_PICTURE_TYPE_I) { - while (show_bits(&s->gb, 9) == 1) - skip_bits(&s->gb, 9); - if (get_bits(&s->gb, 19) != DC_MARKER) { - av_log(s->avctx, AV_LOG_ERROR, + if (h->c.pict_type == AV_PICTURE_TYPE_I) { + while (show_bits(&h->c.gb, 9) == 1) + skip_bits(&h->c.gb, 9); + if (get_bits(&h->c.gb, 19) != DC_MARKER) { + av_log(h->c.avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", - s->mb_x, s->mb_y); + h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } } else { - while (show_bits(&s->gb, 10) == 1) - skip_bits(&s->gb, 10); - if (get_bits(&s->gb, 17) != MOTION_MARKER) { - av_log(s->avctx, AV_LOG_ERROR, + while (show_bits(&h->c.gb, 10) == 1) + skip_bits(&h->c.gb, 10); + if (get_bits(&h->c.gb, 17) != MOTION_MARKER) { + av_log(h->c.avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", - s->mb_x, s->mb_y); + h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } } - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x - 1, s->mb_y, part_a_end); + ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, + h->c.mb_x - 1, h->c.mb_y, part_a_end); - ret = mpeg4_decode_partition_b(s, mb_num); + ret = mpeg4_decode_partition_b(h, mb_num); if (ret < 0) { - if (s->pict_type == AV_PICTURE_TYPE_P) - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x, s->mb_y, ER_DC_ERROR); + if (h->c.pict_type == AV_PICTURE_TYPE_P) + 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_DC_ERROR); return ret; } else { - if (s->pict_type == AV_PICTURE_TYPE_P) - ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, - s->mb_x - 1, s->mb_y, ER_DC_END); + if (h->c.pict_type == AV_PICTURE_TYPE_P) + ff_er_add_slice(&h->c.er, h->c.resync_mb_x, h->c.resync_mb_y, + h->c.mb_x - 1, h->c.mb_y, ER_DC_END); } return 0; @@ -1377,7 +1382,7 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, int n, int coded, int intra, int use_intra_dc_vlc, int rvlc) { - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; int level, i, last, run, qmul, qadd, pred; int av_uninit(dc_pred_dir); const RLTable *rl; @@ -1390,15 +1395,15 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, // FIXME add short header support if (use_intra_dc_vlc) { /* DC coef */ - if (s->partitioned_frame) { - level = s->dc_val[s->block_index[n]]; + if (h->c.partitioned_frame) { + level = h->c.dc_val[h->c.block_index[n]]; if (n < 4) - level = FASTDIV((level + (s->y_dc_scale >> 1)), s->y_dc_scale); + level = FASTDIV((level + (h->c.y_dc_scale >> 1)), h->c.y_dc_scale); else - level = FASTDIV((level + (s->c_dc_scale >> 1)), s->c_dc_scale); - dc_pred_dir = (s->pred_dir_table[s->mb_x + s->mb_y * s->mb_stride] << n) & 32; + level = FASTDIV((level + (h->c.c_dc_scale >> 1)), h->c.c_dc_scale); + dc_pred_dir = (h->c.pred_dir_table[h->c.mb_x + h->c.mb_y * h->c.mb_stride] << n) & 32; } else { - level = mpeg4_decode_dc(s, n, &dc_pred_dir); + level = mpeg4_decode_dc(h, n, &dc_pred_dir); if (level < 0) return level; } @@ -1406,7 +1411,7 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, i = 0; } else { i = -1; - pred = mpeg4_pred_dc(s, n, &dc_pred_dir); + pred = mpeg4_pred_dc(&h->c, n, &dc_pred_dir); } if (!coded) goto not_coded; @@ -1418,20 +1423,20 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, rl = &ff_mpeg4_rl_intra; rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0]; } - if (s->ac_pred) { + if (h->c.ac_pred) { if (dc_pred_dir == 0) - scan_table = s->permutated_intra_v_scantable; /* left */ + scan_table = h->c.permutated_intra_v_scantable; /* left */ else - scan_table = s->permutated_intra_h_scantable; /* top */ + scan_table = h->c.permutated_intra_h_scantable; /* top */ } else { - scan_table = s->intra_scantable.permutated; + scan_table = h->c.intra_scantable.permutated; } qmul = 1; qadd = 0; } else { i = -1; if (!coded) { - s->block_last_index[n] = i; + h->c.block_last_index[n] = i; return 0; } if (rvlc) @@ -1439,7 +1444,7 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, else rl = &ff_h263_rl_inter; - scan_table = s->intra_scantable.permutated; + scan_table = h->c.intra_scantable.permutated; if (ctx->mpeg_quant) { qmul = 1; @@ -1449,61 +1454,61 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, else rl_vlc = ff_h263_rl_inter.rl_vlc[0]; } else { - qmul = s->qscale << 1; - qadd = (s->qscale - 1) | 1; + qmul = h->c.qscale << 1; + qadd = (h->c.qscale - 1) | 1; if (rvlc) - rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale]; + rl_vlc = ff_rvlc_rl_inter.rl_vlc[h->c.qscale]; else - rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale]; + rl_vlc = ff_h263_rl_inter.rl_vlc[h->c.qscale]; } } { - OPEN_READER(re, &s->gb); + OPEN_READER(re, &h->c.gb); for (;;) { - UPDATE_CACHE(re, &s->gb); - GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); + UPDATE_CACHE(re, &h->c.gb); + GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 0); if (level == 0) { /* escape */ if (rvlc) { - if (SHOW_UBITS(re, &s->gb, 1) == 0) { - av_log(s->avctx, AV_LOG_ERROR, + if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); return AVERROR_INVALIDDATA; } - SKIP_CACHE(re, &s->gb, 1); + SKIP_CACHE(re, &h->c.gb, 1); - last = SHOW_UBITS(re, &s->gb, 1); - SKIP_CACHE(re, &s->gb, 1); - run = SHOW_UBITS(re, &s->gb, 6); - SKIP_COUNTER(re, &s->gb, 1 + 1 + 6); - UPDATE_CACHE(re, &s->gb); + last = SHOW_UBITS(re, &h->c.gb, 1); + SKIP_CACHE(re, &h->c.gb, 1); + run = SHOW_UBITS(re, &h->c.gb, 6); + SKIP_COUNTER(re, &h->c.gb, 1 + 1 + 6); + UPDATE_CACHE(re, &h->c.gb); - if (SHOW_UBITS(re, &s->gb, 1) == 0) { - av_log(s->avctx, AV_LOG_ERROR, + if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); return AVERROR_INVALIDDATA; } - SKIP_CACHE(re, &s->gb, 1); + SKIP_CACHE(re, &h->c.gb, 1); - level = SHOW_UBITS(re, &s->gb, 11); - SKIP_CACHE(re, &s->gb, 11); + level = SHOW_UBITS(re, &h->c.gb, 11); + SKIP_CACHE(re, &h->c.gb, 11); - if (SHOW_UBITS(re, &s->gb, 5) != 0x10) { - av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); + if (SHOW_UBITS(re, &h->c.gb, 5) != 0x10) { + av_log(h->c.avctx, AV_LOG_ERROR, "reverse esc missing\n"); return AVERROR_INVALIDDATA; } - SKIP_CACHE(re, &s->gb, 5); + SKIP_CACHE(re, &h->c.gb, 5); level = level * qmul + qadd; - level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); - SKIP_COUNTER(re, &s->gb, 1 + 11 + 5 + 1); + level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); + SKIP_COUNTER(re, &h->c.gb, 1 + 11 + 5 + 1); i += run + 1; if (last) i += 192; } else { int cache; - cache = GET_CACHE(re, &s->gb); + cache = GET_CACHE(re, &h->c.gb); if (IS_3IV1) cache ^= 0xC0000000; @@ -1511,54 +1516,54 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, if (cache & 0x80000000) { if (cache & 0x40000000) { /* third escape */ - SKIP_CACHE(re, &s->gb, 2); - last = SHOW_UBITS(re, &s->gb, 1); - SKIP_CACHE(re, &s->gb, 1); - run = SHOW_UBITS(re, &s->gb, 6); - SKIP_COUNTER(re, &s->gb, 2 + 1 + 6); - UPDATE_CACHE(re, &s->gb); + SKIP_CACHE(re, &h->c.gb, 2); + last = SHOW_UBITS(re, &h->c.gb, 1); + SKIP_CACHE(re, &h->c.gb, 1); + run = SHOW_UBITS(re, &h->c.gb, 6); + SKIP_COUNTER(re, &h->c.gb, 2 + 1 + 6); + UPDATE_CACHE(re, &h->c.gb); if (IS_3IV1) { - level = SHOW_SBITS(re, &s->gb, 12); - LAST_SKIP_BITS(re, &s->gb, 12); + level = SHOW_SBITS(re, &h->c.gb, 12); + LAST_SKIP_BITS(re, &h->c.gb, 12); } else { - if (SHOW_UBITS(re, &s->gb, 1) == 0) { - av_log(s->avctx, AV_LOG_ERROR, + if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); - 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) return AVERROR_INVALIDDATA; } - SKIP_CACHE(re, &s->gb, 1); + SKIP_CACHE(re, &h->c.gb, 1); - level = SHOW_SBITS(re, &s->gb, 12); - SKIP_CACHE(re, &s->gb, 12); + level = SHOW_SBITS(re, &h->c.gb, 12); + SKIP_CACHE(re, &h->c.gb, 12); - if (SHOW_UBITS(re, &s->gb, 1) == 0) { - av_log(s->avctx, AV_LOG_ERROR, + if (SHOW_UBITS(re, &h->c.gb, 1) == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); - 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) return AVERROR_INVALIDDATA; } - SKIP_COUNTER(re, &s->gb, 1 + 12 + 1); + SKIP_COUNTER(re, &h->c.gb, 1 + 12 + 1); } #if 0 - if (s->error_recognition >= FF_ER_COMPLIANT) { + if (h->c.error_recognition >= FF_ER_COMPLIANT) { const int abs_level= FFABS(level); if (abs_level<=MAX_LEVEL && run<=MAX_RUN) { const int run1= run - rl->max_run[last][abs_level] - 1; if (abs_level <= rl->max_level[last][run]) { - av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); return AVERROR_INVALIDDATA; } - if (s->error_recognition > FF_ER_COMPLIANT) { + if (h->c.error_recognition > FF_ER_COMPLIANT) { if (abs_level <= rl->max_level[last][run]*2) { - av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); return AVERROR_INVALIDDATA; } if (run1 >= 0 && abs_level <= rl->max_level[last][run1]) { - av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); return AVERROR_INVALIDDATA; } } @@ -1571,11 +1576,11 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, level = level * qmul - qadd; if ((unsigned)(level + 2048) > 4095) { - if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) { + if (h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) { if (level > 2560 || level < -2560) { - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", - s->qscale); + h->c.qscale); return AVERROR_INVALIDDATA; } } @@ -1587,33 +1592,33 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, i += 192; } else { /* second escape */ - SKIP_BITS(re, &s->gb, 2); - GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); + SKIP_BITS(re, &h->c.gb, 2); + 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] + 1; // FIXME opt indexing - level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); - LAST_SKIP_BITS(re, &s->gb, 1); + level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); + LAST_SKIP_BITS(re, &h->c.gb, 1); } } else { /* first escape */ - SKIP_BITS(re, &s->gb, 1); - GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); + SKIP_BITS(re, &h->c.gb, 1); + GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 1); i += run; 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); - LAST_SKIP_BITS(re, &s->gb, 1); + level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); + LAST_SKIP_BITS(re, &h->c.gb, 1); } } } else { i += run; - level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); - LAST_SKIP_BITS(re, &s->gb, 1); + level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); + LAST_SKIP_BITS(re, &h->c.gb, 1); } - ff_tlog(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62); + ff_tlog(h->c.avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62); if (i > 62) { i -= 192; if (i & (~63)) { - 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 AVERROR_INVALIDDATA; } @@ -1623,22 +1628,22 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, block[scan_table[i]] = level; } - CLOSE_READER(re, &s->gb); + CLOSE_READER(re, &h->c.gb); } not_coded: if (intra) { if (!use_intra_dc_vlc) { - block[0] = mpeg4_get_level_dc(s, n, pred, block[0]); + block[0] = mpeg4_get_level_dc(&h->c, n, pred, block[0]); i -= i >> 31; // if (i == -1) i = 0; } - ff_mpeg4_pred_ac(s, block, n, dc_pred_dir); - if (s->ac_pred) + ff_mpeg4_pred_ac(h, block, n, dc_pred_dir); + if (h->c.ac_pred) i = 63; // FIXME not optimal } - s->block_last_index[n] = i; + h->c.block_last_index[n] = i; return 0; } @@ -1646,72 +1651,71 @@ not_coded: * decode partition C of one MB. * @return <0 if an error occurred */ -static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64]) +static int mpeg4_decode_partitioned_mb(H263DecContext *const h, int16_t block[6][64]) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; - int cbp, mb_type, use_intra_dc_vlc; - const int xy = s->mb_x + s->mb_y * s->mb_stride; + Mpeg4DecContext *const ctx = h263_to_mpeg4(h); + const int xy = h->c.mb_x + h->c.mb_y * h->c.mb_stride; - mb_type = s->cur_pic.mb_type[xy]; - cbp = s->cbp_table[xy]; + const int mb_type = h->c.cur_pic.mb_type[xy]; + int cbp = h->c.cbp_table[xy]; - use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold; + const int use_intra_dc_vlc = h->c.qscale < ctx->intra_dc_threshold; - if (s->cur_pic.qscale_table[xy] != s->qscale) - ff_set_qscale(s, s->cur_pic.qscale_table[xy]); + if (h->c.cur_pic.qscale_table[xy] != h->c.qscale) + ff_set_qscale(&h->c, h->c.cur_pic.qscale_table[xy]); - if (s->pict_type == AV_PICTURE_TYPE_P || - s->pict_type == AV_PICTURE_TYPE_S) { + if (h->c.pict_type == AV_PICTURE_TYPE_P || + h->c.pict_type == AV_PICTURE_TYPE_S) { int i; for (i = 0; i < 4; i++) { - s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0]; - s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1]; + h->c.mv[0][i][0] = h->c.cur_pic.motion_val[0][h->c.block_index[i]][0]; + h->c.mv[0][i][1] = h->c.cur_pic.motion_val[0][h->c.block_index[i]][1]; } - s->mb_intra = IS_INTRA(mb_type); + h->c.mb_intra = IS_INTRA(mb_type); if (IS_SKIP(mb_type)) { /* skip mb */ for (i = 0; i < 6; i++) - s->block_last_index[i] = -1; - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - if (s->pict_type == AV_PICTURE_TYPE_S + h->c.block_last_index[i] = -1; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + if (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE) { - s->mcsel = 1; - s->mb_skipped = 0; - s->cur_pic.mbskip_table[xy] = 0; + h->c.mcsel = 1; + h->c.mb_skipped = 0; + h->c.cur_pic.mbskip_table[xy] = 0; } else { - s->mcsel = 0; - s->mb_skipped = 1; - s->cur_pic.mbskip_table[xy] = 1; + h->c.mcsel = 0; + h->c.mb_skipped = 1; + h->c.cur_pic.mbskip_table[xy] = 1; } - } else if (s->mb_intra) { - s->ac_pred = IS_ACPRED(s->cur_pic.mb_type[xy]); - } else if (!s->mb_intra) { - // s->mcsel = 0; // FIXME do we need to init that? + } else if (h->c.mb_intra) { + h->c.ac_pred = IS_ACPRED(h->c.cur_pic.mb_type[xy]); + } else if (!h->c.mb_intra) { + // h->c.mcsel = 0; // FIXME do we need to init that? - s->mv_dir = MV_DIR_FORWARD; + h->c.mv_dir = MV_DIR_FORWARD; if (IS_8X8(mb_type)) { - s->mv_type = MV_TYPE_8X8; + h->c.mv_type = MV_TYPE_8X8; } else { - s->mv_type = MV_TYPE_16X16; + h->c.mv_type = MV_TYPE_16X16; } } } else { /* I-Frame */ - s->mb_intra = 1; - s->ac_pred = IS_ACPRED(s->cur_pic.mb_type[xy]); + h->c.mb_intra = 1; + h->c.ac_pred = IS_ACPRED(h->c.cur_pic.mb_type[xy]); } if (!IS_SKIP(mb_type)) { int i; - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); /* decode each block */ for (i = 0; i < 6; i++) { - if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, s->mb_intra, + if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, h->c.mb_intra, use_intra_dc_vlc, ctx->rvlc) < 0) { - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", - s->mb_x, s->mb_y, s->mb_intra); + h->c.mb_x, h->c.mb_y, h->c.mb_intra); return AVERROR_INVALIDDATA; } cbp += cbp; @@ -1719,300 +1723,300 @@ static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64]) } /* per-MB end of slice check */ - if (--s->mb_num_left <= 0) { + if (--h->c.mb_num_left <= 0) { if (mpeg4_is_resync(ctx)) return SLICE_END; else return SLICE_NOEND; } else { if (mpeg4_is_resync(ctx)) { - const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1; - if (s->cbp_table[xy + delta]) + const int delta = h->c.mb_x + 1 == h->c.mb_width ? 2 : 1; + if (h->c.cbp_table[xy + delta]) return SLICE_END; } return SLICE_OK; } } -static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) +static int mpeg4_decode_mb(H263DecContext *const h, int16_t block[6][64]) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; + Mpeg4DecContext *const ctx = h263_to_mpeg4(h); int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; - 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; int next; - av_assert2(s->h263_pred); + av_assert2(h->c.h263_pred); - if (s->pict_type == AV_PICTURE_TYPE_P || - s->pict_type == AV_PICTURE_TYPE_S) { + if (h->c.pict_type == AV_PICTURE_TYPE_P || + h->c.pict_type == AV_PICTURE_TYPE_S) { do { - if (get_bits1(&s->gb)) { + if (get_bits1(&h->c.gb)) { /* skip mb */ - s->mb_intra = 0; + h->c.mb_intra = 0; for (i = 0; i < 6; i++) - s->block_last_index[i] = -1; - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - if (s->pict_type == AV_PICTURE_TYPE_S && + h->c.block_last_index[i] = -1; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + if (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE) { - s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | + h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; - s->mcsel = 1; - s->mv[0][0][0] = get_amv(ctx, 0); - s->mv[0][0][1] = get_amv(ctx, 1); - s->cur_pic.mbskip_table[xy] = 0; - s->mb_skipped = 0; + h->c.mcsel = 1; + h->c.mv[0][0][0] = get_amv(ctx, 0); + h->c.mv[0][0][1] = get_amv(ctx, 1); + h->c.cur_pic.mbskip_table[xy] = 0; + h->c.mb_skipped = 0; } else { - s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | + h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; - s->mcsel = 0; - s->mv[0][0][0] = 0; - s->mv[0][0][1] = 0; - s->cur_pic.mbskip_table[xy] = 1; - s->mb_skipped = 1; + h->c.mcsel = 0; + h->c.mv[0][0][0] = 0; + h->c.mv[0][0][1] = 0; + h->c.cur_pic.mbskip_table[xy] = 1; + h->c.mb_skipped = 1; } goto end; } - cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); + cbpc = get_vlc2(&h->c.gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2); if (cbpc < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "mcbpc damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "mcbpc damaged at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } } while (cbpc == 20); dquant = cbpc & 8; - s->mb_intra = ((cbpc & 4) != 0); - if (s->mb_intra) + h->c.mb_intra = ((cbpc & 4) != 0); + if (h->c.mb_intra) goto intra; - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); - if (s->pict_type == AV_PICTURE_TYPE_S && + if (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0) - s->mcsel = get_bits1(&s->gb); + h->c.mcsel = get_bits1(&h->c.gb); else - s->mcsel = 0; - cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1) ^ 0x0F; + h->c.mcsel = 0; + cbpy = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1) ^ 0x0F; if (cbpy < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "P cbpy damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "P cbpy damaged at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } cbp = (cbpc & 3) | (cbpy << 2); if (dquant) - ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); - if ((!s->progressive_sequence) && - (cbp || (s->workaround_bugs & FF_BUG_XVID_ILACE))) - s->interlaced_dct = get_bits1(&s->gb); + ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); + if ((!h->c.progressive_sequence) && + (cbp || (h->c.workaround_bugs & FF_BUG_XVID_ILACE))) + h->c.interlaced_dct = get_bits1(&h->c.gb); - s->mv_dir = MV_DIR_FORWARD; + h->c.mv_dir = MV_DIR_FORWARD; if ((cbpc & 16) == 0) { - if (s->mcsel) { - s->cur_pic.mb_type[xy] = MB_TYPE_GMC | MB_TYPE_16x16 | + if (h->c.mcsel) { + h->c.cur_pic.mb_type[xy] = MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; /* 16x16 global motion prediction */ - s->mv_type = MV_TYPE_16X16; + h->c.mv_type = MV_TYPE_16X16; mx = get_amv(ctx, 0); my = get_amv(ctx, 1); - s->mv[0][0][0] = mx; - s->mv[0][0][1] = my; - } else if ((!s->progressive_sequence) && get_bits1(&s->gb)) { - s->cur_pic.mb_type[xy] = MB_TYPE_16x8 | MB_TYPE_FORWARD_MV | + h->c.mv[0][0][0] = mx; + h->c.mv[0][0][1] = my; + } else if ((!h->c.progressive_sequence) && get_bits1(&h->c.gb)) { + h->c.cur_pic.mb_type[xy] = MB_TYPE_16x8 | MB_TYPE_FORWARD_MV | MB_TYPE_INTERLACED; /* 16x8 field motion prediction */ - s->mv_type = MV_TYPE_FIELD; + h->c.mv_type = MV_TYPE_FIELD; - s->field_select[0][0] = get_bits1(&s->gb); - s->field_select[0][1] = get_bits1(&s->gb); + h->c.field_select[0][0] = get_bits1(&h->c.gb); + h->c.field_select[0][1] = get_bits1(&h->c.gb); - ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); + ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y); for (i = 0; i < 2; i++) { - mx = ff_h263_decode_motion(s, pred_x, ctx->f_code); + mx = ff_h263_decode_motion(h, pred_x, ctx->f_code); if (mx >= 0xffff) return AVERROR_INVALIDDATA; - my = ff_h263_decode_motion(s, pred_y / 2, ctx->f_code); + my = ff_h263_decode_motion(h, pred_y / 2, ctx->f_code); if (my >= 0xffff) return AVERROR_INVALIDDATA; - s->mv[0][i][0] = mx; - s->mv[0][i][1] = my; + h->c.mv[0][i][0] = mx; + h->c.mv[0][i][1] = my; } } else { - s->cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + h->c.cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; /* 16x16 motion prediction */ - s->mv_type = MV_TYPE_16X16; - ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); - mx = ff_h263_decode_motion(s, pred_x, ctx->f_code); + h->c.mv_type = MV_TYPE_16X16; + ff_h263_pred_motion(&h->c, 0, 0, &pred_x, &pred_y); + mx = ff_h263_decode_motion(h, pred_x, ctx->f_code); if (mx >= 0xffff) return AVERROR_INVALIDDATA; - my = ff_h263_decode_motion(s, pred_y, ctx->f_code); + my = ff_h263_decode_motion(h, pred_y, ctx->f_code); if (my >= 0xffff) return AVERROR_INVALIDDATA; - s->mv[0][0][0] = mx; - s->mv[0][0][1] = my; + h->c.mv[0][0][0] = mx; + h->c.mv[0][0][1] = my; } } else { - s->cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; - s->mv_type = MV_TYPE_8X8; + h->c.cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV; + h->c.mv_type = MV_TYPE_8X8; for (i = 0; i < 4; i++) { - int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); - mx = ff_h263_decode_motion(s, pred_x, ctx->f_code); + int16_t *mot_val = ff_h263_pred_motion(&h->c, i, 0, &pred_x, &pred_y); + mx = ff_h263_decode_motion(h, pred_x, ctx->f_code); if (mx >= 0xffff) return AVERROR_INVALIDDATA; - my = ff_h263_decode_motion(s, pred_y, ctx->f_code); + my = ff_h263_decode_motion(h, pred_y, ctx->f_code); if (my >= 0xffff) return AVERROR_INVALIDDATA; - s->mv[0][i][0] = mx; - s->mv[0][i][1] = my; + h->c.mv[0][i][0] = mx; + h->c.mv[0][i][1] = my; mot_val[0] = mx; mot_val[1] = my; } } - } else if (s->pict_type == AV_PICTURE_TYPE_B) { + } else if (h->c.pict_type == AV_PICTURE_TYPE_B) { int modb1; // first bit of modb int modb2; // second bit of modb int mb_type; - s->mb_intra = 0; // B-frames never contain intra blocks - s->mcsel = 0; // ... true gmc blocks + h->c.mb_intra = 0; // B-frames never contain intra blocks + h->c.mcsel = 0; // ... true gmc blocks - if (s->mb_x == 0) { + if (h->c.mb_x == 0) { for (i = 0; i < 2; i++) { - s->last_mv[i][0][0] = - s->last_mv[i][0][1] = - s->last_mv[i][1][0] = - s->last_mv[i][1][1] = 0; + h->c.last_mv[i][0][0] = + h->c.last_mv[i][0][1] = + h->c.last_mv[i][1][0] = + h->c.last_mv[i][1][1] = 0; } - ff_thread_progress_await(&s->next_pic.ptr->progress, s->mb_y); + ff_thread_progress_await(&h->c.next_pic.ptr->progress, h->c.mb_y); } /* if we skipped it in the future P-frame than skip it now too */ - s->mb_skipped = s->next_pic.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC + h->c.mb_skipped = h->c.next_pic.mbskip_table[h->c.mb_y * h->c.mb_stride + h->c.mb_x]; // Note, skiptab=0 if last was GMC - if (s->mb_skipped) { + if (h->c.mb_skipped) { /* skip mb */ for (i = 0; i < 6; i++) - s->block_last_index[i] = -1; - - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = - s->mv[0][0][1] = - s->mv[1][0][0] = - s->mv[1][0][1] = 0; - s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | + h->c.block_last_index[i] = -1; + + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.mv[0][0][0] = + h->c.mv[0][0][1] = + h->c.mv[1][0][0] = + h->c.mv[1][0][1] = 0; + h->c.cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; goto end; } - modb1 = get_bits1(&s->gb); + modb1 = get_bits1(&h->c.gb); if (modb1) { // like MB_TYPE_B_DIRECT but no vectors coded mb_type = MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_BIDIR_MV; cbp = 0; } else { - modb2 = get_bits1(&s->gb); - mb_type = get_vlc2(&s->gb, mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 1); + modb2 = get_bits1(&h->c.gb); + mb_type = get_vlc2(&h->c.gb, mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 1); if (mb_type < 0) { - av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal MB_type\n"); return AVERROR_INVALIDDATA; } if (modb2) { cbp = 0; } else { - s->bdsp.clear_blocks(s->block[0]); - cbp = get_bits(&s->gb, 6); + h->c.bdsp.clear_blocks(h->c.block[0]); + cbp = get_bits(&h->c.gb, 6); } if ((!IS_DIRECT(mb_type)) && cbp) { - if (get_bits1(&s->gb)) - ff_set_qscale(s, s->qscale + get_bits1(&s->gb) * 4 - 2); + if (get_bits1(&h->c.gb)) + ff_set_qscale(&h->c, h->c.qscale + get_bits1(&h->c.gb) * 4 - 2); } - if (!s->progressive_sequence) { + if (!h->c.progressive_sequence) { if (cbp) - s->interlaced_dct = get_bits1(&s->gb); + h->c.interlaced_dct = get_bits1(&h->c.gb); - if (!IS_DIRECT(mb_type) && get_bits1(&s->gb)) { + if (!IS_DIRECT(mb_type) && get_bits1(&h->c.gb)) { mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; mb_type &= ~MB_TYPE_16x16; if (HAS_FORWARD_MV(mb_type)) { - s->field_select[0][0] = get_bits1(&s->gb); - s->field_select[0][1] = get_bits1(&s->gb); + h->c.field_select[0][0] = get_bits1(&h->c.gb); + h->c.field_select[0][1] = get_bits1(&h->c.gb); } if (HAS_BACKWARD_MV(mb_type)) { - s->field_select[1][0] = get_bits1(&s->gb); - s->field_select[1][1] = get_bits1(&s->gb); + h->c.field_select[1][0] = get_bits1(&h->c.gb); + h->c.field_select[1][1] = get_bits1(&h->c.gb); } } } - s->mv_dir = 0; + h->c.mv_dir = 0; if ((mb_type & (MB_TYPE_DIRECT2 | MB_TYPE_INTERLACED)) == 0) { - s->mv_type = MV_TYPE_16X16; + h->c.mv_type = MV_TYPE_16X16; if (HAS_FORWARD_MV(mb_type)) { - s->mv_dir = MV_DIR_FORWARD; - - mx = ff_h263_decode_motion(s, s->last_mv[0][0][0], ctx->f_code); - my = ff_h263_decode_motion(s, s->last_mv[0][0][1], ctx->f_code); - s->last_mv[0][1][0] = - s->last_mv[0][0][0] = - s->mv[0][0][0] = mx; - s->last_mv[0][1][1] = - s->last_mv[0][0][1] = - s->mv[0][0][1] = my; + h->c.mv_dir = MV_DIR_FORWARD; + + mx = ff_h263_decode_motion(h, h->c.last_mv[0][0][0], ctx->f_code); + my = ff_h263_decode_motion(h, h->c.last_mv[0][0][1], ctx->f_code); + h->c.last_mv[0][1][0] = + h->c.last_mv[0][0][0] = + h->c.mv[0][0][0] = mx; + h->c.last_mv[0][1][1] = + h->c.last_mv[0][0][1] = + h->c.mv[0][0][1] = my; } if (HAS_BACKWARD_MV(mb_type)) { - s->mv_dir |= MV_DIR_BACKWARD; - - mx = ff_h263_decode_motion(s, s->last_mv[1][0][0], ctx->b_code); - my = ff_h263_decode_motion(s, s->last_mv[1][0][1], ctx->b_code); - s->last_mv[1][1][0] = - s->last_mv[1][0][0] = - s->mv[1][0][0] = mx; - s->last_mv[1][1][1] = - s->last_mv[1][0][1] = - s->mv[1][0][1] = my; + h->c.mv_dir |= MV_DIR_BACKWARD; + + mx = ff_h263_decode_motion(h, h->c.last_mv[1][0][0], ctx->b_code); + my = ff_h263_decode_motion(h, h->c.last_mv[1][0][1], ctx->b_code); + h->c.last_mv[1][1][0] = + h->c.last_mv[1][0][0] = + h->c.mv[1][0][0] = mx; + h->c.last_mv[1][1][1] = + h->c.last_mv[1][0][1] = + h->c.mv[1][0][1] = my; } } else if (!IS_DIRECT(mb_type)) { - s->mv_type = MV_TYPE_FIELD; + h->c.mv_type = MV_TYPE_FIELD; if (HAS_FORWARD_MV(mb_type)) { - s->mv_dir = MV_DIR_FORWARD; + h->c.mv_dir = MV_DIR_FORWARD; for (i = 0; i < 2; i++) { - mx = ff_h263_decode_motion(s, s->last_mv[0][i][0], ctx->f_code); - my = ff_h263_decode_motion(s, s->last_mv[0][i][1] / 2, ctx->f_code); - s->last_mv[0][i][0] = - s->mv[0][i][0] = mx; - s->last_mv[0][i][1] = (s->mv[0][i][1] = my) * 2; + mx = ff_h263_decode_motion(h, h->c.last_mv[0][i][0], ctx->f_code); + my = ff_h263_decode_motion(h, h->c.last_mv[0][i][1] / 2, ctx->f_code); + h->c.last_mv[0][i][0] = + h->c.mv[0][i][0] = mx; + h->c.last_mv[0][i][1] = (h->c.mv[0][i][1] = my) * 2; } } if (HAS_BACKWARD_MV(mb_type)) { - s->mv_dir |= MV_DIR_BACKWARD; + h->c.mv_dir |= MV_DIR_BACKWARD; for (i = 0; i < 2; i++) { - mx = ff_h263_decode_motion(s, s->last_mv[1][i][0], ctx->b_code); - my = ff_h263_decode_motion(s, s->last_mv[1][i][1] / 2, ctx->b_code); - s->last_mv[1][i][0] = - s->mv[1][i][0] = mx; - s->last_mv[1][i][1] = (s->mv[1][i][1] = my) * 2; + mx = ff_h263_decode_motion(h, h->c.last_mv[1][i][0], ctx->b_code); + my = ff_h263_decode_motion(h, h->c.last_mv[1][i][1] / 2, ctx->b_code); + h->c.last_mv[1][i][0] = + h->c.mv[1][i][0] = mx; + h->c.last_mv[1][i][1] = (h->c.mv[1][i][1] = my) * 2; } } } @@ -2023,53 +2027,53 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) mx = my = 0; } else { - mx = ff_h263_decode_motion(s, 0, 1); - my = ff_h263_decode_motion(s, 0, 1); + mx = ff_h263_decode_motion(h, 0, 1); + my = ff_h263_decode_motion(h, 0, 1); } - s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; - mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); + h->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; + mb_type |= ff_mpeg4_set_direct_mv(&h->c, mx, my); } - s->cur_pic.mb_type[xy] = mb_type; + h->c.cur_pic.mb_type[xy] = mb_type; } else { /* I-Frame */ int use_intra_dc_vlc; do { - cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); + cbpc = get_vlc2(&h->c.gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2); if (cbpc < 0) { - av_log(s->avctx, AV_LOG_ERROR, - "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "I cbpc damaged at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } } while (cbpc == 8); dquant = cbpc & 4; - s->mb_intra = 1; + h->c.mb_intra = 1; intra: - s->ac_pred = get_bits1(&s->gb); - if (s->ac_pred) - s->cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; + h->c.ac_pred = get_bits1(&h->c.gb); + if (h->c.ac_pred) + h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; else - s->cur_pic.mb_type[xy] = MB_TYPE_INTRA; + h->c.cur_pic.mb_type[xy] = MB_TYPE_INTRA; - 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) { - av_log(s->avctx, AV_LOG_ERROR, - "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); + av_log(h->c.avctx, AV_LOG_ERROR, + "I cbpy damaged at %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } cbp = (cbpc & 3) | (cbpy << 2); - use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold; + use_intra_dc_vlc = h->c.qscale < ctx->intra_dc_threshold; if (dquant) - ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); + ff_set_qscale(&h->c, h->c.qscale + quant_tab[get_bits(&h->c.gb, 2)]); - if (!s->progressive_sequence) - s->interlaced_dct = get_bits1(&s->gb); + if (!h->c.progressive_sequence) + h->c.interlaced_dct = get_bits1(&h->c.gb); - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); /* decode each block */ for (i = 0; i < 6; i++) { if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, @@ -2091,18 +2095,18 @@ end: /* per-MB end of slice check */ next = mpeg4_is_resync(ctx); if (next) { - if (s->mb_x + s->mb_y*s->mb_width + 1 > next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) { + if (h->c.mb_x + h->c.mb_y*h->c.mb_width + 1 > next && (h->c.avctx->err_recognition & AV_EF_AGGRESSIVE)) { return AVERROR_INVALIDDATA; - } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next) + } else if (h->c.mb_x + h->c.mb_y*h->c.mb_width + 1 >= next) return SLICE_END; - if (s->pict_type == AV_PICTURE_TYPE_B) { - const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1; - ff_thread_progress_await(&s->next_pic.ptr->progress, - (s->mb_x + delta >= s->mb_width) - ? FFMIN(s->mb_y + 1, s->mb_height - 1) - : s->mb_y); - if (s->next_pic.mbskip_table[xy + delta]) + if (h->c.pict_type == AV_PICTURE_TYPE_B) { + const int delta = h->c.mb_x + 1 == h->c.mb_width ? 2 : 1; + ff_thread_progress_await(&h->c.next_pic.ptr->progress, + (h->c.mb_x + delta >= h->c.mb_width) + ? FFMIN(h->c.mb_y + 1, h->c.mb_height - 1) + : h->c.mb_y); + if (h->c.next_pic.mbskip_table[xy + delta]) return SLICE_OK; } @@ -2149,19 +2153,19 @@ static const uint8_t ac_state_tab[22][2] = {0, 11} }; -static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n) +static int mpeg4_decode_studio_block(Mpeg4DecContext *const ctx, int32_t block[64], int n) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; + H263DecContext *const h = &ctx->h; int cc, dct_dc_size, dct_diff, code, j, idx = 1, group = 0, run = 0, additional_code_len, sign, mismatch; const VLCElem *cur_vlc = studio_intra_tab[0]; - const uint8_t *const scantable = s->intra_scantable.permutated; + const uint8_t *const scantable = h->c.intra_scantable.permutated; const uint16_t *quant_matrix; uint32_t flc; - const int min = -1 * (1 << (s->avctx->bits_per_raw_sample + 6)); - const int max = ((1 << (s->avctx->bits_per_raw_sample + 6)) - 1); - int shift = 3 - ctx->dct_precision; + const int min = -1 * (1 << (h->c.avctx->bits_per_raw_sample + 6)); + const int max = ((1 << (h->c.avctx->bits_per_raw_sample + 6)) - 1); + int shift = 3 - ctx->dct_precision; mismatch = 1; @@ -2169,35 +2173,35 @@ static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n if (n < 4) { cc = 0; - dct_dc_size = get_vlc2(&s->gb, studio_luma_dc, STUDIO_INTRA_BITS, 2); - quant_matrix = s->intra_matrix; + dct_dc_size = get_vlc2(&h->c.gb, studio_luma_dc, STUDIO_INTRA_BITS, 2); + quant_matrix = h->c.intra_matrix; } else { cc = (n & 1) + 1; if (ctx->rgb) - dct_dc_size = get_vlc2(&s->gb, studio_luma_dc, STUDIO_INTRA_BITS, 2); + dct_dc_size = get_vlc2(&h->c.gb, studio_luma_dc, STUDIO_INTRA_BITS, 2); else - dct_dc_size = get_vlc2(&s->gb, studio_chroma_dc, STUDIO_INTRA_BITS, 2); - quant_matrix = s->chroma_intra_matrix; + dct_dc_size = get_vlc2(&h->c.gb, studio_chroma_dc, STUDIO_INTRA_BITS, 2); + quant_matrix = h->c.chroma_intra_matrix; } if (dct_dc_size == 0) { dct_diff = 0; } else { - dct_diff = get_xbits(&s->gb, dct_dc_size); + dct_diff = get_xbits(&h->c.gb, dct_dc_size); if (dct_dc_size > 8) { - if(!check_marker(s->avctx, &s->gb, "dct_dc_size > 8")) + if(!check_marker(h->c.avctx, &h->c.gb, "dct_dc_size > 8")) return AVERROR_INVALIDDATA; } } - s->last_dc[cc] += dct_diff; + h->c.last_dc[cc] += dct_diff; if (ctx->mpeg_quant) - block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision); + block[0] = h->c.last_dc[cc] * (8 >> h->c.intra_dc_precision); else - block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision) * (8 >> ctx->dct_precision); + block[0] = h->c.last_dc[cc] * (8 >> h->c.intra_dc_precision) * (8 >> ctx->dct_precision); /* TODO: support mpeg_quant for AC coefficients */ block[0] = av_clip(block[0], min, max); @@ -2205,10 +2209,10 @@ static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n /* AC Coefficients */ while (1) { - group = get_vlc2(&s->gb, cur_vlc, STUDIO_INTRA_BITS, 2); + group = get_vlc2(&h->c.gb, cur_vlc, STUDIO_INTRA_BITS, 2); if (group < 0) { - av_log(s->avctx, AV_LOG_ERROR, "illegal ac coefficient group vlc\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal ac coefficient group vlc\n"); return AVERROR_INVALIDDATA; } @@ -2222,12 +2226,12 @@ static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n /* Zero run length (Table B.47) */ run = 1 << additional_code_len; if (additional_code_len) - run += get_bits(&s->gb, additional_code_len); + run += get_bits(&h->c.gb, additional_code_len); idx += run; continue; } else if (group >= 7 && group <= 12) { /* Zero run length and +/-1 level (Table B.48) */ - code = get_bits(&s->gb, additional_code_len); + code = get_bits(&h->c.gb, additional_code_len); sign = code & 1; code >>= 1; run = (1 << (additional_code_len - 1)) + code; @@ -2241,20 +2245,20 @@ static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n if (idx > 63) return AVERROR_INVALIDDATA; j = scantable[idx++]; - block[j] = get_xbits(&s->gb, additional_code_len); + block[j] = get_xbits(&h->c.gb, additional_code_len); } else if (group == 21) { /* Escape */ if (idx > 63) return AVERROR_INVALIDDATA; j = scantable[idx++]; - additional_code_len = s->avctx->bits_per_raw_sample + ctx->dct_precision + 4; - flc = get_bits(&s->gb, additional_code_len); + additional_code_len = h->c.avctx->bits_per_raw_sample + ctx->dct_precision + 4; + flc = get_bits(&h->c.gb, additional_code_len); if (flc >> (additional_code_len-1)) block[j] = -1 * (( flc ^ ((1 << additional_code_len) -1)) + 1); else block[j] = flc; } - block[j] = ((block[j] * quant_matrix[j] * s->qscale) * (1 << shift)) / 16; + block[j] = ((block[j] * quant_matrix[j] * h->c.qscale) * (1 << shift)) / 16; block[j] = av_clip(block[j], min, max); mismatch ^= block[j]; } @@ -2267,23 +2271,23 @@ static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n static int mpeg4_decode_dpcm_macroblock(Mpeg4DecContext *const ctx, int16_t macroblock[256], int n) { - MPVContext *const s = &ctx->m; - int i, j, w, h, idx = 0; + H263DecContext *const h = &ctx->h; + int j, w, height, idx = 0; int block_mean, rice_parameter, rice_prefix_code, rice_suffix_code, dpcm_residual, left, top, topleft, min_left_top, max_left_top, p, p2, output; - h = 16 >> (n ? s->chroma_y_shift : 0); - w = 16 >> (n ? s->chroma_x_shift : 0); + height = 16 >> (n ? h->c.chroma_y_shift : 0); + w = 16 >> (n ? h->c.chroma_x_shift : 0); - block_mean = get_bits(&s->gb, s->avctx->bits_per_raw_sample); + block_mean = get_bits(&h->c.gb, h->c.avctx->bits_per_raw_sample); if (block_mean == 0){ - av_log(s->avctx, AV_LOG_ERROR, "Forbidden block_mean\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden block_mean\n"); return AVERROR_INVALIDDATA; } - s->last_dc[n] = block_mean * (1 << (ctx->dct_precision + s->intra_dc_precision)); + h->c.last_dc[n] = block_mean * (1 << (ctx->dct_precision + h->c.intra_dc_precision)); - rice_parameter = get_bits(&s->gb, 4); + rice_parameter = get_bits(&h->c.gb, 4); if (rice_parameter == 0) { - av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n"); return AVERROR_INVALIDDATA; } @@ -2291,29 +2295,29 @@ static int mpeg4_decode_dpcm_macroblock(Mpeg4DecContext *const ctx, rice_parameter = 0; if (rice_parameter > 11) { - av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n"); return AVERROR_INVALIDDATA; } - for (i = 0; i < h; i++) { - output = 1 << (s->avctx->bits_per_raw_sample - 1); - top = 1 << (s->avctx->bits_per_raw_sample - 1); + for (int i = 0; i < height; i++) { + output = 1 << (h->c.avctx->bits_per_raw_sample - 1); + top = 1 << (h->c.avctx->bits_per_raw_sample - 1); for (j = 0; j < w; j++) { left = output; topleft = top; - rice_prefix_code = get_unary(&s->gb, 1, 12); + rice_prefix_code = get_unary(&h->c.gb, 1, 12); /* Escape */ if (rice_prefix_code == 11) - dpcm_residual = get_bits(&s->gb, s->avctx->bits_per_raw_sample); + dpcm_residual = get_bits(&h->c.gb, h->c.avctx->bits_per_raw_sample); else { if (rice_prefix_code == 12) { - av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_prefix_code\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "Forbidden rice_prefix_code\n"); return AVERROR_INVALIDDATA; } - rice_suffix_code = get_bitsz(&s->gb, rice_parameter); + rice_suffix_code = get_bitsz(&h->c.gb, rice_parameter); dpcm_residual = (rice_prefix_code << rice_parameter) + rice_suffix_code; } @@ -2342,56 +2346,56 @@ static int mpeg4_decode_dpcm_macroblock(Mpeg4DecContext *const ctx, if (p2 > p) dpcm_residual *= -1; - macroblock[idx++] = output = (dpcm_residual + p) & ((1 << s->avctx->bits_per_raw_sample) - 1); + macroblock[idx++] = output = (dpcm_residual + p) & ((1 << h->c.avctx->bits_per_raw_sample) - 1); } } return 0; } -static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64]) +static int mpeg4_decode_studio_mb(H263DecContext *const h, int16_t block_[12][64]) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; + Mpeg4DecContext *const ctx = h263_to_mpeg4(h); int i; ctx->dpcm_direction = 0; /* StudioMacroblock */ /* Assumes I-VOP */ - s->mb_intra = 1; - if (get_bits1(&s->gb)) { /* compression_mode */ + h->c.mb_intra = 1; + if (get_bits1(&h->c.gb)) { /* compression_mode */ /* DCT */ /* macroblock_type, 1 or 2-bit VLC */ - if (!get_bits1(&s->gb)) { - skip_bits1(&s->gb); - s->qscale = mpeg_get_qscale(s); + if (!get_bits1(&h->c.gb)) { + skip_bits1(&h->c.gb); + h->c.qscale = mpeg_get_qscale(&h->c); } - for (i = 0; i < mpeg4_block_count[s->chroma_format]; i++) { - if (mpeg4_decode_studio_block(s, ctx->block32[i], i) < 0) + for (i = 0; i < mpeg4_block_count[h->c.chroma_format]; i++) { + if (mpeg4_decode_studio_block(ctx, ctx->block32[i], i) < 0) return AVERROR_INVALIDDATA; } } else { /* DPCM */ - check_marker(s->avctx, &s->gb, "DPCM block start"); - ctx->dpcm_direction = get_bits1(&s->gb) ? -1 : 1; + check_marker(h->c.avctx, &h->c.gb, "DPCM block start"); + ctx->dpcm_direction = get_bits1(&h->c.gb) ? -1 : 1; for (i = 0; i < 3; i++) { if (mpeg4_decode_dpcm_macroblock(ctx, ctx->dpcm_macroblock[i], i) < 0) return AVERROR_INVALIDDATA; } } - if (get_bits_left(&s->gb) >= 24 && show_bits(&s->gb, 23) == 0) { - next_start_code_studio(&s->gb); + if (get_bits_left(&h->c.gb) >= 24 && show_bits(&h->c.gb, 23) == 0) { + next_start_code_studio(&h->c.gb); return SLICE_END; } //vcon-stp9L1.bits (first frame) - if (get_bits_left(&s->gb) == 0) + if (get_bits_left(&h->c.gb) == 0) return SLICE_END; //vcon-stp2L1.bits, vcon-stp3L1.bits, vcon-stp6L1.bits, vcon-stp7L1.bits, vcon-stp8L1.bits, vcon-stp10L1.bits (first frame) - if (get_bits_left(&s->gb) < 8U && show_bits(&s->gb, get_bits_left(&s->gb)) == 0) + if (get_bits_left(&h->c.gb) < 8U && show_bits(&h->c.gb, get_bits_left(&h->c.gb)) == 0) return SLICE_END; return SLICE_OK; @@ -2550,7 +2554,7 @@ static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; + MPVContext *const s = &ctx->h.c; int width, height, aspect_ratio_info; int bits_per_raw_sample; int rgb, chroma_format; @@ -2636,7 +2640,7 @@ static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; int width, height, vo_ver_id, aspect_ratio_info; /* vol header */ @@ -2650,12 +2654,12 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) */ if (ctx->vo_type == CORE_STUDIO_VO_TYPE || ctx->vo_type == SIMPLE_STUDIO_VO_TYPE) { - if (s->avctx->profile != AV_PROFILE_UNKNOWN && s->avctx->profile != AV_PROFILE_MPEG4_SIMPLE_STUDIO) + if (h->c.avctx->profile != AV_PROFILE_UNKNOWN && h->c.avctx->profile != AV_PROFILE_MPEG4_SIMPLE_STUDIO) return AVERROR_INVALIDDATA; - s->studio_profile = 1; - s->avctx->profile = AV_PROFILE_MPEG4_SIMPLE_STUDIO; + h->c.studio_profile = 1; + h->c.avctx->profile = AV_PROFILE_MPEG4_SIMPLE_STUDIO; return decode_studio_vol_header(ctx, gb); - } else if (s->studio_profile) { + } else if (h->c.studio_profile) { return AVERROR_PATCHWELCOME; } @@ -2667,97 +2671,97 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) } aspect_ratio_info = get_bits(gb, 4); if (aspect_ratio_info == FF_ASPECT_EXTENDED) { - s->avctx->sample_aspect_ratio.num = get_bits(gb, 8); // par_width - s->avctx->sample_aspect_ratio.den = get_bits(gb, 8); // par_height + h->c.avctx->sample_aspect_ratio.num = get_bits(gb, 8); // par_width + h->c.avctx->sample_aspect_ratio.den = get_bits(gb, 8); // par_height } else { - s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[aspect_ratio_info]; + h->c.avctx->sample_aspect_ratio = ff_h263_pixel_aspect[aspect_ratio_info]; } if ((ctx->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */ int chroma_format = get_bits(gb, 2); if (chroma_format != CHROMA_420) - av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "illegal chroma format\n"); - s->low_delay = get_bits1(gb); + h->c.low_delay = get_bits1(gb); if (get_bits1(gb)) { /* vbv parameters */ get_bits(gb, 15); /* first_half_bitrate */ - check_marker(s->avctx, gb, "after first_half_bitrate"); + check_marker(h->c.avctx, gb, "after first_half_bitrate"); get_bits(gb, 15); /* latter_half_bitrate */ - check_marker(s->avctx, gb, "after latter_half_bitrate"); + check_marker(h->c.avctx, gb, "after latter_half_bitrate"); get_bits(gb, 15); /* first_half_vbv_buffer_size */ - check_marker(s->avctx, gb, "after first_half_vbv_buffer_size"); + check_marker(h->c.avctx, gb, "after first_half_vbv_buffer_size"); get_bits(gb, 3); /* latter_half_vbv_buffer_size */ get_bits(gb, 11); /* first_half_vbv_occupancy */ - check_marker(s->avctx, gb, "after first_half_vbv_occupancy"); + check_marker(h->c.avctx, gb, "after first_half_vbv_occupancy"); get_bits(gb, 15); /* latter_half_vbv_occupancy */ - check_marker(s->avctx, gb, "after latter_half_vbv_occupancy"); + check_marker(h->c.avctx, gb, "after latter_half_vbv_occupancy"); } } else { /* is setting low delay flag only once the smartest thing to do? * low delay detection will not be overridden. */ - if (s->picture_number == 0) { + if (h->c.picture_number == 0) { switch (ctx->vo_type) { case SIMPLE_VO_TYPE: case ADV_SIMPLE_VO_TYPE: - s->low_delay = 1; + h->c.low_delay = 1; break; default: - s->low_delay = 0; + h->c.low_delay = 0; } } } ctx->shape = get_bits(gb, 2); /* vol shape */ if (ctx->shape != RECT_SHAPE) - av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "only rectangular vol supported\n"); if (ctx->shape == GRAY_SHAPE && vo_ver_id != 1) { - av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "Gray shape not supported\n"); skip_bits(gb, 4); /* video_object_layer_shape_extension */ } - check_marker(s->avctx, gb, "before time_increment_resolution"); + check_marker(h->c.avctx, gb, "before time_increment_resolution"); - s->avctx->framerate.num = get_bits(gb, 16); - if (!s->avctx->framerate.num) { - av_log(s->avctx, AV_LOG_ERROR, "framerate==0\n"); + h->c.avctx->framerate.num = get_bits(gb, 16); + if (!h->c.avctx->framerate.num) { + av_log(h->c.avctx, AV_LOG_ERROR, "framerate==0\n"); return AVERROR_INVALIDDATA; } - ctx->time_increment_bits = av_log2(s->avctx->framerate.num - 1) + 1; + ctx->time_increment_bits = av_log2(h->c.avctx->framerate.num - 1) + 1; if (ctx->time_increment_bits < 1) ctx->time_increment_bits = 1; - check_marker(s->avctx, gb, "before fixed_vop_rate"); + check_marker(h->c.avctx, gb, "before fixed_vop_rate"); if (get_bits1(gb) != 0) /* fixed_vop_rate */ - s->avctx->framerate.den = get_bits(gb, ctx->time_increment_bits); + h->c.avctx->framerate.den = get_bits(gb, ctx->time_increment_bits); else - s->avctx->framerate.den = 1; + h->c.avctx->framerate.den = 1; ctx->t_frame = 0; if (ctx->shape != BIN_ONLY_SHAPE) { if (ctx->shape == RECT_SHAPE) { - check_marker(s->avctx, gb, "before width"); + check_marker(h->c.avctx, gb, "before width"); width = get_bits(gb, 13); - check_marker(s->avctx, gb, "before height"); + check_marker(h->c.avctx, gb, "before height"); height = get_bits(gb, 13); - check_marker(s->avctx, gb, "after height"); + check_marker(h->c.avctx, gb, "after height"); if (width && height && /* they should be non zero but who knows */ - !(s->width && s->codec_tag == AV_RL32("MP4S"))) { - if (s->width && s->height && - (s->width != width || s->height != height)) - s->context_reinit = 1; - s->width = width; - s->height = height; + !(h->c.width && h->c.codec_tag == AV_RL32("MP4S"))) { + if (h->c.width && h->c.height && + (h->c.width != width || h->c.height != height)) + h->c.context_reinit = 1; + h->c.width = width; + h->c.height = height; } } - s->progressive_sequence = - s->progressive_frame = get_bits1(gb) ^ 1; - s->interlaced_dct = 0; - if (!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) - av_log(s->avctx, AV_LOG_INFO, /* OBMC Disable */ + h->c.progressive_sequence = + h->c.progressive_frame = get_bits1(gb) ^ 1; + h->c.interlaced_dct = 0; + if (!get_bits1(gb) && (h->c.avctx->debug & FF_DEBUG_PICT_INFO)) + av_log(h->c.avctx, AV_LOG_INFO, /* OBMC Disable */ "MPEG-4 OBMC not supported (very likely buggy encoder)\n"); if (vo_ver_id == 1) ctx->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */ @@ -2765,22 +2769,22 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) ctx->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */ if (ctx->vol_sprite_usage == STATIC_SPRITE) - av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "Static Sprites not supported\n"); if (ctx->vol_sprite_usage == STATIC_SPRITE || ctx->vol_sprite_usage == GMC_SPRITE) { if (ctx->vol_sprite_usage == STATIC_SPRITE) { skip_bits(gb, 13); // sprite_width - check_marker(s->avctx, gb, "after sprite_width"); + check_marker(h->c.avctx, gb, "after sprite_width"); skip_bits(gb, 13); // sprite_height - check_marker(s->avctx, gb, "after sprite_height"); + check_marker(h->c.avctx, gb, "after sprite_height"); skip_bits(gb, 13); // sprite_left - check_marker(s->avctx, gb, "after sprite_left"); + check_marker(h->c.avctx, gb, "after sprite_left"); skip_bits(gb, 13); // sprite_top - check_marker(s->avctx, gb, "after sprite_top"); + check_marker(h->c.avctx, gb, "after sprite_top"); } ctx->num_sprite_warping_points = get_bits(gb, 6); if (ctx->num_sprite_warping_points > 3) { - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", ctx->num_sprite_warping_points); ctx->num_sprite_warping_points = 0; @@ -2796,9 +2800,9 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) if (get_bits1(gb) == 1) { /* not_8_bit */ ctx->quant_precision = get_bits(gb, 4); /* quant_precision */ if (get_bits(gb, 4) != 8) /* bits_per_pixel */ - av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "N-bit not supported\n"); if (ctx->quant_precision != 5) - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "quant precision %d\n", ctx->quant_precision); if (ctx->quant_precision < 3 || ctx->quant_precision > 9) ctx->quant_precision = 5; @@ -2811,7 +2815,7 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) if ((ctx->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */ int i, v; - mpeg4_load_default_matrices(s); + mpeg4_load_default_matrices(&h->c); /* load custom intra matrix */ if (get_bits1(gb)) { @@ -2819,7 +2823,7 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) for (i = 0; i < 64; i++) { int j; if (get_bits_left(gb) < 8) { - av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n"); return AVERROR_INVALIDDATA; } v = get_bits(gb, 8); @@ -2827,14 +2831,14 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) break; last = v; - j = s->idsp.idct_permutation[ff_zigzag_direct[i]]; - s->intra_matrix[j] = last; + j = h->c.idsp.idct_permutation[ff_zigzag_direct[i]]; + h->c.intra_matrix[j] = last; } /* replicate last value */ for (; i < 64; i++) { - int j = s->idsp.idct_permutation[ff_zigzag_direct[i]]; - s->intra_matrix[j] = last; + int j = h->c.idsp.idct_permutation[ff_zigzag_direct[i]]; + h->c.intra_matrix[j] = last; } } @@ -2844,7 +2848,7 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) for (i = 0; i < 64; i++) { int j; if (get_bits_left(gb) < 8) { - av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n"); return AVERROR_INVALIDDATA; } v = get_bits(gb, 8); @@ -2852,14 +2856,14 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) break; last = v; - j = s->idsp.idct_permutation[ff_zigzag_direct[i]]; - s->inter_matrix[j] = v; + j = h->c.idsp.idct_permutation[ff_zigzag_direct[i]]; + h->c.inter_matrix[j] = v; } /* replicate last value */ for (; i < 64; i++) { - int j = s->idsp.idct_permutation[ff_zigzag_direct[i]]; - s->inter_matrix[j] = last; + int j = h->c.idsp.idct_permutation[ff_zigzag_direct[i]]; + h->c.inter_matrix[j] = last; } } @@ -2867,12 +2871,12 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) } if (vo_ver_id != 1) - s->quarter_sample = get_bits1(gb); + h->c.quarter_sample = get_bits1(gb); else - s->quarter_sample = 0; + h->c.quarter_sample = 0; if (get_bits_left(gb) < 4) { - av_log(s->avctx, AV_LOG_ERROR, "VOL Header truncated\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "VOL Header truncated\n"); return AVERROR_INVALIDDATA; } @@ -2894,7 +2898,7 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* inter4v_blocks */ ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* not coded blocks */ } - if (!check_marker(s->avctx, gb, "in complexity estimation part 1")) { + if (!check_marker(h->c.avctx, gb, "in complexity estimation part 1")) { skip_bits_long(gb, pos - get_bits_count(gb)); goto no_cplx_est; } @@ -2912,7 +2916,7 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* halfpel2 */ ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* halfpel4 */ } - if (!check_marker(s->avctx, gb, "in complexity estimation part 2")) { + if (!check_marker(h->c.avctx, gb, "in complexity estimation part 2")) { skip_bits_long(gb, pos - get_bits_count(gb)); goto no_cplx_est; } @@ -2921,7 +2925,7 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb) ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* qpel */ } } else - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method); } else { @@ -2934,19 +2938,19 @@ no_cplx_est: ctx->resync_marker = !get_bits1(gb); /* resync_marker_disabled */ - s->data_partitioning = get_bits1(gb); - if (s->data_partitioning) + h->c.data_partitioning = get_bits1(gb); + if (h->c.data_partitioning) ctx->rvlc = get_bits1(gb); if (vo_ver_id != 1) { ctx->new_pred = get_bits1(gb); if (ctx->new_pred) { - av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "new pred not supported\n"); skip_bits(gb, 2); /* requested upstream message type */ skip_bits1(gb); /* newpred segment type */ } if (get_bits1(gb)) // reduced_res_vop - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n"); } else { ctx->new_pred = 0; @@ -2977,21 +2981,23 @@ no_cplx_est: ctx->scalability = 0; *gb = bak; } else - av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "scalability not supported\n"); // bin shape stuff FIXME } } - if (s->avctx->debug&FF_DEBUG_PICT_INFO) { - av_log(s->avctx, AV_LOG_DEBUG, "tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d, low_delay:%d %s%s%s%s\n", - s->avctx->framerate.den, s->avctx->framerate.num, + if (h->c.avctx->debug&FF_DEBUG_PICT_INFO) { + av_log(h->c.avctx, AV_LOG_DEBUG, "tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d, low_delay:%d %s%s%s%s\n", + h->c.avctx->framerate.den, h->c.avctx->framerate.num, ctx->time_increment_bits, ctx->quant_precision, - s->progressive_sequence, - s->low_delay, - ctx->scalability ? "scalability " :"" , s->quarter_sample ? "qpel " : "", - s->data_partitioning ? "partition " : "", ctx->rvlc ? "rvlc " : "" + h->c.progressive_sequence, + h->c.low_delay, + ctx->scalability ? "scalability " :"" , + h->c.quarter_sample ? "qpel " : "", + h->c.data_partitioning ? "partition " : "", + ctx->rvlc ? "rvlc " : "" ); } @@ -3004,7 +3010,7 @@ no_cplx_est: */ static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; char buf[256]; int i; int e; @@ -3025,7 +3031,7 @@ static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb) if (e >= 2) { ctx->divx_version = ver; ctx->divx_build = build; - s->divx_packed = e == 3 && last == 'p'; + h->c.divx_packed = e == 3 && last == 'p'; } /* libavcodec detection */ @@ -3036,7 +3042,7 @@ static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb) e = sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3) + 1; if (e > 1) { if (ver > 0xFFU || ver2 > 0xFFU || ver3 > 0xFFU) { - av_log(s->avctx, AV_LOG_WARNING, + av_log(h->c.avctx, AV_LOG_WARNING, "Unknown Lavc version string encountered, %d.%d.%d; " "clamping sub-version values to 8-bits.\n", ver, ver2, ver3); @@ -3091,19 +3097,19 @@ static av_cold void switch_to_xvid_idct(AVCodecContext *const avctx, void ff_mpeg4_workaround_bugs(AVCodecContext *avctx) { Mpeg4DecContext *ctx = avctx->priv_data; - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) { - if (s->codec_tag == AV_RL32("XVID") || - s->codec_tag == AV_RL32("XVIX") || - s->codec_tag == AV_RL32("RMP4") || - s->codec_tag == AV_RL32("ZMP4") || - s->codec_tag == AV_RL32("SIPP")) + if (h->c.codec_tag == AV_RL32("XVID") || + h->c.codec_tag == AV_RL32("XVIX") || + h->c.codec_tag == AV_RL32("RMP4") || + h->c.codec_tag == AV_RL32("ZMP4") || + h->c.codec_tag == AV_RL32("SIPP")) ctx->xvid_build = 0; } if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) - if (s->codec_tag == AV_RL32("DIVX") && ctx->vo_type == 0 && + if (h->c.codec_tag == AV_RL32("DIVX") && ctx->vo_type == 0 && ctx->vol_control_parameters == 0) ctx->divx_version = 400; // divx 4 @@ -3112,68 +3118,68 @@ void ff_mpeg4_workaround_bugs(AVCodecContext *avctx) ctx->divx_build = -1; } - if (s->workaround_bugs & FF_BUG_AUTODETECT) { - if (s->codec_tag == AV_RL32("XVIX")) - s->workaround_bugs |= FF_BUG_XVID_ILACE; + if (h->c.workaround_bugs & FF_BUG_AUTODETECT) { + if (h->c.codec_tag == AV_RL32("XVIX")) + h->c.workaround_bugs |= FF_BUG_XVID_ILACE; - if (s->codec_tag == AV_RL32("UMP4")) - s->workaround_bugs |= FF_BUG_UMP4; + if (h->c.codec_tag == AV_RL32("UMP4")) + h->c.workaround_bugs |= FF_BUG_UMP4; if (ctx->divx_version >= 500 && ctx->divx_build < 1814) - s->workaround_bugs |= FF_BUG_QPEL_CHROMA; + h->c.workaround_bugs |= FF_BUG_QPEL_CHROMA; if (ctx->divx_version > 502 && ctx->divx_build < 1814) - s->workaround_bugs |= FF_BUG_QPEL_CHROMA2; + h->c.workaround_bugs |= FF_BUG_QPEL_CHROMA2; if (ctx->xvid_build <= 3U) - s->padding_bug_score = 256 * 256 * 256 * 64; + h->c.padding_bug_score = 256 * 256 * 256 * 64; if (ctx->xvid_build <= 1U) - s->workaround_bugs |= FF_BUG_QPEL_CHROMA; + h->c.workaround_bugs |= FF_BUG_QPEL_CHROMA; if (ctx->xvid_build <= 12U) - s->workaround_bugs |= FF_BUG_EDGE; + h->c.workaround_bugs |= FF_BUG_EDGE; if (ctx->xvid_build <= 32U) - s->workaround_bugs |= FF_BUG_DC_CLIP; + h->c.workaround_bugs |= FF_BUG_DC_CLIP; #define SET_QPEL_FUNC(postfix1, postfix2) \ - s->qdsp.put_ ## postfix1 = ff_put_ ## postfix2; \ - s->qdsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2; \ - s->qdsp.avg_ ## postfix1 = ff_avg_ ## postfix2; + h->c.qdsp.put_ ## postfix1 = ff_put_ ## postfix2; \ + h->c.qdsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2; \ + h->c.qdsp.avg_ ## postfix1 = ff_avg_ ## postfix2; if (ctx->lavc_build < 4653U) - s->workaround_bugs |= FF_BUG_STD_QPEL; + h->c.workaround_bugs |= FF_BUG_STD_QPEL; if (ctx->lavc_build < 4655U) - s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE; + h->c.workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE; if (ctx->lavc_build < 4670U) - s->workaround_bugs |= FF_BUG_EDGE; + h->c.workaround_bugs |= FF_BUG_EDGE; if (ctx->lavc_build <= 4712U) - s->workaround_bugs |= FF_BUG_DC_CLIP; + h->c.workaround_bugs |= FF_BUG_DC_CLIP; if ((ctx->lavc_build&0xFF) >= 100) { if (ctx->lavc_build > 3621476 && ctx->lavc_build < 3752552 && (ctx->lavc_build < 3752037 || ctx->lavc_build > 3752191) // 3.2.1+ ) - s->workaround_bugs |= FF_BUG_IEDGE; + h->c.workaround_bugs |= FF_BUG_IEDGE; } if (ctx->divx_version >= 0) - s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE; + h->c.workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE; if (ctx->divx_version == 501 && ctx->divx_build == 20020416) - s->padding_bug_score = 256 * 256 * 256 * 64; + h->c.padding_bug_score = 256 * 256 * 256 * 64; if (ctx->divx_version < 500U) - s->workaround_bugs |= FF_BUG_EDGE; + h->c.workaround_bugs |= FF_BUG_EDGE; if (ctx->divx_version >= 0) - s->workaround_bugs |= FF_BUG_HPEL_CHROMA; + h->c.workaround_bugs |= FF_BUG_HPEL_CHROMA; } - if (s->workaround_bugs & FF_BUG_STD_QPEL) { + if (h->c.workaround_bugs & FF_BUG_STD_QPEL) { SET_QPEL_FUNC(qpel_pixels_tab[0][5], qpel16_mc11_old_c) SET_QPEL_FUNC(qpel_pixels_tab[0][7], qpel16_mc31_old_c) SET_QPEL_FUNC(qpel_pixels_tab[0][9], qpel16_mc12_old_c) @@ -3190,54 +3196,54 @@ void ff_mpeg4_workaround_bugs(AVCodecContext *avctx) } if (avctx->debug & FF_DEBUG_BUGS) - av_log(s->avctx, AV_LOG_DEBUG, + av_log(h->c.avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n", - s->workaround_bugs, ctx->lavc_build, ctx->xvid_build, - ctx->divx_version, ctx->divx_build, s->divx_packed ? "p" : ""); + h->c.workaround_bugs, ctx->lavc_build, ctx->xvid_build, + ctx->divx_version, ctx->divx_build, h->c.divx_packed ? "p" : ""); if (CONFIG_MPEG4_DECODER && ctx->xvid_build >= 0 && - avctx->idct_algo == FF_IDCT_AUTO && !s->studio_profile) { - switch_to_xvid_idct(avctx, s); + avctx->idct_algo == FF_IDCT_AUTO && !h->c.studio_profile) { + switch_to_xvid_idct(avctx, &h->c); } } static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, int parse_only) { - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; int time_incr, time_increment; int64_t pts; - s->mcsel = 0; - s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* pict type: I = 0 , P = 1 */ - if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay && - ctx->vol_control_parameters == 0 && !(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)) { - av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n"); - s->low_delay = 0; + h->c.mcsel = 0; + h->c.pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* pict type: I = 0 , P = 1 */ + if (h->c.pict_type == AV_PICTURE_TYPE_B && h->c.low_delay && + ctx->vol_control_parameters == 0 && !(h->c.avctx->flags & AV_CODEC_FLAG_LOW_DELAY)) { + av_log(h->c.avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n"); + h->c.low_delay = 0; } - s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B; - if (s->partitioned_frame) - s->decode_mb = mpeg4_decode_partitioned_mb; + h->c.partitioned_frame = h->c.data_partitioning && h->c.pict_type != AV_PICTURE_TYPE_B; + if (h->c.partitioned_frame) + h->decode_mb = mpeg4_decode_partitioned_mb; else - s->decode_mb = mpeg4_decode_mb; + h->decode_mb = mpeg4_decode_mb; time_incr = 0; while (get_bits1(gb) != 0) time_incr++; - check_marker(s->avctx, gb, "before time_increment"); + check_marker(h->c.avctx, gb, "before time_increment"); if (ctx->time_increment_bits == 0 || !(show_bits(gb, ctx->time_increment_bits + 1) & 1)) { - av_log(s->avctx, AV_LOG_WARNING, + av_log(h->c.avctx, AV_LOG_WARNING, "time_increment_bits %d is invalid in relation to the current bitstream, this is likely caused by a missing VOL header\n", ctx->time_increment_bits); for (ctx->time_increment_bits = 1; ctx->time_increment_bits < 16; ctx->time_increment_bits++) { - if (s->pict_type == AV_PICTURE_TYPE_P || - (s->pict_type == AV_PICTURE_TYPE_S && + if (h->c.pict_type == AV_PICTURE_TYPE_P || + (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE)) { if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30) break; @@ -3245,7 +3251,7 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, break; } - av_log(s->avctx, AV_LOG_WARNING, + av_log(h->c.avctx, AV_LOG_WARNING, "time_increment_bits set to %d bits, based on bitstream analysis\n", ctx->time_increment_bits); } @@ -3254,84 +3260,84 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, else time_increment = get_bits(gb, ctx->time_increment_bits); - if (s->pict_type != AV_PICTURE_TYPE_B) { - s->last_time_base = s->time_base; - s->time_base += time_incr; - s->time = s->time_base * (int64_t)s->avctx->framerate.num + time_increment; - if (s->workaround_bugs & FF_BUG_UMP4) { - if (s->time < s->last_non_b_time) { + if (h->c.pict_type != AV_PICTURE_TYPE_B) { + h->c.last_time_base = h->c.time_base; + h->c.time_base += time_incr; + h->c.time = h->c.time_base * (int64_t)h->c.avctx->framerate.num + time_increment; + if (h->c.workaround_bugs & FF_BUG_UMP4) { + if (h->c.time < h->c.last_non_b_time) { /* header is not mpeg-4-compatible, broken encoder, * trying to workaround */ - s->time_base++; - s->time += s->avctx->framerate.num; + h->c.time_base++; + h->c.time += h->c.avctx->framerate.num; } } - s->pp_time = s->time - s->last_non_b_time; - s->last_non_b_time = s->time; + h->c.pp_time = h->c.time - h->c.last_non_b_time; + h->c.last_non_b_time = h->c.time; } else { - s->time = (s->last_time_base + time_incr) * (int64_t)s->avctx->framerate.num + time_increment; - s->pb_time = s->pp_time - (s->last_non_b_time - s->time); - if (s->pp_time <= s->pb_time || - s->pp_time <= s->pp_time - s->pb_time || - s->pp_time <= 0) { + h->c.time = (h->c.last_time_base + time_incr) * (int64_t)h->c.avctx->framerate.num + time_increment; + h->c.pb_time = h->c.pp_time - (h->c.last_non_b_time - h->c.time); + 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) { /* messed up order, maybe after seeking? skipping current B-frame */ return FRAME_SKIPPED; } - ff_mpeg4_init_direct_mv(s); + ff_mpeg4_init_direct_mv(&h->c); if (ctx->t_frame == 0) - ctx->t_frame = s->pb_time; + ctx->t_frame = h->c.pb_time; if (ctx->t_frame == 0) ctx->t_frame = 1; // 1/0 protection - s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, ctx->t_frame) - - ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2; - s->pb_field_time = (ROUNDED_DIV(s->time, ctx->t_frame) - - ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2; - if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) { - s->pb_field_time = 2; - s->pp_field_time = 4; - if (!s->progressive_sequence) + h->c.pp_field_time = (ROUNDED_DIV(h->c.last_non_b_time, ctx->t_frame) - + ROUNDED_DIV(h->c.last_non_b_time - h->c.pp_time, ctx->t_frame)) * 2; + h->c.pb_field_time = (ROUNDED_DIV(h->c.time, ctx->t_frame) - + ROUNDED_DIV(h->c.last_non_b_time - h->c.pp_time, ctx->t_frame)) * 2; + if (h->c.pp_field_time <= h->c.pb_field_time || h->c.pb_field_time <= 1) { + h->c.pb_field_time = 2; + h->c.pp_field_time = 4; + if (!h->c.progressive_sequence) return FRAME_SKIPPED; } } - if (s->avctx->framerate.den) - pts = ROUNDED_DIV(s->time, s->avctx->framerate.den); + if (h->c.avctx->framerate.den) + pts = ROUNDED_DIV(h->c.time, h->c.avctx->framerate.den); else pts = AV_NOPTS_VALUE; - ff_dlog(s->avctx, "MPEG4 PTS: %"PRId64"\n", pts); + ff_dlog(h->c.avctx, "MPEG4 PTS: %"PRId64"\n", pts); - check_marker(s->avctx, gb, "before vop_coded"); + check_marker(h->c.avctx, gb, "before vop_coded"); /* vop coded */ if (get_bits1(gb) != 1) { - if (s->avctx->debug & FF_DEBUG_PICT_INFO) - av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n"); - s->skipped_last_frame = 1; + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) + av_log(h->c.avctx, AV_LOG_ERROR, "vop not coded\n"); + h->c.skipped_last_frame = 1; return FRAME_SKIPPED; } if (ctx->new_pred) decode_new_pred(ctx, gb); if (ctx->shape != BIN_ONLY_SHAPE && - (s->pict_type == AV_PICTURE_TYPE_P || - (s->pict_type == AV_PICTURE_TYPE_S && + (h->c.pict_type == AV_PICTURE_TYPE_P || + (h->c.pict_type == AV_PICTURE_TYPE_S && ctx->vol_sprite_usage == GMC_SPRITE))) { /* rounding type for motion estimation */ - s->no_rounding = get_bits1(gb); + h->c.no_rounding = get_bits1(gb); } else { - s->no_rounding = 0; + h->c.no_rounding = 0; } // FIXME reduced res stuff if (ctx->shape != RECT_SHAPE) { - if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) { + if (ctx->vol_sprite_usage != 1 || h->c.pict_type != AV_PICTURE_TYPE_I) { skip_bits(gb, 13); /* width */ - check_marker(s->avctx, gb, "after width"); + check_marker(h->c.avctx, gb, "after width"); skip_bits(gb, 13); /* height */ - check_marker(s->avctx, gb, "after height"); + check_marker(h->c.avctx, gb, "after height"); skip_bits(gb, 13); /* hor_spat_ref */ - check_marker(s->avctx, gb, "after hor_spat_ref"); + check_marker(h->c.avctx, gb, "after hor_spat_ref"); skip_bits(gb, 13); /* ver_spat_ref */ } skip_bits1(gb); /* change_CR_disable */ @@ -3344,21 +3350,21 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, if (ctx->shape != BIN_ONLY_SHAPE) { skip_bits_long(gb, ctx->cplx_estimation_trash_i); - if (s->pict_type != AV_PICTURE_TYPE_I) + if (h->c.pict_type != AV_PICTURE_TYPE_I) skip_bits_long(gb, ctx->cplx_estimation_trash_p); - if (s->pict_type == AV_PICTURE_TYPE_B) + if (h->c.pict_type == AV_PICTURE_TYPE_B) skip_bits_long(gb, ctx->cplx_estimation_trash_b); if (get_bits_left(gb) < 3) { - av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "Header truncated\n"); return AVERROR_INVALIDDATA; } ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)]; - if (!s->progressive_sequence) { - s->top_field_first = get_bits1(gb); - s->alternate_scan = get_bits1(gb); + if (!h->c.progressive_sequence) { + h->c.top_field_first = get_bits1(gb); + h->c.alternate_scan = get_bits1(gb); } else - s->alternate_scan = 0; + h->c.alternate_scan = 0; } /* Skip at this point when only parsing since the remaining * data is not useful for a parser and requires the @@ -3366,28 +3372,28 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, if (parse_only) goto end; - if (s->alternate_scan) { - ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan); - ff_permute_scantable(s->permutated_intra_h_scantable, ff_alternate_vertical_scan, - s->idsp.idct_permutation); + if (h->c.alternate_scan) { + ff_init_scantable(h->c.idsp.idct_permutation, &h->c.intra_scantable, ff_alternate_vertical_scan); + ff_permute_scantable(h->c.permutated_intra_h_scantable, ff_alternate_vertical_scan, + h->c.idsp.idct_permutation); } else { - ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct); - ff_permute_scantable(s->permutated_intra_h_scantable, ff_alternate_horizontal_scan, - s->idsp.idct_permutation); + ff_init_scantable(h->c.idsp.idct_permutation, &h->c.intra_scantable, ff_zigzag_direct); + ff_permute_scantable(h->c.permutated_intra_h_scantable, ff_alternate_horizontal_scan, + h->c.idsp.idct_permutation); } - ff_permute_scantable(s->permutated_intra_v_scantable, ff_alternate_vertical_scan, - s->idsp.idct_permutation); + ff_permute_scantable(h->c.permutated_intra_v_scantable, ff_alternate_vertical_scan, + h->c.idsp.idct_permutation); - if (s->pict_type == AV_PICTURE_TYPE_S) { + if (h->c.pict_type == AV_PICTURE_TYPE_S) { if((ctx->vol_sprite_usage == STATIC_SPRITE || ctx->vol_sprite_usage == GMC_SPRITE)) { if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0) return AVERROR_INVALIDDATA; if (ctx->sprite_brightness_change) - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n"); if (ctx->vol_sprite_usage == STATIC_SPRITE) - av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n"); + av_log(h->c.avctx, AV_LOG_ERROR, "static sprite not supported\n"); } else { memset(ctx->sprite_offset, 0, sizeof(ctx->sprite_offset)); memset(ctx->sprite_delta, 0, sizeof(ctx->sprite_delta)); @@ -3397,102 +3403,102 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, ctx->f_code = 1; ctx->b_code = 1; if (ctx->shape != BIN_ONLY_SHAPE) { - s->chroma_qscale = s->qscale = get_bits(gb, ctx->quant_precision); - if (s->qscale == 0) { - av_log(s->avctx, AV_LOG_ERROR, + h->c.chroma_qscale = h->c.qscale = get_bits(gb, ctx->quant_precision); + if (h->c.qscale == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG-4 header (qscale=0)\n"); return AVERROR_INVALIDDATA; // makes no sense to continue, as there is nothing left from the image then } - if (s->pict_type != AV_PICTURE_TYPE_I) { + if (h->c.pict_type != AV_PICTURE_TYPE_I) { ctx->f_code = get_bits(gb, 3); /* fcode_for */ if (ctx->f_code == 0) { - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG-4 header (f_code=0)\n"); ctx->f_code = 1; return AVERROR_INVALIDDATA; // makes no sense to continue, as there is nothing left from the image then } } - if (s->pict_type == AV_PICTURE_TYPE_B) { + if (h->c.pict_type == AV_PICTURE_TYPE_B) { ctx->b_code = get_bits(gb, 3); if (ctx->b_code == 0) { - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (b_code=0)\n"); ctx->b_code=1; return AVERROR_INVALIDDATA; // makes no sense to continue, as the MV decoding will break very quickly } } - if (s->avctx->debug & FF_DEBUG_PICT_INFO) { - av_log(s->avctx, AV_LOG_DEBUG, + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) { + av_log(h->c.avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %c size:%d pro:%d alt:%d top:%d %cpel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d time:%"PRId64" tincr:%d\n", - s->qscale, ctx->f_code, ctx->b_code, - s->pict_type == AV_PICTURE_TYPE_I ? 'I' : (s->pict_type == AV_PICTURE_TYPE_P ? 'P' : (s->pict_type == AV_PICTURE_TYPE_B ? 'B' : 'S')), - gb->size_in_bits,s->progressive_sequence, s->alternate_scan, - s->top_field_first, s->quarter_sample ? 'q' : 'h', - s->data_partitioning, ctx->resync_marker, + h->c.qscale, ctx->f_code, ctx->b_code, + h->c.pict_type == AV_PICTURE_TYPE_I ? 'I' : (h->c.pict_type == AV_PICTURE_TYPE_P ? 'P' : (h->c.pict_type == AV_PICTURE_TYPE_B ? 'B' : 'S')), + gb->size_in_bits,h->c.progressive_sequence, h->c.alternate_scan, + h->c.top_field_first, h->c.quarter_sample ? 'q' : 'h', + h->c.data_partitioning, ctx->resync_marker, ctx->num_sprite_warping_points, ctx->sprite_warping_accuracy, - 1 - s->no_rounding, ctx->vo_type, + 1 - h->c.no_rounding, ctx->vo_type, ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold, ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p, ctx->cplx_estimation_trash_b, - s->time, + h->c.time, time_increment ); } if (!ctx->scalability) { - if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I) + if (ctx->shape != RECT_SHAPE && h->c.pict_type != AV_PICTURE_TYPE_I) skip_bits1(gb); // vop shape coding type } else { if (ctx->enhancement_type) { int load_backward_shape = get_bits1(gb); if (load_backward_shape) - av_log(s->avctx, AV_LOG_ERROR, + av_log(h->c.avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); } skip_bits(gb, 2); // ref_select_code } } - s->dct_unquantize_intra = ctx->mpeg_quant ? ctx->dct_unquantize_mpeg2_intra - : ctx->dct_unquantize_h263_intra; + h->c.dct_unquantize_intra = ctx->mpeg_quant ? ctx->dct_unquantize_mpeg2_intra + : ctx->dct_unquantize_h263_intra; // The following tells ff_mpv_reconstruct_mb() to unquantize iff mpeg_quant - s->dct_unquantize_inter = ctx->mpeg_quant ? ctx->dct_unquantize_mpeg2_inter : NULL; + h->c.dct_unquantize_inter = ctx->mpeg_quant ? ctx->dct_unquantize_mpeg2_inter : NULL; end: /* detect buggy encoders which don't set the low_delay flag * (divx4/xvid/opendivx). Note we cannot detect divx5 without B-frames * easily (although it's buggy too) */ if (ctx->vo_type == 0 && ctx->vol_control_parameters == 0 && - ctx->divx_version == -1 && s->picture_number == 0) { - av_log(s->avctx, AV_LOG_WARNING, + ctx->divx_version == -1 && h->c.picture_number == 0) { + av_log(h->c.avctx, AV_LOG_WARNING, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n"); - s->low_delay = 1; + h->c.low_delay = 1; } - s->picture_number++; // better than pic number==0 always ;) + h->c.picture_number++; // better than pic number==0 always ;) - if (s->workaround_bugs & FF_BUG_EDGE) { - s->h_edge_pos = s->width; - s->v_edge_pos = s->height; + if (h->c.workaround_bugs & FF_BUG_EDGE) { + h->c.h_edge_pos = h->c.width; + h->c.v_edge_pos = h->c.height; } return 0; } static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; + AVCodecContext *const avctx = ctx->h.c.avctx; skip_bits(gb, 16); /* Time_code[63..48] */ - check_marker(s->avctx, gb, "after Time_code[63..48]"); + check_marker(avctx, gb, "after Time_code[63..48]"); skip_bits(gb, 16); /* Time_code[47..32] */ - check_marker(s->avctx, gb, "after Time_code[47..32]"); + check_marker(avctx, gb, "after Time_code[47..32]"); skip_bits(gb, 16); /* Time_code[31..16] */ - check_marker(s->avctx, gb, "after Time_code[31..16]"); + check_marker(avctx, gb, "after Time_code[31..16]"); skip_bits(gb, 16); /* Time_code[15..0] */ - check_marker(s->avctx, gb, "after Time_code[15..0]"); + check_marker(avctx, gb, "after Time_code[15..0]"); skip_bits(gb, 4); /* reserved_bits */ } @@ -3502,64 +3508,63 @@ static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb) */ static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; if (get_bits_left(gb) <= 32) return 0; - s->partitioned_frame = 0; - s->interlaced_dct = 0; - s->decode_mb = mpeg4_decode_studio_mb; + h->c.partitioned_frame = 0; + h->c.interlaced_dct = 0; + h->decode_mb = mpeg4_decode_studio_mb; decode_smpte_tc(ctx, gb); skip_bits(gb, 10); /* temporal_reference */ skip_bits(gb, 2); /* vop_structure */ - s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* vop_coding_type */ + h->c.pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* vop_coding_type */ if (get_bits1(gb)) { /* vop_coded */ skip_bits1(gb); /* top_field_first */ skip_bits1(gb); /* repeat_first_field */ - s->progressive_frame = get_bits1(gb) ^ 1; /* progressive_frame */ + h->c.progressive_frame = get_bits1(gb) ^ 1; /* progressive_frame */ } - if (s->pict_type == AV_PICTURE_TYPE_I) { + if (h->c.pict_type == AV_PICTURE_TYPE_I) { if (get_bits1(gb)) reset_studio_dc_predictors(ctx); } if (ctx->shape != BIN_ONLY_SHAPE) { - s->alternate_scan = get_bits1(gb); - s->frame_pred_frame_dct = get_bits1(gb); - ctx->dct_precision = get_bits(gb, 2); - s->intra_dc_precision = get_bits(gb, 2); - s->q_scale_type = get_bits1(gb); + h->c.alternate_scan = get_bits1(gb); + h->c.frame_pred_frame_dct = get_bits1(gb); + ctx->dct_precision = get_bits(gb, 2); + h->c.intra_dc_precision = get_bits(gb, 2); + h->c.q_scale_type = get_bits1(gb); } - ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, - s->alternate_scan ? ff_alternate_vertical_scan : ff_zigzag_direct); + ff_init_scantable(h->c.idsp.idct_permutation, &h->c.intra_scantable, + h->c.alternate_scan ? ff_alternate_vertical_scan : ff_zigzag_direct); - mpeg4_load_default_matrices(s); + mpeg4_load_default_matrices(&h->c); next_start_code_studio(gb); - extension_and_user_data(s, gb, 4); + extension_and_user_data(&h->c, gb, 4); return 0; } static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb) { - MpegEncContext *s = &ctx->m; int visual_object_type; skip_bits(gb, 4); /* visual_object_verid */ visual_object_type = get_bits(gb, 4); if (visual_object_type != VOT_VIDEO_ID) { - avpriv_request_sample(s->avctx, "VO type %u", visual_object_type); + avpriv_request_sample(ctx->h.c.avctx, "VO type %u", visual_object_type); return AVERROR_PATCHWELCOME; } next_start_code_studio(gb); - extension_and_user_data(s, gb, 1); + extension_and_user_data(&ctx->h.c, gb, 1); return 0; } @@ -3577,7 +3582,7 @@ static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb) int ff_mpeg4_parse_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int header, int parse_only) { - MpegEncContext *s = &ctx->m; + MPVContext *const s = &ctx->h.c; unsigned startcode, v; int ret; int vol = 0; @@ -3731,22 +3736,22 @@ end: return decode_vop_header(ctx, gb, parse_only); } -int ff_mpeg4_decode_picture_header(MpegEncContext *s) +int ff_mpeg4_decode_picture_header(H263DecContext *const h) { - Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s; + Mpeg4DecContext *const ctx = h263_to_mpeg4(h); - s->skipped_last_frame = 0; + h->c.skipped_last_frame = 0; if (ctx->bitstream_buffer) { - int buf_size = get_bits_left(&s->gb) / 8U; + int buf_size = get_bits_left(&h->c.gb) / 8U; int bitstream_buffer_size = ctx->bitstream_buffer->size; - const uint8_t *buf = s->gb.buffer; + const uint8_t *buf = h->c.gb.buffer; - if (s->divx_packed) { + if (h->c.divx_packed) { for (int i = 0; i < buf_size - 3; i++) { if (buf[i] == 0 && buf[i+1] == 0 && buf[i+2] == 1) { if (buf[i+3] == 0xB0) { - av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n"); + av_log(h->c.avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n"); bitstream_buffer_size = 0; } break; @@ -3754,8 +3759,8 @@ int ff_mpeg4_decode_picture_header(MpegEncContext *s) } } ctx->bitstream_buffer->size = 0; - if (bitstream_buffer_size && (s->divx_packed || buf_size <= MAX_NVOP_SIZE)) {// divx 5.01+/xvid frame reorder - int ret = init_get_bits8(&s->gb, ctx->bitstream_buffer->data, + if (bitstream_buffer_size && (h->c.divx_packed || buf_size <= MAX_NVOP_SIZE)) {// divx 5.01+/xvid frame reorder + int ret = init_get_bits8(&h->c.gb, ctx->bitstream_buffer->data, bitstream_buffer_size); if (ret < 0) return ret; @@ -3763,20 +3768,20 @@ int ff_mpeg4_decode_picture_header(MpegEncContext *s) av_buffer_unref(&ctx->bitstream_buffer); } - return ff_mpeg4_parse_picture_header(ctx, &s->gb, 0, 0); + return ff_mpeg4_parse_picture_header(ctx, &h->c.gb, 0, 0); } int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt) { Mpeg4DecContext *ctx = avctx->priv_data; - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; int ret; av_assert1(!ctx->bitstream_buffer || !ctx->bitstream_buffer->size); /* divx 5.01+ bitstream reorder stuff */ - if (s->divx_packed) { - int current_pos = ctx->bitstream_buffer && s->gb.buffer == ctx->bitstream_buffer->data ? 0 : (get_bits_count(&s->gb) >> 3); + if (h->c.divx_packed) { + int current_pos = ctx->bitstream_buffer && h->c.gb.buffer == ctx->bitstream_buffer->data ? 0 : (get_bits_count(&h->c.gb) >> 3); int startcode_found = 0; uint8_t *buf = pkt->data; int buf_size = pkt->size; @@ -3797,7 +3802,7 @@ int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt) if (startcode_found) { if (!ctx->showed_packed_warning) { - av_log(s->avctx, AV_LOG_INFO, "Video uses a non-standard and " + av_log(h->c.avctx, AV_LOG_INFO, "Video uses a non-standard and " "wasteful way to store B-frames ('packed B-frames'). " "Consider using the mpeg4_unpack_bframes bitstream filter without encoding but stream copy to fix it.\n"); ctx->showed_packed_warning = 1; @@ -3874,11 +3879,11 @@ static int mpeg4_update_thread_context(AVCodecContext *dst, { Mpeg4DecContext *s = dst->priv_data; const Mpeg4DecContext *s1 = src->priv_data; - int init = s->m.context_initialized; + int init = s->h.c.context_initialized; int ret; if (!init) { - ret = update_mpvctx(&s->m, &s1->m); + ret = update_mpvctx(&s->h.c, &s1->h.c); if (ret < 0) return ret; } @@ -3894,7 +3899,7 @@ static int mpeg4_update_thread_context(AVCodecContext *dst, s->sprite_brightness_change = s1->sprite_brightness_change; s->sprite_warping_accuracy = s1->sprite_warping_accuracy; s->num_sprite_warping_points = s1->num_sprite_warping_points; - s->m.data_partitioning = s1->m.data_partitioning; + s->h.c.data_partitioning = s1->h.c.data_partitioning; s->mpeg_quant = s1->mpeg_quant; s->rvlc = s1->rvlc; s->resync_marker = s1->resync_marker; @@ -3903,7 +3908,7 @@ static int mpeg4_update_thread_context(AVCodecContext *dst, s->enhancement_type = s1->enhancement_type; s->scalability = s1->scalability; s->intra_dc_threshold = s1->intra_dc_threshold; - s->m.divx_packed = s1->m.divx_packed; + s->h.c.divx_packed = s1->h.c.divx_packed; s->divx_version = s1->divx_version; s->divx_build = s1->divx_build; s->xvid_build = s1->xvid_build; @@ -3915,7 +3920,7 @@ static int mpeg4_update_thread_context(AVCodecContext *dst, s->cplx_estimation_trash_p = s1->cplx_estimation_trash_p; s->cplx_estimation_trash_b = s1->cplx_estimation_trash_b; s->rgb = s1->rgb; - s->m.skipped_last_frame = s1->m.skipped_last_frame; + s->h.c.skipped_last_frame = s1->h.c.skipped_last_frame; memcpy(s->sprite_shift, s1->sprite_shift, sizeof(s1->sprite_shift)); memcpy(s->sprite_traj, s1->sprite_traj, sizeof(s1->sprite_traj)); @@ -3985,7 +3990,7 @@ static av_cold int decode_init(AVCodecContext *avctx) { static AVOnce init_static_once = AV_ONCE_INIT; Mpeg4DecContext *ctx = avctx->priv_data; - MpegEncContext *s = &ctx->m; + H263DecContext *const h = &ctx->h; MPVUnquantDSPContext unquant_dsp_ctx; int ret; @@ -4006,18 +4011,18 @@ static av_cold int decode_init(AVCodecContext *avctx) // so that is all we keep. ctx->dct_unquantize_mpeg2_inter = unquant_dsp_ctx.dct_unquantize_mpeg2_inter; - s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table; - s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table; + h->c.y_dc_scale_table = ff_mpeg4_y_dc_scale_table; + h->c.c_dc_scale_table = ff_mpeg4_c_dc_scale_table; - s->h263_pred = 1; - s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */ - s->decode_mb = mpeg4_decode_mb; + h->c.h263_pred = 1; + h->c.low_delay = 0; /* default, might be overridden in the vol header during header parsing */ + h->decode_mb = mpeg4_decode_mb; ctx->time_increment_bits = 4; /* default value for broken headers */ ctx->quant_precision = 5; avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; - ff_qpeldsp_init(&s->qdsp); + ff_qpeldsp_init(&h->c.qdsp); ff_mpeg4videodsp_init(&ctx->mdsp); ff_thread_once(&init_static_once, mpeg4_init_static); diff --git a/libavcodec/mpeg4videodec.h b/libavcodec/mpeg4videodec.h index 9598429d08..337125d4e3 100644 --- a/libavcodec/mpeg4videodec.h +++ b/libavcodec/mpeg4videodec.h @@ -26,13 +26,14 @@ #include #include "get_bits.h" +#include "h263dec.h" #include "mpegvideo.h" #include "mpeg4videodsp.h" #include "libavutil/mem_internal.h" typedef struct Mpeg4DecContext { - MpegEncContext m; + H263DecContext h; int f_code; ///< forward MV resolution int b_code; ///< backward MV resolution for B-frames @@ -108,7 +109,7 @@ typedef struct Mpeg4DecContext { int dct_precision; } 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 header, int parse_only); 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, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture); -int ff_mpeg4_decode_partitions(MPVContext *const s); -int ff_mpeg4_decode_video_packet_header(MPVContext *const s); -int ff_mpeg4_decode_studio_slice_header(MPVContext *const s); +int ff_mpeg4_decode_partitions(H263DecContext *const h); +int ff_mpeg4_decode_video_packet_header(H263DecContext *const h); +int ff_mpeg4_decode_studio_slice_header(H263DecContext *const h); 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 ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt); diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h index 81d2675f50..f76158040d 100644 --- a/libavcodec/mpegvideo.h +++ b/libavcodec/mpegvideo.h @@ -307,7 +307,6 @@ typedef struct MpegEncContext { int first_field; ///< is 1 for the first field of a field picture 0 otherwise 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_ERROR -1 diff --git a/libavcodec/msmpeg4dec.c b/libavcodec/msmpeg4dec.c index 55e51aff3c..0cb14d5762 100644 --- a/libavcodec/msmpeg4dec.c +++ b/libavcodec/msmpeg4dec.c @@ -74,23 +74,24 @@ static VLCElem v2_mb_type_vlc[128]; VLCElem ff_inter_intra_vlc[8]; /* 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; - code = get_vlc2(&s->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); + code = get_vlc2(&h->c.gb, ff_h263_mv_vlc, H263_MV_VLC_BITS, 2); + 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) return 0xffff; if (code == 0) return pred; - sign = get_bits1(&s->gb); + sign = get_bits1(&h->c.gb); shift = f_code - 1; val = code; if (shift) { val = (val - 1) << shift; - val |= get_bits(&s->gb, shift); + val |= get_bits(&h->c.gb, shift); val++; } if (sign) @@ -105,151 +106,155 @@ static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) 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; - 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 (get_bits1(&s->gb)) { + if (get_bits1(&h->c.gb)) { /* skip mb */ - s->mb_intra = 0; + h->c.mb_intra = 0; for(i=0;i<6;i++) - s->block_last_index[i] = -1; - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = 0; - s->mv[0][0][1] = 0; - s->mb_skipped = 1; + h->c.block_last_index[i] = -1; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.mv[0][0][0] = 0; + h->c.mv[0][0][1] = 0; + h->c.mb_skipped = 1; *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16; return 0; } } - if (s->msmpeg4_version == MSMP4_V2) - code = get_vlc2(&s->gb, v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 1); + if (h->c.msmpeg4_version == MSMP4_V2) + code = get_vlc2(&h->c.gb, v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 1); 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){ - 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; } - s->mb_intra = code >>2; + h->c.mb_intra = code >>2; cbp = code & 0x3; } else { - s->mb_intra = 1; - if (s->msmpeg4_version == MSMP4_V2) - cbp = get_vlc2(&s->gb, v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 1); + h->c.mb_intra = 1; + if (h->c.msmpeg4_version == MSMP4_V2) + cbp = get_vlc2(&h->c.gb, v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 1); 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){ - 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; } } - if (!s->mb_intra) { + if (!h->c.mb_intra) { 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){ - 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; } cbp|= cbpy<<2; - if (s->msmpeg4_version == MSMP4_V1 || (cbp&3) != 3) + if (h->c.msmpeg4_version == MSMP4_V1 || (cbp&3) != 3) cbp ^= 0x3C; - ff_h263_pred_motion(s, 0, 0, &mx, &my); - mx= msmpeg4v2_decode_motion(s, mx, 1); - my= msmpeg4v2_decode_motion(s, my, 1); + ff_h263_pred_motion(&h->c, 0, 0, &mx, &my); + mx = msmpeg4v2_decode_motion(h, mx, 1); + my = msmpeg4v2_decode_motion(h, my, 1); - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = mx; - s->mv[0][0][1] = my; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.mv[0][0][0] = mx; + h->c.mv[0][0][1] = my; *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16; } else { int v; - if (s->msmpeg4_version == MSMP4_V2) { - s->ac_pred = get_bits1(&s->gb); - v = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + if (h->c.msmpeg4_version == MSMP4_V2) { + h->c.ac_pred = get_bits1(&h->c.gb); + v = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); 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; } cbp|= v<<2; } else{ - s->ac_pred = 0; - v = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); + h->c.ac_pred = 0; + v = get_vlc2(&h->c.gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1); 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; } 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; } - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); for (i = 0; i < 6; i++) { 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 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; 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; - if (s->pict_type == AV_PICTURE_TYPE_P) { + if (h->c.pict_type == AV_PICTURE_TYPE_P) { if (ms->use_skip_mb_code) { - if (get_bits1(&s->gb)) { + if (get_bits1(&h->c.gb)) { /* skip mb */ - s->mb_intra = 0; + h->c.mb_intra = 0; for(i=0;i<6;i++) - s->block_last_index[i] = -1; - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = 0; - s->mv[0][0][1] = 0; - s->mb_skipped = 1; + h->c.block_last_index[i] = -1; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.mv[0][0][0] = 0; + h->c.mv[0][0][1] = 0; + h->c.mb_skipped = 1; *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16; return 0; } } - code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX], MB_NON_INTRA_VLC_BITS, 3); - //s->mb_intra = (code & 0x40) ? 0 : 1; - s->mb_intra = (~code & 0x40) >> 6; + code = get_vlc2(&h->c.gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX], MB_NON_INTRA_VLC_BITS, 3); + //h->c.mb_intra = (code & 0x40) ? 0 : 1; + h->c.mb_intra = (~code & 0x40) >> 6; cbp = code & 0x3f; } else { - s->mb_intra = 1; - code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc, MSMP4_MB_INTRA_VLC_BITS, 2); + h->c.mb_intra = 1; + code = get_vlc2(&h->c.gb, ff_msmp4_mb_i_vlc, MSMP4_MB_INTRA_VLC_BITS, 2); /* predict coded block pattern */ cbp = 0; for(i=0;i<6;i++) { int val = ((code >> (5 - i)) & 1); 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; *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; 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; } - 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); - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = mx; - s->mv[0][0][1] = my; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.mv[0][0][0] = mx; + h->c.mv[0][0][1] = my; *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16; } 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), - show_bits(&s->gb, 24)); - s->ac_pred = get_bits1(&s->gb); + show_bits(&h->c.gb, 24)); + h->c.ac_pred = get_bits1(&h->c.gb); *mb_type_ptr = MB_TYPE_INTRA; - if(s->inter_intra_pred){ - s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1); - ff_dlog(s->avctx, "%d%d %d %d/", - s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y); + if (h->c.inter_intra_pred) { + h->c.h263_aic_dir = get_vlc2(&h->c.gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1); + ff_dlog(h->c.avctx, "%d%d %d %d/", + h->c.ac_pred, h->c.h263_aic_dir, h->c.mb_x, h->c.mb_y); } 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; } } - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); for (i = 0; i < 6; i++) { 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; } } @@ -357,7 +363,7 @@ static av_cold void msmpeg4_decode_init_static(void) av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx) { static AVOnce init_static_once = AV_ONCE_INIT; - MpegEncContext *s = avctx->priv_data; + H263DecContext *const h = avctx->priv_data; int ret; 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; // 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_V2: - s->decode_mb= msmpeg4v12_decode_mb; + h->decode_mb = msmpeg4v12_decode_mb; break; case MSMP4_V3: case MSMP4_WMV1: - s->decode_mb= msmpeg4v34_decode_mb; + h->decode_mb = msmpeg4v34_decode_mb; break; case MSMP4_WMV2: 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()"); } - 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); 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; // 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 // while at the same time they have the highest computational requirements // 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; - if (s->msmpeg4_version == MSMP4_V1) { - int start_code = get_bits_long(&s->gb, 32); + if (h->c.msmpeg4_version == MSMP4_V1) { + int start_code = get_bits_long(&h->c.gb, 32); 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; } - skip_bits(&s->gb, 5); // frame number */ + skip_bits(&h->c.gb, 5); // frame number */ } - s->pict_type = get_bits(&s->gb, 2) + 1; - if (s->pict_type != AV_PICTURE_TYPE_I && - s->pict_type != AV_PICTURE_TYPE_P){ - av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n"); + h->c.pict_type = get_bits(&h->c.gb, 2) + 1; + if (h->c.pict_type != AV_PICTURE_TYPE_I && + h->c.pict_type != AV_PICTURE_TYPE_P){ + av_log(h->c.avctx, AV_LOG_ERROR, "invalid picture type\n"); return -1; } - s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); - if(s->qscale==0){ - av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n"); + h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); + if (h->c.qscale == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "invalid qscale\n"); return -1; } - if (s->pict_type == AV_PICTURE_TYPE_I) { - code = get_bits(&s->gb, 5); - if (s->msmpeg4_version == MSMP4_V1) { - if(code==0 || code>s->mb_height){ - av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); + if (h->c.pict_type == AV_PICTURE_TYPE_I) { + code = get_bits(&h->c.gb, 5); + if (h->c.msmpeg4_version == MSMP4_V1) { + if(code==0 || code>h->c.mb_height) { + av_log(h->c.avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); return -1; } - s->slice_height = code; + h->c.slice_height = code; }else{ /* 0x17: one slice, 0x18: two slices, ... */ 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; } - 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_V2: 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 break; case MSMP4_V3: - ms->rl_chroma_table_index = decode012(&s->gb); - ms->rl_table_index = decode012(&s->gb); + ms->rl_chroma_table_index = decode012(&h->c.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; 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) - ms->per_mb_rl_table = get_bits1(&s->gb); + ms->per_mb_rl_table = get_bits1(&h->c.gb); else ms->per_mb_rl_table = 0; if (!ms->per_mb_rl_table) { - ms->rl_chroma_table_index = decode012(&s->gb); - ms->rl_table_index = decode012(&s->gb); + ms->rl_chroma_table_index = decode012(&h->c.gb); + ms->rl_table_index = decode012(&h->c.gb); } - ms->dc_table_index = get_bits1(&s->gb); - s->inter_intra_pred= 0; + ms->dc_table_index = get_bits1(&h->c.gb); + h->c.inter_intra_pred= 0; break; default: av_unreachable("ff_msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1"); } - s->no_rounding = 1; - if(s->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", - s->qscale, + h->c.no_rounding = 1; + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) + av_log(h->c.avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n", + h->c.qscale, ms->rl_chroma_table_index, ms->rl_table_index, ms->dc_table_index, ms->per_mb_rl_table, - s->slice_height); + h->c.slice_height); } else { - switch(s->msmpeg4_version){ + switch (h->c.msmpeg4_version) { case MSMP4_V1: case MSMP4_V2: - if (s->msmpeg4_version == MSMP4_V1) + if (h->c.msmpeg4_version == MSMP4_V1) ms->use_skip_mb_code = 1; 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_chroma_table_index = ms->rl_table_index; ms->dc_table_index = 0; //not used ms->mv_table_index = 0; break; case MSMP4_V3: - ms->use_skip_mb_code = get_bits1(&s->gb); - ms->rl_table_index = decode012(&s->gb); + ms->use_skip_mb_code = get_bits1(&h->c.gb); + ms->rl_table_index = decode012(&h->c.gb); 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; 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) - ms->per_mb_rl_table = get_bits1(&s->gb); + ms->per_mb_rl_table = get_bits1(&h->c.gb); else ms->per_mb_rl_table = 0; 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->dc_table_index = get_bits1(&s->gb); + ms->dc_table_index = get_bits1(&h->c.gb); - ms->mv_table_index = get_bits1(&s->gb); - s->inter_intra_pred = s->width*s->height < 320*240 && + ms->mv_table_index = get_bits1(&h->c.gb); + h->c.inter_intra_pred = h->c.width*h->c.height < 320*240 && ms->bit_rate <= II_BITRATE; break; default: av_unreachable("ff_msmpeg4_decode_picture_header() only used by MSMP4V1-3, WMV1"); } - if(s->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", + if (h->c.avctx->debug&FF_DEBUG_PICT_INFO) + 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->rl_table_index, ms->rl_chroma_table_index, ms->dc_table_index, ms->mv_table_index, ms->per_mb_rl_table, - s->qscale); + h->c.qscale); if (ms->flipflop_rounding) { - s->no_rounding ^= 1; + h->c.no_rounding ^= 1; }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, - s->inter_intra_pred, s->width, s->height); + ff_dlog(h->c.avctx, "%d %d %d %d %d\n", h->c.pict_type, ms->bit_rate, + h->c.inter_intra_pred, h->c.width, h->c.height); ms->esc3_level_length = 0; ms->esc3_run_length = 0; @@ -559,30 +565,30 @@ int ff_msmpeg4_decode_picture_header(MpegEncContext * s) 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); - int left= buf_size*8 - get_bits_count(&s->gb); - int length = s->msmpeg4_version >= MSMP4_V3 ? 17 : 16; + MSMP4DecContext *const ms = mpv_to_msmpeg4(h); + int left= buf_size*8 - get_bits_count(&h->c.gb); + 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 */ if(left>=length && leftgb, 5); /* fps */ - ms->bit_rate = get_bits(&s->gb, 11) * 1024; - if (s->msmpeg4_version >= MSMP4_V3) - ms->flipflop_rounding = get_bits1(&s->gb); + skip_bits(&h->c.gb, 5); /* fps */ + ms->bit_rate = get_bits(&h->c.gb, 11) * 1024; + if (h->c.msmpeg4_version >= MSMP4_V3) + ms->flipflop_rounding = get_bits1(&h->c.gb); else ms->flipflop_rounding = 0; } else if(leftflipflop_rounding = 0; - if (s->msmpeg4_version != MSMP4_V2) - av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); + if (h->c.msmpeg4_version != MSMP4_V2) + av_log(h->c.avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); } 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; @@ -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) { - MpegEncContext *const s = &ms->m; + H263DecContext *const h = &ms->h; int level, pred; - if (s->msmpeg4_version <= MSMP4_V2) { + if (h->c.msmpeg4_version <= MSMP4_V2) { 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 { - 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) { - 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; return -1; } level-=256; } 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); if (level == DC_MAX) { - level = get_bits(&s->gb, 8); - if (get_bits1(&s->gb)) + level = get_bits(&h->c.gb, 8); + if (get_bits1(&h->c.gb)) level = -level; } else if (level != 0) { - if (get_bits1(&s->gb)) + if (get_bits1(&h->c.gb)) level = -level; } } - if (s->msmpeg4_version == MSMP4_V1) { + if (h->c.msmpeg4_version == MSMP4_V1) { int32_t *dc_val; - pred = msmpeg4v1_pred_dc(s, n, &dc_val); + pred = msmpeg4v1_pred_dc(&h->c, n, &dc_val); level += pred; /* update predictor */ *dc_val= level; }else{ 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; /* update predictor */ if (n < 4) { - *dc_val = level * s->y_dc_scale; + *dc_val = level * h->c.y_dc_scale; } 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 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 dc_pred_dir = -1; //unused but its passed around, so it needs to be initialized const RLTable *rl; const RL_VLC_ELEM *rl_vlc; int qmul, qadd; - if (s->mb_intra) { + if (h->c.mb_intra) { qmul=1; 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); if (level < 0){ - av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale); - if(s->inter_intra_pred) level=0; + av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, h->c.qscale); + if (h->c.inter_intra_pred) + level = 0; } if (n < 4) { rl = &ff_rl_table[ms->rl_table_index]; - if(level > 256*s->y_dc_scale){ - av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale); - if(!s->inter_intra_pred) return -1; + if (level > 256 * h->c.y_dc_scale) { + av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", h->c.qscale); + if (!h->c.inter_intra_pred) + return -1; } } else { rl = &ff_rl_table[3 + ms->rl_chroma_table_index]; - if(level > 256*s->c_dc_scale){ - av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale); - if(!s->inter_intra_pred) return -1; + if (level > 256 * h->c.c_dc_scale) { + av_log(h->c.avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", h->c.qscale); + if (!h->c.inter_intra_pred) + return -1; } } block[0] = level; - run_diff = s->msmpeg4_version >= MSMP4_WMV1; + run_diff = h->c.msmpeg4_version >= MSMP4_WMV1; i = 0; if (!coded) { goto not_coded; } - if (s->ac_pred) { + if (h->c.ac_pred) { if (dc_pred_dir == 0) - scan_table = s->permutated_intra_v_scantable; /* left */ + scan_table = h->c.permutated_intra_v_scantable; /* left */ else - scan_table = s->permutated_intra_h_scantable; /* top */ + scan_table = h->c.permutated_intra_h_scantable; /* top */ } else { - scan_table = s->intra_scantable.permutated; + scan_table = h->c.intra_scantable.permutated; } rl_vlc= rl->rl_vlc[0]; } else { - qmul = s->qscale << 1; - qadd = (s->qscale - 1) | 1; + qmul = h->c.qscale << 1; + qadd = (h->c.qscale - 1) | 1; i = -1; 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; else run_diff = 1; if (!coded) { - s->block_last_index[n] = i; + h->c.block_last_index[n] = i; return 0; } if(!scan_table) - scan_table = s->inter_scantable.permutated; - rl_vlc= rl->rl_vlc[s->qscale]; + scan_table = h->c.inter_scantable.permutated; + rl_vlc= rl->rl_vlc[h->c.qscale]; } { - OPEN_READER(re, &s->gb); + OPEN_READER(re, &h->c.gb); for(;;) { - UPDATE_CACHE(re, &s->gb); - GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); + UPDATE_CACHE(re, &h->c.gb); + GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 0); if (level==0) { int cache; - cache= GET_CACHE(re, &s->gb); + cache= GET_CACHE(re, &h->c.gb); /* escape */ - if (s->msmpeg4_version == MSMP4_V1 || (cache&0x80000000)==0) { - if (s->msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) { + if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x80000000)==0) { + if (h->c.msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) { /* third escape */ - if (s->msmpeg4_version != MSMP4_V1) - LAST_SKIP_BITS(re, &s->gb, 2); - UPDATE_CACHE(re, &s->gb); - if (s->msmpeg4_version <= MSMP4_V3) { - last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); - run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6); - level= SHOW_SBITS(re, &s->gb, 8); - SKIP_COUNTER(re, &s->gb, 1+6+8); + if (h->c.msmpeg4_version != MSMP4_V1) + LAST_SKIP_BITS(re, &h->c.gb, 2); + UPDATE_CACHE(re, &h->c.gb); + if (h->c.msmpeg4_version <= MSMP4_V3) { + last = SHOW_UBITS(re, &h->c.gb, 1); SKIP_CACHE(re, &h->c.gb, 1); + run = SHOW_UBITS(re, &h->c.gb, 6); SKIP_CACHE(re, &h->c.gb, 6); + level = SHOW_SBITS(re, &h->c.gb, 8); + SKIP_COUNTER(re, &h->c.gb, 1 + 6 + 8); }else{ 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) { int ll; - ff_dlog(s->avctx, "ESC-3 %X at %d %d\n", - show_bits(&s->gb, 24), s->mb_x, s->mb_y); - if(s->qscale<8){ - ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3); + ff_dlog(h->c.avctx, "ESC-3 %X at %d %d\n", + show_bits(&h->c.gb, 24), h->c.mb_x, h->c.mb_y); + if (h->c.qscale < 8) { + ll = SHOW_UBITS(re, &h->c.gb, 3); SKIP_BITS(re, &h->c.gb, 3); 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{ ll=2; - while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){ + while (ll < 8 && SHOW_UBITS(re, &h->c.gb, 1) == 0) { 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_run_length = SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2); - UPDATE_CACHE(re, &s->gb); + ms->esc3_run_length = SHOW_UBITS(re, &h->c.gb, 2) + 3; SKIP_BITS(re, &h->c.gb, 2); + UPDATE_CACHE(re, &h->c.gb); } - run = SHOW_UBITS(re, &s->gb, ms->esc3_run_length); - SKIP_BITS(re, &s->gb, ms->esc3_run_length); + run = SHOW_UBITS(re, &h->c.gb, ms->esc3_run_length); + SKIP_BITS(re, &h->c.gb, ms->esc3_run_length); - sign= SHOW_UBITS(re, &s->gb, 1); - SKIP_BITS(re, &s->gb, 1); + sign= SHOW_UBITS(re, &h->c.gb, 1); + SKIP_BITS(re, &h->c.gb, 1); - level = SHOW_UBITS(re, &s->gb, ms->esc3_level_length); - SKIP_BITS(re, &s->gb, ms->esc3_level_length); + level = SHOW_UBITS(re, &h->c.gb, ms->esc3_level_length); + SKIP_BITS(re, &h->c.gb, ms->esc3_level_length); if(sign) level= -level; } @@ -774,38 +783,40 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block, if(last) i+=192; } else { /* second escape */ - SKIP_BITS(re, &s->gb, 2); - GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); + SKIP_BITS(re, &h->c.gb, 2); + 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 - level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); - LAST_SKIP_BITS(re, &s->gb, 1); + level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); + LAST_SKIP_BITS(re, &h->c.gb, 1); } } else { /* first escape */ - SKIP_BITS(re, &s->gb, 1); - GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); + SKIP_BITS(re, &h->c.gb, 1); + GET_RL_VLC(level, run, re, &h->c.gb, rl_vlc, TEX_VLC_BITS, 2, 1); i+= run; 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); - LAST_SKIP_BITS(re, &s->gb, 1); + level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); + LAST_SKIP_BITS(re, &h->c.gb, 1); } } else { i+= run; - level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); - LAST_SKIP_BITS(re, &s->gb, 1); + level = (level ^ SHOW_SBITS(re, &h->c.gb, 1)) - SHOW_SBITS(re, &h->c.gb, 1); + LAST_SKIP_BITS(re, &h->c.gb, 1); } if (i > 62){ i-= 192; 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) || - !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && + !(h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && 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; break; }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; } } @@ -816,13 +827,13 @@ int ff_msmpeg4_decode_block(MSMP4DecContext *const ms, int16_t * block, 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: - 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; } @@ -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) { 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; - 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) { mx = sym >> 8; my = sym & 0xFF; } else { /* Escape */ - mx = get_bits(&s->gb, 6); - my = get_bits(&s->gb, 6); + mx = get_bits(&h->c.gb, 6); + my = get_bits(&h->c.gb, 6); } mx += *mx_ptr - 32; diff --git a/libavcodec/msmpeg4dec.h b/libavcodec/msmpeg4dec.h index 862c50b3f0..11a36f2136 100644 --- a/libavcodec/msmpeg4dec.h +++ b/libavcodec/msmpeg4dec.h @@ -23,13 +23,14 @@ #define AVCODEC_MSMPEG4DEC_H #include "avcodec.h" +#include "h263dec.h" #include "mpegvideo.h" #define INTER_INTRA_VLC_BITS 3 #define MB_NON_INTRA_VLC_BITS 9 typedef struct MSMP4DecContext { - MpegEncContext m; + H263DecContext h; int bit_rate; int flipflop_rounding; int mv_table_index; @@ -42,18 +43,18 @@ typedef struct MSMP4DecContext { int esc3_run_length; } 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. - return (MSMP4DecContext*)s; + return (MSMP4DecContext*)h; } extern const VLCElem *ff_mb_non_intra_vlc[4]; extern VLCElem ff_inter_intra_vlc[8]; int ff_msmpeg4_decode_init(AVCodecContext *avctx); -int ff_msmpeg4_decode_picture_header(MpegEncContext *s); -int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size); +int ff_msmpeg4_decode_picture_header(H263DecContext *const h); +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); int ff_msmpeg4_decode_block(MSMP4DecContext *ms, int16_t * block, int n, int coded, const uint8_t *scan_table); diff --git a/libavcodec/nvdec_mpeg4.c b/libavcodec/nvdec_mpeg4.c index 8272439031..0351ee169e 100644 --- a/libavcodec/nvdec_mpeg4.c +++ b/libavcodec/nvdec_mpeg4.c @@ -33,7 +33,7 @@ static int nvdec_mpeg4_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) { Mpeg4DecContext *m = avctx->priv_data; - MpegEncContext *s = &m->m; + MPVContext *const s = &m->h.c; NVDECContext *ctx = avctx->internal->hwaccel_priv_data; CUVIDPICPARAMS *pp = &ctx->pic_params; diff --git a/libavcodec/rv10.c b/libavcodec/rv10.c index 9f4dea6141..0a245e90a3 100644 --- a/libavcodec/rv10.c +++ b/libavcodec/rv10.c @@ -52,7 +52,7 @@ #define DC_VLC_BITS 9 typedef struct RVDecContext { - MpegEncContext m; + H263DecContext h; int sub_id; int orig_width, orig_height; } RVDecContext; @@ -80,16 +80,16 @@ static const uint16_t rv_chrom_len_count[15] = { 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; 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 { - 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) { - 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; } } @@ -97,59 +97,59 @@ int ff_rv_decode_dc(MpegEncContext *s, int n) } /* 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; - marker = get_bits1(&s->gb); + marker = get_bits1(&h->c.gb); - if (get_bits1(&s->gb)) - s->pict_type = AV_PICTURE_TYPE_P; + if (get_bits1(&h->c.gb)) + h->c.pict_type = AV_PICTURE_TYPE_P; else - s->pict_type = AV_PICTURE_TYPE_I; + h->c.pict_type = AV_PICTURE_TYPE_I; 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) { - avpriv_request_sample(s->avctx, "PB-frame"); + avpriv_request_sample(h->c.avctx, "PB-frame"); return AVERROR_PATCHWELCOME; } - s->qscale = get_bits(&s->gb, 5); - if (s->qscale == 0) { - av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n"); + h->c.qscale = get_bits(&h->c.gb, 5); + if (h->c.qscale == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n"); return AVERROR_INVALIDDATA; } - if (s->pict_type == AV_PICTURE_TYPE_I) { - if (s->rv10_version == 3) { + if (h->c.pict_type == AV_PICTURE_TYPE_I) { + if (h->c.rv10_version == 3) { /* specific MPEG like DC coding not used */ - s->last_dc[0] = get_bits(&s->gb, 8); - s->last_dc[1] = get_bits(&s->gb, 8); - s->last_dc[2] = get_bits(&s->gb, 8); - ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0], - s->last_dc[1], s->last_dc[2]); + h->c.last_dc[0] = get_bits(&h->c.gb, 8); + h->c.last_dc[1] = get_bits(&h->c.gb, 8); + h->c.last_dc[2] = get_bits(&h->c.gb, 8); + ff_dlog(h->c.avctx, "DC:%d %d %d\n", h->c.last_dc[0], + h->c.last_dc[1], h->c.last_dc[2]); } } /* if multiple packets per frame are sent, the position at which * to display the macroblocks is coded here */ - mb_xy = s->mb_x + s->mb_y * s->mb_width; - if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) { - s->mb_x = get_bits(&s->gb, 6); /* mb_x */ - s->mb_y = get_bits(&s->gb, 6); /* mb_y */ - mb_count = get_bits(&s->gb, 12); + mb_xy = h->c.mb_x + h->c.mb_y * h->c.mb_width; + if (show_bits(&h->c.gb, 12) == 0 || (mb_xy && mb_xy < h->c.mb_num)) { + h->c.mb_x = get_bits(&h->c.gb, 6); /* mb_x */ + h->c.mb_y = get_bits(&h->c.gb, 6); /* mb_y */ + mb_count = get_bits(&h->c.gb, 12); } else { - s->mb_x = 0; - s->mb_y = 0; - mb_count = s->mb_width * s->mb_height; + h->c.mb_x = 0; + h->c.mb_y = 0; + 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; } @@ -159,151 +159,151 @@ static int rv20_decode_picture_header(RVDecContext *rv, int whole_size) static const enum AVPictureType pict_types[] = { AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_I /* hmm ... */, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B }; - MpegEncContext *s = &rv->m; + H263DecContext *const h = &rv->h; int seq, mb_pos, ret; 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) { - av_log(s->avctx, AV_LOG_ERROR, "low delay B\n"); + if (h->c.low_delay && h->c.pict_type == AV_PICTURE_TYPE_B) { + av_log(h->c.avctx, AV_LOG_ERROR, "low delay B\n"); return -1; } - if (!s->last_pic.ptr && s->pict_type == AV_PICTURE_TYPE_B) { - av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n"); + if (!h->c.last_pic.ptr && h->c.pict_type == AV_PICTURE_TYPE_B) { + av_log(h->c.avctx, AV_LOG_ERROR, "early B-frame\n"); return AVERROR_INVALIDDATA; } - if (get_bits1(&s->gb)) { - av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n"); + if (get_bits1(&h->c.gb)) { + av_log(h->c.avctx, AV_LOG_ERROR, "reserved bit set\n"); return AVERROR_INVALIDDATA; } - s->qscale = get_bits(&s->gb, 5); - if (s->qscale == 0) { - av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n"); + h->c.qscale = get_bits(&h->c.gb, 5); + if (h->c.qscale == 0) { + av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n"); return AVERROR_INVALIDDATA; } if (RV_GET_MINOR_VER(rv->sub_id) >= 2) - s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres; + h->c.loop_filter = get_bits1(&h->c.gb) && !h->c.avctx->lowres; 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 - 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) { int f, new_w, new_h; 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 (s->avctx->extradata_size < 8 + 2 * f) { - av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n"); + if (h->c.avctx->extradata_size < 8 + 2 * f) { + av_log(h->c.avctx, AV_LOG_ERROR, "Extradata too small.\n"); return AVERROR_INVALIDDATA; } - new_w = 4 * s->avctx->extradata[6 + 2 * f]; - new_h = 4 * s->avctx->extradata[7 + 2 * f]; + new_w = 4 * h->c.avctx->extradata[6 + 2 * f]; + new_h = 4 * h->c.avctx->extradata[7 + 2 * f]; } else { new_w = rv->orig_width; new_h = rv->orig_height; } - if (new_w != s->width || new_h != s->height || !s->context_initialized) { - AVRational old_aspect = s->avctx->sample_aspect_ratio; - av_log(s->avctx, AV_LOG_DEBUG, + if (new_w != h->c.width || new_h != h->c.height || !h->c.context_initialized) { + AVRational old_aspect = h->c.avctx->sample_aspect_ratio; + av_log(h->c.avctx, AV_LOG_DEBUG, "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; if (whole_size < (new_w + 15)/16 * ((new_h + 15)/16) / 8) return AVERROR_INVALIDDATA; - ff_mpv_common_end(s); + ff_mpv_common_end(&h->c); // attempt to keep aspect during typical resolution switches if (!old_aspect.num) old_aspect = (AVRational){1, 1}; - if (2 * (int64_t)new_w * s->height == (int64_t)new_h * s->width) - s->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) - s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2}); + if (2 * (int64_t)new_w * h->c.height == (int64_t)new_h * h->c.width) + h->c.avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1}); + if ((int64_t)new_w * h->c.height == 2 * (int64_t)new_h * h->c.width) + 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) return ret; - s->width = new_w; - s->height = new_h; - if ((ret = ff_mpv_common_init(s)) < 0) + h->c.width = new_w; + h->c.height = new_h; + if ((ret = ff_mpv_common_init(&h->c)) < 0) return ret; } - if (s->avctx->debug & FF_DEBUG_PICT_INFO) { - av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max); + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) { + 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; - mb_pos = ff_h263_decode_mba(s); + mb_pos = ff_h263_decode_mba(h); - seq |= s->time & ~0x7FFF; - if (seq - s->time > 0x4000) + seq |= h->c.time & ~0x7FFF; + if (seq - h->c.time > 0x4000) seq -= 0x8000; - if (seq - s->time < -0x4000) + if (seq - h->c.time < -0x4000) seq += 0x8000; - if (seq != s->time) { - if (s->pict_type != AV_PICTURE_TYPE_B) { - s->time = seq; - s->pp_time = s->time - s->last_non_b_time; - s->last_non_b_time = s->time; + if (seq != h->c.time) { + if (h->c.pict_type != AV_PICTURE_TYPE_B) { + h->c.time = seq; + h->c.pp_time = h->c.time - h->c.last_non_b_time; + h->c.last_non_b_time = h->c.time; } else { - s->time = seq; - s->pb_time = s->pp_time - (s->last_non_b_time - s->time); + h->c.time = seq; + 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 (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) { - av_log(s->avctx, AV_LOG_DEBUG, + if (h->c.pict_type == AV_PICTURE_TYPE_B) { + 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(h->c.avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current B-frame\n"); #define ERROR_SKIP_FRAME -123 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 - skip_bits(&s->gb, 5); + skip_bits(&h->c.gb, 5); - s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I; - if (s->h263_aic) { - s->y_dc_scale_table = - s->c_dc_scale_table = ff_aic_dc_scale_table; + h->c.h263_aic = h->c.pict_type == AV_PICTURE_TYPE_I; + if (h->c.h263_aic) { + h->c.y_dc_scale_table = + h->c.c_dc_scale_table = ff_aic_dc_scale_table; } else { - s->y_dc_scale_table = - s->c_dc_scale_table = ff_mpeg1_dc_scale_table; + h->c.y_dc_scale_table = + h->c.c_dc_scale_table = ff_mpeg1_dc_scale_table; } - if (!s->avctx->lowres) - s->loop_filter = 1; + if (!h->c.avctx->lowres) + h->c.loop_filter = 1; - if (s->avctx->debug & FF_DEBUG_PICT_INFO) { - av_log(s->avctx, AV_LOG_INFO, + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) { + av_log(h->c.avctx, AV_LOG_INFO, "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, - s->no_rounding); + seq, h->c.mb_x, h->c.mb_y, h->c.pict_type, h->c.qscale, + 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, @@ -351,7 +351,7 @@ static av_cold int rv10_decode_init(AVCodecContext *avctx) { static AVOnce init_static_once = AV_ONCE_INIT; RVDecContext *rv = avctx->priv_data; - MpegEncContext *s = &rv->m; + H263DecContext *const h = &rv->h; int major_ver, minor_ver, micro_ver, ret; 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_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); if (avctx->codec_id == AV_CODEC_ID_RV20) { - s->modified_quant = 1; - s->chroma_qscale_table = ff_h263_chroma_qscale_table; + h->c.modified_quant = 1; + h->c.chroma_qscale_table = ff_h263_chroma_qscale_table; } 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) { case 1: - s->rv10_version = micro_ver ? 3 : 1; - s->obmc = micro_ver == 2; + h->c.rv10_version = micro_ver ? 3 : 1; + h->c.obmc = micro_ver == 2; break; case 2: if (minor_ver >= 2) { - s->low_delay = 0; + h->c.low_delay = 0; avctx->has_b_frames = 1; } 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) { 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; active_bits_size = buf_size * 8; - init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8); - if (s->codec_id == AV_CODEC_ID_RV10) - mb_count = rv10_decode_picture_header(s); + init_get_bits(&h->c.gb, buf, FFMAX(buf_size, buf_size2) * 8); + if (h->c.codec_id == AV_CODEC_ID_RV10) + mb_count = rv10_decode_picture_header(h); else mb_count = rv20_decode_picture_header(rv, whole_size); if (mb_count < 0) { 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; } - if (s->mb_x >= s->mb_width || - s->mb_y >= s->mb_height) { - av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y); + if (h->c.mb_x >= h->c.mb_width || + h->c.mb_y >= h->c.mb_height) { + av_log(h->c.avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", h->c.mb_x, h->c.mb_y); return AVERROR_INVALIDDATA; } - mb_pos = s->mb_y * s->mb_width + s->mb_x; - left = s->mb_width * s->mb_height - mb_pos; + mb_pos = h->c.mb_y * h->c.mb_width + h->c.mb_x; + left = h->c.mb_width * h->c.mb_height - mb_pos; 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; } - 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; - 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? - if (s->cur_pic.ptr) { - ff_er_frame_end(&s->er, NULL); - ff_mpv_frame_end(s); - s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0; + if (h->c.cur_pic.ptr) { + ff_er_frame_end(&h->c.er, NULL); + ff_mpv_frame_end(&h->c); + 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; - ff_mpeg_er_frame_start(s); + ff_mpeg_er_frame_start(&h->c); } else { - if (s->cur_pic.ptr->f->pict_type != s->pict_type) { - av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n"); + if (h->c.cur_pic.ptr->f->pict_type != h->c.pict_type) { + av_log(h->c.avctx, AV_LOG_ERROR, "Slice type mismatch\n"); return AVERROR_INVALIDDATA; } } - ff_dlog(avctx, "qscale=%d\n", s->qscale); + ff_dlog(avctx, "qscale=%d\n", h->c.qscale); /* default quantization values */ - if (s->codec_id == AV_CODEC_ID_RV10) { - if (s->mb_y == 0) - s->first_slice_line = 1; + if (h->c.codec_id == AV_CODEC_ID_RV10) { + if (h->c.mb_y == 0) + h->c.first_slice_line = 1; } else { - s->first_slice_line = 1; - s->resync_mb_x = s->mb_x; + h->c.first_slice_line = 1; + h->c.resync_mb_x = h->c.mb_x; } - start_mb_x = s->mb_x; - s->resync_mb_y = s->mb_y; + start_mb_x = h->c.mb_x; + 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; - s->rv10_first_dc_coded[1] = 0; - s->rv10_first_dc_coded[2] = 0; - ff_init_block_index(s); + h->c.rv10_first_dc_coded[0] = 0; + h->c.rv10_first_dc_coded[1] = 0; + h->c.rv10_first_dc_coded[2] = 0; + ff_init_block_index(&h->c); /* 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; - ff_update_block_index(s, 8, s->avctx->lowres, 1); - ff_tlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y); + ff_update_block_index(&h->c, 8, h->c.avctx->lowres, 1); + ff_tlog(avctx, "**mb x=%d y=%d\n", h->c.mb_x, h->c.mb_y); - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - ret = ff_h263_decode_mb(s, s->block); + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + ret = ff_h263_decode_mb(h, h->c.block); // Repeat the slice end check from ff_h263_decode_mb with our active // bitstream size - if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&s->gb)) { - int v = show_bits(&s->gb, 16); + if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&h->c.gb)) { + int v = show_bits(&h->c.gb, 16); - if (get_bits_count(&s->gb) + 16 > active_bits_size) - v >>= get_bits_count(&s->gb) + 16 - active_bits_size; + if (get_bits_count(&h->c.gb) + 16 > active_bits_size) + v >>= get_bits_count(&h->c.gb) + 16 - active_bits_size; if (!v) ret = SLICE_END; } - if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) && - 8 * buf_size2 >= get_bits_count(&s->gb)) { + if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&h->c.gb) && + 8 * buf_size2 >= get_bits_count(&h->c.gb)) { active_bits_size = buf_size2 * 8; av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", 8 * buf_size, active_bits_size); ret = SLICE_OK; } - if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) { - av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, - s->mb_y); + if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&h->c.gb)) { + av_log(h->c.avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", h->c.mb_x, + h->c.mb_y); return AVERROR_INVALIDDATA; } - if (s->pict_type != AV_PICTURE_TYPE_B) - ff_h263_update_motion_val(s); - ff_mpv_reconstruct_mb(s, s->block); - if (s->loop_filter) - ff_h263_loop_filter(s); - - if (++s->mb_x == s->mb_width) { - s->mb_x = 0; - s->mb_y++; - ff_init_block_index(s); + if (h->c.pict_type != AV_PICTURE_TYPE_B) + ff_h263_update_motion_val(&h->c); + ff_mpv_reconstruct_mb(&h->c, h->c.block); + if (h->c.loop_filter) + ff_h263_loop_filter(&h->c); + + if (++h->c.mb_x == h->c.mb_width) { + h->c.mb_x = 0; + h->c.mb_y++; + ff_init_block_index(&h->c); } - if (s->mb_x == s->resync_mb_x) - s->first_slice_line = 0; + if (h->c.mb_x == h->c.resync_mb_x) + h->c.first_slice_line = 0; if (ret == SLICE_END) 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); return active_bits_size; diff --git a/libavcodec/rv10dec.h b/libavcodec/rv10dec.h index daa6b8d653..e878e164b3 100644 --- a/libavcodec/rv10dec.h +++ b/libavcodec/rv10dec.h @@ -21,8 +21,8 @@ #ifndef 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 */ diff --git a/libavcodec/vaapi_mpeg4.c b/libavcodec/vaapi_mpeg4.c index 533e6750a1..cc4f6d3345 100644 --- a/libavcodec/vaapi_mpeg4.c +++ b/libavcodec/vaapi_mpeg4.c @@ -51,7 +51,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused uint32_t size) { Mpeg4DecContext *ctx = avctx->priv_data; - MpegEncContext *s = &ctx->m; + MPVContext *const s = &ctx->h.c; VAAPIDecodePicture *pic = s->cur_pic.ptr->hwaccel_picture_private; VAPictureParameterBufferMPEG4 pic_param; int i, err; diff --git a/libavcodec/vdpau_mpeg4.c b/libavcodec/vdpau_mpeg4.c index 7ec7a74ad1..668720a231 100644 --- a/libavcodec/vdpau_mpeg4.c +++ b/libavcodec/vdpau_mpeg4.c @@ -34,7 +34,7 @@ static int vdpau_mpeg4_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) { Mpeg4DecContext *ctx = avctx->priv_data; - MpegEncContext * const s = &ctx->m; + MPVContext *const s = &ctx->h.c; MPVPicture *pic = s->cur_pic.ptr; struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private; VdpPictureInfoMPEG4Part2 *info = &pic_ctx->info.mpeg4; diff --git a/libavcodec/wmv2.h b/libavcodec/wmv2.h index 6fc9704c3d..409d9456ab 100644 --- a/libavcodec/wmv2.h +++ b/libavcodec/wmv2.h @@ -44,7 +44,7 @@ void ff_mspel_motion(MpegEncContext *s, 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] = { { 0, 2, 1 }, @@ -52,7 +52,7 @@ static av_always_inline int wmv2_get_cbp_table_index(MpegEncContext *s, int cbp_ { 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 */ diff --git a/libavcodec/wmv2dec.c b/libavcodec/wmv2dec.c index 301c786633..c7b000ec7a 100644 --- a/libavcodec/wmv2dec.c +++ b/libavcodec/wmv2dec.c @@ -59,9 +59,9 @@ typedef struct WMV2DecContext { static void wmv2_add_block(WMV2DecContext *w, int16_t *block1, 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]) { case 0: w->common.wdsp.idct_add(dst, stride, block1); @@ -69,15 +69,15 @@ static void wmv2_add_block(WMV2DecContext *w, int16_t *block1, case 1: ff_simple_idct84_add(dst, stride, block1); 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; case 2: ff_simple_idct48_add(dst, stride, block1); 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; 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) { - int mb_x, mb_y; + H263DecContext *const h = &w->ms.h; int coded_mb_count = 0; - MpegEncContext *const s = &w->ms.m; - uint32_t *const mb_type = s->cur_pic.mb_type; + uint32_t *const mb_type = h->c.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) { case SKIP_TYPE_NONE: - for (mb_y = 0; mb_y < s->mb_height; mb_y++) - for (mb_x = 0; mb_x < s->mb_width; mb_x++) - mb_type[mb_y * s->mb_stride + mb_x] = + for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) + for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) + mb_type[mb_y * h->c.mb_stride + mb_x] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; break; 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; - for (mb_y = 0; mb_y < s->mb_height; mb_y++) - for (mb_x = 0; mb_x < s->mb_width; mb_x++) - mb_type[mb_y * s->mb_stride + mb_x] = - (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) + for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) + mb_type[mb_y * h->c.mb_stride + mb_x] = + (get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; break; case SKIP_TYPE_ROW: - for (mb_y = 0; mb_y < s->mb_height; mb_y++) { - if (get_bits_left(&s->gb) < 1) + for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) { + if (get_bits_left(&h->c.gb) < 1) return AVERROR_INVALIDDATA; - if (get_bits1(&s->gb)) { - for (mb_x = 0; mb_x < s->mb_width; mb_x++) - mb_type[mb_y * s->mb_stride + mb_x] = + if (get_bits1(&h->c.gb)) { + for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) + mb_type[mb_y * h->c.mb_stride + mb_x] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; } else { - for (mb_x = 0; mb_x < s->mb_width; mb_x++) - mb_type[mb_y * s->mb_stride + mb_x] = - (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) + mb_type[mb_y * h->c.mb_stride + mb_x] = + (get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; } } break; case SKIP_TYPE_COL: - for (mb_x = 0; mb_x < s->mb_width; mb_x++) { - if (get_bits_left(&s->gb) < 1) + for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) { + if (get_bits_left(&h->c.gb) < 1) return AVERROR_INVALIDDATA; - if (get_bits1(&s->gb)) { - for (mb_y = 0; mb_y < s->mb_height; mb_y++) - mb_type[mb_y * s->mb_stride + mb_x] = + if (get_bits1(&h->c.gb)) { + for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) + mb_type[mb_y * h->c.mb_stride + mb_x] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; } else { - for (mb_y = 0; mb_y < s->mb_height; mb_y++) - mb_type[mb_y * s->mb_stride + mb_x] = - (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; + for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) + mb_type[mb_y * h->c.mb_stride + mb_x] = + (get_bits1(&h->c.gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV; } } break; } - for (mb_y = 0; mb_y < s->mb_height; mb_y++) - for (mb_x = 0; mb_x < s->mb_width; mb_x++) - coded_mb_count += !IS_SKIP(mb_type[mb_y * s->mb_stride + mb_x]); + for (int mb_y = 0; mb_y < h->c.mb_height; mb_y++) + for (int mb_x = 0; mb_x < h->c.mb_width; mb_x++) + 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 0; @@ -166,20 +165,20 @@ static int parse_mb_skip(WMV2DecContext *w) static int decode_ext_header(WMV2DecContext *w) { - MpegEncContext *const s = &w->ms.m; + H263DecContext *const h = &w->ms.h; GetBitContext gb; int fps; int code; - if (s->avctx->extradata_size < 4) + if (h->c.avctx->extradata_size < 4) 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); w->ms.bit_rate = get_bits(&gb, 11) * 1024; 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->j_type_bit = 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) 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) - av_log(s->avctx, AV_LOG_DEBUG, + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) + av_log(h->c.avctx, AV_LOG_DEBUG, "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, " "slices:%d\n", 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); return 0; } -int ff_wmv2_decode_picture_header(MpegEncContext *s) +int ff_wmv2_decode_picture_header(H263DecContext *const h) { int code; - s->pict_type = get_bits1(&s->gb) + 1; - if (s->pict_type == AV_PICTURE_TYPE_I) { - code = get_bits(&s->gb, 7); - av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code); + h->c.pict_type = get_bits1(&h->c.gb) + 1; + if (h->c.pict_type == AV_PICTURE_TYPE_I) { + code = get_bits(&h->c.gb, 7); + av_log(h->c.avctx, AV_LOG_DEBUG, "I7:%X/\n", code); } - s->chroma_qscale = s->qscale = get_bits(&s->gb, 5); - if (s->qscale <= 0) + h->c.chroma_qscale = h->c.qscale = get_bits(&h->c.gb, 5); + if (h->c.qscale <= 0) return AVERROR_INVALIDDATA; - if (s->pict_type != AV_PICTURE_TYPE_I && show_bits(&s->gb, 1)) { - GetBitContext gb = s->gb; + if (h->c.pict_type != AV_PICTURE_TYPE_I && show_bits(&h->c.gb, 1)) { + GetBitContext gb = h->c.gb; 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) { int block = FFMIN(run, 25); @@ -233,46 +232,46 @@ int ff_wmv2_decode_picture_header(MpegEncContext *s) 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? */ - memset(s->cur_pic.mb_type, 0, - sizeof(*s->cur_pic.mb_type) * s->mb_height * s->mb_stride); + memset(h->c.cur_pic.mb_type, 0, + sizeof(*h->c.cur_pic.mb_type) * h->c.mb_height * h->c.mb_stride); if (w->j_type_bit) - w->j_type = get_bits1(&s->gb); + w->j_type = get_bits1(&h->c.gb); else w->j_type = 0; // FIXME check if (!w->j_type) { 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 w->ms.per_mb_rl_table = 0; if (!w->ms.per_mb_rl_table) { - w->ms.rl_chroma_table_index = decode012(&s->gb); - w->ms.rl_table_index = decode012(&s->gb); + w->ms.rl_chroma_table_index = decode012(&h->c.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, // we discard frames much smaller than this. Frames smaller than 1/8 of the // smallest "black/skip" frame generally contain not much recoverable content // while at the same time they have the highest computational requirements // 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; } - s->inter_intra_pred = 0; - s->no_rounding = 1; - if (s->avctx->debug & FF_DEBUG_PICT_INFO) { - av_log(s->avctx, AV_LOG_DEBUG, + h->c.inter_intra_pred = 0; + h->c.no_rounding = 1; + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) { + av_log(h->c.avctx, AV_LOG_DEBUG, "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); } } else { @@ -283,61 +282,61 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s) ret = parse_mb_skip(w); if (ret < 0) return ret; - cbp_index = decode012(&s->gb); - w->cbp_table_index = wmv2_get_cbp_table_index(s, cbp_index); + cbp_index = decode012(&h->c.gb); + w->cbp_table_index = wmv2_get_cbp_table_index(h->c.qscale, cbp_index); if (w->mspel_bit) - s->mspel = get_bits1(&s->gb); + h->c.mspel = get_bits1(&h->c.gb); else - s->mspel = 0; // FIXME check + h->c.mspel = 0; // FIXME check 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) - w->abt_type = decode012(&s->gb); + w->abt_type = decode012(&h->c.gb); } 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 w->ms.per_mb_rl_table = 0; 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; } - if (get_bits_left(&s->gb) < 2) + if (get_bits_left(&h->c.gb) < 2) return AVERROR_INVALIDDATA; - w->ms.dc_table_index = get_bits1(&s->gb); - w->ms.mv_table_index = get_bits1(&s->gb); + w->ms.dc_table_index = get_bits1(&h->c.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); - s->no_rounding ^= 1; + h->c.inter_intra_pred = 0; // (h->c.width * h->c.height < 320 * 240 && w->ms.bit_rate <= II_BITRATE); + h->c.no_rounding ^= 1; - if (s->avctx->debug & FF_DEBUG_PICT_INFO) { - av_log(s->avctx, AV_LOG_DEBUG, + if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) { + av_log(h->c.avctx, AV_LOG_DEBUG, "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", w->ms.rl_table_index, w->ms.rl_chroma_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, - s->inter_intra_pred); + h->c.inter_intra_pred); } } w->ms.esc3_level_length = 0; w->ms.esc3_run_length = 0; if (w->j_type) { - ff_intrax8_decode_picture(&w->x8, s->cur_pic.ptr, - &s->gb, &s->mb_x, &s->mb_y, - 2 * s->qscale, (s->qscale - 1) | 1, - s->loop_filter, s->low_delay); + ff_intrax8_decode_picture(&w->x8, h->c.cur_pic.ptr, + &h->c.gb, &h->c.mb_x, &h->c.mb_y, + 2 * h->c.qscale, (h->c.qscale - 1) | 1, + h->c.loop_filter, h->c.low_delay); - ff_er_add_slice(&s->er, 0, 0, - (s->mb_x >> 1) - 1, (s->mb_y >> 1) - 1, + ff_er_add_slice(&h->c.er, 0, 0, + (h->c.mb_x >> 1) - 1, (h->c.mb_y >> 1) - 1, ER_MB_END); 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) { - MpegEncContext *const s = &w->ms.m; + H263DecContext *const h = &w->ms.h; ff_msmpeg4_decode_motion(&w->ms, mx_ptr, my_ptr); - if ((((*mx_ptr) | (*my_ptr)) & 1) && s->mspel) - w->common.hshift = get_bits1(&s->gb); + if ((((*mx_ptr) | (*my_ptr)) & 1) && h->c.mspel) + w->common.hshift = get_bits1(&h->c.gb); else w->common.hshift = 0; } static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py) { - MpegEncContext *const s = &w->ms.m; - int xy, wrap, diff, type; - int16_t *A, *B, *C, *mot_val; + H263DecContext *const h = &w->ms.h; + int diff, type; - wrap = s->b8_stride; - xy = s->block_index[0]; + int wrap = h->c.b8_stride; + 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]; - B = s->cur_pic.motion_val[0][xy - wrap]; - C = s->cur_pic.motion_val[0][xy + 2 - wrap]; + const int16_t *A = h->c.cur_pic.motion_val[0][xy - 1]; + const int16_t *B = h->c.cur_pic.motion_val[0][xy - 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])); else diff = 0; if (diff >= 8) - type = get_bits1(&s->gb); + type = get_bits1(&h->c.gb); else type = 2; @@ -390,7 +388,7 @@ static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py) *py = B[1]; } else { /* special case for first (slice) line */ - if (s->first_slice_line) { + if (h->c.first_slice_line) { *px = A[0]; *py = A[1]; } 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, 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 }; int sub_cbp, ret; if (!cbp) { - s->block_last_index[n] = -1; + h->c.block_last_index[n] = -1; return 0; } 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; if (w->abt_type) { 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) { 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; } - s->block_last_index[n] = 63; + h->c.block_last_index[n] = 63; return 0; } else { 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. */ - WMV2DecContext *const w = (WMV2DecContext *) s; + WMV2DecContext *const w = (WMV2DecContext *) h; MSMP4DecContext *const ms = &w->ms; int cbp, code, i, ret; uint8_t *coded_val; @@ -456,40 +454,40 @@ static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64]) if (w->j_type) return 0; - if (s->pict_type == AV_PICTURE_TYPE_P) { - if (IS_SKIP(s->cur_pic.mb_type[s->mb_y * s->mb_stride + s->mb_x])) { + if (h->c.pict_type == AV_PICTURE_TYPE_P) { + if (IS_SKIP(h->c.cur_pic.mb_type[h->c.mb_y * h->c.mb_stride + h->c.mb_x])) { /* skip mb */ - s->mb_intra = 0; + h->c.mb_intra = 0; for (i = 0; i < 6; i++) - s->block_last_index[i] = -1; - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = 0; - s->mv[0][0][1] = 0; - s->mb_skipped = 1; + h->c.block_last_index[i] = -1; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.mv[0][0][0] = 0; + h->c.mv[0][0][1] = 0; + h->c.mb_skipped = 1; w->common.hshift = 0; return 0; } - if (get_bits_left(&s->gb) <= 0) + if (get_bits_left(&h->c.gb) <= 0) 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); - s->mb_intra = (~code & 0x40) >> 6; + h->c.mb_intra = (~code & 0x40) >> 6; cbp = code & 0x3f; } else { - s->mb_intra = 1; - if (get_bits_left(&s->gb) <= 0) + h->c.mb_intra = 1; + if (get_bits_left(&h->c.gb) <= 0) 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); /* predict coded block pattern */ cbp = 0; for (i = 0; i < 6; i++) { int val = ((code >> (5 - i)) & 1); 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; *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; wmv2_pred_motion(w, &mx, &my); if (cbp) { - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); 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; } 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) - w->abt_type = decode012(&s->gb); + w->abt_type = decode012(&h->c.gb); } else w->per_block_abt = 0; } wmv2_decode_motion(w, &mx, &my); - s->mv_dir = MV_DIR_FORWARD; - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = mx; - s->mv[0][0][1] = my; + h->c.mv_dir = MV_DIR_FORWARD; + h->c.mv_type = MV_TYPE_16X16; + h->c.mv[0][0][0] = mx; + h->c.mv[0][0][1] = my; for (i = 0; i < 6; i++) { 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", - s->mb_x, s->mb_y, i); + h->c.mb_x, h->c.mb_y, i); return ret; } } } else { - if (s->pict_type == AV_PICTURE_TYPE_P) - ff_dlog(s->avctx, "%d%d ", s->inter_intra_pred, cbp); - ff_dlog(s->avctx, "I at %d %d %d %06X\n", s->mb_x, s->mb_y, + if (h->c.pict_type == AV_PICTURE_TYPE_P) + ff_dlog(h->c.avctx, "%d%d ", h->c.inter_intra_pred, cbp); + ff_dlog(h->c.avctx, "I at %d %d %d %06X\n", h->c.mb_x, h->c.mb_y, ((cbp & 3) ? 1 : 0) + ((cbp & 0x3C) ? 2 : 0), - show_bits(&s->gb, 24)); - s->ac_pred = get_bits1(&s->gb); - if (s->inter_intra_pred) { - s->h263_aic_dir = get_vlc2(&s->gb, ff_inter_intra_vlc, + show_bits(&h->c.gb, 24)); + h->c.ac_pred = get_bits1(&h->c.gb); + if (h->c.inter_intra_pred) { + h->c.h263_aic_dir = get_vlc2(&h->c.gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1); - ff_dlog(s->avctx, "%d%d %d %d/", - s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y); + ff_dlog(h->c.avctx, "%d%d %d %d/", + h->c.ac_pred, h->c.h263_aic_dir, h->c.mb_x, h->c.mb_y); } 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; } - s->bdsp.clear_blocks(s->block[0]); + h->c.bdsp.clear_blocks(h->c.block[0]); for (i = 0; i < 6; i++) { ret = ff_msmpeg4_decode_block(ms, block[i], i, (cbp >> (5 - i)) & 1, NULL); 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", - s->mb_x, s->mb_y, i); + h->c.mb_x, h->c.mb_y, i); 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) { 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; 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) return ret; - s->decode_mb = wmv2_decode_mb; + h->decode_mb = wmv2_decode_mb; ff_wmv2_common_init(s); 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); } diff --git a/libavcodec/wmv2dec.h b/libavcodec/wmv2dec.h index bc8745bf6f..4dd9359dc9 100644 --- a/libavcodec/wmv2dec.h +++ b/libavcodec/wmv2dec.h @@ -22,9 +22,10 @@ #define AVCODEC_WMV2DEC_H #include "mpegvideo.h" +struct H263DecContext; -int ff_wmv2_decode_picture_header(MpegEncContext * s); -int ff_wmv2_decode_secondary_picture_header(MpegEncContext * s); +int ff_wmv2_decode_picture_header(struct H263DecContext *const h); +int ff_wmv2_decode_secondary_picture_header(struct H263DecContext *const h); void ff_wmv2_add_mb(MpegEncContext *s, int16_t block[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr); diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c index 0eef5b7cfb..9e1d62b90e 100644 --- a/libavcodec/wmv2enc.c +++ b/libavcodec/wmv2enc.c @@ -118,7 +118,7 @@ static int wmv2_encode_picture_header(MPVMainEncContext *const m) put_bits(&s->pb, 2, SKIP_TYPE_NONE); 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) put_bits(&s->pb, 1, s->c.mspel); -- ffmpeg-codebot _______________________________________________ ffmpeg-devel mailing list ffmpeg-devel@ffmpeg.org https://ffmpeg.org/mailman/listinfo/ffmpeg-devel To unsubscribe, visit link above, or email ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".