From f815a2481a19cfd191b9f97e246b307b71d6c790 Mon Sep 17 00:00:00 2001
From: Adam Richter <adamrichter4@gmail.com>
Date: Sun, 12 May 2019 08:02:51 -0700
Subject: [PATCH] "assert(a && b)" --> "assert(a); assert(b)" for more
precise diagnostics, except for libformat.
This patch separates statements of the form "assert(a && b);" into
"assert(a);" and "assert(b);", for more precise diagnostics when
an assertion fails, which can be especially important in cases where
the problem may not be easily reproducible and save developer time.
Usually, this involves functions like av_assert0.
There are a couple of cases that this patch does not change:
(1) assert conjunctions of the form assert(condition && "string literal
to pass to the user as a helpful tip."), and
(2) assert condjunctions where the first part contained a variable
assignment that was used in the second part of the assertion and
not outside the assert (so that the variable assignment be elided
if the assertion checking omitted).
This patch covers all of ffmpeg except for libavformat, which was
covered in a patch that I previously submitted separately.
These changes build without any new complaints that I noticed, and
"make fate" succeeds, but I have not otherwise tested them.
Signed-off-by: Adam Richter <adamrichter4@gmail.com>
---
fftools/cmdutils.c | 3 +-
fftools/ffmpeg.c | 3 +-
libavcodec/4xm.c | 12 +++++---
libavcodec/aaccoder_twoloop.h | 3 +-
libavcodec/aacenc.c | 3 +-
libavcodec/aacenc_quantization_misc.h | 3 +-
libavcodec/aacpsy.c | 6 ++--
libavcodec/ac3enc.c | 15 ++++++----
libavcodec/acelp_filters.c | 3 +-
libavcodec/amfenc.c | 5 ++--
libavcodec/amrnbdec.c | 3 +-
libavcodec/av1_frame_split_bsf.c | 3 +-
libavcodec/avpacket.c | 3 +-
libavcodec/cbs.c | 42 ++++++++++++++++++---------
libavcodec/cbs_av1.c | 9 ++++--
libavcodec/cbs_av1_syntax_template.c | 3 +-
libavcodec/cbs_h2645.c | 10 ++++---
libavcodec/cbs_mpeg2.c | 4 +--
libavcodec/cbs_vp9.c | 8 +++--
libavcodec/celp_filters.c | 3 +-
libavcodec/dca_core.c | 3 +-
libavcodec/decode.c | 4 +--
libavcodec/dvdsubdec.c | 3 +-
libavcodec/dvenc.c | 3 +-
libavcodec/dxva2_h264.c | 3 +-
libavcodec/dxva2_hevc.c | 3 +-
libavcodec/dxva2_vp9.c | 3 +-
libavcodec/error_resilience.c | 3 +-
libavcodec/ffv1dec.c | 3 +-
libavcodec/flacenc.c | 6 ++--
libavcodec/get_bits.h | 35 +++++++++++++++-------
libavcodec/h263dec.c | 3 +-
libavcodec/h2645_parse.c | 6 ++--
libavcodec/h264_refs.c | 3 +-
libavcodec/h264_slice.c | 3 +-
libavcodec/h264chroma_template.c | 20 ++++++++++---
libavcodec/hevc_filter.c | 6 ++--
libavcodec/huffyuv.c | 3 +-
libavcodec/huffyuvenc.c | 5 +++-
libavcodec/ituh263enc.c | 3 +-
libavcodec/ivi.c | 4 ++-
libavcodec/jpeg2000dec.c | 3 +-
libavcodec/lclenc.c | 3 +-
libavcodec/lpc.c | 5 ++--
libavcodec/lzwenc.c | 9 ++++--
libavcodec/mips/h264chroma_msa.c | 31 +++++++++++++++-----
libavcodec/mips/vc1dsp_mmi.c | 20 ++++++++++---
libavcodec/mjpegdec.c | 11 ++++---
libavcodec/motion_est.c | 12 ++++++--
libavcodec/motion_est_template.c | 10 +++++--
libavcodec/mpeg12.c | 3 +-
libavcodec/mpeg12enc.c | 6 ++--
libavcodec/mpeg4videoenc.c | 6 ++--
libavcodec/mpegaudiodec_template.c | 3 +-
libavcodec/mpegaudioenc_template.c | 6 ++--
libavcodec/mpegutils.c | 6 ++--
libavcodec/mpegvideo_enc.c | 9 ++++--
libavcodec/mpegvideo_xvmc.c | 3 +-
libavcodec/mpegvideoencdsp.c | 3 +-
libavcodec/mqcenc.c | 3 +-
libavcodec/put_bits.h | 9 ++++--
libavcodec/rv34.c | 3 +-
libavcodec/rv40dsp.c | 10 +++++--
libavcodec/sanm.c | 3 +-
libavcodec/sinewin_tablegen.h | 3 +-
libavcodec/snow.c | 3 +-
libavcodec/snow.h | 3 +-
libavcodec/snow_dwt.c | 3 +-
libavcodec/snowenc.c | 14 +++++----
libavcodec/svq1enc.c | 24 ++++++++++-----
libavcodec/vaapi_encode.c | 8 +++--
libavcodec/vaapi_encode_h264.c | 3 +-
libavcodec/vaapi_encode_h265.c | 6 ++--
libavcodec/vaapi_encode_vp9.c | 4 +--
libavcodec/vc1_pred.c | 3 +-
libavcodec/vc1dsp.c | 20 ++++++++++---
libavcodec/videodsp_template.c | 6 ++--
libavcodec/vp9.c | 3 +-
libavcodec/vp9recon.c | 3 +-
libavcodec/wmaenc.c | 6 ++--
libavcodec/x86/videodsp_init.c | 6 ++--
libavdevice/avdevice.c | 3 +-
libavdevice/opengl_enc.c | 3 +-
libavfilter/af_atempo.c | 9 +++---
libavfilter/af_dynaudnorm.c | 3 +-
libavfilter/af_surround.c | 8 +++--
libavfilter/asrc_sinc.c | 3 +-
libavfilter/avfilter.c | 3 +-
libavfilter/colorspacedsp_template.c | 3 +-
libavfilter/transform.c | 6 ++--
libavfilter/vf_curves.c | 7 +++--
libavfilter/vf_fieldmatch.c | 4 ++-
libavfilter/vf_lut3d.c | 3 +-
libavfilter/vf_mergeplanes.c | 3 +-
libavfilter/vf_nlmeans.c | 4 ++-
libavfilter/vsrc_testsrc.c | 3 +-
libavutil/frame.c | 6 ++--
libavutil/hwcontext_opencl.c | 4 +--
libavutil/integer.c | 3 +-
libavutil/mathematics.c | 3 +-
libavutil/pixdesc.c | 12 ++++++--
libavutil/rational.c | 3 +-
libavutil/softfloat.h | 3 +-
libswresample/resample.c | 3 +-
libswscale/swscale_unscaled.c | 7 +++--
libswscale/utils.c | 3 +-
libswscale/vscale.c | 3 +-
tests/checkasm/vf_nlmeans.c | 3 +-
108 files changed, 471 insertions(+), 211 deletions(-)
@@ -2257,7 +2257,8 @@ static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionar
int ret;
if (arg) {
char *opts_str = NULL;
- av_assert0(dev && opts);
+ av_assert0(dev);
+ av_assert0(opts);
*dev = av_strdup(arg);
if (!*dev)
return AVERROR(ENOMEM);
@@ -3060,7 +3060,8 @@ static int init_output_stream_streamcopy(OutputStream *ost)
int i, ret;
uint32_t codec_tag = par_dst->codec_tag;
- av_assert0(ist && !ost->filter);
+ av_assert0(ist);
+ av_assert0(!ost->filter);
ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
if (ret >= 0)
@@ -346,7 +346,8 @@ static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
uint16_t *start, *end;
unsigned dc = 0;
- av_assert0(log2w >= 0 && log2h >= 0);
+ av_assert0(log2w >= 0);
+ av_assert0(log2h >= 0);
index = size2index[log2h][log2w];
av_assert0(index >= 0);
@@ -354,7 +355,8 @@ static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
h = 1 << log2h;
code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
BLOCK_TYPE_VLC_BITS, 1);
- av_assert0(code >= 0 && code <= 6);
+ av_assert0(code >= 0);
+ av_assert0(code <= 6);
start = f->last_frame_buffer;
end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
@@ -409,7 +411,8 @@ static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
return AVERROR_INVALIDDATA;
}
- av_assert0(start <= src && src <= end);
+ av_assert0(start <= src);
+ av_assert0(src <= end);
scale = 0;
dc = bytestream2_get_le16(&f->g2);
}
@@ -836,7 +839,8 @@ static int decode_frame(AVCodecContext *avctx, void *data,
if (buf_size < 20)
return AVERROR_INVALIDDATA;
- av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
+ av_assert0(avctx->width % 16 == 0);
+ av_assert0(avctx->height % 16 == 0);
if (buf_size < AV_RL32(buf + 4) + 8) {
av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
@@ -749,7 +749,8 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,
if (!sce->zeroes[w*16+g]) {
if (prev != -1) {
av_unused int sfdiff = sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO;
- av_assert1(sfdiff >= 0 && sfdiff <= 2*SCALE_MAX_DIFF);
+ av_assert1(sfdiff >= 0);
+ av_assert1(sfdiff <= 2*SCALE_MAX_DIFF);
} else if (sce->zeroes[0]) {
/** Set global gain to something useful */
sce->sf_idx[0] = sce->sf_idx[w*16+g];
@@ -407,7 +407,8 @@ static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s,
off_sf = sce->sf_idx[w*16 + i];
}
diff += SCALE_DIFF_ZERO;
- av_assert0(diff >= 0 && diff <= 120);
+ av_assert0(diff >= 0);
+ av_assert0(diff <= 120);
put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
}
}
@@ -34,7 +34,8 @@ static inline float quantize_band_cost_cached(struct AACEncContext *s, int w, in
int *bits, float *energy, int rtz)
{
AACQuantizeBandCostCacheEntry *entry;
- av_assert1(scale_idx >= 0 && scale_idx < 256);
+ av_assert1(scale_idx >= 0);
+ av_assert1(scale_idx < 256);
entry = &s->quantize_band_cost_cache[scale_idx][w*16+g];
if (entry->generation != s->quantize_band_cost_cache_generation || entry->cb != cb || entry->rtz != rtz) {
entry->rd = quantize_band_cost(s, in, scaled, size, scale_idx,
@@ -504,9 +504,11 @@ static int calc_bit_demand(AacPsyContext *ctx, float pe, int bits, int size,
fill_level = av_clipf((float)ctx->fill_level / size, clip_low, clip_high);
clipped_pe = av_clipf(pe, ctx->pe.min, ctx->pe.max);
bit_save = (fill_level + bitsave_add) * bitsave_slope;
- assert(bit_save <= 0.3f && bit_save >= -0.05000001f);
+ assert(bit_save <= 0.3f);
+ assert(bit_save >= -0.05000001f);
bit_spend = (fill_level + bitspend_add) * bitspend_slope;
- assert(bit_spend <= 0.5f && bit_spend >= -0.1f);
+ assert(bit_spend <= 0.5f);
+ assert(bit_spend >= -0.1f);
/* The bit factor graph in the spec is obviously incorrect.
* bit_spend + ((bit_spend - bit_spend))...
* The reference encoder subtracts everything from 1, but also seems incorrect.
@@ -606,19 +606,22 @@ void ff_ac3_group_exponents(AC3EncodeContext *s)
exp1 = p[0];
p += group_size;
delta0 = exp1 - exp0 + 2;
- av_assert2(delta0 >= 0 && delta0 <= 4);
+ av_assert2(delta0 >= 0);
+ av_assert2(delta0 <= 4);
exp0 = exp1;
exp1 = p[0];
p += group_size;
delta1 = exp1 - exp0 + 2;
- av_assert2(delta1 >= 0 && delta1 <= 4);
+ av_assert2(delta1 >= 0);
+ av_assert2(delta1 <= 4);
exp0 = exp1;
exp1 = p[0];
p += group_size;
delta2 = exp1 - exp0 + 2;
- av_assert2(delta2 >= 0 && delta2 <= 4);
+ av_assert2(delta2 >= 0);
+ av_assert2(delta2 <= 4);
block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
}
@@ -1166,7 +1169,8 @@ int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
static inline int sym_quant(int c, int e, int levels)
{
int v = (((levels * c) >> (24 - e)) + levels) >> 1;
- av_assert2(v >= 0 && v < levels);
+ av_assert2(v >= 0);
+ av_assert2(v < levels);
return v;
}
@@ -2179,7 +2183,8 @@ static av_cold int validate_options(AC3EncodeContext *s)
/* calculate words-per-frame for the selected bitrate */
wpf = (avctx->bit_rate / 16) * frame_samples / s->sample_rate;
- av_assert1(wpf > 0 && wpf <= 2048);
+ av_assert1(wpf > 0);
+ av_assert1(wpf <= 2048);
/* find the closest AC-3 bitrate code to the selected bitrate.
this is needed for lookup tables for bandwidth and coupling
@@ -47,7 +47,8 @@ void ff_acelp_interpolate(int16_t* out, const int16_t* in,
{
int n, i;
- av_assert1(frac_pos >= 0 && frac_pos < precision);
+ av_assert1(frac_pos >= 0);
+ av_assert1(frac_pos < precision);
for (n = 0; n < length; n++) {
int idx = 0;
@@ -618,8 +618,9 @@ int ff_amf_send_frame(AVCodecContext *avctx, const AVFrame *frame)
ID3D11Texture2D *texture = (ID3D11Texture2D*)frame->data[0]; // actual texture
int index = (intptr_t)frame->data[1]; // index is a slice in texture array is - set to tell AMF which slice to use
- av_assert0(frame->hw_frames_ctx && ctx->hw_frames_ctx &&
- frame->hw_frames_ctx->data == ctx->hw_frames_ctx->data);
+ av_assert0(frame->hw_frames_ctx);
+ av_assert0(ctx->hw_frames_ctx);
+ av_assert0(frame->hw_frames_ctx->data == ctx->hw_frames_ctx->data);
texture->lpVtbl->SetPrivateData(texture, &AMFTextureArrayIndexGUID, sizeof(index), &index);
@@ -499,7 +499,8 @@ static void decode_8_pulses_31bits(const int16_t *fixed_index,
static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses,
const enum Mode mode, const int subframe)
{
- av_assert1(MODE_4k75 <= (signed)mode && mode <= MODE_12k2);
+ av_assert1(MODE_4k75 <= (signed)mode);
+ av_assert1(mode <= MODE_12k2);
if (mode == MODE_12k2) {
ff_decode_10_pulses_35bits(pulses, fixed_sparse, gray_decode, 5, 3);
@@ -153,7 +153,8 @@ static int av1_frame_split_filter(AVBSFContext *ctx, AVPacket *out)
}
}
}
- av_assert0(frame && s->cur_frame <= s->nb_frames);
+ av_assert0(frame);
+ av_assert0(s->cur_frame <= s->nb_frames);
ret = av_packet_ref(out, s->buffer_pkt);
if (ret < 0)
@@ -465,7 +465,8 @@ int av_packet_split_side_data(AVPacket *pkt){
p= pkt->data + pkt->size - 8 - 5;
for (i=0; ; i++){
size= AV_RB32(p);
- av_assert0(size<=INT_MAX - 5 && p - pkt->data >= size);
+ av_assert0(size<=INT_MAX - 5);
+ av_assert0(p - pkt->data >= size);
pkt->side_data[i].data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
pkt->side_data[i].size = size;
pkt->side_data[i].type = p[4]&127;
@@ -180,7 +180,8 @@ static int cbs_read_fragment_content(CodedBitstreamContext *ctx,
av_buffer_unref(&unit->content_ref);
unit->content = NULL;
- av_assert0(unit->data && unit->data_ref);
+ av_assert0(unit->data);
+ av_assert0(unit->data_ref);
err = ctx->codec->read_unit(ctx, unit);
if (err == AVERROR(ENOSYS)) {
@@ -201,7 +202,8 @@ static int cbs_fill_fragment_data(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag,
const uint8_t *data, size_t size)
{
- av_assert0(!frag->data && !frag->data_ref);
+ av_assert0(!frag->data);
+ av_assert0(!frag->data_ref);
frag->data_ref =
av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
@@ -301,7 +303,8 @@ int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx,
"(type %"PRIu32").\n", i, unit->type);
return err;
}
- av_assert0(unit->data && unit->data_ref);
+ av_assert0(unit->data);
+ av_assert0(unit->data_ref);
}
av_buffer_unref(&frag->data_ref);
@@ -312,7 +315,8 @@ int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx,
av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to assemble fragment.\n");
return err;
}
- av_assert0(frag->data && frag->data_ref);
+ av_assert0(frag->data);
+ av_assert0(frag->data_ref);
return 0;
}
@@ -386,7 +390,8 @@ void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position,
if (!ctx->trace_enable)
return;
- av_assert0(value >= INT_MIN && value <= UINT32_MAX);
+ av_assert0(value >= INT_MIN);
+ av_assert0(value <= UINT32_MAX);
subs = subscripts ? subscripts[0] : 0;
n = 0;
@@ -395,7 +400,8 @@ void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position,
if (n < subs) {
++n;
k = snprintf(name + j, sizeof(name) - j, "[%d", subscripts[n]);
- av_assert0(k > 0 && j + k < sizeof(name));
+ av_assert0(k > 0);
+ av_assert0(j + k < sizeof(name));
j += k;
for (++i; str[i] && str[i] != ']'; i++);
av_assert0(str[i] == ']');
@@ -433,7 +439,8 @@ int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc,
uint32_t value;
int position;
- av_assert0(width > 0 && width <= 32);
+ av_assert0(width > 0);
+ av_assert0(width <= 32);
if (get_bits_left(gbc) < width) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
@@ -473,7 +480,8 @@ int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc,
const int *subscripts, uint32_t value,
uint32_t range_min, uint32_t range_max)
{
- av_assert0(width > 0 && width <= 32);
+ av_assert0(width > 0);
+ av_assert0(width <= 32);
if (value < range_min || value > range_max) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
@@ -512,7 +520,8 @@ int ff_cbs_read_signed(CodedBitstreamContext *ctx, GetBitContext *gbc,
int32_t value;
int position;
- av_assert0(width > 0 && width <= 32);
+ av_assert0(width > 0);
+ av_assert0(width <= 32);
if (get_bits_left(gbc) < width) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
@@ -552,7 +561,8 @@ int ff_cbs_write_signed(CodedBitstreamContext *ctx, PutBitContext *pbc,
const int *subscripts, int32_t value,
int32_t range_min, int32_t range_max)
{
- av_assert0(width > 0 && width <= 32);
+ av_assert0(width > 0);
+ av_assert0(width <= 32);
if (value < range_min || value > range_max) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
@@ -589,7 +599,8 @@ int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx,
size_t size,
void (*free)(void *opaque, uint8_t *data))
{
- av_assert0(!unit->content && !unit->content_ref);
+ av_assert0(!unit->content);
+ av_assert0(!unit->content_ref);
unit->content = av_mallocz(size);
if (!unit->content)
@@ -609,7 +620,8 @@ int ff_cbs_alloc_unit_data(CodedBitstreamContext *ctx,
CodedBitstreamUnit *unit,
size_t size)
{
- av_assert0(!unit->data && !unit->data_ref);
+ av_assert0(!unit->data);
+ av_assert0(!unit->data_ref);
unit->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!unit->data_ref)
@@ -675,7 +687,8 @@ int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx,
if (position == -1)
position = frag->nb_units;
- av_assert0(position >= 0 && position <= frag->nb_units);
+ av_assert0(position >= 0);
+ av_assert0(position <= frag->nb_units);
if (content_buf) {
content_ref = av_buffer_ref(content_buf);
@@ -712,7 +725,8 @@ int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx,
if (position == -1)
position = frag->nb_units;
- av_assert0(position >= 0 && position <= frag->nb_units);
+ av_assert0(position >= 0);
+ av_assert0(position <= frag->nb_units);
if (data_buf)
data_ref = av_buffer_ref(data_buf);
@@ -314,7 +314,8 @@ static int cbs_av1_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc
int position, i;
char bits[33];
- av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
+ av_assert0(range_min <= range_max);
+ av_assert0(range_max - range_min < sizeof(bits) - 1);
if (ctx->trace_enable)
position = get_bits_count(gbc);
@@ -349,7 +350,8 @@ static int cbs_av1_write_increment(CodedBitstreamContext *ctx, PutBitContext *pb
{
int len;
- av_assert0(range_min <= range_max && range_max - range_min < 32);
+ av_assert0(range_min <= range_max);
+ av_assert0(range_max - range_min < 32);
if (value < range_min || value > range_max) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
"%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
@@ -784,7 +786,8 @@ static int cbs_av1_split_fragment(CodedBitstreamContext *ctx,
obu_size = size - 1 - header.obu_extension_flag;
pos = get_bits_count(&gbc);
- av_assert0(pos % 8 == 0 && pos / 8 <= size);
+ av_assert0(pos % 8 == 0);
+ av_assert0(pos / 8 <= size);
obu_length = pos / 8 + obu_size;
@@ -1482,7 +1482,8 @@ static int FUNC(frame_header_obu)(CodedBitstreamContext *ctx, RWContext *rw,
HEADER("Redundant Frame Header");
- av_assert0(priv->frame_header_ref && priv->frame_header);
+ av_assert0(priv->frame_header_ref);
+ av_assert0(priv->frame_header);
init_get_bits(&fh, priv->frame_header,
priv->frame_header_size);
@@ -588,7 +588,8 @@ static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx,
GetByteContext gbc;
int err;
- av_assert0(frag->data && frag->nb_units == 0);
+ av_assert0(frag->data);
+ av_assert0(frag->nb_units == 0);
if (frag->data_size == 0)
return 0;
@@ -1097,8 +1098,8 @@ static int cbs_h2645_write_slice_data(CodedBitstreamContext *ctx,
size_t rest = data_size - (data_bit_start + 7) / 8;
const uint8_t *pos = data + data_bit_start / 8;
- av_assert0(data_bit_start >= 0 &&
- 8 * data_size > data_bit_start);
+ av_assert0(data_bit_start >= 0);
+ av_assert0(8 * data_size > data_bit_start);
if (data_size * 8 + 8 > put_bits_left(pbc))
return AVERROR(ENOSPC);
@@ -1651,7 +1652,8 @@ int ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx,
H264RawSEI *sei = nal->content;
av_assert0(nal->type == H264_NAL_SEI);
- av_assert0(position >= 0 && position < sei->payload_count);
+ av_assert0(position >= 0);
+ av_assert0(position < sei->payload_count);
if (position == 0 && sei->payload_count == 1) {
// Deleting NAL unit entirely.
@@ -274,8 +274,8 @@ static int cbs_mpeg2_write_slice(CodedBitstreamContext *ctx,
size_t rest = slice->data_size - (slice->data_bit_start + 7) / 8;
uint8_t *pos = slice->data + slice->data_bit_start / 8;
- av_assert0(slice->data_bit_start >= 0 &&
- 8 * slice->data_size > slice->data_bit_start);
+ av_assert0(slice->data_bit_start >= 0);
+ av_assert0(8 * slice->data_size > slice->data_bit_start);
if (slice->data_size * 8 + 8 > put_bits_left(pbc))
return AVERROR(ENOSPC);
@@ -100,7 +100,9 @@ static int cbs_vp9_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc
int position, i;
char bits[8];
- av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
+ av_assert0(range_min <= range_max);
+ av_assert0(range_max - range_min < sizeof(bits) - 1);
+
if (ctx->trace_enable)
position = get_bits_count(gbc);
@@ -134,7 +136,9 @@ static int cbs_vp9_write_increment(CodedBitstreamContext *ctx, PutBitContext *pb
{
int len;
- av_assert0(range_min <= range_max && range_max - range_min < 8);
+ av_assert0(range_min <= range_max);
+ av_assert0(range_max - range_min < 8);
+
if (value < range_min || value > range_max) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
"%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
@@ -105,7 +105,8 @@ void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs,
c -= filter_coeffs[1] * filter_coeffs[0];
c -= filter_coeffs[0] * b;
- av_assert2((filter_length&1)==0 && filter_length>=4);
+ av_assert2((filter_length&1) == 0);
+ av_assert2(filter_length >= 4);
old_out0 = out[-4];
old_out1 = out[-3];
@@ -572,7 +572,8 @@ static inline int parse_huffman_codes(DCACoreDecoder *s, int32_t *audio, int abi
static inline int extract_audio(DCACoreDecoder *s, int32_t *audio, int abits, int ch)
{
- av_assert1(abits >= 0 && abits <= DCA_ABITS_MAX);
+ av_assert1(abits >= 0);
+ av_assert1(abits <= DCA_ABITS_MAX);
if (abits == 0) {
// No bits allocated
@@ -1102,8 +1102,8 @@ int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
sub->pts = av_rescale_q(avpkt->pts,
avctx->pkt_timebase, AV_TIME_BASE_Q);
ret = avctx->codec->decode(avctx, sub, got_sub_ptr, &pkt_recoded);
- av_assert1((ret >= 0) >= !!*got_sub_ptr &&
- !!*got_sub_ptr >= !!sub->num_rects);
+ av_assert1((ret >= 0) >= !!*got_sub_ptr);
+ av_assert1(!!*got_sub_ptr >= !!sub->num_rects);
#if FF_API_ASS_TIMING
if (avctx->sub_text_format == FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
@@ -554,7 +554,8 @@ static int append_to_cached_buf(AVCodecContext *avctx,
{
DVDSubContext *ctx = avctx->priv_data;
- av_assert0(buf_size >= 0 && ctx->buf_size <= sizeof(ctx->buf));
+ av_assert0(buf_size >= 0);
+ av_assert0(ctx->buf_size <= sizeof(ctx->buf));
if (buf_size >= sizeof(ctx->buf) - ctx->buf_size) {
av_log(avctx, AV_LOG_WARNING, "Attempt to reconstruct "
"too large SPU packets aborted.\n");
@@ -389,7 +389,8 @@ static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
av_assert2(b->mb[b->next[k]]);
b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
- av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
+ av_assert2(b->prev[a2] == k);
+ av_assert2(a2 + 1 >= 4 || b->prev[a2 + 1] != k);
b->prev[a2] = prev;
}
b->next[prev] = b->next[k];
@@ -41,7 +41,8 @@ struct dxva2_picture_context {
static void fill_picture_entry(DXVA_PicEntry_H264 *pic,
unsigned index, unsigned flag)
{
- assert((index&0x7f) == index && (flag&0x01) == flag);
+ assert((index&0x7f) == index);
+ assert((flag&0x01) == flag);
pic->bPicEntry = index | (flag << 7);
}
@@ -40,7 +40,8 @@ struct hevc_dxva2_picture_context {
static void fill_picture_entry(DXVA_PicEntry_HEVC *pic,
unsigned index, unsigned flag)
{
- av_assert0((index & 0x7f) == index && (flag & 0x01) == flag);
+ av_assert0((index & 0x7f) == index);
+ av_assert0((flag & 0x01) == flag);
pic->bPicEntry = index | (flag << 7);
}
@@ -36,7 +36,8 @@ struct vp9_dxva2_picture_context {
static void fill_picture_entry(DXVA_PicEntry_VPx *pic,
unsigned index, unsigned flag)
{
- av_assert0((index & 0x7f) == index && (flag & 0x01) == flag);
+ av_assert0((index & 0x7f) == index);
+ av_assert0((flag & 0x01) == flag);
pic->bPicEntry = index | (flag << 7);
}
@@ -499,7 +499,8 @@ static void guess_mv(ERContext *s)
av_assert1(!IS_INTRA(s->cur_pic.mb_type[mb_xy]));
- av_assert1(s->last_pic.f && s->last_pic.f->data[0]);
+ av_assert1(s->last_pic.f);
+ av_assert1(s->last_pic.f->data[0]);
j = 0;
if (mb_x > 0)
@@ -318,7 +318,8 @@ static int decode_slice(AVCodecContext *c, void *arg)
(fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
}
- av_assert1(width && height);
+ av_assert1(width);
+ av_assert1(height);
if (f->colorspace == 0 && (f->chroma_planes || !fs->transparency)) {
const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
@@ -714,8 +714,10 @@ static uint64_t calc_rice_params(RiceContext *rc,
RiceContext tmp_rc;
int kmax = (1 << rc->coding_mode) - 2;
- av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
- av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
+ av_assert1(pmin >= 0);
+ av_assert1(pmin <= MAX_PARTITION_ORDER);
+ av_assert1(pmax >= 0);
+ av_assert1(pmax <= MAX_PARTITION_ORDER);
av_assert1(pmin <= pmax);
tmp_rc.coding_mode = rc->coding_mode;
@@ -259,7 +259,10 @@ static inline void refill_64(GetBitContext *s, int is_le)
static inline uint64_t get_val(GetBitContext *s, unsigned n, int is_le)
{
uint64_t ret;
- av_assert2(n>0 && n<=63);
+
+ av_assert2(n > 0);
+ av_assert2(n <= 63);
+
if (is_le) {
ret = s->cache & ((UINT64_C(1) << n) - 1);
s->cache >>= n;
@@ -330,7 +333,8 @@ static inline int get_xbits(GetBitContext *s, int n)
register int sign;
register int32_t cache;
OPEN_READER(re, s);
- av_assert2(n>0 && n<=25);
+ av_assert2(n > 0);
+ av_assert2(n <= 25);
UPDATE_CACHE(re, s);
cache = GET_CACHE(re, s);
sign = ~cache >> 31;
@@ -346,7 +350,8 @@ static inline int get_xbits_le(GetBitContext *s, int n)
register int sign;
register int32_t cache;
OPEN_READER(re, s);
- av_assert2(n>0 && n<=25);
+ av_assert2(n > 0);
+ av_assert2(n <= 25);
UPDATE_CACHE_LE(re, s);
cache = GET_CACHE(re, s);
sign = sign_extend(~cache, n) >> 31;
@@ -360,11 +365,13 @@ static inline int get_sbits(GetBitContext *s, int n)
{
register int tmp;
#if CACHED_BITSTREAM_READER
- av_assert2(n>0 && n<=25);
+ av_assert2(n > 0);
+ av_assert2(n <= 25);
tmp = sign_extend(get_bits(s, n), n);
#else
OPEN_READER(re, s);
- av_assert2(n>0 && n<=25);
+ av_assert2(n > 0);
+ av_assert2(n <= 25);
UPDATE_CACHE(re, s);
tmp = SHOW_SBITS(re, s, n);
LAST_SKIP_BITS(re, s, n);
@@ -381,7 +388,8 @@ static inline unsigned int get_bits(GetBitContext *s, int n)
register unsigned int tmp;
#if CACHED_BITSTREAM_READER
- av_assert2(n>0 && n<=32);
+ av_assert2(n > 0);
+ av_assert2(n <= 32);
if (n > s->bits_left) {
#ifdef BITSTREAM_READER_LE
refill_32(s, 1);
@@ -399,7 +407,8 @@ static inline unsigned int get_bits(GetBitContext *s, int n)
#endif
#else
OPEN_READER(re, s);
- av_assert2(n>0 && n<=25);
+ av_assert2(n > 0);
+ av_assert2(n <= 25);
UPDATE_CACHE(re, s);
tmp = SHOW_UBITS(re, s, n);
LAST_SKIP_BITS(re, s, n);
@@ -420,7 +429,8 @@ static av_always_inline int get_bitsz(GetBitContext *s, int n)
static inline unsigned int get_bits_le(GetBitContext *s, int n)
{
#if CACHED_BITSTREAM_READER
- av_assert2(n>0 && n<=32);
+ av_assert2(n > 0);
+ av_assert2(n <= 32);
if (n > s->bits_left) {
refill_32(s, 1);
if (s->bits_left < 32)
@@ -431,7 +441,8 @@ static inline unsigned int get_bits_le(GetBitContext *s, int n)
#else
register int tmp;
OPEN_READER(re, s);
- av_assert2(n>0 && n<=25);
+ av_assert2(n > 0);
+ av_assert2(n <= 25);
UPDATE_CACHE_LE(re, s);
tmp = SHOW_UBITS_LE(re, s, n);
LAST_SKIP_BITS(re, s, n);
@@ -457,7 +468,8 @@ static inline unsigned int show_bits(GetBitContext *s, int n)
tmp = show_val(s, n);
#else
OPEN_READER_NOSIZE(re, s);
- av_assert2(n>0 && n<=25);
+ av_assert2(n > 0);
+ av_assert2(n <= 25);
UPDATE_CACHE(re, s);
tmp = SHOW_UBITS(re, s, n);
#endif
@@ -545,7 +557,8 @@ static inline void skip_bits1(GetBitContext *s)
*/
static inline unsigned int get_bits_long(GetBitContext *s, int n)
{
- av_assert2(n>=0 && n<=32);
+ av_assert2(n >= 0);
+ av_assert2(n <= 32);
if (!n) {
return 0;
#if CACHED_BITSTREAM_READER
@@ -316,7 +316,8 @@ static int decode_slice(MpegEncContext *s)
s->mb_x = 0;
}
- av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height);
+ av_assert1(s->mb_x == 0);
+ av_assert1(s->mb_y == s->mb_height);
// Detect incorrect padding with wrong stuffing codes used by NEC N-02B
if (s->codec_id == AV_CODEC_ID_MPEG4 &&
@@ -215,7 +215,8 @@ static const char *hevc_nal_type_name[64] = {
static const char *hevc_nal_unit_name(int nal_type)
{
- av_assert0(nal_type >= 0 && nal_type < 64);
+ av_assert0(nal_type >= 0);
+ av_assert0(nal_type < 64);
return hevc_nal_type_name[nal_type];
}
@@ -256,7 +257,8 @@ static const char *h264_nal_type_name[32] = {
static const char *h264_nal_unit_name(int nal_type)
{
- av_assert0(nal_type >= 0 && nal_type < 32);
+ av_assert0(nal_type >= 0);
+ av_assert0(nal_type < 32);
return h264_nal_type_name[nal_type];
}
@@ -511,7 +511,8 @@ static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
*/
static void remove_short_at_index(H264Context *h, int i)
{
- assert(i >= 0 && i < h->short_ref_count);
+ assert(i >= 0);
+ assert(i < h->short_ref_count);
h->short_ref[i] = NULL;
if (--h->short_ref_count)
memmove(&h->short_ref[i], &h->short_ref[i + 1],
@@ -2799,7 +2799,8 @@ int ff_h264_execute_decode_slices(H264Context *h)
if (h->avctx->hwaccel || context_count < 1)
return 0;
- av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
+ av_assert0(context_count);
+ av_assert0(h->slice_ctx[context_count - 1].mb_y < h->mb_height);
if (context_count == 1) {
@@ -36,7 +36,10 @@ static void FUNCC(OPNAME ## h264_chroma_mc1)(uint8_t *_dst /*align 8*/, uint8_t
int i;\
stride >>= sizeof(pixel)-1;\
\
- av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ av_assert2(x < 8);\
+ av_assert2(y < 8);\
+ av_assert2(x >= 0);\
+ av_assert2(y >= 0);\
\
if(D){\
for(i=0; i<h; i++){\
@@ -71,7 +74,10 @@ static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst /*align 8*/, uint8_t
int i;\
stride >>= sizeof(pixel)-1;\
\
- av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ av_assert2(x<8);\
+ av_assert2(y<8);\
+ av_assert2(x>=0);\
+ av_assert2(y>=0);\
\
if(D){\
for(i=0; i<h; i++){\
@@ -110,7 +116,10 @@ static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst /*align 8*/, uint8_t
int i;\
stride >>= sizeof(pixel)-1;\
\
- av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ av_assert2(x < 8);\
+ av_assert2(y < 8);\
+ av_assert2(x >= 0);\
+ av_assert2(y >= 0);\
\
if(D){\
for(i=0; i<h; i++){\
@@ -155,7 +164,10 @@ static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst /*align 8*/, uint8_t
int i;\
stride >>= sizeof(pixel)-1;\
\
- av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ av_assert2(x < 8);\
+ av_assert2(y < 8);\
+ av_assert2(x >= 0);\
+ av_assert2(y >= 0);\
\
if(D){\
for(i=0; i<h; i++){\
@@ -112,8 +112,10 @@ static int get_qPy_pred(HEVCContext *s, int xBase, int yBase, int log2_cb_size)
else
qPy_b = s->qp_y_tab[x_cb + (y_cb - 1) * min_cb_width];
- av_assert2(qPy_a >= -s->ps.sps->qp_bd_offset && qPy_a < 52);
- av_assert2(qPy_b >= -s->ps.sps->qp_bd_offset && qPy_b < 52);
+ av_assert2(qPy_a >= -s->ps.sps->qp_bd_offset);
+ av_assert2(qPy_a < 52);
+ av_assert2(qPy_b >= -s->ps.sps->qp_bd_offset);
+ av_assert2(qPy_b < 52);
return (qPy_a + qPy_b + 1) >> 1;
}
@@ -80,7 +80,8 @@ av_cold void ff_huffyuv_common_init(AVCodecContext *avctx)
s->width = avctx->width;
s->height = avctx->height;
- av_assert1(s->width > 0 && s->height > 0);
+ av_assert1(s->width > 0);
+ av_assert1(s->height > 0);
}
av_cold void ff_huffyuv_common_end(HYuvContext *s)
@@ -165,7 +165,10 @@ static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
for (; i < n && len[i] == val && repeat < 255; i++)
repeat++;
- av_assert0(val < 32 && val >0 && repeat < 256 && repeat>0);
+ av_assert0(val < 32);
+ av_assert0(val > 0);
+ av_assert0(repeat < 256);
+ av_assert0(repeat > 0);
if (repeat > 7) {
buf[index++] = val;
buf[index++] = repeat;
@@ -227,7 +227,8 @@ void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
if(s->h263_slice_structured){
put_bits(&s->pb, 1, 1);
- av_assert1(s->mb_x == 0 && s->mb_y == 0);
+ av_assert1(s->mb_x == 0);
+ av_assert1(s->mb_y == 0);
ff_h263_encode_mba(s);
put_bits(&s->pb, 1, 1);
@@ -89,7 +89,9 @@ static int ivi_mc(const IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_av
int ref_size = (mc_type > 1) * band->pitch + (mc_type & 1);
if (mc_type != -1) {
- av_assert0(offs >= 0 && ref_offs >= 0 && band->ref_buf);
+ av_assert0(offs >= 0);
+ av_assert0(ref_offs >= 0);
+ av_assert0(band->ref_buf);
av_assert0(buf_size - min_size >= offs);
av_assert0(buf_size - min_size - ref_size >= ref_offs);
}
@@ -1541,7 +1541,8 @@ static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
int term_cnt = 0;
int coder_type;
- av_assert0(width <= 1024U && height <= 1024U);
+ av_assert0(width <= 1024U);
+ av_assert0(height <= 1024U);
av_assert0(width*height <= 4096);
memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
@@ -115,7 +115,8 @@ static av_cold int encode_init(AVCodecContext *avctx)
c->avctx= avctx;
- av_assert0(avctx->width && avctx->height);
+ av_assert0(avctx->width);
+ av_assert0(avctx->height);
avctx->extradata = av_mallocz(8 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata)
@@ -210,8 +210,9 @@ int ff_lpc_calc_coefs(LPCContext *s,
int i, j, pass = 0;
int opt_order;
- av_assert2(max_order >= MIN_LPC_ORDER && max_order <= MAX_LPC_ORDER &&
- lpc_type > FF_LPC_TYPE_FIXED);
+ av_assert2(max_order >= MIN_LPC_ORDER);
+ av_assert2(max_order <= MAX_LPC_ORDER);
+ av_assert2(lpc_type > FF_LPC_TYPE_FIXED);
av_assert0(lpc_type == FF_LPC_TYPE_CHOLESKY || lpc_type == FF_LPC_TYPE_LEVINSON);
/* reinit LPC context if parameters have changed */
@@ -77,7 +77,8 @@ static inline int hash(int head, const int add)
head ^= (add << LZW_HASH_SHIFT);
if (head >= LZW_HASH_SIZE)
head -= LZW_HASH_SIZE;
- av_assert2(head >= 0 && head < LZW_HASH_SIZE);
+ av_assert2(head >= 0);
+ av_assert2(head < LZW_HASH_SIZE);
return head;
}
@@ -112,7 +113,8 @@ static inline int hashOffset(const int head)
*/
static inline void writeCode(LZWEncodeState * s, int c)
{
- av_assert2(0 <= c && c < 1 << s->bits);
+ av_assert2(0 <= c);
+ av_assert2(c < 1 << s->bits);
s->put_bits(&s->pb, s->bits, c);
}
@@ -208,7 +210,8 @@ void ff_lzw_encode_init(LZWEncodeState *s, uint8_t *outbuf, int outsize,
s->maxbits = maxbits;
init_put_bits(&s->pb, outbuf, outsize);
s->bufsize = outsize;
- av_assert0(s->maxbits >= 9 && s->maxbits <= LZW_MAXBITS);
+ av_assert0(s->maxbits >= 9);
+ av_assert0(s->maxbits <= LZW_MAXBITS);
s->maxcode = 1 << s->maxbits;
s->output_bytes = 0;
s->last_code = LZW_PREFIX_EMPTY;
@@ -1905,7 +1905,10 @@ static void avg_width8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
void ff_put_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
ptrdiff_t stride, int height, int x, int y)
{
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
if (x && y) {
avc_chroma_hv_8w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
@@ -1921,7 +1924,10 @@ void ff_put_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
void ff_put_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
ptrdiff_t stride, int height, int x, int y)
{
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
if (x && y) {
avc_chroma_hv_4w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
@@ -1939,7 +1945,10 @@ void ff_put_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
{
int32_t cnt;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
if (x && y) {
avc_chroma_hv_2w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
@@ -1960,8 +1969,10 @@ void ff_put_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
void ff_avg_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
ptrdiff_t stride, int height, int x, int y)
{
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
-
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
if (x && y) {
avc_chroma_hv_and_aver_dst_8w_msa(src, dst, stride, x, (8 - x), y,
@@ -1978,7 +1989,10 @@ void ff_avg_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
void ff_avg_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
ptrdiff_t stride, int height, int x, int y)
{
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
if (x && y) {
avc_chroma_hv_and_aver_dst_4w_msa(src, dst, stride, x, (8 - x), y,
@@ -1997,7 +2011,10 @@ void ff_avg_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
{
int32_t cnt;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
if (x && y) {
avc_chroma_hv_and_aver_dst_2w_msa(src, dst, stride, x, (8 - x), y,
@@ -2252,7 +2252,10 @@ void ff_put_no_rnd_vc1_chroma_mc8_mmi(uint8_t *dst /* align 8 */,
DECLARE_VAR_ALL64;
DECLARE_VAR_ADDRT;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
__asm__ volatile(
"li %[tmp0], 0x06 \n\t"
@@ -2307,7 +2310,10 @@ void ff_put_no_rnd_vc1_chroma_mc4_mmi(uint8_t *dst /* align 8 */,
DECLARE_VAR_LOW32;
DECLARE_VAR_ADDRT;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
__asm__ volatile(
"li %[tmp0], 0x06 \n\t"
@@ -2360,7 +2366,10 @@ void ff_avg_no_rnd_vc1_chroma_mc8_mmi(uint8_t *dst /* align 8 */,
DECLARE_VAR_ALL64;
DECLARE_VAR_ADDRT;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
__asm__ volatile(
"li %[tmp0], 0x06 \n\t"
@@ -2418,7 +2427,10 @@ void ff_avg_no_rnd_vc1_chroma_mc4_mmi(uint8_t *dst /* align 8 */,
DECLARE_VAR_LOW32;
DECLARE_VAR_ADDRT;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
__asm__ volatile(
"li %[tmp0], 0x06 \n\t"
@@ -1180,7 +1180,8 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
point_transform += bits - s->bits;
mask = ((1 << s->bits) - 1) << point_transform;
- av_assert0(nb_components>=1 && nb_components<=4);
+ av_assert0(nb_components >= 1);
+ av_assert0(nb_components <= 4);
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
@@ -1483,7 +1484,9 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
int c = s->comp_index[0];
uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
- av_assert0(ss>=0 && Ah>=0 && Al>=0);
+ av_assert0(ss >= 0);
+ av_assert0(Ah >= 0);
+ av_assert0(Al >= 0);
if (se < ss || se > 63) {
av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
return AVERROR_INVALIDDATA;
@@ -1674,8 +1677,8 @@ next_field:
if (s->avctx->hwaccel) {
int bytes_to_start = get_bits_count(&s->gb) / 8;
- av_assert0(bytes_to_start >= 0 &&
- s->raw_scan_buffer_size >= bytes_to_start);
+ av_assert0(bytes_to_start >= 0);
+ av_assert0(s->raw_scan_buffer_size >= bytes_to_start);
ret = s->avctx->hwaccel->decode_slice(s->avctx,
s->raw_scan_buffer + bytes_to_start,
@@ -115,7 +115,12 @@ static av_always_inline int cmp_direct_inline(MpegEncContext *s, const int x, co
uint8_t * const * const src= c->src[src_index];
int d;
//FIXME check chroma 4mv, (no crashes ...)
- av_assert2(x >= c->xmin && hx <= c->xmax<<(qpel+1) && y >= c->ymin && hy <= c->ymax<<(qpel+1));
+
+ av_assert2(x >= c->xmin);
+ av_assert2(hx <= c->xmax<<(qpel+1));
+ av_assert2(y >= c->ymin);
+ av_assert2(hy <= c->ymax<<(qpel+1));
+
if(x >= c->xmin && hx <= c->xmax<<(qpel+1) && y >= c->ymin && hy <= c->ymax<<(qpel+1)){
const int time_pp= s->pp_time;
const int time_pb= s->pb_time;
@@ -1436,7 +1441,10 @@ static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y)
if(s->mv_type == MV_TYPE_16X16) break;
}
- av_assert2(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);
+ av_assert2(xmax <= 15);
+ av_assert2(ymax <= 15);
+ av_assert2(xmin >= -16);
+ av_assert2(ymin >= -16);
if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){
s->b_direct_mv_table[mot_xy][0]= 0;
@@ -143,7 +143,10 @@ static int hpel_motion_search(MpegEncContext * s,
}
CHECK_HALF_MV(0, 1, mx , my)
}
- av_assert2(bx >= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2);
+ av_assert2(bx >= xmin*2);
+ av_assert2(bx <= xmax*2);
+ av_assert2(by >= ymin*2);
+ av_assert2(by <= ymax*2);
}
*mx_ptr = bx;
@@ -344,7 +347,10 @@ static int qpel_motion_search(MpegEncContext * s,
CHECK_QUARTER_MV(nx&3, ny&3, nx>>2, ny>>2)
}
- av_assert2(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
+ av_assert2(bx >= xmin*4);
+ av_assert2(bx <= xmax*4);
+ av_assert2(by >= ymin*4);
+ av_assert2(by <= ymax*4);
*mx_ptr = bx;
*my_ptr = by;
@@ -193,7 +193,8 @@ int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size,
*/
for (i = 0; i < buf_size; i++) {
- av_assert1(pc->frame_start_found >= 0 && pc->frame_start_found <= 4);
+ av_assert1(pc->frame_start_found >= 0);
+ av_assert1(pc->frame_start_found <= 4);
if (pc->frame_start_found & 1) {
if (state == EXT_START_CODE && (buf[i] & 0xF0) != 0x80)
pc->frame_start_found--;
@@ -620,7 +620,8 @@ static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
sign = 1;
}
- av_assert2(code > 0 && code <= 16);
+ av_assert2(code > 0);
+ av_assert2(code <= 16);
put_bits(&s->pb,
ff_mpeg12_mbMotionVectorTable[code][1],
@@ -864,7 +865,8 @@ static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
} else {
- av_assert2(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
+ av_assert2(!s->frame_pred_frame_dct);
+ av_assert2(s->mv_type == MV_TYPE_FIELD);
if (cbp) {
if (s->dquant) {
@@ -497,7 +497,8 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
s->last_mv[i][1][1] = 0;
}
- av_assert2(s->dquant >= -2 && s->dquant <= 2);
+ av_assert2(s->dquant >= -2);
+ av_assert2(s->dquant <= 2);
av_assert2((s->dquant & 1) == 0);
av_assert2(mb_type >= 0);
@@ -561,7 +562,8 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
s->b_count++;
s->f_count++;
} else {
- av_assert2(mb_type > 0 && mb_type < 4);
+ av_assert2(mb_type > 0);
+ av_assert2(mb_type < 4);
if (s->mv_type != MV_TYPE_FIELD) {
if (s->mv_dir & MV_DIR_FORWARD) {
ff_h263_encode_motion_vector(s,
@@ -1605,7 +1605,8 @@ static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
}
- av_assert1(i <= buf_size - HEADER_SIZE && i >= 0);
+ av_assert1(i <= buf_size - HEADER_SIZE);
+ av_assert1(i >= 0);
memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
s->last_buf_size += i;
}
@@ -413,7 +413,8 @@ static void compute_scale_factors(MpegAudioContext *s,
ff_dlog(NULL, "%2d:%d in=%x %x %d\n",
j, i, vmax, s->scale_factor_table[index], index);
/* store the scale factor */
- av_assert2(index >=0 && index <= 63);
+ av_assert2(index >=0);
+ av_assert2(index <= 63);
sf[i] = index;
}
@@ -713,7 +714,8 @@ static void encode_frame(MpegAudioContext *s,
#endif
if (q[m] >= steps)
q[m] = steps - 1;
- av_assert2(q[m] >= 0 && q[m] < steps);
+ av_assert2(q[m] >= 0);
+ av_assert2(q[m] < steps);
}
bits = ff_mpa_quant_bits[qindex];
if (bits < 0) {
@@ -236,7 +236,8 @@ void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_
else if (!USES_LIST(mb_type, 0))
av_log(avctx, AV_LOG_DEBUG, "<");
else {
- av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
+ av_assert2(USES_LIST(mb_type, 0));
+ av_assert2(USES_LIST(mb_type, 1));
av_log(avctx, AV_LOG_DEBUG, "X");
}
@@ -335,7 +336,8 @@ void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_
} else if (!USES_LIST(mb_type, 0)) {
COLOR(0, 48)
} else {
- av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
+ av_assert2(USES_LIST(mb_type, 0));
+ av_assert2(USES_LIST(mb_type, 1));
COLOR(300,48)
}
@@ -1374,7 +1374,8 @@ static int estimate_best_b_count(MpegEncContext *s)
int best_b_count = -1;
int ret = 0;
- av_assert0(scale >= 0 && scale <= 3);
+ av_assert0(scale >= 0);
+ av_assert0(scale <= 3);
//emms_c();
//s->next_picture_ptr->quality;
@@ -1809,7 +1810,8 @@ static int frame_start(MpegEncContext *s)
}
if (s->dct_error_sum) {
- av_assert2(s->noise_reduction && s->encoding);
+ av_assert2(s->noise_reduction);
+ av_assert2(s->encoding);
update_noise_reduction(s);
}
@@ -3642,7 +3644,8 @@ static void set_frame_distances(MpegEncContext * s){
if(s->pict_type==AV_PICTURE_TYPE_B){
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
- av_assert1(s->pb_time > 0 && s->pb_time < s->pp_time);
+ av_assert1(s->pb_time > 0);
+ av_assert1(s->pb_time < s->pp_time);
}else{
s->pp_time= s->time - s->last_non_b_time;
s->last_non_b_time= s->time;
@@ -43,7 +43,8 @@
void ff_xvmc_init_block(MpegEncContext *s)
{
struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
- assert(render && render->xvmc_id == AV_XVMC_ID);
+ assert(render);
+ assert(render->xvmc_id == AV_XVMC_ID);
s->block = (int16_t (*)[64])(render->data_blocks + render->next_free_data_block_num * 64);
}
@@ -40,7 +40,8 @@ static int try_8x8basis_c(int16_t rem[64], int16_t weight[64],
(BASIS_SHIFT - RECON_SHIFT));
int w = weight[i];
b >>= RECON_SHIFT;
- av_assert2(-512 < b && b < 512);
+ av_assert2(-512 < b);
+ av_assert2(b < 512);
sum += (w * b) * (w * b) >> 4;
}
@@ -130,7 +130,8 @@ int ff_mqc_flush_to(MqcState *mqc, uint8_t *dst, int *dst_len)
if (mqc->bp < mqc->bpstart) {
av_assert1(mqc->bpstart - mqc->bp == 1);
av_assert1(*dst_len > 0);
- av_assert1(mqc->bp[0] == 0 && dst[0] == 0);
+ av_assert1(mqc->bp[0] == 0);
+ av_assert1(dst[0] == 0);
(*dst_len) --;
memmove(dst, dst+1, *dst_len);
return mqc->bp - mqc->bpstart + 1 + *dst_len;
@@ -166,7 +166,8 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
unsigned int bit_buf;
int bit_left;
- av_assert2(n <= 31 && value < (1U << n));
+ av_assert2(n <= 31);
+ av_assert2(value < (1U << n));
bit_buf = s->bit_buf;
bit_left = s->bit_left;
@@ -214,7 +215,8 @@ static inline void put_bits_le(PutBitContext *s, int n, unsigned int value)
unsigned int bit_buf;
int bit_left;
- av_assert2(n <= 31 && value < (1U << n));
+ av_assert2(n <= 31);
+ av_assert2(value < (1U << n));
bit_buf = s->bit_buf;
bit_left = s->bit_left;
@@ -239,7 +241,8 @@ static inline void put_bits_le(PutBitContext *s, int n, unsigned int value)
static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
{
- av_assert2(n >= 0 && n <= 31);
+ av_assert2(n >= 0);
+ av_assert2(n <= 31);
put_bits(pb, n, av_mod_uintp2(value, n));
}
@@ -1815,7 +1815,8 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
}else
r->si.end = si.start;
}
- av_assert0 (size >= 0 && size <= buf_size - offset);
+ av_assert0 (size >= 0);
+ av_assert0 (size <= buf_size - offset);
last = rv34_decode_slice(r, r->si.end, buf + offset, size);
if(last)
break;
@@ -303,7 +303,10 @@ static void OPNAME ## rv40_chroma_mc4_c(uint8_t *dst /*align 8*/,\
int i;\
int bias = rv40_bias[y>>1][x>>1];\
\
- av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ av_assert2(x < 8);\
+ av_assert2(y < 8);\
+ av_assert2(x >= 0);\
+ av_assert2(y >= 0);\
\
if(D){\
for(i = 0; i < h; i++){\
@@ -339,7 +342,10 @@ static void OPNAME ## rv40_chroma_mc8_c(uint8_t *dst/*align 8*/,\
int i;\
int bias = rv40_bias[y>>1][x>>1];\
\
- av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ av_assert2(x < 8);\
+ av_assert2(y < 8);\
+ av_assert2(x >= 0);\
+ av_assert2(y >= 0);\
\
if(D){\
for(i = 0; i < h; i++){\
@@ -841,7 +841,8 @@ static int process_block(SANMVideoContext *ctx, uint8_t *dst, uint8_t *prev1,
int my = motion_vectors[code][1];
int index = prev2 - (const uint8_t *)ctx->frm2;
- av_assert2(index >= 0 && index < (ctx->buf_size >> 1));
+ av_assert2(index >= 0);
+ av_assert2(index < (ctx->buf_size >> 1));
if (index < -mx - my * stride ||
(ctx->buf_size >> 1) - index < mx + size + (my + size - 1) * stride) {
@@ -74,7 +74,8 @@ av_cold void AAC_RENAME(ff_sine_window_init)(INTFLOAT *window, int n) {
}
av_cold void AAC_RENAME(ff_init_ff_sine_windows)(int index) {
- assert(index >= 0 && index < FF_ARRAY_ELEMS(AAC_RENAME(ff_sine_windows)));
+ assert(index >= 0);
+ assert(index < FF_ARRAY_ELEMS(AAC_RENAME(ff_sine_windows)));
#if !CONFIG_HARDCODED_TABLES
AAC_RENAME(ff_sine_window_init)(AAC_RENAME(ff_sine_windows)[index], 1 << index);
#endif
@@ -175,7 +175,8 @@ static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int
int16_t *tmpI= tmpIt;
uint8_t *tmp2= tmp2t[0];
const uint8_t *hpel[11];
- av_assert2(dx<16 && dy<16);
+ av_assert2(dx < 16);
+ av_assert2(dy < 16);
r= brane[dx + 16*dy]&15;
l= brane[dx + 16*dy]>>4;
@@ -681,7 +681,8 @@ static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, i
else max_run= FFMIN(run, w-x-1);
if(parent_xc)
max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
- av_assert2(max_run >= 0 && max_run <= run);
+ av_assert2(max_run >= 0);
+ av_assert2(max_run <= run);
x+= max_run;
run-= max_run;
@@ -79,7 +79,8 @@ void ff_slice_buffer_release(slice_buffer *buf, int line)
{
IDWTELEM *buffer;
- av_assert1(line >= 0 && line < buf->line_count);
+ av_assert1(line >= 0);
+ av_assert1(line < buf->line_count);
av_assert1(buf->line[line]);
buffer = buf->line[line];
@@ -408,8 +408,10 @@ static int encode_q_branch(SnowContext *s, int level, int x, int y){
av_assert1(iscore < 255*255*256 + s->lambda2*10);
av_assert1(iscore >= 0);
- av_assert1(l>=0 && l<=255);
- av_assert1(pl>=0 && pl<=255);
+ av_assert1(l >= 0);
+ av_assert1(l <= 255);
+ av_assert1(pl >= 0);
+ av_assert1(pl <= 255);
if(level==0){
int varc= iscore >> 8;
@@ -908,8 +910,9 @@ static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int
unsigned value;
int rd, index;
- av_assert2(mb_x>=0 && mb_y>=0);
- av_assert2(mb_x<b_stride);
+ av_assert2(mb_x >= 0);
+ av_assert2(mb_y >= 0);
+ av_assert2(mb_x < b_stride);
if(intra){
block->color[0] = p[0];
@@ -962,7 +965,8 @@ static av_always_inline int check_4block_inter(SnowContext *s, int mb_x, int mb_
backup[2] = block[b_stride];
backup[3] = block[b_stride + 1];
- av_assert2(mb_x>=0 && mb_y>=0);
+ av_assert2(mb_x >= 0);
+ av_assert2(mb_y >= 0);
av_assert2(mb_x<b_stride);
av_assert2(((mb_x|mb_y)&1) == 0);
@@ -155,7 +155,8 @@ static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,
score = sqr - (diff * (int64_t)diff >> (level + 3)); // FIXME: 64 bits slooow
if (score < best_vector_score) {
int mean = diff + (size >> 1) >> (level + 3);
- av_assert2(mean > -300 && mean < 300);
+ av_assert2(mean > -300);
+ av_assert2(mean < 300);
mean = av_clip(mean, intra ? 0 : -256, 255);
best_vector_score = score;
best_vector[stage] = i;
@@ -208,8 +209,10 @@ static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,
if (!split) {
av_assert1(best_mean >= 0 && best_mean < 256 || !intra);
- av_assert1(best_mean >= -256 && best_mean < 256);
- av_assert1(best_count >= 0 && best_count < 7);
+ av_assert1(best_mean >= -256);
+ av_assert1(best_mean < 256);
+ av_assert1(best_count >= 0);
+ av_assert1(best_count < 7);
av_assert1(level < 4 || best_count == 0);
/* output the encoding */
@@ -220,7 +223,8 @@ static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,
mean_vlc[best_mean][0]);
for (i = 0; i < best_count; i++) {
- av_assert2(best_vector[i] >= 0 && best_vector[i] < 16);
+ av_assert2(best_vector[i] >= 0);
+ av_assert2(best_vector[i] < 16);
put_bits(&s->reorder_pb[level], 4, best_vector[i]);
}
@@ -419,10 +423,14 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
s->m.pb = s->reorder_pb[5];
mx = motion_ptr[0];
my = motion_ptr[1];
- av_assert1(mx >= -32 && mx <= 31);
- av_assert1(my >= -32 && my <= 31);
- av_assert1(pred_x >= -32 && pred_x <= 31);
- av_assert1(pred_y >= -32 && pred_y <= 31);
+ av_assert1(mx >= -32);
+ av_assert1(mx <= 31);
+ av_assert1(my >= -32);
+ av_assert1(my <= 31);
+ av_assert1(pred_x >= -32);
+ av_assert1(pred_x <= 31);
+ av_assert1(pred_y >= -32);
+ av_assert1(pred_y <= 31);
ff_h263_encode_motion(&s->m.pb, mx - pred_x, 1);
ff_h263_encode_motion(&s->m.pb, my - pred_y, 1);
s->reorder_pb[5] = s->m.pb;
@@ -688,7 +688,10 @@ static void vaapi_encode_set_b_pictures(AVCodecContext *avctx,
VAAPIEncodePicture *pic, *next, *ref;
int i, len;
- av_assert0(start && end && start != end && start->next != end);
+ av_assert0(start);
+ av_assert0(end);
+ av_assert0(start != end);
+ av_assert0(start->next != end);
// If we are at the maximum depth then encode all pictures as
// non-referenced B-pictures. Also do this if there is exactly one
@@ -899,7 +902,8 @@ static int vaapi_encode_clear_old(AVCodecContext *avctx)
for (pic = ctx->pic_start; pic; pic = next) {
next = pic->next;
if (pic->encode_complete && pic->ref_count[1] == 0) {
- av_assert0(pic->ref_removed[0] && pic->ref_removed[1]);
+ av_assert0(pic->ref_removed[0]);
+ av_assert0(pic->ref_removed[1]);
if (prev)
prev->next = next;
else
@@ -712,7 +712,8 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *ref = pic->refs[i];
VAAPIEncodeH264Picture *href;
- av_assert0(ref && ref->encode_order < pic->encode_order);
+ av_assert0(ref);
+ av_assert0(ref->encode_order < pic->encode_order);
href = ref->priv_data;
vpic->ReferenceFrames[i] = (VAPictureH264) {
@@ -703,7 +703,8 @@ static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx,
hpic->pic_type = 1;
} else {
VAAPIEncodePicture *irap_ref;
- av_assert0(pic->refs[0] && pic->refs[1]);
+ av_assert0(pic->refs[0]);
+ av_assert0(pic->refs[1]);
for (irap_ref = pic; irap_ref; irap_ref = irap_ref->refs[1]) {
if (irap_ref->type == PICTURE_TYPE_I)
break;
@@ -817,7 +818,8 @@ static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *ref = pic->refs[i];
VAAPIEncodeH265Picture *href;
- av_assert0(ref && ref->encode_order < pic->encode_order);
+ av_assert0(ref);
+ av_assert0(ref->encode_order < pic->encode_order);
href = ref->priv_data;
vpic->reference_frames[i] = (VAPictureHEVC) {
@@ -116,8 +116,8 @@ static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
{
VAAPIEncodeVP9Picture *href0 = pic->refs[0]->priv_data,
*href1 = pic->refs[1]->priv_data;
- av_assert0(href0->slot < pic->b_depth + 1 &&
- href1->slot < pic->b_depth + 1);
+ av_assert0(href0->slot < pic->b_depth + 1);
+ av_assert0(href1->slot < pic->b_depth + 1);
if (pic->b_depth == ctx->max_b_depth) {
// Unreferenced frame.
@@ -658,7 +658,8 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
px = A[0];
py = A[1];
} else /*if (field_b && b_valid)*/ {
- av_assert1(field_b && b_valid);
+ av_assert1(field_b);
+ av_assert1(b_valid);
px = B[0];
py = B[1];
}
@@ -793,7 +793,10 @@ static void put_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
const int D = (x) * (y);
int i;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
for (i = 0; i < h; i++) {
dst[0] = chroma_mc(0);
@@ -818,7 +821,10 @@ static void put_no_rnd_vc1_chroma_mc4_c(uint8_t *dst, uint8_t *src,
const int D = (x) * (y);
int i;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
for (i = 0; i < h; i++) {
dst[0] = chroma_mc(0);
@@ -841,7 +847,10 @@ static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
const int D = (x) * (y);
int i;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
for (i = 0; i < h; i++) {
dst[0] = avg2(dst[0], chroma_mc(0));
@@ -867,7 +876,10 @@ static void avg_no_rnd_vc1_chroma_mc4_c(uint8_t *dst /* align 8 */,
const int D = ( x) * ( y);
int i;
- av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+ av_assert2(x < 8);
+ av_assert2(y < 8);
+ av_assert2(x >= 0);
+ av_assert2(y >= 0);
for (i = 0; i < h; i++) {
dst[0] = avg2(dst[0], chroma_mc(0));
@@ -55,8 +55,10 @@ void FUNC(ff_emulated_edge_mc)(uint8_t *buf, const uint8_t *src,
start_x = FFMAX(0, -src_x);
end_y = FFMIN(block_h, h-src_y);
end_x = FFMIN(block_w, w-src_x);
- av_assert2(start_y < end_y && block_h);
- av_assert2(start_x < end_x && block_w);
+ av_assert2(start_y < end_y);
+ av_assert2(block_h);
+ av_assert2(start_x < end_x);
+ av_assert2(block_w);
w = end_x - start_x;
src += start_y * src_linesize + start_x * sizeof(pixel);
@@ -180,7 +180,8 @@ static int update_size(AVCodecContext *avctx, int w, int h)
int bytesperpixel = s->bytesperpixel, ret, cols, rows;
int lflvl_len, i;
- av_assert0(w > 0 && h > 0);
+ av_assert0(w > 0);
+ av_assert0(h > 0);
if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
@@ -91,7 +91,8 @@ static av_always_inline int check_intra_mode(VP9TileData *td, int mode, uint8_t
[DC_129_PRED] = { 0 }
};
- av_assert2(mode >= 0 && mode < 10);
+ av_assert2(mode >= 0);
+ av_assert2(mode < 10);
mode = mode_conv[mode][have_left][have_top];
if (edges[mode].needs_top) {
uint8_t *top, *topleft;
@@ -162,7 +162,8 @@ static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
q_end = q + s->block_len;
if (s->version == 1) {
last_exp = *exp_param++;
- av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
+ av_assert0(last_exp - 10 >= 0);
+ av_assert0(last_exp - 10 < 32);
put_bits(&s->pb, 5, last_exp - 10);
q += *ptr++;
} else
@@ -170,7 +171,8 @@ static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
while (q < q_end) {
int exp = *exp_param++;
int code = exp - last_exp + 60;
- av_assert1(code >= 0 && code < 120);
+ av_assert1(code >= 0);
+ av_assert1(code < 120);
put_bits(&s->pb, ff_aac_scalefactor_bits[code],
ff_aac_scalefactor_code[code]);
/* XXX: use a table */
@@ -185,8 +185,10 @@ static av_always_inline void emulated_edge_mc(uint8_t *dst, const uint8_t *src,
start_x = FFMAX(0, -src_x);
end_y = FFMIN(block_h, h-src_y);
end_x = FFMIN(block_w, w-src_x);
- av_assert2(start_x < end_x && block_w > 0);
- av_assert2(start_y < end_y && block_h > 0);
+ av_assert2(start_x < end_x);
+ av_assert2(block_w > 0);
+ av_assert2(start_y < end_y);
+ av_assert2(block_h > 0);
// fill in the to-be-copied part plus all above/below
src += (src_y_add + start_y) * src_stride + start_x;
@@ -144,7 +144,8 @@ int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatConte
AVDictionary **device_options)
{
int ret;
- av_assert0(s && caps);
+ av_assert0(s);
+ av_assert0(caps);
av_assert0(s->iformat || s->oformat);
if ((s->oformat && !s->oformat->create_device_capabilities) ||
(s->iformat && !s->iformat->create_device_capabilities))
@@ -997,7 +997,8 @@ static av_cold int opengl_init_context(OpenGLContext *opengl)
goto fail;
desc = av_pix_fmt_desc_get(opengl->pix_fmt);
- av_assert0(desc->nb_components > 0 && desc->nb_components <= 4);
+ av_assert0(desc->nb_components > 0);
+ av_assert0(desc->nb_components <= 4);
glGenTextures(desc->nb_components, opengl->texture_name);
opengl->glprocs.glGenBuffers(2, &opengl->index_buffer);
@@ -802,9 +802,9 @@ static int yae_overlap_add(ATempoContext *atempo,
uint8_t *dst = *dst_ref;
- av_assert0(start_here <= stop_here &&
- frag->position[1] <= start_here &&
- overlap <= frag->nsamples);
+ av_assert0(start_here <= stop_here);
+ av_assert0(frag->position[1] <= start_here);
+ av_assert0(overlap <= frag->nsamples);
if (atempo->format == AV_SAMPLE_FMT_U8) {
yae_blend(uint8_t);
@@ -973,7 +973,8 @@ static int yae_flush(ATempoContext *atempo,
start_here = FFMAX(atempo->position[1], overlap_end);
stop_here = frag->position[1] + frag->nsamples;
offset = start_here - frag->position[1];
- av_assert0(start_here <= stop_here && frag->position[1] <= start_here);
+ av_assert0(start_here <= stop_here);
+ av_assert0(frag->position[1] <= start_here);
src = frag->data + offset * atempo->stride;
dst = (uint8_t *)*dst_ref;
@@ -492,7 +492,8 @@ static void update_gain_history(DynamicAudioNormalizerContext *s, int channel,
static inline double update_value(double new, double old, double aggressiveness)
{
- av_assert0((aggressiveness >= 0.0) && (aggressiveness <= 1.0));
+ av_assert0(aggressiveness >= 0.0);
+ av_assert0(aggressiveness <= 1.0);
return aggressiveness * new + (1.0 - aggressiveness) * old;
}
@@ -336,8 +336,12 @@ static void stereo_transform(float *x, float *y, float angle)
static void stereo_position(float a, float p, float *x, float *y)
{
- av_assert2(a >= -1.f && a <= 1.f);
- av_assert2(p >= 0.f && p <= M_PI);
+ av_assert2(a >= -1.f);
+ av_assert2(a <= 1.f);
+
+ av_assert2(p >= 0.f);
+ av_assert2(p <= M_PI);
+
*x = av_clipf(a+a*FFMAX(0, p*p-M_PI_2), -1, 1);
*y = av_clipf(cosf(a*M_PI_2+M_PI)*cosf(M_PI_2-p/M_PI)*M_LN10+1, -1, 1);
}
@@ -119,7 +119,8 @@ static float *make_lpf(int num_taps, float Fc, float beta, float rho,
float *h = av_calloc(num_taps, sizeof(*h)), sum = 0;
float mult = scale / bessel_I_0(beta), mult1 = 1.f / (.5f * m + rho);
- av_assert0(Fc >= 0 && Fc <= 1);
+ av_assert0(Fc >= 0);
+ av_assert0(Fc <= 1);
for (i = 0; i <= m / 2; i++) {
float z = i - .5f * m, x = z * M_PI, y = z * mult1;
@@ -164,7 +164,8 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
link->srcpad = &src->output_pads[srcpad];
link->dstpad = &dst->input_pads[dstpad];
link->type = src->output_pads[srcpad].type;
- av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
+ av_assert0(AV_PIX_FMT_NONE == -1);
+ av_assert0(AV_SAMPLE_FMT_NONE == -1);
link->format = -1;
ff_framequeue_init(&link->fifo, &src->graph->internal->frame_queues);
@@ -70,7 +70,8 @@ static void fn(yuv2rgb)(int16_t *rgb[3], ptrdiff_t rgb_stride,
av_assert2(yuv2rgb_coeffs[0][1][0] == 0);
av_assert2(yuv2rgb_coeffs[2][2][0] == 0);
- av_assert2(yuv2rgb_coeffs[1][0][0] == cy && yuv2rgb_coeffs[2][0][0] == cy);
+ av_assert2(yuv2rgb_coeffs[1][0][0] == cy);
+ av_assert2(yuv2rgb_coeffs[2][0][0] == cy);
w = AV_CEIL_RSHIFT(w, SS_W);
h = AV_CEIL_RSHIFT(h, SS_H);
@@ -179,8 +179,10 @@ int avfilter_transform(const uint8_t *src, uint8_t *dst,
x_s = avpriv_mirror(x_s, width-1);
y_s = avpriv_mirror(y_s, height-1);
- av_assert2(x_s >= 0 && y_s >= 0);
- av_assert2(x_s < width && y_s < height);
+ av_assert2(x_s >= 0);
+ av_assert2(y_s >= 0);
+ av_assert2(x_s < width);
+ av_assert2(y_s < height);
def = src[(int)y_s * src_stride + (int)x_s];
}
@@ -311,8 +311,11 @@ static inline int interpolate(void *log_ctx, uint16_t *y,
const int x_start = point->x * scale;
const int x_end = point->next->x * scale;
- av_assert0(x_start >= 0 && x_start < lut_size &&
- x_end >= 0 && x_end < lut_size);
+ av_assert0(x_start >= 0);
+ av_assert0(x_start < lut_size);
+
+ av_assert0(x_end >= 0);
+ av_assert0(x_end < lut_size);
for (x = x_start; x <= x_end; x++) {
const double xx = (x - x_start) * 1./scale;
@@ -696,7 +696,9 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
prv = src; \
if (!prv) /* received only one frame at that point */ \
return 0; \
- av_assert0(prv && src && nxt); \
+ av_assert0(prv); \
+ av_assert0(src); \
+ av_assert0(nxt); \
} while (0)
if (FF_INLINK_IDX(inlink) == INPUT_MAIN) {
av_assert0(fm->got_frame[INPUT_MAIN] == 0);
@@ -991,7 +991,8 @@ static int config_clut(AVFilterLink *inlink)
av_log(ctx, AV_LOG_WARNING, "The Hald CLUT width does not match the level\n");
return AVERROR_INVALIDDATA;
}
- av_assert0(w == h && w == size);
+ av_assert0(w == h);
+ av_assert0(w == size);
level *= level;
if (level > MAX_LEVEL) {
const int max_clut_level = sqrt(MAX_LEVEL);
@@ -86,7 +86,8 @@ static av_cold int init(AVFilterContext *ctx)
s->nb_inputs = FFMAX(s->nb_inputs, s->map[i][1] + 1);
}
- av_assert0(s->nb_inputs && s->nb_inputs <= 4);
+ av_assert0(s->nb_inputs);
+ av_assert0(s->nb_inputs <= 4);
for (i = 0; i < s->nb_inputs; i++) {
AVFilterPad pad = { 0 };
@@ -113,7 +113,9 @@ static void compute_safe_ssd_integral_image_c(uint32_t *dst, ptrdiff_t dst_lines
const uint32_t *dst_top = dst - dst_linesize_32;
/* SIMD-friendly assumptions allowed here */
- av_assert2(!(w & 0xf) && w >= 16 && h >= 1);
+ av_assert2(!(w & 0xf));
+ av_assert2(w >= 16);
+ av_assert2(h >= 1);
for (y = 0; y < h; y++) {
for (x = 0; x < w; x += 4) {
@@ -301,7 +301,8 @@ static void haldclutsrc_fill_picture(AVFilterContext *ctx, AVFrame *frame)
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
uint8_t rgba_map[4];
- av_assert0(w == h && w == level*level*level);
+ av_assert0(w == h);
+ av_assert0(w == level*level*level);
ff_fill_rgba_map(rgba_map, frame->format);
@@ -444,7 +444,8 @@ int av_frame_ref(AVFrame *dst, const AVFrame *src)
{
int i, ret = 0;
- av_assert1(dst->width == 0 && dst->height == 0);
+ av_assert1(dst->width == 0);
+ av_assert1(dst->height == 0);
av_assert1(dst->channels == 0);
dst->format = src->format;
@@ -581,7 +582,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
{
- av_assert1(dst->width == 0 && dst->height == 0);
+ av_assert1(dst->width == 0);
+ av_assert1(dst->height == 0);
av_assert1(dst->channels == 0);
*dst = *src;
@@ -500,8 +500,8 @@ static int opencl_device_create_internal(AVHWDeviceContext *hwdev,
*device_name_src = NULL;
int err, found, p, d;
- av_assert0(selector->enumerate_platforms &&
- selector->enumerate_devices);
+ av_assert0(selector->enumerate_platforms);
+ av_assert0(selector->enumerate_devices);
err = selector->enumerate_platforms(hwdev, &nb_platforms, &platforms,
selector->context);
@@ -119,7 +119,8 @@ AVInteger av_mod_i(AVInteger *quot, AVInteger a, AVInteger b){
return av_sub_i(zero_i, a);
}
- av_assert2((int16_t)a.v[AV_INTEGER_SIZE-1] >= 0 && (int16_t)b.v[AV_INTEGER_SIZE-1] >= 0);
+ av_assert2((int16_t)a.v[AV_INTEGER_SIZE-1] >= 0);
+ av_assert2((int16_t)b.v[AV_INTEGER_SIZE-1] >= 0);
av_assert2(av_log2_i(b)>=0);
if(i > 0)
@@ -60,7 +60,8 @@ int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
int64_t r = 0;
av_assert2(c > 0);
av_assert2(b >=0);
- av_assert2((unsigned)(rnd&~AV_ROUND_PASS_MINMAX)<=5 && (rnd&~AV_ROUND_PASS_MINMAX)!=4);
+ av_assert2((unsigned)(rnd&~AV_ROUND_PASS_MINMAX) <= 5);
+ av_assert2((rnd&~AV_ROUND_PASS_MINMAX) != 4);
if (c <= 0 || b < 0 || !((unsigned)(rnd&~AV_ROUND_PASS_MINMAX)<=5 && (rnd&~AV_ROUND_PASS_MINMAX)!=4))
return INT64_MIN;
@@ -2566,13 +2566,18 @@ void ff_check_pixfmt_descriptors(void){
av_assert0(d->log2_chroma_w <= 3);
av_assert0(d->log2_chroma_h <= 3);
av_assert0(d->nb_components <= 4);
- av_assert0(d->name && d->name[0]);
+ av_assert0(d->name);
+ av_assert0(d->name[0]);
av_assert2(av_get_pix_fmt(d->name) == i);
for (j=0; j<FF_ARRAY_ELEMS(d->comp); j++) {
const AVComponentDescriptor *c = &d->comp[j];
if(j>=d->nb_components) {
- av_assert0(!c->plane && !c->step && !c->offset && !c->shift && !c->depth);
+ av_assert0(!c->plane);
+ av_assert0(!c->step);
+ av_assert0(!c->offset);
+ av_assert0(!c->shift);
+ av_assert0(!c->depth);
continue;
}
if (d->flags & AV_PIX_FMT_FLAG_BITSTREAM) {
@@ -2583,7 +2588,8 @@ void ff_check_pixfmt_descriptors(void){
if (d->flags & AV_PIX_FMT_FLAG_BAYER)
continue;
av_read_image_line(tmp, (void*)data, linesize, d, 0, 0, j, 2, 0);
- av_assert0(tmp[0] == 0 && tmp[1] == 0);
+ av_assert0(tmp[0] == 0);
+ av_assert0(tmp[1] == 0);
tmp[0] = tmp[1] = (1<<c->depth) - 1;
av_write_image_line(tmp, data, linesize, d, 0, 0, j, 2);
}
@@ -69,7 +69,8 @@ int av_reduce(int *dst_num, int *dst_den,
den = next_den;
}
av_assert2(av_gcd(a1.num, a1.den) <= 1U);
- av_assert2(a1.num <= max && a1.den <= max);
+ av_assert2(a1.num <= max);
+ av_assert2(a1.den <= max);
*dst_num = sign ? -a1.num : a1.num;
*dst_den = a1.den;
@@ -82,7 +82,8 @@ static inline av_const SoftFloat av_normalize1_sf(SoftFloat a){
a.exp++;
a.mant>>=1;
}
- av_assert2(a.mant < 0x40000000 && a.mant > -0x40000000);
+ av_assert2(a.mant < 0x40000000);
+ av_assert2(a.mant > -0x40000000);
av_assert2(a.exp <= MAX_EXP);
return a;
#elif 1
@@ -390,7 +390,8 @@ static int rebuild_filter_bank_with_compensation(ResampleContext *c)
if (phase_count == c->phase_count)
return 0;
- av_assert0(!c->frac && !c->dst_incr_mod);
+ av_assert0(!c->frac);
+ av_assert0(!c->dst_incr_mod);
new_filter_bank = av_calloc(c->filter_alloc, (phase_count + 1) * c->felem_size);
if (!new_filter_bank)
@@ -202,8 +202,11 @@ static int planarToP01xWrapper(SwsContext *c, const uint8_t *src8[],
src_format->comp[2].depth - src_format->comp[2].shift,
};
- av_assert0(!(srcStride[0] % 2 || srcStride[1] % 2 || srcStride[2] % 2 ||
- dstStride[0] % 2 || dstStride[1] % 2));
+ av_assert0(!(srcStride[0] % 2));
+ av_assert0(!(srcStride[1] % 2));
+ av_assert0(!(srcStride[2] % 2));
+ av_assert0(!(dstStride[0] % 2));
+ av_assert0(!(dstStride[1] % 2));
for (y = 0; y < srcSliceH; y++) {
uint16_t *tdstY = dstY;
@@ -1223,7 +1223,8 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
return AVERROR(EINVAL);
}
}
- av_assert2(desc_src && desc_dst);
+ av_assert2(desc_src);
+ av_assert2(desc_dst);
i = flags & (SWS_POINT |
SWS_AREA |
@@ -194,7 +194,8 @@ static int any_vscale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int
desc->dst->plane[2].line[dp2],
desc->alpha ? desc->dst->plane[3].line[dp3] : NULL };
- av_assert1(!c->yuv2packed1 && !c->yuv2packed2);
+ av_assert1(!c->yuv2packed1);
+ av_assert1(!c->yuv2packed2);
((yuv2anyX_fn)inst->pfn)(c, lum_filter + sliceY * lum_fsize,
(const int16_t**)src0, lum_fsize, chr_filter + sliceY * chr_fsize,
(const int16_t**)src1, (const int16_t**)src2, chr_fsize, (const int16_t**)src3, dst, dstW, sliceY);
@@ -74,7 +74,8 @@ void checkasm_check_nlmeans(void)
const int safe_pw = (u_endx_safe - startx_safe) & ~0xf;
const int safe_ph = endy_safe - starty_safe;
- av_assert0(safe_pw && safe_ph);
+ av_assert0(safe_pw);
+ av_assert0(safe_ph);
av_assert0(startx_safe - s1x >= 0); av_assert0(startx_safe - s1x < w);
av_assert0(starty_safe - s1y >= 0); av_assert0(starty_safe - s1y < h);
av_assert0(startx_safe - s2x >= 0); av_assert0(startx_safe - s2x < w);
--
2.21.0