virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-01-29 22:00:58 +02:00
Code Issues Releases Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  configure: add support for bdver1 and bdver2 CPU types.
  avio: make avio_close NULL the freed buffer
  pixdesc: cosmetics
  proresenc: Don't free a buffer not owned by the codec
  proresenc: Write the full value in one put_bits call
  adpcmenc: Calculate the IMA_QT predictor without overflow
  x86: Add convenience macros to check for CPU extensions and flags
  x86: h264dsp: drop some unnecessary ifdefs around prototype declarations
  mss12: merge decode_pixel() and decode_top_left_pixel()
  mss12: reduce SliceContext size from 1067 to 164 KB
  mss12: move SliceContexts out of the common context into the codec contexts

Conflicts:
	libavformat/aviobuf.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2012-09-04 17:04:51 +02:00
commit 9dcc4c30f9
9 changed files with 166 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
configure vendored
View File

@ -2404,7 +2404,7 @@ suncc_flags(){
prescott|nocona) echo -xarch=sse3 -xchip=pentium4 ;; prescott|nocona) echo -xarch=sse3 -xchip=pentium4 ;;
*-sse3) echo -xarch=sse3 ;; *-sse3) echo -xarch=sse3 ;;
core2) echo -xarch=ssse3 -xchip=core2 ;; core2) echo -xarch=ssse3 -xchip=core2 ;;
amdfam10|barcelona) echo -xarch=sse4_1 ;; amdfam10|barcelona|bdver*) echo -xarch=sse4_1 ;;
athlon-4|athlon-[mx]p) echo -xarch=ssea ;; athlon-4|athlon-[mx]p) echo -xarch=ssea ;;
k8|opteron|athlon64|athlon-fx) k8|opteron|athlon64|athlon-fx)
echo -xarch=sse2a ;; echo -xarch=sse2a ;;
@ -2773,7 +2773,7 @@ elif enabled x86; then
disable cmov disable cmov
;; ;;
# targets that do support conditional mov (cmov) # targets that do support conditional mov (cmov)
i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64*|k8*|opteron*|athlon-fx|core2|amdfam10|barcelona|atom) i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64*|k8*|opteron*|athlon-fx|core2|amdfam10|barcelona|atom|bdver*)
cpuflags="-march=$cpu" cpuflags="-march=$cpu"
enable cmov enable cmov
enable fast_cmov enable fast_cmov

11
libavcodec/mss1.c
View File

@ -30,7 +30,7 @@
typedef struct MSS1Context { typedef struct MSS1Context {
MSS12Context ctx; MSS12Context ctx;
AVFrame pic; AVFrame pic;
SliceContext sc[2]; SliceContext sc;
} MSS1Context; } MSS1Context;
static void arith_normalise(ArithCoder *c) static void arith_normalise(ArithCoder *c)
@ -89,7 +89,7 @@ static int arith_get_number(ArithCoder *c, int mod_val)
return val; return val;
} }
static int arith_get_prob(ArithCoder *c, int *probs) static int arith_get_prob(ArithCoder *c, int16_t *probs)
{ {
int range = c->high - c->low + 1; int range = c->high - c->low + 1;
int val = ((c->value - c->low + 1) * probs[0] - 1) / range; int val = ((c->value - c->low + 1) * probs[0] - 1) / range;
@ -162,7 +162,8 @@ static int mss1_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
c->pal_stride = -ctx->pic.linesize[0]; c->pal_stride = -ctx->pic.linesize[0];
c->keyframe = !arith_get_bit(&acoder); c->keyframe = !arith_get_bit(&acoder);
if (c->keyframe) { if (c->keyframe) {
ff_mss12_codec_reset(c); c->corrupted = 0;
ff_mss12_slicecontext_reset(&ctx->sc);
pal_changed = decode_pal(c, &acoder); pal_changed = decode_pal(c, &acoder);
ctx->pic.key_frame = 1; ctx->pic.key_frame = 1;
ctx->pic.pict_type = AV_PICTURE_TYPE_I; ctx->pic.pict_type = AV_PICTURE_TYPE_I;
@ -172,7 +173,7 @@ static int mss1_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
ctx->pic.key_frame = 0; ctx->pic.key_frame = 0;
ctx->pic.pict_type = AV_PICTURE_TYPE_P; ctx->pic.pict_type = AV_PICTURE_TYPE_P;
} }
c->corrupted = ff_mss12_decode_rect(&c->sc[0], &acoder, 0, 0, c->corrupted = ff_mss12_decode_rect(&ctx->sc, &acoder, 0, 0,
avctx->width, avctx->height); avctx->width, avctx->height);
if (c->corrupted) if (c->corrupted)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -194,7 +195,7 @@ static av_cold int mss1_decode_init(AVCodecContext *avctx)
c->ctx.avctx = avctx; c->ctx.avctx = avctx;
avctx->coded_frame = &c->pic; avctx->coded_frame = &c->pic;
ret = ff_mss12_decode_init(&c->ctx, 0); ret = ff_mss12_decode_init(&c->ctx, 0, &c->sc, NULL);
avctx->pix_fmt = PIX_FMT_PAL8; avctx->pix_fmt = PIX_FMT_PAL8;

171
libavcodec/mss12.c
View File

@ -61,13 +61,9 @@ static void model_reset(Model *m)
m->weights[i] = 1; m->weights[i] = 1;
m->cum_prob[i] = m->num_syms - i; m->cum_prob[i] = m->num_syms - i;
} }
m->weights[0] = -1; m->weights[0] = 0;
m->idx2sym[0] = -1; for (i = 0; i < m->num_syms; i++)
m->sym2idx[m->num_syms] = -1;
for (i = 0; i < m->num_syms; i++) {
m->sym2idx[i] = i + 1;
m->idx2sym[i + 1] = i; m->idx2sym[i + 1] = i;
}
} }
static av_cold void model_init(Model *m, int num_syms, int thr_weight) static av_cold void model_init(Model *m, int num_syms, int thr_weight)
@ -75,7 +71,6 @@ static av_cold void model_init(Model *m, int num_syms, int thr_weight)
m->num_syms = num_syms; m->num_syms = num_syms;
m->thr_weight = thr_weight; m->thr_weight = thr_weight;
m->threshold = num_syms * thr_weight; m->threshold = num_syms * thr_weight;
model_reset(m);
} }
static void model_rescale_weights(Model *m) static void model_rescale_weights(Model *m)
@ -109,8 +104,6 @@ void ff_mss12_model_update(Model *m, int val)
m->idx2sym[val] = sym2; m->idx2sym[val] = sym2;
m->idx2sym[i] = sym1; m->idx2sym[i] = sym1;
m->sym2idx[sym1] = i;
m->sym2idx[sym2] = val;
val = i; val = i;
} }
@ -123,7 +116,7 @@ void ff_mss12_model_update(Model *m, int val)
static void pixctx_reset(PixContext *ctx) static void pixctx_reset(PixContext *ctx)
{ {
int i, j, k; int i, j;
if (!ctx->special_initial_cache) if (!ctx->special_initial_cache)
for (i = 0; i < ctx->cache_size; i++) for (i = 0; i < ctx->cache_size; i++)
@ -137,16 +130,15 @@ static void pixctx_reset(PixContext *ctx)
model_reset(&ctx->cache_model); model_reset(&ctx->cache_model);
model_reset(&ctx->full_model); model_reset(&ctx->full_model);
for (i = 0; i < 4; i++) for (i = 0; i < 15; i++)
for (j = 0; j < sec_order_sizes[i]; j++) for (j = 0; j < 4; j++)
for (k = 0; k < 4; k++) model_reset(&ctx->sec_models[i][j]);
model_reset(&ctx->sec_models[i][j][k]);
} }
static av_cold void pixctx_init(PixContext *ctx, int cache_size, static av_cold void pixctx_init(PixContext *ctx, int cache_size,
int full_model_syms, int special_initial_cache) int full_model_syms, int special_initial_cache)
{ {
int i, j, k; int i, j, k, idx;
ctx->cache_size = cache_size + 4; ctx->cache_size = cache_size + 4;
ctx->num_syms = cache_size; ctx->num_syms = cache_size;
@ -155,57 +147,36 @@ static av_cold void pixctx_init(PixContext *ctx, int cache_size,
model_init(&ctx->cache_model, ctx->num_syms + 1, THRESH_LOW); model_init(&ctx->cache_model, ctx->num_syms + 1, THRESH_LOW);
model_init(&ctx->full_model, full_model_syms, THRESH_HIGH); model_init(&ctx->full_model, full_model_syms, THRESH_HIGH);
for (i = 0; i < 4; i++) for (i = 0, idx = 0; i < 4; i++)
for (j = 0; j < sec_order_sizes[i]; j++) for (j = 0; j < sec_order_sizes[i]; j++, idx++)
for (k = 0; k < 4; k++) for (k = 0; k < 4; k++)
model_init(&ctx->sec_models[i][j][k], 2 + i, model_init(&ctx->sec_models[idx][k], 2 + i,
i ? THRESH_LOW : THRESH_ADAPTIVE); i ? THRESH_LOW : THRESH_ADAPTIVE);
} }
static int decode_top_left_pixel(ArithCoder *acoder, PixContext *pctx) static av_always_inline int decode_pixel(ArithCoder *acoder, PixContext *pctx,
uint8_t *ngb, int num_ngb, int any_ngb)
{ {
int i, val, pix; int i, val, pix;
val = acoder->get_model_sym(acoder, &pctx->cache_model); val = acoder->get_model_sym(acoder, &pctx->cache_model);
if (val < pctx->num_syms) { if (val < pctx->num_syms) {
pix = pctx->cache[val]; if (any_ngb) {
} else { int idx, j;
pix = acoder->get_model_sym(acoder, &pctx->full_model);
for (i = 0; i < pctx->cache_size - 1; i++)
if (pctx->cache[i] == pix)
break;
val = i;
}
if (val) {
for (i = val; i > 0; i--)
pctx->cache[i] = pctx->cache[i - 1];
pctx->cache[0] = pix;
}
return pix; idx = 0;
} for (i = 0; i < pctx->cache_size; i++) {
for (j = 0; j < num_ngb; j++)
static int decode_pixel(ArithCoder *acoder, PixContext *pctx, if (pctx->cache[i] == ngb[j])
uint8_t *ngb, int num_ngb) break;
{ if (j == num_ngb) {
int i, val, pix; if (idx == val)
break;
val = acoder->get_model_sym(acoder, &pctx->cache_model); idx++;
if (val < pctx->num_syms) { }
int idx, j;
idx = 0;
for (i = 0; i < pctx->cache_size; i++) {
for (j = 0; j < num_ngb; j++)
if (pctx->cache[i] == ngb[j])
break;
if (j == num_ngb) {
if (idx == val)
break;
idx++;
} }
val = FFMIN(i, pctx->cache_size - 1);
} }
val = FFMIN(i, pctx->cache_size - 1);
pix = pctx->cache[val]; pix = pctx->cache[val];
} else { } else {
pix = acoder->get_model_sym(acoder, &pctx->full_model); pix = acoder->get_model_sym(acoder, &pctx->full_model);
@ -268,50 +239,52 @@ static int decode_pixel_in_context(ArithCoder *acoder, PixContext *pctx,
switch (nlen) { switch (nlen) {
case 1: case 1:
case 4:
layer = 0; layer = 0;
break; break;
case 2: case 2:
if (neighbours[TOP] == neighbours[TOP_LEFT]) { if (neighbours[TOP] == neighbours[TOP_LEFT]) {
if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT]) if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT])
layer = 3; layer = 1;
else if (neighbours[LEFT] == neighbours[TOP_LEFT]) else if (neighbours[LEFT] == neighbours[TOP_LEFT])
layer = 2; layer = 2;
else else
layer = 4; layer = 3;
} else if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT]) { } else if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT]) {
if (neighbours[LEFT] == neighbours[TOP_LEFT]) if (neighbours[LEFT] == neighbours[TOP_LEFT])
layer = 1; layer = 4;
else else
layer = 5; layer = 5;
} else if (neighbours[LEFT] == neighbours[TOP_LEFT]) { } else if (neighbours[LEFT] == neighbours[TOP_LEFT]) {
layer = 6; layer = 6;
} else { } else {
layer = 0; layer = 7;
} }
break; break;
case 3: case 3:
if (neighbours[TOP] == neighbours[TOP_LEFT]) if (neighbours[TOP] == neighbours[TOP_LEFT])
layer = 0; layer = 8;
else if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT]) else if (neighbours[TOP_RIGHT] == neighbours[TOP_LEFT])
layer = 1; layer = 9;
else if (neighbours[LEFT] == neighbours[TOP_LEFT]) else if (neighbours[LEFT] == neighbours[TOP_LEFT])
layer = 2; layer = 10;
else if (neighbours[TOP_RIGHT] == neighbours[TOP]) else if (neighbours[TOP_RIGHT] == neighbours[TOP])
layer = 3; layer = 11;
else if (neighbours[TOP] == neighbours[LEFT]) else if (neighbours[TOP] == neighbours[LEFT])
layer = 4; layer = 12;
else else
layer = 5; layer = 13;
break;
case 4:
layer = 14;
break; break;
} }
pix = acoder->get_model_sym(acoder, pix = acoder->get_model_sym(acoder,
&pctx->sec_models[nlen - 1][layer][sub]); &pctx->sec_models[layer][sub]);
if (pix < nlen) if (pix < nlen)
return ref_pix[pix]; return ref_pix[pix];
else else
return decode_pixel(acoder, pctx, ref_pix, nlen); return decode_pixel(acoder, pctx, ref_pix, nlen, 1);
} }
static int decode_region(ArithCoder *acoder, uint8_t *dst, uint8_t *rgb_pic, static int decode_region(ArithCoder *acoder, uint8_t *dst, uint8_t *rgb_pic,
@ -326,7 +299,7 @@ static int decode_region(ArithCoder *acoder, uint8_t *dst, uint8_t *rgb_pic,
for (j = 0; j < height; j++) { for (j = 0; j < height; j++) {
for (i = 0; i < width; i++) { for (i = 0; i < width; i++) {
if (!i && !j) if (!i && !j)
p = decode_top_left_pixel(acoder, pctx); p = decode_pixel(acoder, pctx, NULL, 0, 0);
else else
p = decode_pixel_in_context(acoder, pctx, dst + i, stride, p = decode_pixel_in_context(acoder, pctx, dst + i, stride,
i, j, width - i - 1); i, j, width - i - 1);
@ -418,7 +391,7 @@ static int decode_region_masked(MSS12Context const *c, ArithCoder *acoder,
return -1; return -1;
} else if (mask[i] != 0x80) { } else if (mask[i] != 0x80) {
if (!i && !j) if (!i && !j)
p = decode_top_left_pixel(acoder, pctx); p = decode_pixel(acoder, pctx, NULL, 0, 0);
else else
p = decode_pixel_in_context(acoder, pctx, dst + i, stride, p = decode_pixel_in_context(acoder, pctx, dst + i, stride,
i, j, width - i - 1); i, j, width - i - 1);
@ -435,39 +408,30 @@ static int decode_region_masked(MSS12Context const *c, ArithCoder *acoder,
return 0; return 0;
} }
static av_cold void codec_init(MSS12Context *c, int version) static av_cold void slicecontext_init(SliceContext *sc,
int version, int full_model_syms)
{ {
int i; model_init(&sc->intra_region, 2, THRESH_ADAPTIVE);
for (i = 0; i < (c->slice_split ? 2 : 1); i++) { model_init(&sc->inter_region, 2, THRESH_ADAPTIVE);
c->sc[i].c = c; model_init(&sc->split_mode, 3, THRESH_HIGH);
model_init(&c->sc[i].intra_region, 2, THRESH_ADAPTIVE); model_init(&sc->edge_mode, 2, THRESH_HIGH);
model_init(&c->sc[i].inter_region, 2, THRESH_ADAPTIVE); model_init(&sc->pivot, 3, THRESH_LOW);
model_init(&c->sc[i].split_mode, 3, THRESH_HIGH);
model_init(&c->sc[i].edge_mode, 2, THRESH_HIGH);
model_init(&c->sc[i].pivot, 3, THRESH_LOW);
pixctx_init(&c->sc[i].intra_pix_ctx, 8, c->full_model_syms, 0); pixctx_init(&sc->intra_pix_ctx, 8, full_model_syms, 0);
pixctx_init(&c->sc[i].inter_pix_ctx, version ? 3 : 2, pixctx_init(&sc->inter_pix_ctx, version ? 3 : 2,
c->full_model_syms, version ? 1 : 0); full_model_syms, version ? 1 : 0);
}
c->corrupted = 1;
} }
void ff_mss12_codec_reset(MSS12Context *c) void ff_mss12_slicecontext_reset(SliceContext *sc)
{ {
int i; model_reset(&sc->intra_region);
for (i = 0; i < (c->slice_split ? 2 : 1); i++) { model_reset(&sc->inter_region);
model_reset(&c->sc[i].intra_region); model_reset(&sc->split_mode);
model_reset(&c->sc[i].inter_region); model_reset(&sc->edge_mode);
model_reset(&c->sc[i].split_mode); model_reset(&sc->pivot);
model_reset(&c->sc[i].edge_mode); pixctx_reset(&sc->intra_pix_ctx);
model_reset(&c->sc[i].pivot); pixctx_reset(&sc->inter_pix_ctx);
pixctx_reset(&c->sc[i].intra_pix_ctx);
pixctx_reset(&c->sc[i].inter_pix_ctx);
}
c->corrupted = 0;
} }
static int decode_pivot(SliceContext *sc, ArithCoder *acoder, int base) static int decode_pivot(SliceContext *sc, ArithCoder *acoder, int base)
@ -505,7 +469,7 @@ static int decode_region_intra(SliceContext *sc, ArithCoder *acoder,
uint8_t *dst = c->pal_pic + x + y * stride; uint8_t *dst = c->pal_pic + x + y * stride;
uint8_t *rgb_dst = c->rgb_pic + x * 3 + y * rgb_stride; uint8_t *rgb_dst = c->rgb_pic + x * 3 + y * rgb_stride;
pix = decode_top_left_pixel(acoder, &sc->intra_pix_ctx); pix = decode_pixel(acoder, &sc->intra_pix_ctx, NULL, 0, 0);
rgb_pix = c->pal[pix]; rgb_pix = c->pal[pix];
for (i = 0; i < height; i++, dst += stride, rgb_dst += rgb_stride) { for (i = 0; i < height; i++, dst += stride, rgb_dst += rgb_stride) {
memset(dst, pix, width); memset(dst, pix, width);
@ -531,7 +495,7 @@ static int decode_region_inter(SliceContext *sc, ArithCoder *acoder,
mode = acoder->get_model_sym(acoder, &sc->inter_region); mode = acoder->get_model_sym(acoder, &sc->inter_region);
if (!mode) { if (!mode) {
mode = decode_top_left_pixel(acoder, &sc->inter_pix_ctx); mode = decode_pixel(acoder, &sc->inter_pix_ctx, NULL, 0, 0);
if (c->avctx->err_recognition & AV_EF_EXPLODE && if (c->avctx->err_recognition & AV_EF_EXPLODE &&
( c->rgb_pic && mode != 0x01 && mode != 0x02 && mode != 0x04 || ( c->rgb_pic && mode != 0x01 && mode != 0x02 && mode != 0x04 ||
@ -595,7 +559,8 @@ int ff_mss12_decode_rect(SliceContext *sc, ArithCoder *acoder,
return 0; return 0;
} }
av_cold int ff_mss12_decode_init(MSS12Context *c, int version) av_cold int ff_mss12_decode_init(MSS12Context *c, int version,
SliceContext* sc1, SliceContext *sc2)
{ {
AVCodecContext *avctx = c->avctx; AVCodecContext *avctx = c->avctx;
int i; int i;
@ -690,7 +655,13 @@ av_cold int ff_mss12_decode_init(MSS12Context *c, int version)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
codec_init(c, version); sc1->c = c;
slicecontext_init(sc1, version, c->full_model_syms);
if (c->slice_split) {
sc2->c = c;
slicecontext_init(sc2, version, c->full_model_syms);
}
c->corrupted = 1;
return 0; return 0;
} }

18
libavcodec/mss12.h
View File

@ -38,10 +38,9 @@
#define THRESH_HIGH 50 #define THRESH_HIGH 50
typedef struct Model { typedef struct Model {
int cum_prob[MODEL_MAX_SYMS + 1]; int16_t cum_prob[MODEL_MAX_SYMS + 1];
int weights[MODEL_MAX_SYMS + 1]; int16_t weights[MODEL_MAX_SYMS + 1];
int idx2sym[MODEL_MAX_SYMS + 1]; uint8_t idx2sym[MODEL_MAX_SYMS + 1];
int sym2idx[MODEL_MAX_SYMS + 1];
int num_syms; int num_syms;
int thr_weight, threshold; int thr_weight, threshold;
} Model; } Model;
@ -60,7 +59,7 @@ typedef struct PixContext {
int cache_size, num_syms; int cache_size, num_syms;
uint8_t cache[12]; uint8_t cache[12];
Model cache_model, full_model; Model cache_model, full_model;
Model sec_models[4][8][4]; Model sec_models[15][4];
int special_initial_cache; int special_initial_cache;
} PixContext; } PixContext;
@ -86,21 +85,18 @@ typedef struct MSS12Context {
int rgb_stride; int rgb_stride;
int free_colours; int free_colours;
int keyframe; int keyframe;
Model intra_region, inter_region;
Model pivot, edge_mode, split_mode;
PixContext intra_pix_ctx, inter_pix_ctx;
int mvX, mvY; int mvX, mvY;
int corrupted; int corrupted;
int slice_split; int slice_split;
int full_model_syms; int full_model_syms;
SliceContext sc[2];
} MSS12Context; } MSS12Context;
int ff_mss12_decode_rect(SliceContext *ctx, ArithCoder *acoder, int ff_mss12_decode_rect(SliceContext *ctx, ArithCoder *acoder,
int x, int y, int width, int height); int x, int y, int width, int height);
void ff_mss12_model_update(Model *m, int val); void ff_mss12_model_update(Model *m, int val);
void ff_mss12_codec_reset(MSS12Context *ctx); void ff_mss12_slicecontext_reset(SliceContext *sc);
av_cold int ff_mss12_decode_init(MSS12Context *ctx, int version); av_cold int ff_mss12_decode_init(MSS12Context *c, int version,
SliceContext* sc1, SliceContext *sc2);
av_cold int ff_mss12_decode_end(MSS12Context *ctx); av_cold int ff_mss12_decode_end(MSS12Context *ctx);
#define ARITH_GET_BIT(VERSION) \ #define ARITH_GET_BIT(VERSION) \

16
libavcodec/mss2.c
View File

@ -106,7 +106,7 @@ static int arith2_get_number(ArithCoder *c, int n)
return val; return val;
} }
static int arith2_get_prob(ArithCoder *c, int *probs) static int arith2_get_prob(ArithCoder *c, int16_t *probs)
{ {
int range = c->high - c->low + 1, n = *probs; int range = c->high - c->low + 1, n = *probs;
int scale = av_log2(range) - av_log2(n); int scale = av_log2(range) - av_log2(n);
@ -671,14 +671,18 @@ static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
buf += get_bits_count(&gb) >> 3; buf += get_bits_count(&gb) >> 3;
buf_size -= get_bits_count(&gb) >> 3; buf_size -= get_bits_count(&gb) >> 3;
} else { } else {
if (keyframe) if (keyframe) {
ff_mss12_codec_reset(c); c->corrupted = 0;
ff_mss12_slicecontext_reset(&ctx->sc[0]);
if (c->slice_split)
ff_mss12_slicecontext_reset(&ctx->sc[1]);
}
else if (c->corrupted) else if (c->corrupted)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING); bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
arith2_init(&acoder, &gB); arith2_init(&acoder, &gB);
c->keyframe = keyframe; c->keyframe = keyframe;
if (c->corrupted = ff_mss12_decode_rect(&c->sc[0], &acoder, 0, 0, if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[0], &acoder, 0, 0,
avctx->width, avctx->width,
ctx->split_position)) ctx->split_position))
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -690,7 +694,7 @@ static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING); bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
arith2_init(&acoder, &gB); arith2_init(&acoder, &gB);
if (c->corrupted = ff_mss12_decode_rect(&c->sc[1], &acoder, 0, if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[1], &acoder, 0,
ctx->split_position, ctx->split_position,
avctx->width, avctx->width,
avctx->height - ctx->split_position)) avctx->height - ctx->split_position))
@ -830,7 +834,7 @@ static av_cold int mss2_decode_init(AVCodecContext *avctx)
int ret; int ret;
c->avctx = avctx; c->avctx = avctx;
avctx->coded_frame = &ctx->pic; avctx->coded_frame = &ctx->pic;
if (ret = ff_mss12_decode_init(c, 1)) if (ret = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1]))
return ret; return ret;
c->pal_stride = c->mask_stride; c->pal_stride = c->mask_stride;
c->pal_pic = av_malloc(c->pal_stride * avctx->height); c->pal_pic = av_malloc(c->pal_stride * avctx->height);

6
libavcodec/x86/h264dsp_init.c
View File

@ -39,11 +39,9 @@ IDCT_ADD_FUNC(8_dc, 10, sse2)
IDCT_ADD_FUNC(8, 8, mmx) IDCT_ADD_FUNC(8, 8, mmx)
IDCT_ADD_FUNC(8, 8, sse2) IDCT_ADD_FUNC(8, 8, sse2)
IDCT_ADD_FUNC(8, 10, sse2) IDCT_ADD_FUNC(8, 10, sse2)
#if HAVE_AVX_EXTERNAL
IDCT_ADD_FUNC(, 10, avx) IDCT_ADD_FUNC(, 10, avx)
IDCT_ADD_FUNC(8_dc, 10, avx) IDCT_ADD_FUNC(8_dc, 10, avx)
IDCT_ADD_FUNC(8, 10, avx) IDCT_ADD_FUNC(8, 10, avx)
#endif
#define IDCT_ADD_REP_FUNC(NUM, REP, DEPTH, OPT) \ #define IDCT_ADD_REP_FUNC(NUM, REP, DEPTH, OPT) \
@ -64,10 +62,8 @@ IDCT_ADD_REP_FUNC(, 16intra, 8, mmx)
IDCT_ADD_REP_FUNC(, 16intra, 8, mmx2) IDCT_ADD_REP_FUNC(, 16intra, 8, mmx2)
IDCT_ADD_REP_FUNC(, 16intra, 8, sse2) IDCT_ADD_REP_FUNC(, 16intra, 8, sse2)
IDCT_ADD_REP_FUNC(, 16intra, 10, sse2) IDCT_ADD_REP_FUNC(, 16intra, 10, sse2)
#if HAVE_AVX_EXTERNAL
IDCT_ADD_REP_FUNC(, 16, 10, avx) IDCT_ADD_REP_FUNC(, 16, 10, avx)
IDCT_ADD_REP_FUNC(, 16intra, 10, avx) IDCT_ADD_REP_FUNC(, 16intra, 10, avx)
#endif
#define IDCT_ADD_REP_FUNC2(NUM, REP, DEPTH, OPT) \ #define IDCT_ADD_REP_FUNC2(NUM, REP, DEPTH, OPT) \
@ -79,9 +75,7 @@ IDCT_ADD_REP_FUNC2(, 8, 8, mmx)
IDCT_ADD_REP_FUNC2(, 8, 8, mmx2) IDCT_ADD_REP_FUNC2(, 8, 8, mmx2)
IDCT_ADD_REP_FUNC2(, 8, 8, sse2) IDCT_ADD_REP_FUNC2(, 8, 8, sse2)
IDCT_ADD_REP_FUNC2(, 8, 10, sse2) IDCT_ADD_REP_FUNC2(, 8, 10, sse2)
#if HAVE_AVX_EXTERNAL
IDCT_ADD_REP_FUNC2(, 8, 10, avx) IDCT_ADD_REP_FUNC2(, 8, 10, avx)
#endif
void ff_h264_luma_dc_dequant_idct_mmx(DCTELEM *output, DCTELEM *input, int qmul); void ff_h264_luma_dc_dequant_idct_mmx(DCTELEM *output, DCTELEM *input, int qmul);
void ff_h264_luma_dc_dequant_idct_sse2(DCTELEM *output, DCTELEM *input, int qmul); void ff_h264_luma_dc_dequant_idct_sse2(DCTELEM *output, DCTELEM *input, int qmul);

2
libavformat/aviobuf.c
View File

@ -796,7 +796,7 @@ int avio_close(AVIOContext *s)
avio_flush(s); avio_flush(s);
h = s->opaque; h = s->opaque;
av_free(s->buffer); av_freep(&s->buffer);
if (!s->write_flag) if (!s->write_flag)
av_log(s, AV_LOG_DEBUG, "Statistics: %"PRId64" bytes read, %d seeks\n", s->bytes_read, s->seek_count); av_log(s, AV_LOG_DEBUG, "Statistics: %"PRId64" bytes read, %d seeks\n", s->bytes_read, s->seek_count);
av_free(s); av_free(s);

18
libavutil/pixdesc.c
View File

@ -26,8 +26,10 @@
#include "intreadwrite.h" #include "intreadwrite.h"
void av_read_image_line(uint16_t *dst, const uint8_t *data[4], const int linesize[4], void av_read_image_line(uint16_t *dst,
const AVPixFmtDescriptor *desc, int x, int y, int c, int w, const uint8_t *data[4], const int linesize[4],
const AVPixFmtDescriptor *desc,
int x, int y, int c, int w,
int read_pal_component) int read_pal_component)
{ {
AVComponentDescriptor comp = desc->comp[c]; AVComponentDescriptor comp = desc->comp[c];
@ -53,7 +55,8 @@ void av_read_image_line(uint16_t *dst, const uint8_t *data[4], const int linesiz
*dst++ = val; *dst++ = val;
} }
} else { } else {
const uint8_t *p = data[plane] + y * linesize[plane] + x * step + comp.offset_plus1 - 1; const uint8_t *p = data[plane] + y * linesize[plane] +
x * step + comp.offset_plus1 - 1;
int is_8bit = shift + depth <= 8; int is_8bit = shift + depth <= 8;
if (is_8bit) if (is_8bit)
@ -71,8 +74,10 @@ void av_read_image_line(uint16_t *dst, const uint8_t *data[4], const int linesiz
} }
} }
void av_write_image_line(const uint16_t *src, uint8_t *data[4], const int linesize[4], void av_write_image_line(const uint16_t *src,
const AVPixFmtDescriptor *desc, int x, int y, int c, int w) uint8_t *data[4], const int linesize[4],
const AVPixFmtDescriptor *desc,
int x, int y, int c, int w)
{ {
AVComponentDescriptor comp = desc->comp[c]; AVComponentDescriptor comp = desc->comp[c];
int plane = comp.plane; int plane = comp.plane;
@ -93,7 +98,8 @@ void av_write_image_line(const uint16_t *src, uint8_t *data[4], const int linesi
} }
} else { } else {
int shift = comp.shift; int shift = comp.shift;
uint8_t *p = data[plane] + y * linesize[plane] + x * step + comp.offset_plus1 - 1; uint8_t *p = data[plane] + y * linesize[plane] +
x * step + comp.offset_plus1 - 1;
if (shift + depth <= 8) { if (shift + depth <= 8) {
p += !!(flags & PIX_FMT_BE); p += !!(flags & PIX_FMT_BE);

57
libavutil/x86/cpu.h Normal file
View File

@ -0,0 +1,57 @@
/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVUTIL_X86_CPU_H
#define AVUTIL_X86_CPU_H
#include "config.h"
#include "libavutil/cpu.h"
#define CPUEXT(flags, suffix, cpuext) \
(HAVE_ ## cpuext ## suffix && ((flags) & AV_CPU_FLAG_ ## cpuext))
#define AV_CPU_FLAG_AMD3DNOW AV_CPU_FLAG_3DNOW
#define AV_CPU_FLAG_AMD3DNOWEXT AV_CPU_FLAG_3DNOWEXT
#define EXTERNAL_AMD3DNOW(flags) CPUEXT(flags, _EXTERNAL, AMD3DNOW)
#define EXTERNAL_AMD3DNOWEXT(flags) CPUEXT(flags, _EXTERNAL, AMD3DNOWEXT)
#define EXTERNAL_MMX(flags) CPUEXT(flags, _EXTERNAL, MMX)
#define EXTERNAL_MMXEXT(flags) CPUEXT(flags, _EXTERNAL, MMXEXT)
#define EXTERNAL_SSE(flags) CPUEXT(flags, _EXTERNAL, SSE)
#define EXTERNAL_SSE2(flags) CPUEXT(flags, _EXTERNAL, SSE2)
#define EXTERNAL_SSE3(flags) CPUEXT(flags, _EXTERNAL, SSE3)
#define EXTERNAL_SSSE3(flags) CPUEXT(flags, _EXTERNAL, SSSE3)
#define EXTERNAL_SSE4(flags) CPUEXT(flags, _EXTERNAL, SSE4)
#define EXTERNAL_SSE42(flags) CPUEXT(flags, _EXTERNAL, SSE42)
#define EXTERNAL_AVX(flags) CPUEXT(flags, _EXTERNAL, AVX)
#define EXTERNAL_FMA4(flags) CPUEXT(flags, _EXTERNAL, FMA4)
#define INLINE_AMD3DNOW(flags) CPUEXT(flags, _INLINE, AMD3DNOW)
#define INLINE_AMD3DNOWEXT(flags) CPUEXT(flags, _INLINE, AMD3DNOWEXT)
#define INLINE_MMX(flags) CPUEXT(flags, _INLINE, MMX)
#define INLINE_MMXEXT(flags) CPUEXT(flags, _INLINE, MMXEXT)
#define INLINE_SSE(flags) CPUEXT(flags, _INLINE, SSE)
#define INLINE_SSE2(flags) CPUEXT(flags, _INLINE, SSE2)
#define INLINE_SSE3(flags) CPUEXT(flags, _INLINE, SSE3)
#define INLINE_SSSE3(flags) CPUEXT(flags, _INLINE, SSSE3)
#define INLINE_SSE4(flags) CPUEXT(flags, _INLINE, SSE4)
#define INLINE_SSE42(flags) CPUEXT(flags, _INLINE, SSE42)
#define INLINE_AVX(flags) CPUEXT(flags, _INLINE, AVX)
#define INLINE_FMA4(flags) CPUEXT(flags, _INLINE, FMA4)
#endif /* AVUTIL_X86_CPU_H */