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

Merge remote-tracking branch 'cehoyos/master'

Browse Source 
* cehoyos/master:
  Support compilation on aix with gcc.
  Rename "AVClass class" as "AVClass component_class".
  Rename constant FRAMESIZE in ra144 codec as FRAME_SIZE.
  Rename thread_init() in libavcodec and libavfilter as library_thread_init().
  Rename constant HZ in af_biquads.c as HERTZ.
  Drop local lable from ppc asm timer.

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2013-06-30 21:18:12 +02:00
commit b00e56bec5
20 changed files with 55 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure vendored
View File

@ -3392,6 +3392,8 @@ enabled spic && enable_weak pic
# OS specific
case $target_os in
aix)
;;
haiku)
prefix_default="/boot/common"
network_extralibs="-lnetwork"

4
libavcodec/cljr.c
View File

@ -168,7 +168,7 @@ static const AVOption options[] = {
{ NULL },
};
static const AVClass class = {
static const AVClass cljr_class = {
.class_name = "cljr encoder",
.item_name = av_default_item_name,
.option = options,
@ -185,6 +185,6 @@ AVCodec ff_cljr_encoder = {
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV411P,
AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
.priv_class = &class,
.priv_class = &cljr_class,
};
#endif

4
libavcodec/dnxhdenc.c
View File

@ -43,7 +43,7 @@ static const AVOption options[]={
{NULL}
};
static const AVClass class = {
static const AVClass dnxhd_class = {
.class_name = "dnxhd",
.item_name = av_default_item_name,
.option = options,
@ -1049,6 +1049,6 @@ AVCodec ff_dnxhd_encoder = {
AV_PIX_FMT_YUV422P10,
AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
.priv_class = &class,
.priv_class = &dnxhd_class,
.defaults = dnxhd_defaults,
};

4
libavcodec/dvdsubdec.c
View File

@ -591,7 +591,7 @@ static const AVOption options[] = {
{ "palette", "set the global palette", OFFSET(palette_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
{ NULL }
};
static const AVClass class = {
static const AVClass dvdsub_class = {
.class_name = "dvdsubdec",
.item_name = av_default_item_name,
.option = options,
@ -606,5 +606,5 @@ AVCodec ff_dvdsub_decoder = {
.init = dvdsub_init,
.decode = dvdsub_decode,
.long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
.priv_class = &class,
.priv_class = &dvdsub_class,
};

4
libavcodec/ffv1enc.c
View File

@ -1135,7 +1135,7 @@ static const AVOption options[] = {
{ NULL }
};
static const AVClass class = {
static const AVClass ffv1_class = {
.class_name = "ffv1 encoder",
.item_name = av_default_item_name,
.option = options,
@ -1169,5 +1169,5 @@ AVCodec ff_ffv1_encoder = {
},
.long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
.defaults = ffv1_defaults,
.priv_class = &class,
.priv_class = &ffv1_class,
};

4
libavcodec/g726.c
View File

@ -368,7 +368,7 @@ static const AVOption options[] = {
{ NULL },
};
static const AVClass class = {
static const AVClass g726_class = {
.class_name = "g726",
.item_name = av_default_item_name,
.option = options,
@ -391,7 +391,7 @@ AVCodec ff_adpcm_g726_encoder = {
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
.priv_class = &class,
.priv_class = &g726_class,
.defaults = defaults,
};
#endif

4
libavcodec/jpeg2000dec.c
View File

@ -1434,7 +1434,7 @@ static const AVProfile profiles[] = {
{ FF_PROFILE_UNKNOWN },
};
static const AVClass class = {
static const AVClass jpeg2000_class = {
.class_name = "jpeg2000",
.item_name = av_default_item_name,
.option = options,
@ -1450,7 +1450,7 @@ AVCodec ff_jpeg2000_decoder = {
.priv_data_size = sizeof(Jpeg2000DecoderContext),
.init_static_data = jpeg2000_init_static_data,
.decode = jpeg2000_decode_frame,
.priv_class = &class,
.priv_class = &jpeg2000_class,
.max_lowres = 5,
.profiles = NULL_IF_CONFIG_SMALL(profiles)
};

4
libavcodec/pthread.c
View File

@ -249,7 +249,7 @@ static int avcodec_thread_execute2(AVCodecContext *avctx, action_func2* func2, v
return avcodec_thread_execute(avctx, NULL, arg, ret, job_count, 0);
}
static int thread_init(AVCodecContext *avctx)
static int avcodec_thread_init(AVCodecContext *avctx)
{
int i;
ThreadContext *c;
@ -1103,7 +1103,7 @@ int ff_thread_init(AVCodecContext *avctx)
validate_thread_parameters(avctx);
if (avctx->active_thread_type&FF_THREAD_SLICE)
return thread_init(avctx);
return avcodec_thread_init(avctx);
else if (avctx->active_thread_type&FF_THREAD_FRAME)
return frame_thread_init(avctx);

2
libavcodec/ra144.h
View File

@ -30,7 +30,7 @@
#define BLOCKSIZE 40 ///< subblock size in 16-bit words
#define BUFFERSIZE 146 ///< the size of the adaptive codebook
#define FIXED_CB_SIZE 128 ///< size of fixed codebooks
#define FRAMESIZE 20 ///< size of encoded frame
#define FRAME_SIZE 20 ///< size of encoded frame
#define LPC_ORDER 10 ///< order of LPC filter
typedef struct RA144Context {

6
libavcodec/ra144dec.c
View File

@ -76,7 +76,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *data,
RA144Context *ractx = avctx->priv_data;
GetBitContext gb;
if (buf_size < FRAMESIZE) {
if (buf_size < FRAME_SIZE) {
av_log(avctx, AV_LOG_ERROR,
"Frame too small (%d bytes). Truncated file?\n", buf_size);
*got_frame_ptr = 0;
@ -89,7 +89,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *data,
return ret;
samples = (int16_t *)frame->data[0];
init_get_bits(&gb, buf, FRAMESIZE * 8);
init_get_bits(&gb, buf, FRAME_SIZE * 8);
for (i = 0; i < LPC_ORDER; i++)
lpc_refl[i] = ff_lpc_refl_cb[i][get_bits(&gb, sizes[i])];
@ -122,7 +122,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *data,
*got_frame_ptr = 1;
return FRAMESIZE;
return FRAME_SIZE;
}
AVCodec ff_ra_144_decoder = {

4
libavcodec/ra144enc.c
View File

@ -447,7 +447,7 @@ static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
if (ractx->last_frame)
return 0;
if ((ret = ff_alloc_packet2(avctx, avpkt, FRAMESIZE)) < 0)
if ((ret = ff_alloc_packet2(avctx, avpkt, FRAME_SIZE)) < 0)
return ret;
/**
@ -536,7 +536,7 @@ static int ra144_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
ff_af_queue_remove(&ractx->afq, avctx->frame_size, &avpkt->pts,
&avpkt->duration);
avpkt->size = FRAMESIZE;
avpkt->size = FRAME_SIZE;
*got_packet_ptr = 1;
return 0;
}

4
libavcodec/rawdec.c
View File

@ -48,7 +48,7 @@ static const AVOption options[]={
{NULL}
};
static const AVClass class = {
static const AVClass rawdec_class = {
.class_name = "rawdec",
.option = options,
.version = LIBAVUTIL_VERSION_INT,
@ -351,5 +351,5 @@ AVCodec ff_rawvideo_decoder = {
.close = raw_close_decoder,
.decode = raw_decode,
.long_name = NULL_IF_CONFIG_SMALL("raw video"),
.priv_class = &class,
.priv_class = &rawdec_class,
};

36
libavfilter/af_biquads.c
View File

@ -83,7 +83,7 @@ enum FilterType {
enum WidthType {
NONE,
HZ,
HERTZ,
OCTAVE,
QFACTOR,
SLOPE,
@ -250,7 +250,7 @@ static int config_output(AVFilterLink *outlink)
case NONE:
alpha = 0.0;
break;
case HZ:
case HERTZ:
alpha = sin(w0) / (2 * p->frequency / p->width);
break;
case OCTAVE:
@ -470,8 +470,8 @@ AVFilter avfilter_af_##name_ = { \
static const AVOption equalizer_options[] = {
{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
@ -488,8 +488,8 @@ DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter
static const AVOption bass_options[] = {
{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
@ -506,8 +506,8 @@ DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");
static const AVOption treble_options[] = {
{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
@ -524,8 +524,8 @@ DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");
static const AVOption bandpass_options[] = {
{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
@ -541,8 +541,8 @@ DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.")
static const AVOption bandreject_options[] = {
{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
@ -557,8 +557,8 @@ DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filte
static const AVOption lowpass_options[] = {
{"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
{"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
@ -575,8 +575,8 @@ DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.
static const AVOption highpass_options[] = {
{"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
@ -593,8 +593,8 @@ DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequenc
static const AVOption allpass_options[] = {
{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HZ}, HZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HZ}, 0, 0, FLAGS, "width_type"},
{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, SLOPE, FLAGS, "width_type"},
{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},

4
libavfilter/pthread.c
View File

@ -146,7 +146,7 @@ static int thread_execute(AVFilterContext *ctx, action_func *func,
return 0;
}
static int thread_init(ThreadContext *c, int nb_threads)
static int avfilter_thread_init(ThreadContext *c, int nb_threads)
{
int i, ret;
@ -208,7 +208,7 @@ int ff_graph_thread_init(AVFilterGraph *graph)
if (!graph->internal->thread)
return AVERROR(ENOMEM);
ret = thread_init(graph->internal->thread, graph->nb_threads);
ret = avfilter_thread_init(graph->internal->thread, graph->nb_threads);
if (ret <= 1) {
av_freep(&graph->internal->thread);
graph->thread_type = 0;

4
libavformat/flvdec.c
View File

@ -911,7 +911,7 @@ static const AVOption options[] = {
{ NULL }
};
static const AVClass class = {
static const AVClass flv_class = {
.class_name = "flvdec",
.item_name = av_default_item_name,
.option = options,
@ -928,5 +928,5 @@ AVInputFormat ff_flv_demuxer = {
.read_seek = flv_read_seek,
.read_close = flv_read_close,
.extensions = "flv",
.priv_class = &class,
.priv_class = &flv_class,
};

4
libavformat/gsmdec.c
View File

@ -80,7 +80,7 @@ static const AVOption options[] = {
{ NULL },
};
static const AVClass class = {
static const AVClass gsm_class = {
.class_name = "gsm demuxer",
.item_name = av_default_item_name,
.option = options,
@ -96,5 +96,5 @@ AVInputFormat ff_gsm_demuxer = {
.flags = AVFMT_GENERIC_INDEX,
.extensions = "gsm",
.raw_codec_id = AV_CODEC_ID_GSM,
.priv_class = &class,
.priv_class = &gsm_class,
};

4
libavformat/mov.c
View File

@ -3414,7 +3414,7 @@ static const AVOption options[] = {
{NULL}
};
static const AVClass class = {
static const AVClass mov_class = {
.class_name = "mov,mp4,m4a,3gp,3g2,mj2",
.item_name = av_default_item_name,
.option = options,
@ -3430,6 +3430,6 @@ AVInputFormat ff_mov_demuxer = {
.read_packet = mov_read_packet,
.read_close = mov_read_close,
.read_seek = mov_read_seek,
.priv_class = &class,
.priv_class = &mov_class,
.flags = AVFMT_NO_BYTE_SEEK,
};

4
libavformat/spdifenc.c
View File

@ -92,7 +92,7 @@ static const AVOption options[] = {
{ NULL },
};
static const AVClass class = {
static const AVClass spdif_class = {
.class_name = "spdif",
.item_name = av_default_item_name,
.option = options,
@ -552,5 +552,5 @@ AVOutputFormat ff_spdif_muxer = {
.write_packet = spdif_write_packet,
.write_trailer = spdif_write_trailer,
.flags = AVFMT_NOTIMESTAMPS,
.priv_class = &class,
.priv_class = &spdif_class,
};

4
libavutil/eval.c
View File

@ -52,7 +52,7 @@ typedef struct Parser {
double *var;
} Parser;
static const AVClass class = { "Eval", av_default_item_name, NULL, LIBAVUTIL_VERSION_INT, offsetof(Parser,log_offset), offsetof(Parser,log_ctx) };
static const AVClass eval_class = { "Eval", av_default_item_name, NULL, LIBAVUTIL_VERSION_INT, offsetof(Parser,log_offset), offsetof(Parser,log_ctx) };
static const int8_t si_prefixes['z' - 'E' + 1] = {
['y'-'E']= -24,
@ -657,7 +657,7 @@ int av_expr_parse(AVExpr **expr, const char *s,
if (!av_isspace(*s++)) *wp++ = s[-1];
*wp++ = 0;
p.class = &class;
p.class = &eval_class;
p.stack_index=100;
p.s= w;
p.const_names = const_names;

3
libavutil/ppc/timer.h
View File

@ -31,12 +31,11 @@ static inline uint64_t read_time(void)
/* from section 2.2.1 of the 32-bit PowerPC PEM */
__asm__ volatile(
"1:\n"
"mftbu %2\n"
"mftb %0\n"
"mftbu %1\n"
"cmpw %2,%1\n"
"bne 1b\n"
"bne $-0x10\n"
: "=r"(tbl), "=r"(tbu), "=r"(temp)
:
: "cc");