#include "libavutil/internal.h"
#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
#include "error_resilience.h"
#include "hwaccel.h"
#include "idctdsp.h"
#include "profiles.h"
#include "thread.h"
#include "xvididct.h"
+#include "unary.h"
/* The defines below define the number of bits that are read at once for
* reading vlc values. Changing these may improve speed and data cache needs
#define SPRITE_TRAJ_VLC_BITS 6
#define DC_VLC_BITS 9
#define MB_TYPE_B_VLC_BITS 4
+#define STUDIO_INTRA_BITS 9
+
+static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb);
static VLC dc_lum, dc_chrom;
static VLC sprite_trajectory;
llabs(sprite_offset[0][i] + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL) + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
llabs(sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
- llabs(sprite_delta[i][1] * (w+16LL)) >= INT_MAX ||
+ llabs(sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
llabs(sd[0]) >= INT_MAX ||
llabs(sd[1]) >= INT_MAX ||
llabs(sprite_offset[0][i] + sd[0] * (w+16LL)) >= INT_MAX ||
/* is there enough space left for a video packet + header */
if (get_bits_count(&s->gb) > s->gb.size_in_bits - 20)
- return -1;
+ return AVERROR_INVALIDDATA;
for (len = 0; len < 32; len++)
if (get_bits1(&s->gb))
if (len != ff_mpeg4_get_video_packet_prefix_length(s)) {
av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (ctx->shape != RECT_SHAPE) {
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);
- return -1;
+ return AVERROR_INVALIDDATA;
}
s->mb_x = mb_num % s->mb_width;
return 0;
}
+static void reset_studio_dc_predictors(MpegEncContext *s)
+{
+ /* Reset DC Predictors */
+ s->last_dc[0] =
+ s->last_dc[1] =
+ s->last_dc[2] = 1 << (s->avctx->bits_per_raw_sample + s->dct_precision + s->intra_dc_precision - 1);
+}
+
+/**
+ * Decode the next video packet.
+ * @return <0 if something went wrong
+ */
+int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
+{
+ MpegEncContext *s = &ctx->m;
+ GetBitContext *gb = &s->gb;
+ unsigned vlc_len;
+ uint16_t mb_num;
+
+ if (get_bits_left(gb) >= 32 && get_bits_long(gb, 32) == SLICE_START_CODE) {
+ vlc_len = av_log2(s->mb_width * s->mb_height) + 1;
+ mb_num = get_bits(gb, vlc_len);
+
+ if (mb_num >= s->mb_num)
+ return AVERROR_INVALIDDATA;
+
+ s->mb_x = mb_num % s->mb_width;
+ s->mb_y = mb_num / s->mb_width;
+
+ if (ctx->shape != BIN_ONLY_SHAPE)
+ s->qscale = mpeg_get_qscale(s);
+
+ if (get_bits1(gb)) { /* slice_extension_flag */
+ skip_bits1(gb); /* intra_slice */
+ skip_bits1(gb); /* slice_VOP_id_enable */
+ skip_bits(gb, 6); /* slice_VOP_id */
+ while (get_bits1(gb)) /* extra_bit_slice */
+ skip_bits(gb, 8); /* extra_information_slice */
+ }
+
+ reset_studio_dc_predictors(s);
+ }
+ else {
+ return AVERROR_INVALIDDATA;
+ }
+
+ return 0;
+}
+
/**
* Get the average motion vector for a GMC MB.
* @param n either 0 for the x component or 1 for y
len >>= s->quarter_sample;
if (s->real_sprite_warping_points == 1) {
- if (ctx->divx_version == 500 && ctx->divx_build == 413)
+ if (ctx->divx_version == 500 && ctx->divx_build == 413 && a >= s->quarter_sample)
sum = s->sprite_offset[0][n] / (1 << (a - s->quarter_sample));
else
sum = RSHIFT(s->sprite_offset[0][n] * (1 << s->quarter_sample), a);
if (code < 0 || code > 9 /* && s->nbit < 9 */) {
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (code == 0) {
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");
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
}
int i;
do {
- if (show_bits_long(&s->gb, 19) == DC_MARKER)
+ if (show_bits(&s->gb, 19) == DC_MARKER)
return mb_num - 1;
cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, 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);
- return -1;
+ return AVERROR_INVALIDDATA;
}
} while (cbpc == 8);
if (dc < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"DC corrupted at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return dc;
}
dir <<= 1;
if (dc_pred_dir)
if (cbpc < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (cbpc == 20)
goto try_again;
if (!s->mcsel) {
mx = ff_h263_decode_motion(s, pred_x, s->f_code);
if (mx >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
my = ff_h263_decode_motion(s, pred_y, s->f_code);
if (my >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
s->current_picture.mb_type[xy] = MB_TYPE_16x16 |
MB_TYPE_L0;
} else {
int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
mx = ff_h263_decode_motion(s, pred_x, s->f_code);
if (mx >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
my = ff_h263_decode_motion(s, pred_y, s->f_code);
if (my >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
mot_val[0] = mx;
mot_val[1] = my;
}
if (cbpy < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
s->cbp_table[xy] |= cbpy << 2;
if (cbpy < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (s->cbp_table[xy] & 8)
if (dc < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"DC corrupted at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return dc;
}
dir <<= 1;
if (dc_pred_dir)
if (cbpy < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (s->cbp_table[xy] & 8)
{
MpegEncContext *s = &ctx->m;
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;
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);
- return -1;
+ 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);
- return -1;
+ return AVERROR_INVALIDDATA;
}
s->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_long(&s->gb, 19) != DC_MARKER) {
+ if (get_bits(&s->gb, 19) != DC_MARKER) {
av_log(s->avctx, AV_LOG_ERROR,
"marker missing after first I partition at %d %d\n",
s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
} else {
while (show_bits(&s->gb, 10) == 1)
av_log(s->avctx, AV_LOG_ERROR,
"marker missing after first P partition at %d %d\n",
s->mb_x, s->mb_y);
- return -1;
+ 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);
- if (mpeg4_decode_partition_b(s, mb_num) < 0) {
+ ret = mpeg4_decode_partition_b(s, 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);
- return -1;
+ 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,
} else {
level = mpeg4_decode_dc(s, n, &dc_pred_dir);
if (level < 0)
- return -1;
+ return level;
}
block[0] = level;
i = 0;
if (SHOW_UBITS(re, &s->gb, 1) == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"1. marker bit missing in rvlc esc\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
SKIP_CACHE(re, &s->gb, 1);
if (SHOW_UBITS(re, &s->gb, 1) == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"2. marker bit missing in rvlc esc\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
SKIP_CACHE(re, &s->gb, 1);
if (SHOW_UBITS(re, &s->gb, 5) != 0x10) {
av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
SKIP_CACHE(re, &s->gb, 5);
av_log(s->avctx, AV_LOG_ERROR,
"1. marker bit missing in 3. esc\n");
if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
- return -1;
+ return AVERROR_INVALIDDATA;
}
SKIP_CACHE(re, &s->gb, 1);
av_log(s->avctx, AV_LOG_ERROR,
"2. marker bit missing in 3. esc\n");
if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR))
- return -1;
+ return AVERROR_INVALIDDATA;
}
SKIP_COUNTER(re, &s->gb, 1 + 12 + 1);
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");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (s->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");
- return -1;
+ 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");
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
}
av_log(s->avctx, AV_LOG_ERROR,
"|level| overflow in 3. esc, qp=%d\n",
s->qscale);
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
level = level < 0 ? -2048 : 2047;
if (i & (~63)) {
av_log(s->avctx, AV_LOG_ERROR,
"ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
block[scan_table[i]] = level;
av_log(s->avctx, AV_LOG_ERROR,
"texture corrupted at %d %d %d\n",
s->mb_x, s->mb_y, s->mb_intra);
- return -1;
+ return AVERROR_INVALIDDATA;
}
cbp += cbp;
}
if (cbpc < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"mcbpc damaged at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
} while (cbpc == 20);
for (i = 0; i < 2; i++) {
mx = ff_h263_decode_motion(s, pred_x, s->f_code);
if (mx >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
my = ff_h263_decode_motion(s, pred_y / 2, s->f_code);
if (my >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
s->mv[0][i][0] = mx;
s->mv[0][i][1] = my;
mx = ff_h263_decode_motion(s, pred_x, s->f_code);
if (mx >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
my = ff_h263_decode_motion(s, pred_y, s->f_code);
if (my >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
s->mv[0][0][0] = mx;
s->mv[0][0][1] = my;
}
mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
mx = ff_h263_decode_motion(s, pred_x, s->f_code);
if (mx >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
my = ff_h263_decode_motion(s, pred_y, s->f_code);
if (my >= 0xffff)
- return -1;
+ return AVERROR_INVALIDDATA;
s->mv[0][i][0] = mx;
s->mv[0][i][1] = my;
mot_val[0] = mx;
mb_type = get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
if (mb_type < 0) {
av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
mb_type = mb_type_b_map[mb_type];
if (modb2) {
if (cbpc < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
} while (cbpc == 8);
if (cbpy < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
cbp = (cbpc & 3) | (cbpy << 2);
/* decode each block */
for (i = 0; i < 6; i++) {
if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 1, 0) < 0)
- return -1;
+ return AVERROR_INVALIDDATA;
cbp += cbp;
}
goto end;
/* decode each block */
for (i = 0; i < 6; i++) {
if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 0, 0) < 0)
- return -1;
+ return AVERROR_INVALIDDATA;
cbp += cbp;
}
int 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)) {
- return -1;
+ return AVERROR_INVALIDDATA;
} else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
return SLICE_END;
return SLICE_OK;
}
+/* As per spec, studio start code search isn't the same as the old type of start code */
+static void next_start_code_studio(GetBitContext *gb)
+{
+ align_get_bits(gb);
+
+ while (get_bits_left(gb) >= 24 && show_bits(gb, 24) != 0x1) {
+ get_bits(gb, 8);
+ }
+}
+
+/* additional_code, vlc index */
+static const uint8_t ac_state_tab[22][2] =
+{
+ {0, 0},
+ {0, 1},
+ {1, 1},
+ {2, 1},
+ {3, 1},
+ {4, 1},
+ {5, 1},
+ {1, 2},
+ {2, 2},
+ {3, 2},
+ {4, 2},
+ {5, 2},
+ {6, 2},
+ {1, 3},
+ {2, 4},
+ {3, 5},
+ {4, 6},
+ {5, 7},
+ {6, 8},
+ {7, 9},
+ {8, 10},
+ {0, 11}
+};
+
+static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n)
+{
+ Mpeg4DecContext *ctx = s->avctx->priv_data;
+
+ int cc, dct_dc_size, dct_diff, code, j, idx = 1, group = 0, run = 0,
+ additional_code_len, sign, mismatch;
+ VLC *cur_vlc = &ctx->studio_intra_tab[0];
+ uint8_t *const scantable = s->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 - s->dct_precision;
+
+ mismatch = 1;
+
+ memset(block, 0, 64 * sizeof(int32_t));
+
+ if (n < 4) {
+ cc = 0;
+ dct_dc_size = get_vlc2(&s->gb, ctx->studio_luma_dc.table, STUDIO_INTRA_BITS, 2);
+ quant_matrix = s->intra_matrix;
+ } else {
+ cc = (n & 1) + 1;
+ if (ctx->rgb)
+ dct_dc_size = get_vlc2(&s->gb, ctx->studio_luma_dc.table, STUDIO_INTRA_BITS, 2);
+ else
+ dct_dc_size = get_vlc2(&s->gb, ctx->studio_chroma_dc.table, STUDIO_INTRA_BITS, 2);
+ quant_matrix = s->chroma_intra_matrix;
+ }
+
+ if (dct_dc_size < 0) {
+ av_log(s->avctx, AV_LOG_ERROR, "illegal dct_dc_size vlc\n");
+ return AVERROR_INVALIDDATA;
+ } else if (dct_dc_size == 0) {
+ dct_diff = 0;
+ } else {
+ dct_diff = get_xbits(&s->gb, dct_dc_size);
+
+ if (dct_dc_size > 8) {
+ if(!check_marker(s->avctx, &s->gb, "dct_dc_size > 8"))
+ return AVERROR_INVALIDDATA;
+ }
+
+ }
+
+ s->last_dc[cc] += dct_diff;
+
+ if (s->mpeg_quant)
+ block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision);
+ else
+ block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision) * (8 >> s->dct_precision);
+ /* TODO: support mpeg_quant for AC coefficients */
+
+ block[0] = av_clip(block[0], min, max);
+ mismatch ^= block[0];
+
+ /* AC Coefficients */
+ while (1) {
+ group = get_vlc2(&s->gb, cur_vlc->table, STUDIO_INTRA_BITS, 2);
+
+ if (group < 0) {
+ av_log(s->avctx, AV_LOG_ERROR, "illegal ac coefficient group vlc\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ additional_code_len = ac_state_tab[group][0];
+ cur_vlc = &ctx->studio_intra_tab[ac_state_tab[group][1]];
+
+ if (group == 0) {
+ /* End of Block */
+ break;
+ } else if (group >= 1 && group <= 6) {
+ /* Zero run length (Table B.47) */
+ run = 1 << additional_code_len;
+ if (additional_code_len)
+ run += get_bits(&s->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);
+ sign = code & 1;
+ code >>= 1;
+ run = (1 << (additional_code_len - 1)) + code;
+ idx += run;
+ if (idx > 63)
+ return AVERROR_INVALIDDATA;
+ j = scantable[idx++];
+ block[j] = sign ? 1 : -1;
+ } else if (group >= 13 && group <= 20) {
+ /* Level value (Table B.49) */
+ if (idx > 63)
+ return AVERROR_INVALIDDATA;
+ j = scantable[idx++];
+ block[j] = get_xbits(&s->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 + s->dct_precision + 4;
+ flc = get_bits(&s->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] = av_clip(block[j], min, max);
+ mismatch ^= block[j];
+ }
+
+ block[63] ^= mismatch & 1;
+
+ return 0;
+}
+
+static int mpeg4_decode_dpcm_macroblock(MpegEncContext *s, int16_t macroblock[256], int n)
+{
+ int i, j, w, h, 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);
+
+ block_mean = get_bits(&s->gb, s->avctx->bits_per_raw_sample);
+ if (block_mean == 0){
+ av_log(s->avctx, AV_LOG_ERROR, "Forbidden block_mean\n");
+ return AVERROR_INVALIDDATA;
+ }
+ s->last_dc[n] = block_mean * (1 << (s->dct_precision + s->intra_dc_precision));
+
+ rice_parameter = get_bits(&s->gb, 4);
+ if (rice_parameter == 0) {
+ av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (rice_parameter == 15)
+ rice_parameter = 0;
+
+ if (rice_parameter > 11) {
+ av_log(s->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 (j = 0; j < w; j++) {
+ left = output;
+ topleft = top;
+
+ rice_prefix_code = get_unary(&s->gb, 1, 12);
+
+ /* Escape */
+ if (rice_prefix_code == 11)
+ dpcm_residual = get_bits(&s->gb, s->avctx->bits_per_raw_sample);
+ else {
+ if (rice_prefix_code == 12) {
+ av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_prefix_code\n");
+ return AVERROR_INVALIDDATA;
+ }
+ rice_suffix_code = get_bitsz(&s->gb, rice_parameter);
+ dpcm_residual = (rice_prefix_code << rice_parameter) + rice_suffix_code;
+ }
+
+ /* Map to a signed residual */
+ if (dpcm_residual & 1)
+ dpcm_residual = (-1 * dpcm_residual) >> 1;
+ else
+ dpcm_residual = (dpcm_residual >> 1);
+
+ if (i != 0)
+ top = macroblock[idx-w];
+
+ p = left + top - topleft;
+ min_left_top = FFMIN(left, top);
+ if (p < min_left_top)
+ p = min_left_top;
+
+ max_left_top = FFMAX(left, top);
+ if (p > max_left_top)
+ p = max_left_top;
+
+ p2 = (FFMIN(min_left_top, topleft) + FFMAX(max_left_top, topleft)) >> 1;
+ if (p2 == p)
+ p2 = block_mean;
+
+ if (p2 > p)
+ dpcm_residual *= -1;
+
+ macroblock[idx++] = output = (dpcm_residual + p) & ((1 << s->avctx->bits_per_raw_sample) - 1);
+ }
+ }
+
+ return 0;
+}
+
+static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64])
+{
+ int i;
+
+ s->dpcm_direction = 0;
+
+ /* StudioMacroblock */
+ /* Assumes I-VOP */
+ s->mb_intra = 1;
+ if (get_bits1(&s->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);
+ }
+
+ for (i = 0; i < mpeg4_block_count[s->chroma_format]; i++) {
+ if (mpeg4_decode_studio_block(s, (*s->block32)[i], i) < 0)
+ return AVERROR_INVALIDDATA;
+ }
+ } else {
+ /* DPCM */
+ check_marker(s->avctx, &s->gb, "DPCM block start");
+ s->dpcm_direction = get_bits1(&s->gb) ? -1 : 1;
+ for (i = 0; i < 3; i++) {
+ if (mpeg4_decode_dpcm_macroblock(s, (*s->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);
+ return SLICE_END;
+ }
+
+ //vcon-stp9L1.bits (first frame)
+ if (get_bits_left(&s->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)
+ return SLICE_END;
+
+ return SLICE_OK;
+}
+
static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
{
int hours, minutes, seconds;
if (!show_bits(gb, 23)) {
av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
hours = get_bits(gb, 5);
return 0;
}
-static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb)
+static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb, int *profile, int *level)
{
- s->avctx->profile = get_bits(gb, 4);
- s->avctx->level = get_bits(gb, 4);
+ *profile = get_bits(gb, 4);
+ *level = get_bits(gb, 4);
// for Simple profile, level 0
- if (s->avctx->profile == 0 && s->avctx->level == 8) {
- s->avctx->level = 0;
+ if (*profile == 0 && *level == 8) {
+ *level = 0;
}
return 0;
return 0;
}
+static void mpeg4_load_default_matrices(MpegEncContext *s)
+{
+ int i, v;
+
+ /* load default matrices */
+ for (i = 0; i < 64; i++) {
+ int j = s->idsp.idct_permutation[i];
+ v = ff_mpeg4_default_intra_matrix[i];
+ s->intra_matrix[j] = v;
+ s->chroma_intra_matrix[j] = v;
+
+ v = ff_mpeg4_default_non_intra_matrix[i];
+ s->inter_matrix[j] = v;
+ s->chroma_inter_matrix[j] = v;
+ }
+}
+
static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
{
MpegEncContext *s = &ctx->m;
/* vol header */
skip_bits(gb, 1); /* random access */
s->vo_type = get_bits(gb, 8);
+
+ /* If we are in studio profile (per vo_type), check if its all consistent
+ * and if so continue pass control to decode_studio_vol_header().
+ * elIf something is inconsistent, error out
+ * else continue with (non studio) vol header decpoding.
+ */
+ if (s->vo_type == CORE_STUDIO_VO_TYPE ||
+ s->vo_type == SIMPLE_STUDIO_VO_TYPE) {
+ if (s->avctx->profile != FF_PROFILE_UNKNOWN && s->avctx->profile != FF_PROFILE_MPEG4_SIMPLE_STUDIO)
+ return AVERROR_INVALIDDATA;
+ s->studio_profile = 1;
+ s->avctx->profile = FF_PROFILE_MPEG4_SIMPLE_STUDIO;
+ return decode_studio_vol_header(ctx, gb);
+ } else if (s->studio_profile) {
+ return AVERROR_PATCHWELCOME;
+ }
+
if (get_bits1(gb) != 0) { /* is_ol_id */
vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
skip_bits(gb, 3); /* vo_priority */
if ((s->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */
int i, v;
- /* load default matrixes */
- for (i = 0; i < 64; i++) {
- int j = s->idsp.idct_permutation[i];
- v = ff_mpeg4_default_intra_matrix[i];
- s->intra_matrix[j] = v;
- s->chroma_intra_matrix[j] = v;
-
- v = ff_mpeg4_default_non_intra_matrix[i];
- s->inter_matrix[j] = v;
- s->chroma_inter_matrix[j] = v;
- }
+ mpeg4_load_default_matrices(s);
/* load custom intra matrix */
if (get_bits1(gb)) {
return 0;
}
+static int read_quant_matrix_ext(MpegEncContext *s, GetBitContext *gb)
+{
+ int i, j, v;
+
+ if (get_bits1(gb)) {
+ if (get_bits_left(gb) < 64*8)
+ return AVERROR_INVALIDDATA;
+ /* intra_quantiser_matrix */
+ for (i = 0; i < 64; i++) {
+ v = get_bits(gb, 8);
+ j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
+ s->intra_matrix[j] = v;
+ s->chroma_intra_matrix[j] = v;
+ }
+ }
+
+ if (get_bits1(gb)) {
+ if (get_bits_left(gb) < 64*8)
+ return AVERROR_INVALIDDATA;
+ /* non_intra_quantiser_matrix */
+ for (i = 0; i < 64; i++) {
+ get_bits(gb, 8);
+ }
+ }
+
+ if (get_bits1(gb)) {
+ if (get_bits_left(gb) < 64*8)
+ return AVERROR_INVALIDDATA;
+ /* chroma_intra_quantiser_matrix */
+ for (i = 0; i < 64; i++) {
+ v = get_bits(gb, 8);
+ j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
+ s->chroma_intra_matrix[j] = v;
+ }
+ }
+
+ if (get_bits1(gb)) {
+ if (get_bits_left(gb) < 64*8)
+ return AVERROR_INVALIDDATA;
+ /* chroma_non_intra_quantiser_matrix */
+ for (i = 0; i < 64; i++) {
+ get_bits(gb, 8);
+ }
+ }
+
+ next_start_code_studio(gb);
+ return 0;
+}
+
+static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id)
+{
+ uint32_t startcode;
+ uint8_t extension_type;
+
+ startcode = show_bits_long(gb, 32);
+ if (startcode == USER_DATA_STARTCODE || startcode == EXT_STARTCODE) {
+
+ if ((id == 2 || id == 4) && startcode == EXT_STARTCODE) {
+ skip_bits_long(gb, 32);
+ extension_type = get_bits(gb, 4);
+ if (extension_type == QUANT_MATRIX_EXT_ID)
+ read_quant_matrix_ext(s, gb);
+ }
+ }
+}
+
+static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb)
+{
+ MpegEncContext *s = &ctx->m;
+
+ skip_bits(gb, 16); /* Time_code[63..48] */
+ check_marker(s->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]");
+ skip_bits(gb, 16); /* Time_code[31..16] */
+ check_marker(s->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]");
+ skip_bits(gb, 4); /* reserved_bits */
+}
+
+/**
+ * Decode the next studio vop header.
+ * @return <0 if something went wrong
+ */
+static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
+{
+ MpegEncContext *s = &ctx->m;
+
+ if (get_bits_left(gb) <= 32)
+ return 0;
+
+ s->partitioned_frame = 0;
+ s->interlaced_dct = 0;
+ s->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 */
+ 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 */
+ }
+
+ if (s->pict_type == AV_PICTURE_TYPE_I) {
+ if (get_bits1(gb))
+ reset_studio_dc_predictors(s);
+ }
+
+ if (ctx->shape != BIN_ONLY_SHAPE) {
+ s->alternate_scan = get_bits1(gb);
+ s->frame_pred_frame_dct = get_bits1(gb);
+ s->dct_precision = get_bits(gb, 2);
+ s->intra_dc_precision = get_bits(gb, 2);
+ s->q_scale_type = get_bits1(gb);
+ }
+
+ if (s->alternate_scan) {
+ ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
+ ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
+ ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
+ ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
+ } else {
+ ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
+ ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
+ ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
+ ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
+ }
+
+ mpeg4_load_default_matrices(s);
+
+ next_start_code_studio(gb);
+ extension_and_user_data(s, 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);
+ return AVERROR_PATCHWELCOME;
+ }
+
+ next_start_code_studio(gb);
+ extension_and_user_data(s, gb, 1);
+
+ return 0;
+}
+
+static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
+{
+ MpegEncContext *s = &ctx->m;
+ int width, height;
+ int bits_per_raw_sample;
+
+ // random_accessible_vol and video_object_type_indication have already
+ // been read by the caller decode_vol_header()
+ skip_bits(gb, 4); /* video_object_layer_verid */
+ ctx->shape = get_bits(gb, 2); /* video_object_layer_shape */
+ skip_bits(gb, 4); /* video_object_layer_shape_extension */
+ skip_bits1(gb); /* progressive_sequence */
+ if (ctx->shape != BIN_ONLY_SHAPE) {
+ ctx->rgb = get_bits1(gb); /* rgb_components */
+ s->chroma_format = get_bits(gb, 2); /* chroma_format */
+ if (!s->chroma_format) {
+ av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ bits_per_raw_sample = get_bits(gb, 4); /* bit_depth */
+ if (bits_per_raw_sample == 10) {
+ if (ctx->rgb) {
+ s->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
+ }
+ else {
+ s->avctx->pix_fmt = s->chroma_format == CHROMA_422 ? AV_PIX_FMT_YUV422P10 : AV_PIX_FMT_YUV444P10;
+ }
+ }
+ else {
+ avpriv_request_sample(s->avctx, "MPEG-4 Studio profile bit-depth %u", bits_per_raw_sample);
+ return AVERROR_PATCHWELCOME;
+ }
+ s->avctx->bits_per_raw_sample = bits_per_raw_sample;
+ }
+ if (ctx->shape == RECT_SHAPE) {
+ check_marker(s->avctx, gb, "before video_object_layer_width");
+ width = get_bits(gb, 14); /* video_object_layer_width */
+ check_marker(s->avctx, gb, "before video_object_layer_height");
+ height = get_bits(gb, 14); /* video_object_layer_height */
+ check_marker(s->avctx, gb, "after video_object_layer_height");
+
+ /* Do the same check as non-studio profile */
+ if (width && height) {
+ if (s->width && s->height &&
+ (s->width != width || s->height != height))
+ s->context_reinit = 1;
+ s->width = width;
+ s->height = height;
+ }
+ }
+ s->aspect_ratio_info = get_bits(gb, 4);
+ if (s->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
+ } else {
+ s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[s->aspect_ratio_info];
+ }
+ skip_bits(gb, 4); /* frame_rate_code */
+ skip_bits(gb, 15); /* first_half_bit_rate */
+ check_marker(s->avctx, gb, "after first_half_bit_rate");
+ skip_bits(gb, 15); /* latter_half_bit_rate */
+ check_marker(s->avctx, gb, "after latter_half_bit_rate");
+ skip_bits(gb, 15); /* first_half_vbv_buffer_size */
+ check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
+ skip_bits(gb, 3); /* latter_half_vbv_buffer_size */
+ skip_bits(gb, 11); /* first_half_vbv_buffer_size */
+ check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
+ skip_bits(gb, 15); /* latter_half_vbv_occupancy */
+ check_marker(s->avctx, gb, "after latter_half_vbv_occupancy");
+ s->low_delay = get_bits1(gb);
+ s->mpeg_quant = get_bits1(gb); /* mpeg2_stream */
+
+ next_start_code_studio(gb);
+ extension_and_user_data(s, gb, 2);
+
+ return 0;
+}
+
/**
* Decode MPEG-4 headers.
- * @return <0 if no VOP found (or a damaged one)
+ *
+ * @param header If set the absence of a VOP is not treated as error; otherwise, it is treated as such.
+ * @return <0 if an error occurred
* FRAME_SKIPPED if a not coded VOP is found
- * 0 if a VOP is found
+ * 0 else
*/
-int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb)
+int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int header)
{
MpegEncContext *s = &ctx->m;
unsigned startcode, v;
/* search next start code */
align_get_bits(gb);
+ // If we have not switched to studio profile than we also did not switch bps
+ // that means something else (like a previous instance) outside set bps which
+ // would be inconsistant with the currect state, thus reset it
+ if (!s->studio_profile && s->avctx->bits_per_raw_sample != 8)
+ s->avctx->bits_per_raw_sample = 0;
+
if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
skip_bits(gb, 24);
if (get_bits(gb, 8) == 0xF0)
(ctx->divx_version >= 0 || ctx->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
av_log(s->avctx, AV_LOG_VERBOSE, "frame skip %d\n", gb->size_in_bits);
return FRAME_SKIPPED; // divx bug
+ } else if (header && get_bits_count(gb) == gb->size_in_bits) {
+ return 0; // ordinary return value for parsing of extradata
} else
- return -1; // end of stream
+ return AVERROR_INVALIDDATA; // end of stream
}
/* use the bits after the test */
} else if (startcode == GOP_STARTCODE) {
mpeg4_decode_gop_header(s, gb);
} else if (startcode == VOS_STARTCODE) {
- mpeg4_decode_profile_level(s, gb);
+ int profile, level;
+ mpeg4_decode_profile_level(s, gb, &profile, &level);
+ if (profile == FF_PROFILE_MPEG4_SIMPLE_STUDIO &&
+ (level > 0 && level < 9)) {
+ s->studio_profile = 1;
+ next_start_code_studio(gb);
+ extension_and_user_data(s, gb, 0);
+ } else if (s->studio_profile) {
+ avpriv_request_sample(s->avctx, "Mixes studio and non studio profile\n");
+ return AVERROR_PATCHWELCOME;
+ }
+ s->avctx->profile = profile;
+ s->avctx->level = level;
} else if (startcode == VISUAL_OBJ_STARTCODE) {
- mpeg4_decode_visual_object(s, gb);
+ if (s->studio_profile) {
+ if ((ret = decode_studiovisualobject(ctx, gb)) < 0)
+ return ret;
+ } else
+ mpeg4_decode_visual_object(s, gb);
} else if (startcode == VOP_STARTCODE) {
break;
}
s->low_delay = 1;
s->avctx->has_b_frames = !s->low_delay;
- return decode_vop_header(ctx, gb);
+ if (s->studio_profile) {
+ if (!s->avctx->bits_per_raw_sample) {
+ av_log(s->avctx, AV_LOG_ERROR, "Missing VOL header\n");
+ return AVERROR_INVALIDDATA;
+ }
+ return decode_studio_vop_header(ctx, gb);
+ } else
+ return decode_vop_header(ctx, gb);
}
av_cold void ff_mpeg4videodec_static_init(void) {
}
#endif
+static av_cold int init_studio_vlcs(Mpeg4DecContext *ctx)
+{
+ int i, ret;
+
+ for (i = 0; i < 12; i++) {
+ ret = init_vlc(&ctx->studio_intra_tab[i], STUDIO_INTRA_BITS, 22,
+ &ff_mpeg4_studio_intra[i][0][1], 4, 2,
+ &ff_mpeg4_studio_intra[i][0][0], 4, 2,
+ 0);
+
+ if (ret < 0)
+ return ret;
+ }
+
+ ret = init_vlc(&ctx->studio_luma_dc, STUDIO_INTRA_BITS, 19,
+ &ff_mpeg4_studio_dc_luma[0][1], 4, 2,
+ &ff_mpeg4_studio_dc_luma[0][0], 4, 2,
+ 0);
+ if (ret < 0)
+ return ret;
+
+ ret = init_vlc(&ctx->studio_chroma_dc, STUDIO_INTRA_BITS, 19,
+ &ff_mpeg4_studio_dc_chroma[0][1], 4, 2,
+ &ff_mpeg4_studio_dc_chroma[0][0], 4, 2,
+ 0);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+
static av_cold int decode_init(AVCodecContext *avctx)
{
Mpeg4DecContext *ctx = avctx->priv_data;
return ret;
ff_mpeg4videodec_static_init();
+ if ((ret = init_studio_vlcs(ctx)) < 0)
+ return ret;
s->h263_pred = 1;
s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
return 0;
}
+static av_cold int decode_end(AVCodecContext *avctx)
+{
+ Mpeg4DecContext *ctx = avctx->priv_data;
+ int i;
+
+ if (!avctx->internal->is_copy) {
+ for (i = 0; i < 12; i++)
+ ff_free_vlc(&ctx->studio_intra_tab[i]);
+
+ ff_free_vlc(&ctx->studio_luma_dc);
+ ff_free_vlc(&ctx->studio_chroma_dc);
+ }
+
+ return ff_h263_decode_end(avctx);
+}
+
static const AVOption mpeg4_options[] = {
{"quarter_sample", "1/4 subpel MC", offsetof(MpegEncContext, quarter_sample), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
{"divx_packed", "divx style packed b frames", offsetof(MpegEncContext, divx_packed), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
.id = AV_CODEC_ID_MPEG4,
.priv_data_size = sizeof(Mpeg4DecContext),
.init = decode_init,
- .close = ff_h263_decode_end,
+ .close = decode_end,
.decode = ff_h263_decode_frame,
.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
projects / ffmpeg / blobdiff