highperfocused/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote branch 'qatar/master'

Browse Source 
* qatar/master: (23 commits)
  doc: Check standalone compilation before submitting new components.
  Fix standalone compilation of pipe protocol.
  Fix standalone compilation of ac3_fixed encoder.
  Fix standalone compilation of binkaudio_dct / binkaudio_rdft decoders.
  Fix standalone compilation of IMC decoder.
  Fix standalone compilation of WTV demuxer.
  Fix standalone compilation of MXPEG decoder.
  flashsv: K&R cosmetics
  matroskaenc: fix memory leak
  vc1: make overlap filter for I-frames bit-exact.
  vc1dec: use s->start/end_mb_y instead of passing them as function args.
  Revert "VC1: merge idct8x8, coeff adjustments and put_pixels."
  Replace strncpy() with av_strlcpy().
  indeo3: Eliminate use of long.
  get_bits: make cache unsigned to eliminate undefined signed overflow.
  asfdec: fix assert failure on invalid files
  avfilter: check malloc return values.
Not pulled as reason for reindent is not pulled:  mpegvideo: reindent.
  nutenc: check malloc return values.
Not pulled due to much simpler solution in ffmpeg  *: don't av_malloc(0).
  ...

Conflicts:
	doc/developer.texi
	libavcodec/Makefile
	libavcodec/get_bits.h
	libavcodec/mpegvideo.c
	libavformat/Makefile
	libavutil/log.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-05-05 03:09:48 +02:00
commit b000b86e1d
25 changed files with 490 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
configure vendored
View File

@ -1252,14 +1252,14 @@ aac_encoder_select="mdct sinewin"
aac_latm_decoder_select="aac_decoder aac_latm_parser" aac_latm_decoder_select="aac_decoder aac_latm_parser"
ac3_decoder_select="mdct ac3dsp ac3_parser" ac3_decoder_select="mdct ac3dsp ac3_parser"
ac3_encoder_select="mdct ac3dsp" ac3_encoder_select="mdct ac3dsp"
ac3_fixed_encoder_select="ac3dsp" ac3_fixed_encoder_select="mdct ac3dsp"
alac_encoder_select="lpc" alac_encoder_select="lpc"
amrnb_decoder_select="lsp" amrnb_decoder_select="lsp"
amrwb_decoder_select="lsp" amrwb_decoder_select="lsp"
atrac1_decoder_select="mdct sinewin" atrac1_decoder_select="mdct sinewin"
atrac3_decoder_select="mdct" atrac3_decoder_select="mdct"
binkaudio_dct_decoder_select="mdct rdft dct" binkaudio_dct_decoder_select="mdct rdft dct sinewin"
binkaudio_rdft_decoder_select="mdct rdft" binkaudio_rdft_decoder_select="mdct rdft sinewin"
cavs_decoder_select="golomb" cavs_decoder_select="golomb"
cook_decoder_select="mdct sinewin" cook_decoder_select="mdct sinewin"
cscd_decoder_suggest="zlib" cscd_decoder_suggest="zlib"
@ -1291,7 +1291,7 @@ h264_dxva2_hwaccel_deps="dxva2api_h"
h264_dxva2_hwaccel_select="dxva2 h264_decoder" h264_dxva2_hwaccel_select="dxva2 h264_decoder"
h264_vaapi_hwaccel_select="vaapi" h264_vaapi_hwaccel_select="vaapi"
h264_vdpau_decoder_select="vdpau h264_decoder" h264_vdpau_decoder_select="vdpau h264_decoder"
imc_decoder_select="fft mdct" imc_decoder_select="fft mdct sinewin"
jpegls_decoder_select="golomb" jpegls_decoder_select="golomb"
jpegls_encoder_select="golomb" jpegls_encoder_select="golomb"
ljpeg_encoder_select="aandct" ljpeg_encoder_select="aandct"

7
doc/developer.texi
View File

@ -312,9 +312,14 @@ send a reminder by email. Your patch should eventually be dealt with.
If it depends on a parser or a library, did you add that dependency in If it depends on a parser or a library, did you add that dependency in
configure? configure?
@item @item
Did you "git add" the appropriate files before committing? Did you @code{git add} the appropriate files before committing?
@item
Did you make sure it compiles standalone, i.e. with
@code{configure --disable-everything --enable-decoder=foo}
(or @code{--enable-demuxer} or whatever your component is)?
@end enumerate @end enumerate
@section patch submission checklist @section patch submission checklist
@enumerate @enumerate

3
ffmpeg.c
View File

@ -3816,8 +3816,7 @@ static int opt_streamid(const char *opt, const char *arg)
char *p; char *p;
char idx_str[16]; char idx_str[16];
strncpy(idx_str, arg, sizeof(idx_str)); av_strlcpy(idx_str, arg, sizeof(idx_str));
idx_str[sizeof(idx_str)-1] = '\0';
p = strchr(idx_str, ':'); p = strchr(idx_str, ':');
if (!p) { if (!p) {
fprintf(stderr, fprintf(stderr,

3
libavcodec/Makefile
View File

@ -277,7 +277,7 @@ OBJS-$(CONFIG_MSRLE_DECODER) += msrle.o msrledec.o
OBJS-$(CONFIG_MSVIDEO1_DECODER) += msvideo1.o OBJS-$(CONFIG_MSVIDEO1_DECODER) += msvideo1.o
OBJS-$(CONFIG_MSVIDEO1_ENCODER) += msvideo1enc.o elbg.o OBJS-$(CONFIG_MSVIDEO1_ENCODER) += msvideo1enc.o elbg.o
OBJS-$(CONFIG_MSZH_DECODER) += lcldec.o OBJS-$(CONFIG_MSZH_DECODER) += lcldec.o
OBJS-$(CONFIG_MXPEG_DECODER) += mxpegdec.o OBJS-$(CONFIG_MXPEG_DECODER) += mxpegdec.o mjpegdec.o mjpeg.o
OBJS-$(CONFIG_NELLYMOSER_DECODER) += nellymoserdec.o nellymoser.o OBJS-$(CONFIG_NELLYMOSER_DECODER) += nellymoserdec.o nellymoser.o
OBJS-$(CONFIG_NELLYMOSER_ENCODER) += nellymoserenc.o nellymoser.o OBJS-$(CONFIG_NELLYMOSER_ENCODER) += nellymoserenc.o nellymoser.o
OBJS-$(CONFIG_NUV_DECODER) += nuv.o rtjpeg.o OBJS-$(CONFIG_NUV_DECODER) += nuv.o rtjpeg.o
@ -556,6 +556,7 @@ OBJS-$(CONFIG_SPDIF_DEMUXER) += aacadtsdec.o mpeg4audio.o
OBJS-$(CONFIG_WEBM_MUXER) += xiph.o mpeg4audio.o \ OBJS-$(CONFIG_WEBM_MUXER) += xiph.o mpeg4audio.o \
flacdec.o flacdata.o flac.o \ flacdec.o flacdata.o flac.o \
mpegaudiodata.o vorbis_data.o mpegaudiodata.o vorbis_data.o
OBJS-$(CONFIG_WTV_DEMUXER) += mpeg4audio.o mpegaudiodata.o
# external codec libraries # external codec libraries
OBJS-$(CONFIG_LIBCELT_DECODER) += libcelt_dec.o OBJS-$(CONFIG_LIBCELT_DECODER) += libcelt_dec.o

43
libavcodec/ac3enc.c
View File

@ -33,6 +33,7 @@
#include "libavutil/audioconvert.h" #include "libavutil/audioconvert.h"
#include "libavutil/avassert.h" #include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/crc.h" #include "libavutil/crc.h"
#include "libavutil/opt.h" #include "libavutil/opt.h"
#include "avcodec.h" #include "avcodec.h"
@ -1551,10 +1552,10 @@ static void dprint_options(AVCodecContext *avctx)
char strbuf[32]; char strbuf[32];
switch (s->bitstream_id) { switch (s->bitstream_id) {
case 6: strncpy(strbuf, "AC-3 (alt syntax)", 32); break; case 6: av_strlcpy(strbuf, "AC-3 (alt syntax)", 32); break;
case 8: strncpy(strbuf, "AC-3 (standard)", 32); break; case 8: av_strlcpy(strbuf, "AC-3 (standard)", 32); break;
case 9: strncpy(strbuf, "AC-3 (dnet half-rate)", 32); break; case 9: av_strlcpy(strbuf, "AC-3 (dnet half-rate)", 32); break;
case 10: strncpy(strbuf, "AC-3 (dnet quater-rate", 32); break; case 10: av_strlcpy(strbuf, "AC-3 (dnet quater-rate", 32); break;
default: snprintf(strbuf, 32, "ERROR"); default: snprintf(strbuf, 32, "ERROR");
} }
av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id); av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id);
@ -1581,9 +1582,9 @@ static void dprint_options(AVCodecContext *avctx)
if (opt->audio_production_info) { if (opt->audio_production_info) {
av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level); av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
switch (opt->room_type) { switch (opt->room_type) {
case 0: strncpy(strbuf, "notindicated", 32); break; case 0: av_strlcpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "large", 32); break; case 1: av_strlcpy(strbuf, "large", 32); break;
case 2: strncpy(strbuf, "small", 32); break; case 2: av_strlcpy(strbuf, "small", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type); default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type);
} }
av_dlog(avctx, "room_type: %s\n", strbuf); av_dlog(avctx, "room_type: %s\n", strbuf);
@ -1595,9 +1596,9 @@ static void dprint_options(AVCodecContext *avctx)
av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level); av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
if (s->channel_mode == AC3_CHMODE_STEREO) { if (s->channel_mode == AC3_CHMODE_STEREO) {
switch (opt->dolby_surround_mode) { switch (opt->dolby_surround_mode) {
case 0: strncpy(strbuf, "notindicated", 32); break; case 0: av_strlcpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "on", 32); break; case 1: av_strlcpy(strbuf, "on", 32); break;
case 2: strncpy(strbuf, "off", 32); break; case 2: av_strlcpy(strbuf, "off", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode); default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode);
} }
av_dlog(avctx, "dsur_mode: %s\n", strbuf); av_dlog(avctx, "dsur_mode: %s\n", strbuf);
@ -1609,9 +1610,9 @@ static void dprint_options(AVCodecContext *avctx)
if (s->bitstream_id == 6) { if (s->bitstream_id == 6) {
if (opt->extended_bsi_1) { if (opt->extended_bsi_1) {
switch (opt->preferred_stereo_downmix) { switch (opt->preferred_stereo_downmix) {
case 0: strncpy(strbuf, "notindicated", 32); break; case 0: av_strlcpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "ltrt", 32); break; case 1: av_strlcpy(strbuf, "ltrt", 32); break;
case 2: strncpy(strbuf, "loro", 32); break; case 2: av_strlcpy(strbuf, "loro", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix); default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix);
} }
av_dlog(avctx, "dmix_mode: %s\n", strbuf); av_dlog(avctx, "dmix_mode: %s\n", strbuf);
@ -1628,23 +1629,23 @@ static void dprint_options(AVCodecContext *avctx)
} }
if (opt->extended_bsi_2) { if (opt->extended_bsi_2) {
switch (opt->dolby_surround_ex_mode) { switch (opt->dolby_surround_ex_mode) {
case 0: strncpy(strbuf, "notindicated", 32); break; case 0: av_strlcpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "on", 32); break; case 1: av_strlcpy(strbuf, "on", 32); break;
case 2: strncpy(strbuf, "off", 32); break; case 2: av_strlcpy(strbuf, "off", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode); default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode);
} }
av_dlog(avctx, "dsurex_mode: %s\n", strbuf); av_dlog(avctx, "dsurex_mode: %s\n", strbuf);
switch (opt->dolby_headphone_mode) { switch (opt->dolby_headphone_mode) {
case 0: strncpy(strbuf, "notindicated", 32); break; case 0: av_strlcpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "on", 32); break; case 1: av_strlcpy(strbuf, "on", 32); break;
case 2: strncpy(strbuf, "off", 32); break; case 2: av_strlcpy(strbuf, "off", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode); default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode);
} }
av_dlog(avctx, "dheadphone_mode: %s\n", strbuf); av_dlog(avctx, "dheadphone_mode: %s\n", strbuf);
switch (opt->ad_converter_type) { switch (opt->ad_converter_type) {
case 0: strncpy(strbuf, "standard", 32); break; case 0: av_strlcpy(strbuf, "standard", 32); break;
case 1: strncpy(strbuf, "hdcd", 32); break; case 1: av_strlcpy(strbuf, "hdcd", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type); default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type);
} }
av_dlog(avctx, "ad_conv_type: %s\n", strbuf); av_dlog(avctx, "ad_conv_type: %s\n", strbuf);

4
libavcodec/ass.c
View File

@ -21,6 +21,7 @@
#include "avcodec.h" #include "avcodec.h"
#include "ass.h" #include "ass.h"
#include "libavutil/avstring.h"
int ff_ass_subtitle_header(AVCodecContext *avctx, int ff_ass_subtitle_header(AVCodecContext *avctx,
const char *font, int font_size, const char *font, int font_size,
@ -97,8 +98,7 @@ int ff_ass_add_rect(AVSubtitle *sub, const char *dialog,
rects[sub->num_rects]->type = SUBTITLE_ASS; rects[sub->num_rects]->type = SUBTITLE_ASS;
rects[sub->num_rects]->ass = av_malloc(len + dlen + 1); rects[sub->num_rects]->ass = av_malloc(len + dlen + 1);
strcpy (rects[sub->num_rects]->ass , header); strcpy (rects[sub->num_rects]->ass , header);
strncpy(rects[sub->num_rects]->ass + len, dialog, dlen); av_strlcpy(rects[sub->num_rects]->ass + len, dialog, dlen + 1);
rects[sub->num_rects]->ass[len+dlen] = 0;
sub->num_rects++; sub->num_rects++;
return dlen; return dlen;
} }

4
libavcodec/flashsv.c
View File

@ -148,7 +148,7 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
if ((avctx->width != s->image_width) || (avctx->height != s->image_height)) { if ((avctx->width != s->image_width) || (avctx->height != s->image_height)) {
av_log(avctx, AV_LOG_ERROR, "Frame width or height differs from first frames!\n"); av_log(avctx, AV_LOG_ERROR, "Frame width or height differs from first frames!\n");
av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n", avctx->height, av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n", avctx->height,
avctx->width,s->image_height, s->image_width); avctx->width, s->image_height, s->image_width);
return -1; return -1;
} }
@ -195,7 +195,7 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
s->zstream.next_in = buf + (get_bits_count(&gb) / 8); s->zstream.next_in = buf + (get_bits_count(&gb) / 8);
s->zstream.avail_in = size; s->zstream.avail_in = size;
s->zstream.next_out = s->tmpblock; s->zstream.next_out = s->tmpblock;
s->zstream.avail_out = s->block_size*3; s->zstream.avail_out = s->block_size * 3;
ret = inflate(&(s->zstream), Z_FINISH); ret = inflate(&(s->zstream), Z_FINISH);
if (ret == Z_DATA_ERROR) { if (ret == Z_DATA_ERROR) {
av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n"); av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");

2
libavcodec/get_bits.h
View File

@ -127,7 +127,7 @@ for examples see get_bits, show_bits, skip_bits, get_vlc
# define OPEN_READER(name, gb) \ # define OPEN_READER(name, gb) \
unsigned int name##_index = (gb)->index; \ unsigned int name##_index = (gb)->index; \
av_unused int name##_cache av_unused unsigned int name##_cache
# define CLOSE_READER(name, gb) (gb)->index = name##_index # define CLOSE_READER(name, gb) (gb)->index = name##_index

22
libavcodec/indeo3.c
View File

@ -149,13 +149,13 @@ static av_cold void iv_free_func(Indeo3DecodeContext *s)
} }
struct ustr { struct ustr {
long xpos; int xpos;
long ypos; int ypos;
long width; int width;
long height; int height;
long split_flag; int split_flag;
long split_direction; int split_direction;
long usl7; int usl7;
}; };
@ -203,12 +203,12 @@ struct ustr {
static void iv_Decode_Chunk(Indeo3DecodeContext *s, static void iv_Decode_Chunk(Indeo3DecodeContext *s,
uint8_t *cur, uint8_t *ref, int width, int height, uint8_t *cur, uint8_t *ref, int width, int height,
const uint8_t *buf1, long cb_offset, const uint8_t *hdr, const uint8_t *buf1, int cb_offset, const uint8_t *hdr,
const uint8_t *buf2, int min_width_160) const uint8_t *buf2, int min_width_160)
{ {
uint8_t bit_buf; uint8_t bit_buf;
unsigned long bit_pos, lv, lv1, lv2; unsigned int bit_pos, lv, lv1, lv2;
long *width_tbl, width_tbl_arr[10]; int *width_tbl, width_tbl_arr[10];
const signed char *ref_vectors; const signed char *ref_vectors;
uint8_t *cur_frm_pos, *ref_frm_pos, *cp, *cp2; uint8_t *cur_frm_pos, *ref_frm_pos, *cp, *cp2;
uint32_t *cur_lp, *ref_lp; uint32_t *cur_lp, *ref_lp;
@ -982,7 +982,7 @@ static int iv_decode_frame(AVCodecContext *avctx,
Indeo3DecodeContext *s = avctx->priv_data; Indeo3DecodeContext *s = avctx->priv_data;
unsigned int image_width, image_height, unsigned int image_width, image_height,
chroma_width, chroma_height; chroma_width, chroma_height;
unsigned long flags, cb_offset, data_size, unsigned int flags, cb_offset, data_size,
y_offset, v_offset, u_offset, mc_vector_count; y_offset, v_offset, u_offset, mc_vector_count;
const uint8_t *hdr_pos, *buf_pos; const uint8_t *hdr_pos, *buf_pos;

63
libavcodec/ppc/vc1dsp_altivec.c
View File

@ -130,8 +130,7 @@ do { \
/** Do inverse transform on 8x8 block /** Do inverse transform on 8x8 block
*/ */
static void vc1_inv_trans_8x8_altivec(DCTELEM block[64], static void vc1_inv_trans_8x8_altivec(DCTELEM block[64])
int sign, int rangered)
{ {
vector signed short src0, src1, src2, src3, src4, src5, src6, src7; vector signed short src0, src1, src2, src3, src4, src5, src6, src7;
vector signed int s0, s1, s2, s3, s4, s5, s6, s7; vector signed int s0, s1, s2, s3, s4, s5, s6, s7;
@ -145,9 +144,6 @@ static void vc1_inv_trans_8x8_altivec(DCTELEM block[64],
const vector unsigned int vec_2 = vec_splat_u32(2); const vector unsigned int vec_2 = vec_splat_u32(2);
const vector signed int vec_1s = vec_splat_s32(1); const vector signed int vec_1s = vec_splat_s32(1);
const vector unsigned int vec_1 = vec_splat_u32(1); const vector unsigned int vec_1 = vec_splat_u32(1);
const vector unsigned short rangered_shift = vec_splat_u16(1);
const vector signed short signed_bias = vec_sl(vec_splat_s16(4),
vec_splat_u16(4));
src0 = vec_ld( 0, block); src0 = vec_ld( 0, block);
src1 = vec_ld( 16, block); src1 = vec_ld( 16, block);
@ -217,27 +213,6 @@ static void vc1_inv_trans_8x8_altivec(DCTELEM block[64],
src6 = vec_pack(sE, s6); src6 = vec_pack(sE, s6);
src7 = vec_pack(sF, s7); src7 = vec_pack(sF, s7);
if (rangered) {
if (!sign) {
src0 = vec_sub(src0, signed_bias);
src1 = vec_sub(src1, signed_bias);
src2 = vec_sub(src2, signed_bias);
src3 = vec_sub(src3, signed_bias);
src4 = vec_sub(src4, signed_bias);
src5 = vec_sub(src5, signed_bias);
src6 = vec_sub(src6, signed_bias);
src7 = vec_sub(src7, signed_bias);
}
src0 = vec_sl(src0, rangered_shift);
src1 = vec_sl(src1, rangered_shift);
src2 = vec_sl(src2, rangered_shift);
src3 = vec_sl(src3, rangered_shift);
src4 = vec_sl(src4, rangered_shift);
src5 = vec_sl(src5, rangered_shift);
src6 = vec_sl(src6, rangered_shift);
src7 = vec_sl(src7, rangered_shift);
}
vec_st(src0, 0, block); vec_st(src0, 0, block);
vec_st(src1, 16, block); vec_st(src1, 16, block);
vec_st(src2, 32, block); vec_st(src2, 32, block);
@ -248,36 +223,6 @@ static void vc1_inv_trans_8x8_altivec(DCTELEM block[64],
vec_st(src7,112, block); vec_st(src7,112, block);
} }
static void vc1_inv_trans_8x8_add_altivec(uint8_t *dest, int stride, DCTELEM *b)
{
vc1_inv_trans_8x8_altivec(b, 0, 0);
ff_add_pixels_clamped_c(b, dest, stride);
}
static void vc1_inv_trans_8x8_put_signed_altivec(uint8_t *dest, int stride, DCTELEM *b)
{
vc1_inv_trans_8x8_altivec(b, 1, 0);
ff_put_signed_pixels_clamped_c(b, dest, stride);
}
static void vc1_inv_trans_8x8_put_signed_rangered_altivec(uint8_t *dest, int stride, DCTELEM *b)
{
vc1_inv_trans_8x8_altivec(b, 1, 1);
ff_put_signed_pixels_clamped_c(b, dest, stride);
}
static void vc1_inv_trans_8x8_put_altivec(uint8_t *dest, int stride, DCTELEM *b)
{
vc1_inv_trans_8x8_altivec(b, 0, 0);
ff_put_pixels_clamped_c(b, dest, stride);
}
static void vc1_inv_trans_8x8_put_rangered_altivec(uint8_t *dest, int stride, DCTELEM *b)
{
vc1_inv_trans_8x8_altivec(b, 0, 1);
ff_put_pixels_clamped_c(b, dest, stride);
}
/** Do inverse transform on 8x4 part of block /** Do inverse transform on 8x4 part of block
*/ */
static void vc1_inv_trans_8x4_altivec(uint8_t *dest, int stride, DCTELEM *block) static void vc1_inv_trans_8x4_altivec(uint8_t *dest, int stride, DCTELEM *block)
@ -396,11 +341,7 @@ void ff_vc1dsp_init_altivec(VC1DSPContext* dsp)
if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC)) if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC))
return; return;
dsp->vc1_inv_trans_8x8_add = vc1_inv_trans_8x8_add_altivec; dsp->vc1_inv_trans_8x8 = vc1_inv_trans_8x8_altivec;
dsp->vc1_inv_trans_8x8_put_signed[0] = vc1_inv_trans_8x8_put_signed_altivec;
dsp->vc1_inv_trans_8x8_put_signed[1] = vc1_inv_trans_8x8_put_signed_rangered_altivec;
dsp->vc1_inv_trans_8x8_put[0] = vc1_inv_trans_8x8_put_altivec;
dsp->vc1_inv_trans_8x8_put[1] = vc1_inv_trans_8x8_put_rangered_altivec;
dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_altivec; dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_altivec;
dsp->put_no_rnd_vc1_chroma_pixels_tab[0] = put_no_rnd_vc1_chroma_mc8_altivec; dsp->put_no_rnd_vc1_chroma_pixels_tab[0] = put_no_rnd_vc1_chroma_mc8_altivec;
dsp->avg_no_rnd_vc1_chroma_pixels_tab[0] = avg_no_rnd_vc1_chroma_mc8_altivec; dsp->avg_no_rnd_vc1_chroma_pixels_tab[0] = avg_no_rnd_vc1_chroma_mc8_altivec;

28
libavcodec/vc1.c
View File

@ -280,28 +280,6 @@ static int vop_dquant_decoding(VC1Context *v)
static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb); static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
static void simple_idct_put_rangered(uint8_t *dest, int line_size, DCTELEM *block)
{
int i;
ff_simple_idct(block);
for (i = 0; i < 64; i++) block[i] = (block[i] - 64) << 1;
ff_put_pixels_clamped_c(block, dest, line_size);
}
static void simple_idct_put_signed(uint8_t *dest, int line_size, DCTELEM *block)
{
ff_simple_idct(block);
ff_put_signed_pixels_clamped_c(block, dest, line_size);
}
static void simple_idct_put_signed_rangered(uint8_t *dest, int line_size, DCTELEM *block)
{
int i;
ff_simple_idct(block);
for (i = 0; i < 64; i++) block[i] <<= 1;
ff_put_signed_pixels_clamped_c(block, dest, line_size);
}
/** /**
* Decode Simple/Main Profiles sequence header * Decode Simple/Main Profiles sequence header
* @see Figure 7-8, p16-17 * @see Figure 7-8, p16-17
@ -359,11 +337,7 @@ int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitConte
v->res_fasttx = get_bits1(gb); v->res_fasttx = get_bits1(gb);
if (!v->res_fasttx) if (!v->res_fasttx)
{ {
v->vc1dsp.vc1_inv_trans_8x8_add = ff_simple_idct_add; v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct;
v->vc1dsp.vc1_inv_trans_8x8_put[0] = ff_simple_idct_put;
v->vc1dsp.vc1_inv_trans_8x8_put[1] = simple_idct_put_rangered;
v->vc1dsp.vc1_inv_trans_8x8_put_signed[0] = simple_idct_put_signed;
v->vc1dsp.vc1_inv_trans_8x8_put_signed[1] = simple_idct_put_signed_rangered;
v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add; v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add; v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add; v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;

2
libavcodec/vc1.h
View File

@ -317,6 +317,8 @@ typedef struct VC1Context{
int bi_type; int bi_type;
int x8_type; int x8_type;
DCTELEM (*block)[6][64];
int n_allocated_blks, cur_blk_idx, left_blk_idx, topleft_blk_idx, top_blk_idx;
uint32_t *cbp_base, *cbp; uint32_t *cbp_base, *cbp;
uint8_t *is_intra_base, *is_intra; uint8_t *is_intra_base, *is_intra;
int16_t (*luma_mv_base)[2], (*luma_mv)[2]; int16_t (*luma_mv_base)[2], (*luma_mv)[2];

382
libavcodec/vc1dec.c
View File

@ -160,6 +160,72 @@ enum Imode {
/** @} */ //Bitplane group /** @} */ //Bitplane group
static void vc1_put_signed_blocks_clamped(VC1Context *v)
{
MpegEncContext *s = &v->s;
/* The put pixels loop is always one MB row behind the decoding loop,
* because we can only put pixels when overlap filtering is done, and
* for filtering of the bottom edge of a MB, we need the next MB row
* present as well.
* Within the row, the put pixels loop is also one MB col behind the
* decoding loop. The reason for this is again, because for filtering
* of the right MB edge, we need the next MB present. */
if (!s->first_slice_line) {
if (s->mb_x) {
s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
s->dest[0] - 16 * s->linesize - 16,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
s->dest[0] - 16 * s->linesize - 8,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
s->dest[0] - 8 * s->linesize - 16,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
s->dest[0] - 8 * s->linesize - 8,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
s->dest[1] - 8 * s->uvlinesize - 8,
s->uvlinesize);
s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
s->dest[2] - 8 * s->uvlinesize - 8,
s->uvlinesize);
}
if (s->mb_x == s->mb_width - 1) {
s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
s->dest[0] - 16 * s->linesize,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
s->dest[0] - 16 * s->linesize + 8,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
s->dest[0] - 8 * s->linesize,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
s->dest[0] - 8 * s->linesize + 8,
s->linesize);
s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
s->dest[1] - 8 * s->uvlinesize,
s->uvlinesize);
s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
s->dest[2] - 8 * s->uvlinesize,
s->uvlinesize);
}
}
#define inc_blk_idx(idx) do { \
idx++; \
if (idx >= v->n_allocated_blks) \
idx = 0; \
} while (0)
inc_blk_idx(v->topleft_blk_idx);
inc_blk_idx(v->top_blk_idx);
inc_blk_idx(v->left_blk_idx);
inc_blk_idx(v->cur_blk_idx);
}
static void vc1_loop_filter_iblk(VC1Context *v, int pq) static void vc1_loop_filter_iblk(VC1Context *v, int pq)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
@ -187,6 +253,151 @@ static void vc1_loop_filter_iblk(VC1Context *v, int pq)
} }
} }
static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
{
MpegEncContext *s = &v->s;
int j;
/* The loopfilter runs 1 row and 1 column behind the overlap filter, which
* means it runs two rows/cols behind the decoding loop. */
if (!s->first_slice_line) {
if (s->mb_x) {
if (s->mb_y >= s->start_mb_y + 2) {
v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
if (s->mb_x >= 2)
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
for(j = 0; j < 2; j++) {
v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
if (s->mb_x >= 2) {
v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
}
}
}
v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
}
if (s->mb_x == s->mb_width - 1) {
if (s->mb_y >= s->start_mb_y + 2) {
v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
if (s->mb_x)
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
for(j = 0; j < 2; j++) {
v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize, s->uvlinesize, pq);
if (s->mb_x >= 2) {
v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 16 * s->uvlinesize, s->uvlinesize, pq);
}
}
}
v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
}
if (s->mb_y == s->mb_height) {
if (s->mb_x) {
if (s->mb_x >= 2)
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
if (s->mb_x >= 2) {
for(j = 0; j < 2; j++) {
v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
}
}
}
if (s->mb_x == s->mb_width - 1) {
if (s->mb_x)
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
if (s->mb_x) {
for(j = 0; j < 2; j++) {
v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize, s->uvlinesize, pq);
}
}
}
}
}
}
static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
{
MpegEncContext *s = &v->s;
int mb_pos;
if (v->condover == CONDOVER_NONE)
return;
mb_pos = s->mb_x + s->mb_y * s->mb_stride;
/* Within a MB, the horizontal overlap always runs before the vertical.
* To accomplish that, we run the H on left and internal borders of the
* currently decoded MB. Then, we wait for the next overlap iteration
* to do H overlap on the right edge of this MB, before moving over and
* running the V overlap. Therefore, the V overlap makes us trail by one
* MB col and the H overlap filter makes us trail by one MB row. This
* is reflected in the time at which we run the put_pixels loop. */
if(v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
if(s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
v->over_flags_plane[mb_pos - 1])) {
v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
v->block[v->cur_blk_idx][0]);
v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
v->block[v->cur_blk_idx][2]);
if(!(s->flags & CODEC_FLAG_GRAY)) {
v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
v->block[v->cur_blk_idx][4]);
v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
v->block[v->cur_blk_idx][5]);
}
}
v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
v->block[v->cur_blk_idx][1]);
v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
v->block[v->cur_blk_idx][3]);
if (s->mb_x == s->mb_width - 1) {
if(!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
v->over_flags_plane[mb_pos - s->mb_stride])) {
v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
v->block[v->cur_blk_idx][0]);
v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
v->block[v->cur_blk_idx][1]);
if(!(s->flags & CODEC_FLAG_GRAY)) {
v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
v->block[v->cur_blk_idx][4]);
v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
v->block[v->cur_blk_idx][5]);
}
}
v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
v->block[v->cur_blk_idx][2]);
v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
v->block[v->cur_blk_idx][3]);
}
}
if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
if(!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
v->block[v->left_blk_idx][0]);
v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
v->block[v->left_blk_idx][1]);
if(!(s->flags & CODEC_FLAG_GRAY)) {
v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
v->block[v->left_blk_idx][4]);
v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
v->block[v->left_blk_idx][5]);
}
}
v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
v->block[v->left_blk_idx][2]);
v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
v->block[v->left_blk_idx][3]);
}
}
/** Do motion compensation over 1 macroblock /** Do motion compensation over 1 macroblock
* Mostly adapted hpel_motion and qpel_motion from mpegvideo.c * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
*/ */
@ -2016,7 +2227,8 @@ static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquan
if(i==1) if(i==1)
v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block); v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
else{ else{
v->vc1dsp.vc1_inv_trans_8x8_add(dst, linesize, block); v->vc1dsp.vc1_inv_trans_8x8(block);
s->dsp.add_pixels_clamped(block, dst, linesize);
} }
} }
break; break;
@ -2258,7 +2470,7 @@ static int vc1_decode_p_mb(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
int i; int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp; /* cbp decoding stuff */ int cbp; /* cbp decoding stuff */
int mqdiff, mquant; /* MB quantization */ int mqdiff, mquant; /* MB quantization */
@ -2288,8 +2500,6 @@ static int vc1_decode_p_mb(VC1Context *v)
{ {
if (!skipped) if (!skipped)
{ {
vc1_idct_func idct8x8_fn;
GET_MVDATA(dmv_x, dmv_y); GET_MVDATA(dmv_x, dmv_y);
if (s->mb_intra) { if (s->mb_intra) {
@ -2324,7 +2534,6 @@ static int vc1_decode_p_mb(VC1Context *v)
VC1_TTMB_VLC_BITS, 2); VC1_TTMB_VLC_BITS, 2);
if(!s->mb_intra) vc1_mc_1mv(v, 0); if(!s->mb_intra) vc1_mc_1mv(v, 0);
dst_idx = 0; dst_idx = 0;
idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
for (i=0; i<6; i++) for (i=0; i<6; i++)
{ {
s->dc_val[0][s->block_index[i]] = 0; s->dc_val[0][s->block_index[i]] = 0;
@ -2342,9 +2551,9 @@ static int vc1_decode_p_mb(VC1Context *v)
vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset); vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
idct8x8_fn(s->dest[dst_idx] + off, v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
i & 4 ? s->uvlinesize : s->linesize, if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
s->block[i]); s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
if(v->pq >= 9 && v->overlap) { if(v->pq >= 9 && v->overlap) {
if(v->c_avail) if(v->c_avail)
v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize); v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
@ -2380,7 +2589,6 @@ static int vc1_decode_p_mb(VC1Context *v)
{ {
int intra_count = 0, coded_inter = 0; int intra_count = 0, coded_inter = 0;
int is_intra[6], is_coded[6]; int is_intra[6], is_coded[6];
vc1_idct_func idct8x8_fn;
/* Get CBPCY */ /* Get CBPCY */
cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2); cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
for (i=0; i<6; i++) for (i=0; i<6; i++)
@ -2431,7 +2639,6 @@ static int vc1_decode_p_mb(VC1Context *v)
} }
if (!v->ttmbf && coded_inter) if (!v->ttmbf && coded_inter)
ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2); ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
for (i=0; i<6; i++) for (i=0; i<6; i++)
{ {
dst_idx += i >> 2; dst_idx += i >> 2;
@ -2447,9 +2654,9 @@ static int vc1_decode_p_mb(VC1Context *v)
vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset); vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
idct8x8_fn(s->dest[dst_idx] + off, v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
(i&4)?s->uvlinesize:s->linesize, if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
s->block[i]); s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
if(v->pq >= 9 && v->overlap) { if(v->pq >= 9 && v->overlap) {
if(v->c_avail) if(v->c_avail)
v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize); v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
@ -2497,7 +2704,7 @@ static void vc1_decode_b_mb(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
int i; int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */ int cbp = 0; /* cbp decoding stuff */
int mqdiff, mquant; /* MB quantization */ int mqdiff, mquant; /* MB quantization */
@ -2510,7 +2717,6 @@ static void vc1_decode_b_mb(VC1Context *v)
int skipped, direct; int skipped, direct;
int dmv_x[2], dmv_y[2]; int dmv_x[2], dmv_y[2];
int bmvtype = BMV_TYPE_BACKWARD; int bmvtype = BMV_TYPE_BACKWARD;
vc1_idct_func idct8x8_fn;
mquant = v->pq; /* Loosy initialization */ mquant = v->pq; /* Loosy initialization */
s->mb_intra = 0; s->mb_intra = 0;
@ -2608,7 +2814,6 @@ static void vc1_decode_b_mb(VC1Context *v)
} }
} }
dst_idx = 0; dst_idx = 0;
idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
for (i=0; i<6; i++) for (i=0; i<6; i++)
{ {
s->dc_val[0][s->block_index[i]] = 0; s->dc_val[0][s->block_index[i]] = 0;
@ -2626,9 +2831,9 @@ static void vc1_decode_b_mb(VC1Context *v)
vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset); vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue; if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
idct8x8_fn(s->dest[dst_idx] + off, v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
i & 4 ? s->uvlinesize : s->linesize, if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
s->block[i]); s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
} else if(val) { } else if(val) {
vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), NULL); vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), NULL);
if(!v->ttmbf && ttmb < 8) ttmb = -1; if(!v->ttmbf && ttmb < 8) ttmb = -1;
@ -2641,12 +2846,11 @@ static void vc1_decode_b_mb(VC1Context *v)
*/ */
static void vc1_decode_i_blocks(VC1Context *v) static void vc1_decode_i_blocks(VC1Context *v)
{ {
int k; int k, j;
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
int cbp, val; int cbp, val;
uint8_t *coded_val; uint8_t *coded_val;
int mb_pos; int mb_pos;
vc1_idct_func idct8x8_fn;
/* select codingmode used for VLC tables selection */ /* select codingmode used for VLC tables selection */
switch(v->y_ac_table_index){ switch(v->y_ac_table_index){
@ -2681,10 +2885,6 @@ static void vc1_decode_i_blocks(VC1Context *v)
s->mb_x = s->mb_y = 0; s->mb_x = s->mb_y = 0;
s->mb_intra = 1; s->mb_intra = 1;
s->first_slice_line = 1; s->first_slice_line = 1;
if(v->pq >= 9 && v->overlap) {
idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
} else
idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put[!!v->rangeredfrm];
for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) { for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
s->mb_x = 0; s->mb_x = 0;
ff_init_block_index(s); ff_init_block_index(s);
@ -2721,9 +2921,14 @@ static void vc1_decode_i_blocks(VC1Context *v)
vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2); vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue; if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
idct8x8_fn(dst[k], v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
k & 4 ? s->uvlinesize : s->linesize, if(v->pq >= 9 && v->overlap) {
s->block[k]); if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] <<= 1;
s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
} else {
if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] = (s->block[k][j] - 64) << 1;
s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
}
} }
if(v->pq >= 9 && v->overlap) { if(v->pq >= 9 && v->overlap) {
@ -2770,7 +2975,7 @@ static void vc1_decode_i_blocks(VC1Context *v)
/** Decode blocks of I-frame for advanced profile /** Decode blocks of I-frame for advanced profile
*/ */
static void vc1_decode_i_blocks_adv(VC1Context *v, int mby_start, int mby_end) static void vc1_decode_i_blocks_adv(VC1Context *v)
{ {
int k; int k;
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
@ -2779,9 +2984,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v, int mby_start, int mby_end)
int mb_pos; int mb_pos;
int mquant = v->pq; int mquant = v->pq;
int mqdiff; int mqdiff;
int overlap;
GetBitContext *gb = &s->gb; GetBitContext *gb = &s->gb;
vc1_idct_func idct8x8_fn;
/* select codingmode used for VLC tables selection */ /* select codingmode used for VLC tables selection */
switch(v->y_ac_table_index){ switch(v->y_ac_table_index){
@ -2812,27 +3015,20 @@ static void vc1_decode_i_blocks_adv(VC1Context *v, int mby_start, int mby_end)
s->mb_x = s->mb_y = 0; s->mb_x = s->mb_y = 0;
s->mb_intra = 1; s->mb_intra = 1;
s->first_slice_line = 1; s->first_slice_line = 1;
s->mb_y = mby_start; s->mb_y = s->start_mb_y;
if (mby_start) { if (s->start_mb_y) {
s->mb_x = 0; s->mb_x = 0;
ff_init_block_index(s); ff_init_block_index(s);
memset(&s->coded_block[s->block_index[0]-s->b8_stride], 0, memset(&s->coded_block[s->block_index[0]-s->b8_stride], 0,
s->b8_stride * sizeof(*s->coded_block)); s->b8_stride * sizeof(*s->coded_block));
} }
idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[0]; for(; s->mb_y < s->end_mb_y; s->mb_y++) {
for(; s->mb_y < mby_end; s->mb_y++) {
s->mb_x = 0; s->mb_x = 0;
ff_init_block_index(s); ff_init_block_index(s);
for(;s->mb_x < s->mb_width; s->mb_x++) { for(;s->mb_x < s->mb_width; s->mb_x++) {
uint8_t *dst[6]; DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
ff_update_block_index(s); ff_update_block_index(s);
dst[0] = s->dest[0]; s->dsp.clear_blocks(block[0]);
dst[1] = dst[0] + 8;
dst[2] = s->dest[0] + s->linesize * 8;
dst[3] = dst[2] + 8;
dst[4] = s->dest[1];
dst[5] = s->dest[2];
s->dsp.clear_blocks(s->block[0]);
mb_pos = s->mb_x + s->mb_y * s->mb_stride; mb_pos = s->mb_x + s->mb_y * s->mb_stride;
s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA; s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
s->current_picture.motion_val[1][s->block_index[0]][0] = 0; s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
@ -2845,13 +3041,8 @@ static void vc1_decode_i_blocks_adv(VC1Context *v, int mby_start, int mby_end)
else else
v->s.ac_pred = v->acpred_plane[mb_pos]; v->s.ac_pred = v->acpred_plane[mb_pos];
if(v->condover == CONDOVER_SELECT) { if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
if(v->overflg_is_raw) v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
overlap = get_bits1(&v->s.gb);
else
overlap = v->over_flags_plane[mb_pos];
} else
overlap = (v->condover == CONDOVER_ALL);
GET_MQUANT(); GET_MQUANT();
@ -2873,40 +3064,18 @@ static void vc1_decode_i_blocks_adv(VC1Context *v, int mby_start, int mby_end)
v->a_avail = !s->first_slice_line || (k==2 || k==3); v->a_avail = !s->first_slice_line || (k==2 || k==3);
v->c_avail = !!s->mb_x || (k==1 || k==3); v->c_avail = !!s->mb_x || (k==1 || k==3);
vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant); vc1_decode_i_block_adv(v, block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue; if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
idct8x8_fn(dst[k], v->vc1dsp.vc1_inv_trans_8x8(block[k]);
k & 4 ? s->uvlinesize : s->linesize,
s->block[k]);
} }
if(overlap) { vc1_smooth_overlap_filter_iblk(v);
if(s->mb_x) { vc1_put_signed_blocks_clamped(v);
v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize); if(v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
if(!(s->flags & CODEC_FLAG_GRAY)) {
v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
}
}
v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
if(!s->first_slice_line) {
v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
if(!(s->flags & CODEC_FLAG_GRAY)) {
v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
}
}
v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
}
if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
if(get_bits_count(&s->gb) > v->bits) { if(get_bits_count(&s->gb) > v->bits) {
ff_er_add_slice(s, 0, mby_start, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)); ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits); av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
return; return;
} }
@ -2917,12 +3086,21 @@ static void vc1_decode_i_blocks_adv(VC1Context *v, int mby_start, int mby_end)
ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16); ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
s->first_slice_line = 0; s->first_slice_line = 0;
} }
/* raw bottom MB row */
s->mb_x = 0;
ff_init_block_index(s);
for(;s->mb_x < s->mb_width; s->mb_x++) {
ff_update_block_index(s);
vc1_put_signed_blocks_clamped(v);
if(v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
}
if (v->s.loop_filter) if (v->s.loop_filter)
ff_draw_horiz_band(s, (s->mb_height-1)*16, 16); ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
ff_er_add_slice(s, 0, mby_start, s->mb_width - 1, mby_end - 1, (AC_END|DC_END|MV_END)); ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
} }
static void vc1_decode_p_blocks(VC1Context *v, int mby_start, int mby_end) static void vc1_decode_p_blocks(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
int apply_loop_filter; int apply_loop_filter;
@ -2955,17 +3133,17 @@ static void vc1_decode_p_blocks(VC1Context *v, int mby_start, int mby_end)
apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY); apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
s->first_slice_line = 1; s->first_slice_line = 1;
memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride); memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
for(s->mb_y = mby_start; s->mb_y < mby_end; s->mb_y++) { for(s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
s->mb_x = 0; s->mb_x = 0;
ff_init_block_index(s); ff_init_block_index(s);
for(; s->mb_x < s->mb_width; s->mb_x++) { for(; s->mb_x < s->mb_width; s->mb_x++) {
ff_update_block_index(s); ff_update_block_index(s);
vc1_decode_p_mb(v); vc1_decode_p_mb(v);
if (s->mb_y != mby_start && apply_loop_filter) if (s->mb_y != s->start_mb_y && apply_loop_filter)
vc1_apply_p_loop_filter(v); vc1_apply_p_loop_filter(v);
if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) { if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
ff_er_add_slice(s, 0, mby_start, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)); ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y); av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
return; return;
} }
@ -2974,7 +3152,7 @@ static void vc1_decode_p_blocks(VC1Context *v, int mby_start, int mby_end)
memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0])*s->mb_stride); memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0])*s->mb_stride);
memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride); memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0])*s->mb_stride); memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0])*s->mb_stride);
if (s->mb_y != mby_start) ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16); if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
s->first_slice_line = 0; s->first_slice_line = 0;
} }
if (apply_loop_filter) { if (apply_loop_filter) {
@ -2985,12 +3163,12 @@ static void vc1_decode_p_blocks(VC1Context *v, int mby_start, int mby_end)
vc1_apply_p_loop_filter(v); vc1_apply_p_loop_filter(v);
} }
} }
if (mby_end >= mby_start) if (s->end_mb_y >= s->start_mb_y)
ff_draw_horiz_band(s, (mby_end-1) * 16, 16); ff_draw_horiz_band(s, (s->end_mb_y-1) * 16, 16);
ff_er_add_slice(s, 0, mby_start, s->mb_width - 1, mby_end - 1, (AC_END|DC_END|MV_END)); ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
} }
static void vc1_decode_b_blocks(VC1Context *v, int mby_start, int mby_end) static void vc1_decode_b_blocks(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
@ -3020,7 +3198,7 @@ static void vc1_decode_b_blocks(VC1Context *v, int mby_start, int mby_end)
} }
s->first_slice_line = 1; s->first_slice_line = 1;
for(s->mb_y = mby_start; s->mb_y < mby_end; s->mb_y++) { for(s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
s->mb_x = 0; s->mb_x = 0;
ff_init_block_index(s); ff_init_block_index(s);
for(; s->mb_x < s->mb_width; s->mb_x++) { for(; s->mb_x < s->mb_width; s->mb_x++) {
@ -3028,7 +3206,7 @@ static void vc1_decode_b_blocks(VC1Context *v, int mby_start, int mby_end)
vc1_decode_b_mb(v); vc1_decode_b_mb(v);
if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) { if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
ff_er_add_slice(s, 0, mby_start, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)); ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y); av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
return; return;
} }
@ -3042,7 +3220,7 @@ static void vc1_decode_b_blocks(VC1Context *v, int mby_start, int mby_end)
} }
if (v->s.loop_filter) if (v->s.loop_filter)
ff_draw_horiz_band(s, (s->mb_height-1)*16, 16); ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
ff_er_add_slice(s, 0, mby_start, s->mb_width - 1, mby_end - 1, (AC_END|DC_END|MV_END)); ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
} }
static void vc1_decode_skip_blocks(VC1Context *v) static void vc1_decode_skip_blocks(VC1Context *v)
@ -3064,17 +3242,21 @@ static void vc1_decode_skip_blocks(VC1Context *v)
s->pict_type = AV_PICTURE_TYPE_P; s->pict_type = AV_PICTURE_TYPE_P;
} }
static void vc1_decode_blocks(VC1Context *v, int mby_start, int mby_end) static void vc1_decode_blocks(VC1Context *v)
{ {
v->s.esc3_level_length = 0; v->s.esc3_level_length = 0;
if(v->x8_type){ if(v->x8_type){
ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) ); ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) );
}else{ }else{
v->cur_blk_idx = 0;
v->left_blk_idx = -1;
v->topleft_blk_idx = 1;
v->top_blk_idx = 2;
switch(v->s.pict_type) { switch(v->s.pict_type) {
case AV_PICTURE_TYPE_I: case AV_PICTURE_TYPE_I:
if(v->profile == PROFILE_ADVANCED) if(v->profile == PROFILE_ADVANCED)
vc1_decode_i_blocks_adv(v, mby_start, mby_end); vc1_decode_i_blocks_adv(v);
else else
vc1_decode_i_blocks(v); vc1_decode_i_blocks(v);
break; break;
@ -3082,16 +3264,16 @@ static void vc1_decode_blocks(VC1Context *v, int mby_start, int mby_end)
if(v->p_frame_skipped) if(v->p_frame_skipped)
vc1_decode_skip_blocks(v); vc1_decode_skip_blocks(v);
else else
vc1_decode_p_blocks(v, mby_start, mby_end); vc1_decode_p_blocks(v);
break; break;
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
if(v->bi_type){ if(v->bi_type){
if(v->profile == PROFILE_ADVANCED) if(v->profile == PROFILE_ADVANCED)
vc1_decode_i_blocks_adv(v, mby_start, mby_end); vc1_decode_i_blocks_adv(v);
else else
vc1_decode_i_blocks(v); vc1_decode_i_blocks(v);
}else }else
vc1_decode_b_blocks(v, mby_start, mby_end); vc1_decode_b_blocks(v);
break; break;
} }
} }
@ -3341,6 +3523,8 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx)
v->acpred_plane = av_malloc(s->mb_stride * s->mb_height); v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height); v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
v->n_allocated_blks = s->mb_width + 2;
v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride); v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
v->cbp = v->cbp_base + s->mb_stride; v->cbp = v->cbp_base + s->mb_stride;
v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride); v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
@ -3556,8 +3740,9 @@ static int vc1_decode_frame(AVCodecContext *avctx,
for (i = 0; i <= n_slices; i++) { for (i = 0; i <= n_slices; i++) {
if (i && get_bits1(&s->gb)) if (i && get_bits1(&s->gb))
vc1_parse_frame_header_adv(v, &s->gb); vc1_parse_frame_header_adv(v, &s->gb);
vc1_decode_blocks(v, i == 0 ? 0 : FFMAX(0, slices[i-1].mby_start), s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start);
i == n_slices ? s->mb_height : FFMIN(s->mb_height, slices[i].mby_start)); s->end_mb_y = (i == n_slices) ? s->mb_height : FFMIN(s->mb_height, slices[i].mby_start);
vc1_decode_blocks(v);
if (i != n_slices) s->gb = slices[i].gb; if (i != n_slices) s->gb = slices[i].gb;
} }
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits); //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
@ -3614,6 +3799,7 @@ static av_cold int vc1_decode_end(AVCodecContext *avctx)
av_freep(&v->acpred_plane); av_freep(&v->acpred_plane);
av_freep(&v->over_flags_plane); av_freep(&v->over_flags_plane);
av_freep(&v->mb_type_base); av_freep(&v->mb_type_base);
av_freep(&v->block);
av_freep(&v->cbp_base); av_freep(&v->cbp_base);
av_freep(&v->ttblk_base); av_freep(&v->ttblk_base);
av_freep(&v->is_intra_base); // FIXME use v->mb_type[] av_freep(&v->is_intra_base); // FIXME use v->mb_type[]

108
libavcodec/vc1dsp.c
View File

@ -78,6 +78,58 @@ static void vc1_h_overlap_c(uint8_t* src, int stride)
} }
} }
static void vc1_v_s_overlap_c(DCTELEM *top, DCTELEM *bottom)
{
int i;
int a, b, c, d;
int d1, d2;
int rnd1 = 4, rnd2 = 3;
for(i = 0; i < 8; i++) {
a = top[48];
b = top[56];
c = bottom[0];
d = bottom[8];
d1 = a - d;
d2 = a - d + b - c;
top[48] = ((a << 3) - d1 + rnd1) >> 3;
top[56] = ((b << 3) - d2 + rnd2) >> 3;
bottom[0] = ((c << 3) + d2 + rnd1) >> 3;
bottom[8] = ((d << 3) + d1 + rnd2) >> 3;
bottom++;
top++;
rnd2 = 7 - rnd2;
rnd1 = 7 - rnd1;
}
}
static void vc1_h_s_overlap_c(DCTELEM *left, DCTELEM *right)
{
int i;
int a, b, c, d;
int d1, d2;
int rnd1 = 4, rnd2 = 3;
for(i = 0; i < 8; i++) {
a = left[6];
b = left[7];
c = right[0];
d = right[1];
d1 = a - d;
d2 = a - d + b - c;
left[6] = ((a << 3) - d1 + rnd1) >> 3;
left[7] = ((b << 3) - d2 + rnd2) >> 3;
right[0] = ((c << 3) + d2 + rnd1) >> 3;
right[1] = ((d << 3) + d1 + rnd2) >> 3;
right += 8;
left += 8;
rnd2 = 7 - rnd2;
rnd1 = 7 - rnd1;
}
}
/** /**
* VC-1 in-loop deblocking filter for one line * VC-1 in-loop deblocking filter for one line
* @param src source block type * @param src source block type
@ -199,7 +251,7 @@ static void vc1_inv_trans_8x8_dc_c(uint8_t *dest, int linesize, DCTELEM *block)
} }
} }
static av_always_inline void vc1_inv_trans_8x8_c(DCTELEM block[64], int shl, int sub) static void vc1_inv_trans_8x8_c(DCTELEM block[64])
{ {
int i; int i;
register int t1,t2,t3,t4,t5,t6,t7,t8; register int t1,t2,t3,t4,t5,t6,t7,t8;
@ -254,50 +306,20 @@ static av_always_inline void vc1_inv_trans_8x8_c(DCTELEM block[64], int shl, int
t3 = 9 * src[ 8] - 16 * src[24] + 4 * src[40] + 15 * src[56]; t3 = 9 * src[ 8] - 16 * src[24] + 4 * src[40] + 15 * src[56];
t4 = 4 * src[ 8] - 9 * src[24] + 15 * src[40] - 16 * src[56]; t4 = 4 * src[ 8] - 9 * src[24] + 15 * src[40] - 16 * src[56];
dst[ 0] = (((t5 + t1 ) >> 7) - sub) << shl; dst[ 0] = (t5 + t1) >> 7;
dst[ 8] = (((t6 + t2 ) >> 7) - sub) << shl; dst[ 8] = (t6 + t2) >> 7;
dst[16] = (((t7 + t3 ) >> 7) - sub) << shl; dst[16] = (t7 + t3) >> 7;
dst[24] = (((t8 + t4 ) >> 7) - sub) << shl; dst[24] = (t8 + t4) >> 7;
dst[32] = (((t8 - t4 + 1) >> 7) - sub) << shl; dst[32] = (t8 - t4 + 1) >> 7;
dst[40] = (((t7 - t3 + 1) >> 7) - sub) << shl; dst[40] = (t7 - t3 + 1) >> 7;
dst[48] = (((t6 - t2 + 1) >> 7) - sub) << shl; dst[48] = (t6 - t2 + 1) >> 7;
dst[56] = (((t5 - t1 + 1) >> 7) - sub) << shl; dst[56] = (t5 - t1 + 1) >> 7;
src++; src++;
dst++; dst++;
} }
} }
static void vc1_inv_trans_8x8_add_c(uint8_t *dest, int linesize, DCTELEM *block)
{
vc1_inv_trans_8x8_c(block, 0, 0);
ff_add_pixels_clamped_c(block, dest, linesize);
}
static void vc1_inv_trans_8x8_put_signed_c(uint8_t *dest, int linesize, DCTELEM *block)
{
vc1_inv_trans_8x8_c(block, 0, 0);
ff_put_signed_pixels_clamped_c(block, dest, linesize);
}
static void vc1_inv_trans_8x8_put_signed_rangered_c(uint8_t *dest, int linesize, DCTELEM *block)
{
vc1_inv_trans_8x8_c(block, 1, 0);
ff_put_signed_pixels_clamped_c(block, dest, linesize);
}
static void vc1_inv_trans_8x8_put_c(uint8_t *dest, int linesize, DCTELEM *block)
{
vc1_inv_trans_8x8_c(block, 0, 0);
ff_put_pixels_clamped_c(block, dest, linesize);
}
static void vc1_inv_trans_8x8_put_rangered_c(uint8_t *dest, int linesize, DCTELEM *block)
{
vc1_inv_trans_8x8_c(block, 1, 64);
ff_put_pixels_clamped_c(block, dest, linesize);
}
/** Do inverse transform on 8x4 part of block /** Do inverse transform on 8x4 part of block
*/ */
static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, int linesize, DCTELEM *block) static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, int linesize, DCTELEM *block)
@ -692,11 +714,7 @@ static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*a
} }
av_cold void ff_vc1dsp_init(VC1DSPContext* dsp) { av_cold void ff_vc1dsp_init(VC1DSPContext* dsp) {
dsp->vc1_inv_trans_8x8_add = vc1_inv_trans_8x8_add_c; dsp->vc1_inv_trans_8x8 = vc1_inv_trans_8x8_c;
dsp->vc1_inv_trans_8x8_put_signed[0] = vc1_inv_trans_8x8_put_signed_c;
dsp->vc1_inv_trans_8x8_put_signed[1] = vc1_inv_trans_8x8_put_signed_rangered_c;
dsp->vc1_inv_trans_8x8_put[0] = vc1_inv_trans_8x8_put_c;
dsp->vc1_inv_trans_8x8_put[1] = vc1_inv_trans_8x8_put_rangered_c;
dsp->vc1_inv_trans_4x8 = vc1_inv_trans_4x8_c; dsp->vc1_inv_trans_4x8 = vc1_inv_trans_4x8_c;
dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_c; dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_c;
dsp->vc1_inv_trans_4x4 = vc1_inv_trans_4x4_c; dsp->vc1_inv_trans_4x4 = vc1_inv_trans_4x4_c;
@ -706,6 +724,8 @@ av_cold void ff_vc1dsp_init(VC1DSPContext* dsp) {
dsp->vc1_inv_trans_4x4_dc = vc1_inv_trans_4x4_dc_c; dsp->vc1_inv_trans_4x4_dc = vc1_inv_trans_4x4_dc_c;
dsp->vc1_h_overlap = vc1_h_overlap_c; dsp->vc1_h_overlap = vc1_h_overlap_c;
dsp->vc1_v_overlap = vc1_v_overlap_c; dsp->vc1_v_overlap = vc1_v_overlap_c;
dsp->vc1_h_s_overlap = vc1_h_s_overlap_c;
dsp->vc1_v_s_overlap = vc1_v_s_overlap_c;
dsp->vc1_v_loop_filter4 = vc1_v_loop_filter4_c; dsp->vc1_v_loop_filter4 = vc1_v_loop_filter4_c;
dsp->vc1_h_loop_filter4 = vc1_h_loop_filter4_c; dsp->vc1_h_loop_filter4 = vc1_h_loop_filter4_c;
dsp->vc1_v_loop_filter8 = vc1_v_loop_filter8_c; dsp->vc1_v_loop_filter8 = vc1_v_loop_filter8_c;

12
libavcodec/vc1dsp.h
View File

@ -30,13 +30,9 @@
#include "dsputil.h" #include "dsputil.h"
typedef void (*vc1_idct_func)(uint8_t *dest, int line_size, DCTELEM *block);
typedef struct VC1DSPContext { typedef struct VC1DSPContext {
/* vc1 functions */ /* vc1 functions */
vc1_idct_func vc1_inv_trans_8x8_add; void (*vc1_inv_trans_8x8)(DCTELEM *b);
vc1_idct_func vc1_inv_trans_8x8_put_signed[2];
vc1_idct_func vc1_inv_trans_8x8_put[2];
void (*vc1_inv_trans_8x4)(uint8_t *dest, int line_size, DCTELEM *block); void (*vc1_inv_trans_8x4)(uint8_t *dest, int line_size, DCTELEM *block);
void (*vc1_inv_trans_4x8)(uint8_t *dest, int line_size, DCTELEM *block); void (*vc1_inv_trans_4x8)(uint8_t *dest, int line_size, DCTELEM *block);
void (*vc1_inv_trans_4x4)(uint8_t *dest, int line_size, DCTELEM *block); void (*vc1_inv_trans_4x4)(uint8_t *dest, int line_size, DCTELEM *block);
@ -44,8 +40,10 @@ typedef struct VC1DSPContext {
void (*vc1_inv_trans_8x4_dc)(uint8_t *dest, int line_size, DCTELEM *block); void (*vc1_inv_trans_8x4_dc)(uint8_t *dest, int line_size, DCTELEM *block);
void (*vc1_inv_trans_4x8_dc)(uint8_t *dest, int line_size, DCTELEM *block); void (*vc1_inv_trans_4x8_dc)(uint8_t *dest, int line_size, DCTELEM *block);
void (*vc1_inv_trans_4x4_dc)(uint8_t *dest, int line_size, DCTELEM *block); void (*vc1_inv_trans_4x4_dc)(uint8_t *dest, int line_size, DCTELEM *block);
void (*vc1_v_overlap)(uint8_t* src, int stride); void (*vc1_v_overlap)(uint8_t *src, int stride);
void (*vc1_h_overlap)(uint8_t* src, int stride); void (*vc1_h_overlap)(uint8_t *src, int stride);
void (*vc1_v_s_overlap)(DCTELEM *top, DCTELEM *bottom);
void (*vc1_h_s_overlap)(DCTELEM *left, DCTELEM *right);
void (*vc1_v_loop_filter4)(uint8_t *src, int stride, int pq); void (*vc1_v_loop_filter4)(uint8_t *src, int stride, int pq);
void (*vc1_h_loop_filter4)(uint8_t *src, int stride, int pq); void (*vc1_h_loop_filter4)(uint8_t *src, int stride, int pq);
void (*vc1_v_loop_filter8)(uint8_t *src, int stride, int pq); void (*vc1_v_loop_filter8)(uint8_t *src, int stride, int pq);

27
libavfilter/avfilter.c
View File

@ -585,28 +585,53 @@ int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *in
return AVERROR(EINVAL); return AVERROR(EINVAL);
ret = av_mallocz(sizeof(AVFilterContext)); ret = av_mallocz(sizeof(AVFilterContext));
if (!ret)
return AVERROR(ENOMEM);
ret->av_class = &avfilter_class; ret->av_class = &avfilter_class;
ret->filter = filter; ret->filter = filter;
ret->name = inst_name ? av_strdup(inst_name) : NULL; ret->name = inst_name ? av_strdup(inst_name) : NULL;
ret->priv = av_mallocz(filter->priv_size); if (filter->priv_size) {
ret->priv = av_mallocz(filter->priv_size);
if (!ret->priv)
goto err;
}
ret->input_count = pad_count(filter->inputs); ret->input_count = pad_count(filter->inputs);
if (ret->input_count) { if (ret->input_count) {
ret->input_pads = av_malloc(sizeof(AVFilterPad) * ret->input_count); ret->input_pads = av_malloc(sizeof(AVFilterPad) * ret->input_count);
if (!ret->input_pads)
goto err;
memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->input_count); memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->input_count);
ret->inputs = av_mallocz(sizeof(AVFilterLink*) * ret->input_count); ret->inputs = av_mallocz(sizeof(AVFilterLink*) * ret->input_count);
if (!ret->inputs)
goto err;
} }
ret->output_count = pad_count(filter->outputs); ret->output_count = pad_count(filter->outputs);
if (ret->output_count) { if (ret->output_count) {
ret->output_pads = av_malloc(sizeof(AVFilterPad) * ret->output_count); ret->output_pads = av_malloc(sizeof(AVFilterPad) * ret->output_count);
if (!ret->output_pads)
goto err;
memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->output_count); memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->output_count);
ret->outputs = av_mallocz(sizeof(AVFilterLink*) * ret->output_count); ret->outputs = av_mallocz(sizeof(AVFilterLink*) * ret->output_count);
if (!ret->outputs)
goto err;
} }
*filter_ctx = ret; *filter_ctx = ret;
return 0; return 0;
err:
av_freep(&ret->inputs);
av_freep(&ret->input_pads);
ret->input_count = 0;
av_freep(&ret->outputs);
av_freep(&ret->output_pads);
ret->output_count = 0;
av_freep(&ret->priv);
av_free(ret);
return AVERROR(ENOMEM);
} }
void avfilter_free(AVFilterContext *filter) void avfilter_free(AVFilterContext *filter)

3
libavformat/Makefile
View File

@ -299,7 +299,8 @@ OBJS-$(CONFIG_WEBM_MUXER) += matroskaenc.o matroska.o \
flacenc_header.o avlanguage.o flacenc_header.o avlanguage.o
OBJS-$(CONFIG_WSAUD_DEMUXER) += westwood.o OBJS-$(CONFIG_WSAUD_DEMUXER) += westwood.o
OBJS-$(CONFIG_WSVQA_DEMUXER) += westwood.o OBJS-$(CONFIG_WSVQA_DEMUXER) += westwood.o
OBJS-$(CONFIG_WTV_DEMUXER) += wtvdec.o wtv.o asf.o asfdec.o mpegts.o riff.o OBJS-$(CONFIG_WTV_DEMUXER) += wtvdec.o wtv.o asfdec.o asf.o asfcrypt.o \
avlanguage.o mpegts.o isom.o riff.o
OBJS-$(CONFIG_WV_DEMUXER) += wv.o apetag.o OBJS-$(CONFIG_WV_DEMUXER) += wv.o apetag.o
OBJS-$(CONFIG_XA_DEMUXER) += xa.o OBJS-$(CONFIG_XA_DEMUXER) += xa.o
OBJS-$(CONFIG_XWMA_DEMUXER) += xwma.o riff.o OBJS-$(CONFIG_XWMA_DEMUXER) += xwma.o riff.o

14
libavformat/asfdec.c
View File

@ -845,11 +845,21 @@ static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
if (asf->packet_flags & 0x01) { if (asf->packet_flags & 0x01) {
DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal
if(asf->packet_frag_size > asf->packet_size_left - rsize){ if(asf->packet_frag_size > asf->packet_size_left - rsize){
av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid\n"); if (asf->packet_frag_size > asf->packet_size_left - rsize + asf->packet_padsize) {
return -1; av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid (%d-%d)\n", asf->packet_size_left, rsize);
return -1;
} else {
int diff = asf->packet_frag_size - (asf->packet_size_left - rsize);
asf->packet_size_left += diff;
asf->packet_padsize -= diff;
}
} }
//printf("Fragsize %d\n", asf->packet_frag_size); //printf("Fragsize %d\n", asf->packet_frag_size);
} else { } else {
if (rsize > asf->packet_size_left) {
av_log(s, AV_LOG_ERROR, "packet_replic_size is invalid\n");
return -1;
}
asf->packet_frag_size = asf->packet_size_left - rsize; asf->packet_frag_size = asf->packet_size_left - rsize;
//printf("Using rest %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize); //printf("Using rest %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize);
} }

26
libavformat/file.c
View File

@ -51,6 +51,19 @@ static int file_get_handle(URLContext *h)
return (intptr_t) h->priv_data; return (intptr_t) h->priv_data;
} }
static int file_check(URLContext *h, int mask)
{
struct stat st;
int ret = stat(h->filename, &st);
if (ret < 0)
return AVERROR(errno);
ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ : 0;
ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0;
return ret;
}
#if CONFIG_FILE_PROTOCOL #if CONFIG_FILE_PROTOCOL
static int file_open(URLContext *h, const char *filename, int flags) static int file_open(URLContext *h, const char *filename, int flags)
@ -95,19 +108,6 @@ static int file_close(URLContext *h)
return close(fd); return close(fd);
} }
static int file_check(URLContext *h, int mask)
{
struct stat st;
int ret = stat(h->filename, &st);
if (ret < 0)
return AVERROR(errno);
ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ : 0;
ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0;
return ret;
}
URLProtocol ff_file_protocol = { URLProtocol ff_file_protocol = {
.name = "file", .name = "file",
.url_open = file_open, .url_open = file_open,

4
libavformat/matroskaenc.c
View File

@ -403,8 +403,6 @@ static int64_t mkv_write_cues(AVIOContext *pb, mkv_cues *cues, int num_tracks)
} }
end_ebml_master(pb, cues_element); end_ebml_master(pb, cues_element);
av_free(cues->entries);
av_free(cues);
return currentpos; return currentpos;
} }
@ -1164,6 +1162,8 @@ static int mkv_write_trailer(AVFormatContext *s)
end_ebml_master(pb, mkv->segment); end_ebml_master(pb, mkv->segment);
av_free(mkv->tracks); av_free(mkv->tracks);
av_freep(&mkv->cues->entries);
av_freep(&mkv->cues);
av_destruct_packet(&mkv->cur_audio_pkt); av_destruct_packet(&mkv->cur_audio_pkt);
avio_flush(pb); avio_flush(pb);
return 0; return 0;

2
libavformat/movenc.c
View File

@ -829,7 +829,7 @@ static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
memset(compressor_name,0,32); memset(compressor_name,0,32);
/* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */ /* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */
if (track->mode == MODE_MOV && track->enc->codec && track->enc->codec->name) if (track->mode == MODE_MOV && track->enc->codec && track->enc->codec->name)
strncpy(compressor_name,track->enc->codec->name,31); av_strlcpy(compressor_name,track->enc->codec->name,32);
avio_w8(pb, strlen(compressor_name)); avio_w8(pb, strlen(compressor_name));
avio_write(pb, compressor_name, 31); avio_write(pb, compressor_name, 31);

3
libavformat/mp3enc.c
View File

@ -24,6 +24,7 @@
#include "id3v1.h" #include "id3v1.h"
#include "id3v2.h" #include "id3v2.h"
#include "rawenc.h" #include "rawenc.h"
#include "libavutil/avstring.h"
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
#include "libavutil/opt.h" #include "libavutil/opt.h"
@ -32,7 +33,7 @@ static int id3v1_set_string(AVFormatContext *s, const char *key,
{ {
AVMetadataTag *tag; AVMetadataTag *tag;
if ((tag = av_metadata_get(s->metadata, key, NULL, 0))) if ((tag = av_metadata_get(s->metadata, key, NULL, 0)))
strncpy(buf, tag->value, buf_size); av_strlcpy(buf, tag->value, buf_size);
return !!tag; return !!tag;
} }

6
libavformat/nutenc.c
View File

@ -589,6 +589,12 @@ static int write_header(AVFormatContext *s){
nut->chapter = av_mallocz(sizeof(ChapterContext)*s->nb_chapters); nut->chapter = av_mallocz(sizeof(ChapterContext)*s->nb_chapters);
nut->time_base= av_mallocz(sizeof(AVRational )*(s->nb_streams + nut->time_base= av_mallocz(sizeof(AVRational )*(s->nb_streams +
s->nb_chapters)); s->nb_chapters));
if (!nut->stream || (s->nb_chapters && !nut->chapter) || !nut->time_base) {
av_freep(&nut->stream);
av_freep(&nut->chapter);
av_freep(&nut->time_base);
return AVERROR(ENOMEM);
}
for(i=0; i<s->nb_streams; i++){ for(i=0; i<s->nb_streams; i++){
AVStream *st= s->streams[i]; AVStream *st= s->streams[i];

3
libpostproc/postprocess.c
View File

@ -86,6 +86,7 @@ try to unroll inner for(x=0 ... loop to avoid these damn if(x ... checks
//#define DEBUG_BRIGHTNESS //#define DEBUG_BRIGHTNESS
#include "postprocess.h" #include "postprocess.h"
#include "postprocess_internal.h" #include "postprocess_internal.h"
#include "libavutil/avstring.h"
unsigned postproc_version(void) unsigned postproc_version(void)
{ {
@ -766,7 +767,7 @@ pp_mode *pp_get_mode_by_name_and_quality(const char *name, int quality)
ppMode->maxClippedThreshold= 0.01; ppMode->maxClippedThreshold= 0.01;
ppMode->error=0; ppMode->error=0;
strncpy(temp, name, GET_MODE_BUFFER_SIZE); av_strlcpy(temp, name, GET_MODE_BUFFER_SIZE);
av_log(NULL, AV_LOG_DEBUG, "pp: %s\n", name); av_log(NULL, AV_LOG_DEBUG, "pp: %s\n", name);

30
tests/ref/fate/vc1
View File

@ -1,15 +1,15 @@
0, 0, 38016, 0xf4715db5 0, 0, 38016, 0xa6f15db5
0, 3600, 38016, 0xf4715db5 0, 3600, 38016, 0xa6f15db5
0, 7200, 38016, 0xf4715db5 0, 7200, 38016, 0xa6f15db5
0, 10800, 38016, 0xf46af0e1 0, 10800, 38016, 0x5c4ef0e7
0, 14400, 38016, 0x9c1c2cf1 0, 14400, 38016, 0x53a42d1d
0, 18000, 38016, 0xff12d87f 0, 18000, 38016, 0x68f7d89e
0, 21600, 38016, 0x7408432b 0, 21600, 38016, 0xc15f4368
0, 25200, 38016, 0x7408432b 0, 25200, 38016, 0xc15f4368
0, 28800, 38016, 0x8d11479a 0, 28800, 38016, 0xd1bd47a8
0, 32400, 38016, 0x8d11479a 0, 32400, 38016, 0xd1bd47a8
0, 36000, 38016, 0xc4a121ab 0, 36000, 38016, 0xe1e821ca
0, 39600, 38016, 0xc4a121ab 0, 39600, 38016, 0xe1e821ca
0, 43200, 38016, 0xc4a121ab 0, 43200, 38016, 0xe1e821ca
0, 46800, 38016, 0xc4a121ab 0, 46800, 38016, 0xe1e821ca
0, 50400, 38016, 0xc4a121ab 0, 50400, 38016, 0xe1e821ca