/*
- * MPEG4 decoder.
+ * MPEG-4 decoder
* Copyright (c) 2000,2001 Fabrice Bellard
* Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
*
*/
#include "error_resilience.h"
+#include "idctdsp.h"
#include "internal.h"
+#include "mpegutils.h"
#include "mpegvideo.h"
+#include "mpegvideodata.h"
#include "mpeg4video.h"
#include "h263.h"
+#include "profiles.h"
#include "thread.h"
+#include "xvididct.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
MB_TYPE_L0 | MB_TYPE_16x16,
};
+static inline int check_marker(AVCodecContext *avctx, GetBitContext *s, const char *msg)
+{
+ int bit = get_bits1(s);
+ if (!bit)
+ av_log(avctx, AV_LOG_INFO, "Marker bit missing %s\n", msg);
+
+ return bit;
+}
+
/**
* Predict the ac.
* @param n block index (0-3 are luma, 4-5 are chroma)
n == 1 || n == 3) {
/* same qscale */
for (i = 1; i < 8; i++)
- block[s->dsp.idct_permutation[i << 3]] += ac_val[i];
+ block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
} else {
/* different qscale, we must rescale */
for (i = 1; i < 8; i++)
- block[s->dsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
+ block[s->idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
}
} else {
const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride;
n == 2 || n == 3) {
/* same qscale */
for (i = 1; i < 8; i++)
- block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
+ block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
} else {
/* different qscale, we must rescale */
for (i = 1; i < 8; i++)
- block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
+ block[s->idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
}
}
}
/* left copy */
for (i = 1; i < 8; i++)
- ac_val1[i] = block[s->dsp.idct_permutation[i << 3]];
+ ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
/* top copy */
for (i = 1; i < 8; i++)
- ac_val1[8 + i] = block[s->dsp.idct_permutation[i]];
+ ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
}
/**
while ((1 << alpha) < w)
alpha++;
while ((1 << beta) < h)
- beta++; /* typo in the mpeg4 std for the definition of w' and h' */
+ beta++; /* typo in the MPEG-4 std for the definition of w' and h' */
w2 = 1 << alpha;
h2 = 1 << beta;
/* sprite_ref[3][0] = (a >> 1) * (2 * vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
* sprite_ref[3][1] = (a >> 1) * (2 * vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
- /* this is mostly identical to the mpeg4 std (and is totally unreadable
+ /* This is mostly identical to the MPEG-4 std (and is totally unreadable
* because of that...). Perhaps it should be reordered to be more readable.
* The idea behind this virtual_ref mess is to be able to use shifts later
* per pixel instead of divides so the distance between points is converted
while (get_bits1(&s->gb) != 0)
time_incr++;
- check_marker(&s->gb, "before time_increment in video packed header");
+ 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->gb, "before vop_coding_type in video packed header");
+ check_marker(s->avctx, &s->gb, "before vop_coding_type in video packed header");
skip_bits(&s->gb, 2); /* vop coding type */
// FIXME not rect stuff here
if (code > 8) {
if (get_bits1(&s->gb) == 0) { /* marker */
- if (s->err_recognition & AV_EF_BITSTREAM) {
+ if (s->avctx->err_recognition & AV_EF_BITSTREAM) {
av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
return -1;
}
level = level * qmul - qadd;
if ((unsigned)(level + 2048) > 4095) {
- if (s->err_recognition & AV_EF_BITSTREAM) {
+ if (s->avctx->err_recognition & AV_EF_BITSTREAM) {
if (level > 2560 || level < -2560) {
av_log(s->avctx, AV_LOG_ERROR,
"|level| overflow in 3. esc, qp=%d\n",
if (!IS_SKIP(mb_type)) {
int i;
- s->dsp.clear_blocks(s->block[0]);
+ s->bdsp.clear_blocks(s->block[0]);
/* decode each block */
for (i = 0; i < 6; i++) {
if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, s->mb_intra, ctx->rvlc) < 0) {
}
} while (cbpc == 20);
- s->dsp.clear_blocks(s->block[0]);
+ s->bdsp.clear_blocks(s->block[0]);
dquant = cbpc & 8;
s->mb_intra = ((cbpc & 4) != 0);
if (s->mb_intra)
ff_thread_await_progress(&s->next_picture_ptr->tf, s->mb_y, 0);
}
- /* if we skipped it in the future P Frame than skip it now too */
+ /* if we skipped it in the future P-frame than skip it now too */
s->mb_skipped = s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
if (s->mb_skipped) {
if (modb2) {
cbp = 0;
} else {
- s->dsp.clear_blocks(s->block[0]);
+ s->bdsp.clear_blocks(s->block[0]);
cbp = get_bits(&s->gb, 6);
}
if (!s->progressive_sequence)
s->interlaced_dct = get_bits1(&s->gb);
- s->dsp.clear_blocks(s->block[0]);
+ s->bdsp.clear_blocks(s->block[0]);
/* decode each block */
for (i = 0; i < 6; i++) {
if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 1, 0) < 0)
s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[s->aspect_ratio_info];
}
- if ((s->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */
+ 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");
}
} else {
/* is setting low delay flag only once the smartest thing to do?
- * low delay detection won't be overriden. */
+ * low delay detection will not be overridden. */
if (s->picture_number == 0)
s->low_delay = 0;
}
skip_bits(gb, 4); /* video_object_layer_shape_extension */
}
- check_marker(gb, "before time_increment_resolution");
+ check_marker(s->avctx, gb, "before time_increment_resolution");
- s->avctx->time_base.den = get_bits(gb, 16);
- if (!s->avctx->time_base.den) {
- av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
- s->avctx->time_base.num = 0;
+ s->avctx->framerate.num = get_bits(gb, 16);
+ if (!s->avctx->framerate.num) {
+ av_log(s->avctx, AV_LOG_ERROR, "framerate==0\n");
return -1;
}
- ctx->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
+ ctx->time_increment_bits = av_log2(s->avctx->framerate.num - 1) + 1;
if (ctx->time_increment_bits < 1)
ctx->time_increment_bits = 1;
- check_marker(gb, "before fixed_vop_rate");
+ check_marker(s->avctx, gb, "before fixed_vop_rate");
if (get_bits1(gb) != 0) /* fixed_vop_rate */
- s->avctx->time_base.num = get_bits(gb, ctx->time_increment_bits);
+ s->avctx->framerate.den = get_bits(gb, ctx->time_increment_bits);
else
- s->avctx->time_base.num = 1;
+ s->avctx->framerate.den = 1;
ctx->t_frame = 0;
s->interlaced_dct = 0;
if (!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
av_log(s->avctx, AV_LOG_INFO, /* OBMC Disable */
- "MPEG4 OBMC not supported (very likely buggy encoder)\n");
+ "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 */
else
/* load default matrixes */
for (i = 0; i < 64; i++) {
- int j = s->dsp.idct_permutation[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;
break;
last = v;
- j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+ j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
s->intra_matrix[j] = last;
s->chroma_intra_matrix[j] = last;
}
/* replicate last value */
for (; i < 64; i++) {
- int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+ int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
s->intra_matrix[j] = last;
s->chroma_intra_matrix[j] = last;
}
break;
last = v;
- j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+ j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
s->inter_matrix[j] = v;
s->chroma_inter_matrix[j] = v;
}
/* replicate last value */
for (; i < 64; i++) {
- int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+ int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
s->inter_matrix[j] = last;
s->chroma_inter_matrix[j] = last;
}
ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* intra_cae */
ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* inter_cae */
ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* no_update */
- ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* upampling */
+ ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* upsampling */
}
if (!get_bits1(gb)) {
ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* intra_blocks */
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(gb, "in complexity estimation part 1")) {
+ if (!check_marker(s->avctx, gb, "in complexity estimation part 1")) {
skip_bits_long(gb, pos - get_bits_count(gb));
goto no_cplx_est;
}
ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* halfpel2 */
ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* halfpel4 */
}
- if (!check_marker(gb, "in complexity estimation part 2")) {
+ if (!check_marker(s->avctx, gb, "in complexity estimation part 2")) {
skip_bits_long(gb, pos - get_bits_count(gb));
goto no_cplx_est;
}
s->divx_packed = e == 3 && last == 'p';
if (s->divx_packed && !ctx->showed_packed_warning) {
av_log(s->avctx, AV_LOG_WARNING,
- "Invalid and inefficient vfw-avi packed B frames detected\n");
+ "Invalid and inefficient vfw-avi packed B-frames detected\n");
ctx->showed_packed_warning = 1;
}
}
if (e == 1)
ctx->xvid_build = build;
+ 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"))
+ ctx->xvid_build = 0;
+ }
+
+ if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1)
+ if (s->codec_tag == AV_RL32("DIVX") && s->vo_type == 0 &&
+ ctx->vol_control_parameters == 0)
+ ctx->divx_version = 400; // divx 4
+
+ if (ctx->xvid_build >= 0 && ctx->divx_version >= 0) {
+ ctx->divx_version =
+ ctx->divx_build = -1;
+ }
+
+ if (CONFIG_MPEG4_DECODER && ctx->xvid_build >= 0)
+ ff_xvid_idct_init(&s->idsp, s->avctx);
+
return 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 &&
- s->vol_control_parameters == 0 && !(s->flags & CODEC_FLAG_LOW_DELAY)) {
- av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
+ 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;
}
while (get_bits1(gb) != 0)
time_incr++;
- check_marker(gb, "before time_increment");
+ check_marker(s->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_ERROR,
- "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
-
+ /* Headers seem incomplete; try to guess time_increment_bits. */
for (ctx->time_increment_bits = 1;
ctx->time_increment_bits < 16;
ctx->time_increment_bits++) {
} else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
break;
}
-
- av_log(s->avctx, AV_LOG_ERROR,
- "my guess is %d bits ;)\n", ctx->time_increment_bits);
}
if (IS_3IV1)
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 * s->avctx->time_base.den + time_increment;
+ s->time = s->time_base * s->avctx->framerate.num + time_increment;
if (s->workaround_bugs & FF_BUG_UMP4) {
if (s->time < s->last_non_b_time) {
/* header is not mpeg-4-compatible, broken encoder,
* trying to workaround */
s->time_base++;
- s->time += s->avctx->time_base.den;
+ s->time += s->avctx->framerate.num;
}
}
s->pp_time = s->time - s->last_non_b_time;
s->last_non_b_time = s->time;
} else {
- s->time = (s->last_time_base + time_incr) * s->avctx->time_base.den + time_increment;
+ s->time = (s->last_time_base + time_incr) * 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) {
- /* messed up order, maybe after seeking? skipping current b-frame */
+ /* messed up order, maybe after seeking? skipping current B-frame */
return FRAME_SKIPPED;
}
ff_mpeg4_init_direct_mv(s);
}
}
- check_marker(gb, "before vop_coded");
+ check_marker(s->avctx, gb, "before vop_coded");
/* vop coded */
if (get_bits1(gb) != 1) {
}
if (s->alternate_scan) {
- ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
- ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
- ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
- ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_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->dsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
- ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
- ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
- ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
+ 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);
}
if (s->pict_type == AV_PICTURE_TYPE_S &&
s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR,
- "Error, header damaged or not MPEG4 header (qscale=0)\n");
+ "Error, header damaged or not MPEG-4 header (qscale=0)\n");
return -1; // makes no sense to continue, as there is nothing left from the image then
}
s->f_code = get_bits(gb, 3); /* fcode_for */
if (s->f_code == 0) {
av_log(s->avctx, AV_LOG_ERROR,
- "Error, header damaged or not MPEG4 header (f_code=0)\n");
+ "Error, header damaged or not MPEG-4 header (f_code=0)\n");
return -1; // makes no sense to continue, as there is nothing left from the image then
}
} else
s->data_partitioning, ctx->resync_marker,
ctx->num_sprite_warping_points, s->sprite_warping_accuracy,
1 - s->no_rounding, s->vo_type,
- s->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
+ ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
ctx->cplx_estimation_trash_b);
}
}
}
/* detect buggy encoders which don't set the low_delay flag
- * (divx4/xvid/opendivx). Note we cannot detect divx5 without b-frames
+ * (divx4/xvid/opendivx). Note we cannot detect divx5 without B-frames
* easily (although it's buggy too) */
- if (s->vo_type == 0 && s->vol_control_parameters == 0 &&
+ if (s->vo_type == 0 && ctx->vol_control_parameters == 0 &&
ctx->divx_version == -1 && s->picture_number == 0) {
av_log(s->avctx, AV_LOG_WARNING,
"looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
}
/**
- * Decode mpeg4 headers.
+ * Decode MPEG-4 headers.
* @return <0 if no VOP found (or a damaged one)
* FRAME_SKIPPED if a not coded VOP is found
* 0 if a VOP is found
}
end:
- if (s->flags & CODEC_FLAG_LOW_DELAY)
+ if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
s->low_delay = 1;
s->avctx->has_b_frames = !s->low_delay;
- if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) {
- if (s->stream_codec_tag == AV_RL32("XVID") ||
- 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"))
- ctx->xvid_build = 0;
- }
-
- if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1)
- if (s->codec_tag == AV_RL32("DIVX") && s->vo_type == 0 &&
- s->vol_control_parameters == 0)
- ctx->divx_version = 400; // divx 4
-
- if (ctx->xvid_build >= 0 && ctx->divx_version >= 0) {
- ctx->divx_version =
- 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;
s->workaround_bugs |= FF_BUG_HPEL_CHROMA;
}
-#if HAVE_MMX
- if (s->codec_id == AV_CODEC_ID_MPEG4 && ctx->xvid_build >= 0 &&
- s->avctx->idct_algo == FF_IDCT_AUTO &&
- (av_get_cpu_flags() & AV_CPU_FLAG_MMX)) {
- s->avctx->idct_algo = FF_IDCT_XVIDMMX;
- ff_dct_common_init(s);
- s->picture_number = 0;
- }
-#endif
if (s->avctx->debug & FF_DEBUG_BUGS)
av_log(s->avctx, AV_LOG_DEBUG,
Mpeg4DecContext *ctx = avctx->priv_data;
MpegEncContext *s = &ctx->m;
- /* divx 5.01+ bistream reorder stuff */
+ /* divx 5.01+ bitstream reorder stuff */
if (s->divx_packed) {
int current_pos = get_bits_count(&s->gb) >> 3;
int startcode_found = 0;
av_fast_malloc(&s->bitstream_buffer,
&s->allocated_bitstream_buffer_size,
buf_size - current_pos +
- FF_INPUT_BUFFER_PADDING_SIZE);
+ AV_INPUT_BUFFER_PADDING_SIZE);
if (!s->bitstream_buffer)
return AVERROR(ENOMEM);
memcpy(s->bitstream_buffer, buf + current_pos,
{
Mpeg4DecContext *s = dst->priv_data;
const Mpeg4DecContext *s1 = src->priv_data;
+ int init = s->m.context_initialized;
int ret = ff_mpeg_update_thread_context(dst, src);
if (ret < 0)
return ret;
+ if (CONFIG_MPEG4_DECODER && !init && s1->xvid_build >= 0)
+ ff_xvid_idct_init(&s->m.idsp, dst);
+
s->shape = s1->shape;
s->time_increment_bits = s1->time_increment_bits;
+ s->xvid_build = s1->xvid_build;
return 0;
}
if (!done) {
done = 1;
- ff_init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
- ff_init_rl(&ff_rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
- ff_init_rl(&ff_rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
+ ff_rl_init(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
+ ff_rl_init(&ff_rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
+ ff_rl_init(&ff_rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
INIT_VLC_RL(ff_rvlc_rl_inter, 1072);
INIT_VLC_RL(ff_rvlc_rl_intra, 1072);
}
s->h263_pred = 1;
- s->low_delay = 0; /* default, might be overriden in the vol header during header parsing */
+ s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
s->decode_mb = mpeg4_decode_mb;
ctx->time_increment_bits = 4; /* default value for broken headers */
return 0;
}
-static const AVProfile mpeg4_video_profiles[] = {
- { FF_PROFILE_MPEG4_SIMPLE, "Simple Profile" },
- { FF_PROFILE_MPEG4_SIMPLE_SCALABLE, "Simple Scalable Profile" },
- { FF_PROFILE_MPEG4_CORE, "Core Profile" },
- { FF_PROFILE_MPEG4_MAIN, "Main Profile" },
- { FF_PROFILE_MPEG4_N_BIT, "N-bit Profile" },
- { FF_PROFILE_MPEG4_SCALABLE_TEXTURE, "Scalable Texture Profile" },
- { FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION, "Simple Face Animation Profile" },
- { FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE, "Basic Animated Texture Profile" },
- { FF_PROFILE_MPEG4_HYBRID, "Hybrid Profile" },
- { FF_PROFILE_MPEG4_ADVANCED_REAL_TIME, "Advanced Real Time Simple Profile" },
- { FF_PROFILE_MPEG4_CORE_SCALABLE, "Code Scalable Profile" },
- { FF_PROFILE_MPEG4_ADVANCED_CODING, "Advanced Coding Profile" },
- { FF_PROFILE_MPEG4_ADVANCED_CORE, "Advanced Core Profile" },
- { FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE, "Advanced Scalable Texture Profile" },
- { FF_PROFILE_MPEG4_SIMPLE_STUDIO, "Simple Studio Profile" },
- { FF_PROFILE_MPEG4_ADVANCED_SIMPLE, "Advanced Simple Profile" },
-};
-
AVCodec ff_mpeg4_decoder = {
.name = "mpeg4",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
.init = decode_init,
.close = ff_h263_decode_end,
.decode = ff_h263_decode_frame,
- .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
- CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
- CODEC_CAP_FRAME_THREADS,
+ .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
+ AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
+ AV_CODEC_CAP_FRAME_THREADS,
.flush = ff_mpeg_flush,
.pix_fmts = ff_h263_hwaccel_pixfmt_list_420,
- .profiles = NULL_IF_CONFIG_SMALL(mpeg4_video_profiles),
+ .profiles = NULL_IF_CONFIG_SMALL(ff_mpeg4_video_profiles),
.update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg4_update_thread_context),
};
projects / ffmpeg / blobdiff