static void update_configuration(sh_video_t *sh, enum AVPixelFormat pix_fmt) {
vd_ffmpeg_ctx *ctx = sh->context;
AVCodecContext *avctx = ctx->avctx;
if (!avctx->sample_aspect_ratio.den) {
mp_msg(MSGT_DECVIDEO, MSGL_WARN, "FFmpeg bug: Invalid aspect\n");
avctx->sample_aspect_ratio.den = 1;
}
// it is possible another vo buffers to be used after vo config()
// lavc reset its buffers on width/heigh change but not on aspect change!!!
if (av_cmp_q(avctx->sample_aspect_ratio, ctx->last_sample_aspect_ratio) ||
pix_fmt != ctx->pix_fmt ||
!ctx->vo_initialized)
{
float aspect= av_q2d(avctx->sample_aspect_ratio) * avctx->width / avctx->height;
ctx->vo_initialized = 0;
// this is a special-case HACK for MPEG-1/2 VDPAU that uses neither get_format nor
// sets the value correctly in avcodec_open.
set_format_params(avctx, pix_fmt);
mp_msg(MSGT_DECVIDEO, MSGL_V, "[ffmpeg] aspect_ratio: %f\n", aspect);
// Do not overwrite sh->original_aspect on the first call,
// if a container aspect is available (which is preferred then).
// But set it even if the sample aspect did not change, since a
// resolution change can cause an aspect change even if the
// _sample_ aspect is unchanged.
if (sh->original_aspect == 0 || ctx->last_sample_aspect_ratio.den)
sh->original_aspect = aspect;
ctx->last_sample_aspect_ratio = avctx->sample_aspect_ratio;
ctx->pix_fmt = pix_fmt;
ctx->best_csp = pixfmt2imgfmt2(pix_fmt, avctx->codec_id);
}
}
int main(void)
{
AVRational a,b,r;
for (a.num = -2; a.num <= 2; a.num++) {
for (a.den = -2; a.den <= 2; a.den++) {
for (b.num = -2; b.num <= 2; b.num++) {
for (b.den = -2; b.den <= 2; b.den++) {
int c = av_cmp_q(a,b);
double d = av_q2d(a) == av_q2d(b) ?
0 : (av_q2d(a) - av_q2d(b));
if (d > 0) d = 1;
else if (d < 0) d = -1;
else if (d != d) d = INT_MIN;
if (c != d)
av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num,
a.den, b.num, b.den, c,d);
r = av_sub_q(av_add_q(b,a), b);
if(b.den && (r.num*a.den != a.num*r.den || !r.num != !a.num || !r.den != !a.den))
av_log(NULL, AV_LOG_ERROR, "%d/%d ", r.num, r.den);
}
}
}
}
return 0;
}
static int find_frame_rate_index(MpegEncContext *s){
int i;
AVRational bestq= (AVRational){0, 0};
AVRational ext;
AVRational target = av_inv_q(s->avctx->time_base);
for(i=1;i<14;i++) {
if(s->avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL && i>=9) break;
for (ext.num=1; ext.num <= 4; ext.num++) {
for (ext.den=1; ext.den <= 32; ext.den++) {
AVRational q = av_mul_q(ext, ff_mpeg12_frame_rate_tab[i]);
if(s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
continue;
if(av_gcd(ext.den, ext.num) != 1)
continue;
if( bestq.num==0
|| av_nearer_q(target, bestq, q) < 0
|| ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0){
bestq = q;
s->frame_rate_index= i;
s->mpeg2_frame_rate_ext.num = ext.num;
s->mpeg2_frame_rate_ext.den = ext.den;
}
}
}
}
if(av_cmp_q(target, bestq))
return -1;
else
return 0;
}
const MXFSamplesPerFrame *ff_mxf_get_samples_per_frame(AVFormatContext *s,
AVRational time_base)
{
int idx = av_find_nearest_q_idx(time_base, mxf_time_base);
AVRational diff = av_sub_q(time_base, mxf_time_base[idx]);
diff.num = abs(diff.num);
if (av_cmp_q(diff, (AVRational){1, 1000}) >= 0)
return NULL;
if (av_cmp_q(time_base, mxf_time_base[idx]))
av_log(s, AV_LOG_WARNING,
"%d/%d input time base matched %d/%d container time base\n",
time_base.num, time_base.den,
mxf_spf[idx].time_base.num,
mxf_spf[idx].time_base.den);
return &mxf_spf[idx];
}
/**
* Return the 4 bit value that specifies the given aspect ratio.
* This may be one of the standard aspect ratios or it specifies
* that the aspect will be stored explicitly later.
*/
av_const int ff_h263_aspect_to_info(AVRational aspect){
int i;
if(aspect.num==0) aspect= (AVRational){1,1};
for(i=1; i<6; i++){
if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
return i;
}
}
return FF_ASPECT_EXTENDED;
}
int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
{
/* n/d is q, a/b is the median between q1 and q2 */
int64_t a = q1.num * (int64_t)q2.den + q2.num * (int64_t)q1.den;
int64_t b = 2 * (int64_t)q1.den * q2.den;
/* rnd_up(a*d/b) > n => a*d/b > n */
int64_t x_up = av_rescale_rnd(a, q.den, b, AV_ROUND_UP);
/* rnd_down(a*d/b) < n => a*d/b < n */
int64_t x_down = av_rescale_rnd(a, q.den, b, AV_ROUND_DOWN);
return ((x_up > q.num) - (x_down < q.num)) * av_cmp_q(q2, q1);
}
static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
if (av_cmp_q(inlink->time_base, outlink->time_base)) {
int64_t orig_pts = samplesref->pts;
samplesref->pts = av_rescale_q(samplesref->pts, inlink->time_base, outlink->time_base);
av_log(ctx, AV_LOG_DEBUG, "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
inlink ->time_base.num, inlink ->time_base.den, orig_pts,
outlink->time_base.num, outlink->time_base.den, samplesref->pts);
}
return ff_filter_samples(outlink, samplesref);
}
static int start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
if (av_cmp_q(inlink->time_base, outlink->time_base)) {
int64_t orig_pts = picref->pts;
picref->pts = av_rescale_q(picref->pts, inlink->time_base, outlink->time_base);
av_log(ctx, AV_LOG_DEBUG, "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
inlink ->time_base.num, inlink ->time_base.den, orig_pts,
outlink->time_base.num, outlink->time_base.den, picref->pts);
}
inlink->cur_buf = NULL;
return ff_start_frame(outlink, picref);
}
static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
AVFilterBufferRef *outsamples = insamples;
if (av_cmp_q(inlink->time_base, outlink->time_base)) {
outsamples = avfilter_ref_buffer(insamples, ~0);
outsamples->pts = av_rescale_q(insamples->pts, inlink->time_base, outlink->time_base);
av_log(ctx, AV_LOG_DEBUG, "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
inlink ->time_base.num, inlink ->time_base.den, insamples ->pts,
outlink->time_base.num, outlink->time_base.den, outsamples->pts);
avfilter_unref_buffer(insamples);
}
return ff_filter_samples(outlink, outsamples);
}
static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
AVFilterBufferRef *picref2 = picref;
if (av_cmp_q(inlink->time_base, outlink->time_base)) {
picref2 = avfilter_ref_buffer(picref, ~0);
picref2->pts = av_rescale_q(picref->pts, inlink->time_base, outlink->time_base);
av_log(ctx, AV_LOG_DEBUG, "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
inlink ->time_base.num, inlink ->time_base.den, picref ->pts,
outlink->time_base.num, outlink->time_base.den, picref2->pts);
avfilter_unref_buffer(picref);
}
ff_start_frame(outlink, picref2);
}
main(){
AVRational a,b;
for(a.num=-2; a.num<=2; a.num++){
for(a.den=-2; a.den<=2; a.den++){
for(b.num=-2; b.num<=2; b.num++){
for(b.den=-2; b.den<=2; b.den++){
int c= av_cmp_q(a,b);
double d= av_q2d(a) == av_q2d(b) ? 0 : (av_q2d(a) - av_q2d(b));
if(d>0) d=1;
else if(d<0) d=-1;
else if(d != d) d= INT_MIN;
if(c!=d) av_log(0, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num, a.den, b.num, b.den, c,d);
}
}
}
}
}
const MXFSamplesPerFrame *ff_mxf_get_samples_per_frame(AVFormatContext *s, AVRational time_base)
{
int i;
for (i = 0; i < FF_ARRAY_ELEMS(mxf_samples_per_frames); i++) {
if (!av_cmp_q(mxf_samples_per_frames[i].time_base, time_base))
return &mxf_samples_per_frames[i];
}
// Find closest container time base for approximative codec time base like 1/29.97, 1/30, ...
for (i = 0; i < FF_ARRAY_ELEMS(mxf_samples_per_frames); i++) {
if (fabs(av_q2d(mxf_samples_per_frames[i].time_base) - av_q2d(time_base)) < 0.0001) {
av_log(s, AV_LOG_WARNING, "%d/%d input time base matched %d/%d container time base\n",
time_base.num, time_base.den,
mxf_samples_per_frames[i].time_base.num, mxf_samples_per_frames[i].time_base.den);
return &mxf_samples_per_frames[i];
}
}
return NULL;
}
AVRational AVFormatWriter::GetCodecTimeBase(void)
{
AVRational result;
result.den = (int)floor(m_frameRate * 100);
result.num = 100;
if (m_avVideoCodec && m_avVideoCodec->supported_framerates) {
const AVRational *p= m_avVideoCodec->supported_framerates;
AVRational req =
(AVRational){result.den, result.num};
const AVRational *best = NULL;
AVRational best_error= (AVRational){INT_MAX, 1};
for(; p->den!=0; p++) {
AVRational error = av_sub_q(req, *p);
if (error.num <0)
error.num *= -1;
if (av_cmp_q(error, best_error) < 0) {
best_error = error;
best = p;
}
}
if (best && best->num && best->den)
{
result.den = best->num;
result.num = best->den;
}
}
if (result.den == 2997)
{
result.den = 30000;
result.num = 1001;
}
else if (result.den == 5994)
{
result.den = 60000;
result.num = 1001;
}
return result;
}
// Create the 'nclc' atom for video tracks. Guessed entirely from image size following ffdshow.
// FIXME: read H.264 VUI/MPEG2 etc and especially read chroma positioning information.
// this needs the parsers working
// References: http://developer.apple.com/quicktime/icefloe/dispatch019.html
// http://www.mir.com/DMG/chroma.html
void set_track_colorspace_ext(ImageDescriptionHandle imgDescHandle, Fixed displayW, Fixed displayH)
{
ImageDescription *imgDesc = *imgDescHandle;
Boolean isHd, isPAL; // otherwise NTSC
AVRational palRatio = (AVRational) {5, 4}, displayRatio = (AVRational) {
displayW, displayH
};
int colorPrimaries, transferFunction, yuvMatrix;
isHd = imgDesc->height > 576;
isPAL = imgDesc->height == 576 || av_cmp_q(palRatio, displayRatio) == 0;
NCLCColorInfoImageDescriptionExtension **nclc = (NCLCColorInfoImageDescriptionExtension**)NewHandle(sizeof(NCLCColorInfoImageDescriptionExtension));
if (isHd) {
colorPrimaries = kQTPrimaries_ITU_R709_2;
transferFunction = kQTTransferFunction_ITU_R709_2;
yuvMatrix = kQTMatrix_ITU_R_709_2;
} else if (isPAL) {
colorPrimaries = kQTPrimaries_EBU_3213;
transferFunction = kQTTransferFunction_ITU_R709_2;
yuvMatrix = kQTMatrix_ITU_R_601_4;
} else {
colorPrimaries = kQTPrimaries_SMPTE_C;
transferFunction = kQTTransferFunction_ITU_R709_2;
yuvMatrix = kQTMatrix_ITU_R_601_4;
}
**nclc = (NCLCColorInfoImageDescriptionExtension) {
EndianU32_NtoB(kVideoColorInfoImageDescriptionExtensionType),
EndianU16_NtoB(colorPrimaries),
EndianU16_NtoB(transferFunction),
EndianU16_NtoB(yuvMatrix)
};
AddImageDescriptionExtension(imgDescHandle, (Handle)nclc, kColorInfoImageDescriptionExtension);
DisposeHandle((Handle)nclc);
}
static int config(struct vf_instance *vf, int w, int h, int dw, int dh,
unsigned flags, unsigned fmt)
{
int ret;
AVFilterLink *out;
AVRational iar, dar;
av_reduce(&iar.num, &iar.den, w, h, INT_MAX);
av_reduce(&dar.num, &dar.den, dw, dh, INT_MAX);
vf->priv->in_pixfmt = imgfmt2pixfmt(fmt);
vf->priv->in_imgfmt = fmt;
vf->priv->in_w = w;
vf->priv->in_h = h;
vf->priv->in_sar = av_div_q(dar, iar);
ret = avfilter_graph_config(vf->priv->graph, NULL);
if (ret < 0)
return 0;
out = vf->priv->out->inputs[0];
vf->priv->out_w = out->w;
vf->priv->out_h = out->h;
vf->priv->out_pixfmt = out->format;
vf->priv->out_imgfmt = pixfmt2imgfmt(out->format);
vf->priv->out_sar = out->sample_aspect_ratio;
if (vf->priv->out_sar.num != vf->priv->in_sar.num ||
vf->priv->out_sar.den != vf->priv->in_sar.den ||
out->w != w || out->h != h) {
av_reduce(&iar.num, &iar.den, out->w, out->h, INT_MAX);
dar = av_mul_q(iar, out->sample_aspect_ratio);
if (av_cmp_q(dar, iar) >= 0) {
dh = out->h;
dw = av_rescale(dh, dar.num, dar.den);
} else {
dw = out->w;
dh = av_rescale(dw, dar.den, dar.num);
}
}
return vf_next_config(vf, out->w, out->h, dw, dh, flags, fmt);
}
int main(void)
{
AVRational a,b,r;
int i,j,k;
static const int64_t numlist[] = {
INT64_MIN, INT64_MIN+1, INT64_MAX, INT32_MIN, INT32_MAX, 1,0,-1,
123456789, INT32_MAX-1, INT32_MAX+1LL, UINT32_MAX-1, UINT32_MAX, UINT32_MAX+1LL
};
for (a.num = -2; a.num <= 2; a.num++) {
for (a.den = -2; a.den <= 2; a.den++) {
for (b.num = -2; b.num <= 2; b.num++) {
for (b.den = -2; b.den <= 2; b.den++) {
int c = av_cmp_q(a,b);
double d = av_q2d(a) == av_q2d(b) ?
0 : (av_q2d(a) - av_q2d(b));
if (d > 0) d = 1;
else if (d < 0) d = -1;
else if (d != d) d = INT_MIN;
if (c != d)
av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num,
a.den, b.num, b.den, c,d);
r = av_sub_q(av_add_q(b,a), b);
if(b.den && (r.num*a.den != a.num*r.den || !r.num != !a.num || !r.den != !a.den))
av_log(NULL, AV_LOG_ERROR, "%d/%d ", r.num, r.den);
}
}
}
}
for (i = 0; i < FF_ARRAY_ELEMS(numlist); i++) {
int64_t a = numlist[i];
for (j = 0; j < FF_ARRAY_ELEMS(numlist); j++) {
int64_t b = numlist[j];
if (b<=0)
continue;
for (k = 0; k < FF_ARRAY_ELEMS(numlist); k++) {
int64_t c = numlist[k];
int64_t res;
AVInteger ai;
if (c<=0)
continue;
res = av_rescale_rnd(a,b,c, AV_ROUND_ZERO);
ai = av_mul_i(av_int2i(a), av_int2i(b));
ai = av_div_i(ai, av_int2i(c));
if (av_cmp_i(ai, av_int2i(INT64_MAX)) > 0 && res == INT64_MIN)
continue;
if (av_cmp_i(ai, av_int2i(INT64_MIN)) < 0 && res == INT64_MIN)
continue;
if (av_cmp_i(ai, av_int2i(res)) == 0)
continue;
// Special exception for INT64_MIN, remove this in case INT64_MIN is handled without off by 1 error
if (av_cmp_i(ai, av_int2i(res-1)) == 0 && a == INT64_MIN)
continue;
av_log(NULL, AV_LOG_ERROR, "%"PRId64" * %"PRId64" / %"PRId64" = %"PRId64" or %"PRId64"\n", a,b,c, res, av_i2int(ai));
}
}
}
for (a.num = 1; a.num <= 10; a.num++) {
for (a.den = 1; a.den <= 10; a.den++) {
if (av_gcd(a.num, a.den) > 1)
continue;
for (b.num = 1; b.num <= 10; b.num++) {
for (b.den = 1; b.den <= 10; b.den++) {
int start;
if (av_gcd(b.num, b.den) > 1)
continue;
if (av_cmp_q(b, a) < 0)
continue;
for (start = 0; start < 10 ; start++) {
int acc= start;
int i;
for (i = 0; i<100; i++) {
int exact = start + av_rescale_q(i+1, b, a);
acc = av_add_stable(a, acc, b, 1);
if (FFABS(acc - exact) > 2) {
av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %d\n", a.num,
a.den, b.num, b.den, acc, exact);
return 1;
}
}
}
}
}
}
}
for (a.den = 1; a.den < 0x100000000U/3; a.den*=3) {
for (a.num = -1; a.num < (1<<27); a.num += 1 + a.num/100) {
float f = av_int2float(av_q2intfloat(a));
float f2 = av_q2d(a);
if (fabs(f - f2) > fabs(f)/5000000) {
av_log(NULL, AV_LOG_ERROR, "%d/%d %f %f\n", a.num,
a.den, f, f2);
return 1;
}
}
}
return 0;
}
/* "user interface" functions */
static void dump_stream_format(AVFormatContext *ic, int i,
int index, int is_output)
{
char buf[256];
int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
AVStream *st = ic->streams[i];
int g = av_gcd(st->time_base.num, st->time_base.den);
AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
avcodec_string(buf, sizeof(buf), st->codec, is_output);
av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
/* the pid is an important information, so we display it */
/* XXX: add a generic system */
if (flags & AVFMT_SHOW_IDS)
av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
if (lang)
av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
st->time_base.num / g, st->time_base.den / g);
av_log(NULL, AV_LOG_INFO, ": %s", buf);
if (st->sample_aspect_ratio.num && // default
av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
AVRational display_aspect_ratio;
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
st->codec->width * st->sample_aspect_ratio.num,
st->codec->height * st->sample_aspect_ratio.den,
1024 * 1024);
av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
display_aspect_ratio.num, display_aspect_ratio.den);
}
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (st->avg_frame_rate.den && st->avg_frame_rate.num)
print_fps(av_q2d(st->avg_frame_rate), "fps");
#if FF_API_R_FRAME_RATE
if (st->r_frame_rate.den && st->r_frame_rate.num)
print_fps(av_q2d(st->r_frame_rate), "tbr");
#endif
if (st->time_base.den && st->time_base.num)
print_fps(1 / av_q2d(st->time_base), "tbn");
if (st->codec->time_base.den && st->codec->time_base.num)
print_fps(1 / av_q2d(st->codec->time_base), "tbc");
}
if (st->disposition & AV_DISPOSITION_DEFAULT)
av_log(NULL, AV_LOG_INFO, " (default)");
if (st->disposition & AV_DISPOSITION_DUB)
av_log(NULL, AV_LOG_INFO, " (dub)");
if (st->disposition & AV_DISPOSITION_ORIGINAL)
av_log(NULL, AV_LOG_INFO, " (original)");
if (st->disposition & AV_DISPOSITION_COMMENT)
av_log(NULL, AV_LOG_INFO, " (comment)");
if (st->disposition & AV_DISPOSITION_LYRICS)
av_log(NULL, AV_LOG_INFO, " (lyrics)");
if (st->disposition & AV_DISPOSITION_KARAOKE)
av_log(NULL, AV_LOG_INFO, " (karaoke)");
if (st->disposition & AV_DISPOSITION_FORCED)
av_log(NULL, AV_LOG_INFO, " (forced)");
if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
av_log(NULL, AV_LOG_INFO, " (visual impaired)");
if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
av_log(NULL, AV_LOG_INFO, " (clean effects)");
av_log(NULL, AV_LOG_INFO, "\n");
dump_metadata(NULL, st->metadata, " ");
dump_sidedata(NULL, st, " ");
}
static int config_out_props(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = outlink->src->inputs[0];
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
TInterlaceContext *tinterlace = ctx->priv;
int i;
tinterlace->vsub = desc->log2_chroma_h;
outlink->w = inlink->w;
outlink->h = tinterlace->mode == MODE_MERGE || tinterlace->mode == MODE_PAD || tinterlace->mode == MODE_MERGEX2?
inlink->h*2 : inlink->h;
if (tinterlace->mode == MODE_MERGE || tinterlace->mode == MODE_PAD || tinterlace->mode == MODE_MERGEX2)
outlink->sample_aspect_ratio = av_mul_q(inlink->sample_aspect_ratio,
av_make_q(2, 1));
if (tinterlace->mode == MODE_PAD) {
uint8_t black[4] = { 0, 0, 0, 16 };
int ret;
ff_draw_init(&tinterlace->draw, outlink->format, 0);
ff_draw_color(&tinterlace->draw, &tinterlace->color, black);
if (ff_fmt_is_in(outlink->format, full_scale_yuvj_pix_fmts))
tinterlace->color.comp[0].u8[0] = 0;
ret = av_image_alloc(tinterlace->black_data, tinterlace->black_linesize,
outlink->w, outlink->h, outlink->format, 16);
if (ret < 0)
return ret;
ff_fill_rectangle(&tinterlace->draw, &tinterlace->color, tinterlace->black_data,
tinterlace->black_linesize, 0, 0, outlink->w, outlink->h);
}
if (tinterlace->flags & (TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF)
&& !(tinterlace->mode == MODE_INTERLEAVE_TOP
|| tinterlace->mode == MODE_INTERLEAVE_BOTTOM)) {
av_log(ctx, AV_LOG_WARNING, "low_pass_filter flags ignored with mode %d\n",
tinterlace->mode);
tinterlace->flags &= ~(TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF);
}
tinterlace->preout_time_base = inlink->time_base;
if (tinterlace->mode == MODE_INTERLACEX2) {
tinterlace->preout_time_base.den *= 2;
outlink->frame_rate = av_mul_q(inlink->frame_rate, (AVRational){2,1});
outlink->time_base = av_mul_q(inlink->time_base , (AVRational){1,2});
} else if (tinterlace->mode == MODE_MERGEX2) {
outlink->frame_rate = inlink->frame_rate;
outlink->time_base = inlink->time_base;
} else if (tinterlace->mode != MODE_PAD) {
outlink->frame_rate = av_mul_q(inlink->frame_rate, (AVRational){1,2});
outlink->time_base = av_mul_q(inlink->time_base , (AVRational){2,1});
}
for (i = 0; i<FF_ARRAY_ELEMS(standard_tbs); i++){
if (!av_cmp_q(standard_tbs[i], outlink->time_base))
break;
}
if (i == FF_ARRAY_ELEMS(standard_tbs) ||
(tinterlace->flags & TINTERLACE_FLAG_EXACT_TB))
outlink->time_base = tinterlace->preout_time_base;
tinterlace->csp = av_pix_fmt_desc_get(outlink->format);
if (tinterlace->flags & TINTERLACE_FLAG_CVLPF) {
if (tinterlace->csp->comp[0].depth > 8)
tinterlace->lowpass_line = lowpass_line_complex_c_16;
else
tinterlace->lowpass_line = lowpass_line_complex_c;
if (ARCH_X86)
ff_tinterlace_init_x86(tinterlace);
} else if (tinterlace->flags & TINTERLACE_FLAG_VLPF) {
if (tinterlace->csp->comp[0].depth > 8)
tinterlace->lowpass_line = lowpass_line_c_16;
else
tinterlace->lowpass_line = lowpass_line_c;
if (ARCH_X86)
ff_tinterlace_init_x86(tinterlace);
}
av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n", tinterlace->mode,
(tinterlace->flags & TINTERLACE_FLAG_CVLPF) ? "complex" :
(tinterlace->flags & TINTERLACE_FLAG_VLPF) ? "linear" : "off",
inlink->h, outlink->h);
return 0;
}
/* "user interface" functions */
static void dump_stream_format(AVFormatContext *ic, int i,
int index, int is_output)
{
char buf[256];
int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
AVStream *st = ic->streams[i];
AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
char *separator = ic->dump_separator;
AVCodecContext *avctx;
int ret;
avctx = avcodec_alloc_context3(NULL);
if (!avctx)
return;
ret = avcodec_parameters_to_context(avctx, st->codecpar);
if (ret < 0) {
avcodec_free_context(&avctx);
return;
}
// Fields which are missing from AVCodecParameters need to be taken from the AVCodecContext
avctx->properties = st->codec->properties;
avctx->codec = st->codec->codec;
avctx->qmin = st->codec->qmin;
avctx->qmax = st->codec->qmax;
avctx->coded_width = st->codec->coded_width;
avctx->coded_height = st->codec->coded_height;
if (separator)
av_opt_set(avctx, "dump_separator", separator, 0);
avcodec_string(buf, sizeof(buf), avctx, is_output);
avcodec_free_context(&avctx);
av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
/* the pid is an important information, so we display it */
/* XXX: add a generic system */
if (flags & AVFMT_SHOW_IDS)
av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
if (lang)
av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
st->time_base.num, st->time_base.den);
av_log(NULL, AV_LOG_INFO, ": %s", buf);
if (st->sample_aspect_ratio.num &&
av_cmp_q(st->sample_aspect_ratio, st->codecpar->sample_aspect_ratio)) {
AVRational display_aspect_ratio;
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
st->codecpar->width * (int64_t)st->sample_aspect_ratio.num,
st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
1024 * 1024);
av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
display_aspect_ratio.num, display_aspect_ratio.den);
}
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
int fps = st->avg_frame_rate.den && st->avg_frame_rate.num;
int tbr = st->r_frame_rate.den && st->r_frame_rate.num;
int tbn = st->time_base.den && st->time_base.num;
int tbc = st->codec->time_base.den && st->codec->time_base.num;
if (fps || tbr || tbn || tbc)
av_log(NULL, AV_LOG_INFO, "%s", separator);
if (fps)
print_fps(av_q2d(st->avg_frame_rate), tbr || tbn || tbc ? "fps, " : "fps");
if (tbr)
print_fps(av_q2d(st->r_frame_rate), tbn || tbc ? "tbr, " : "tbr");
if (tbn)
print_fps(1 / av_q2d(st->time_base), tbc ? "tbn, " : "tbn");
if (tbc)
print_fps(1 / av_q2d(st->codec->time_base), "tbc");
}
if (st->disposition & AV_DISPOSITION_DEFAULT)
av_log(NULL, AV_LOG_INFO, " (default)");
if (st->disposition & AV_DISPOSITION_DUB)
av_log(NULL, AV_LOG_INFO, " (dub)");
if (st->disposition & AV_DISPOSITION_ORIGINAL)
av_log(NULL, AV_LOG_INFO, " (original)");
if (st->disposition & AV_DISPOSITION_COMMENT)
av_log(NULL, AV_LOG_INFO, " (comment)");
if (st->disposition & AV_DISPOSITION_LYRICS)
av_log(NULL, AV_LOG_INFO, " (lyrics)");
if (st->disposition & AV_DISPOSITION_KARAOKE)
av_log(NULL, AV_LOG_INFO, " (karaoke)");
if (st->disposition & AV_DISPOSITION_FORCED)
av_log(NULL, AV_LOG_INFO, " (forced)");
if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
av_log(NULL, AV_LOG_INFO, " (visual impaired)");
if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
av_log(NULL, AV_LOG_INFO, " (clean effects)");
if (st->disposition & AV_DISPOSITION_DESCRIPTIONS)
av_log(NULL, AV_LOG_INFO, " (descriptions)");
if (st->disposition & AV_DISPOSITION_DEPENDENT)
av_log(NULL, AV_LOG_INFO, " (dependent)");
av_log(NULL, AV_LOG_INFO, "\n");
dump_metadata(NULL, st->metadata, " ");
dump_sidedata(NULL, st, " ");
}
/* add a video output stream to the container */
static AVStream *icv_add_video_stream_FFMPEG(AVFormatContext *oc,
CodecID codec_id,
int w, int h, int bitrate,
double fps, int pixel_format)
{
AVCodecContext *c;
AVStream *st;
int frame_rate, frame_rate_base;
AVCodec *codec;
st = av_new_stream(oc, 0);
if (!st) {
CV_WARN("Could not allocate stream");
return NULL;
}
#if LIBAVFORMAT_BUILD > 4628
c = st->codec;
#else
c = &(st->codec);
#endif
#if LIBAVFORMAT_BUILD > 4621
c->codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
#else
c->codec_id = oc->oformat->video_codec;
#endif
if(codec_id != CODEC_ID_NONE){
c->codec_id = codec_id;
}
//if(codec_tag) c->codec_tag=codec_tag;
codec = avcodec_find_encoder(c->codec_id);
c->codec_type = CODEC_TYPE_VIDEO;
/* put sample parameters */
c->bit_rate = bitrate;
/* resolution must be a multiple of two */
c->width = w;
c->height = h;
/* time base: this is the fundamental unit of time (in seconds) in terms
of which frame timestamps are represented. for fixed-fps content,
timebase should be 1/framerate and timestamp increments should be
identically 1. */
frame_rate=cvRound(fps);
frame_rate_base=1;
while (fabs((double)frame_rate/frame_rate_base) - fps > 0.001){
frame_rate_base*=10;
frame_rate=cvRound(fps*frame_rate_base);
}
#if LIBAVFORMAT_BUILD > 4752
c->time_base.den = frame_rate;
c->time_base.num = frame_rate_base;
/* adjust time base for supported framerates */
if(codec && codec->supported_framerates){
const AVRational *p= codec->supported_framerates;
AVRational req = {frame_rate, frame_rate_base};
const AVRational *best=NULL;
AVRational best_error= {INT_MAX, 1};
for(; p->den!=0; p++){
AVRational error= av_sub_q(req, *p);
if(error.num <0) error.num *= -1;
if(av_cmp_q(error, best_error) < 0){
best_error= error;
best= p;
}
}
c->time_base.den= best->num;
c->time_base.num= best->den;
}
#else
c->frame_rate = frame_rate;
c->frame_rate_base = frame_rate_base;
#endif
c->gop_size = 12; /* emit one intra frame every twelve frames at most */
c->pix_fmt = (PixelFormat) pixel_format;
if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
c->max_b_frames = 2;
}
if (c->codec_id == CODEC_ID_MPEG1VIDEO || c->codec_id == CODEC_ID_MSMPEG4V3){
/* needed to avoid using macroblocks in which some coeffs overflow
this doesnt happen with normal video, it just happens here as the
motion of the chroma plane doesnt match the luma plane */
/* avoid FFMPEG warning 'clipping 1 dct coefficients...' */
c->mb_decision=2;
}
#if LIBAVCODEC_VERSION_INT>0x000409
// some formats want stream headers to be seperate
if(oc->oformat->flags & AVFMT_GLOBALHEADER)
{
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
#endif
return st;
}
int ff_decklink_set_format(AVFormatContext *avctx,
int width, int height,
int tb_num, int tb_den,
enum AVFieldOrder field_order,
decklink_direction_t direction, int num)
{
struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
BMDDisplayModeSupport support;
IDeckLinkDisplayModeIterator *itermode;
IDeckLinkDisplayMode *mode;
int i = 1;
HRESULT res;
av_log(avctx, AV_LOG_DEBUG, "Trying to find mode for frame size %dx%d, frame timing %d/%d, field order %d, direction %d, mode number %d, format code %s\n",
width, height, tb_num, tb_den, field_order, direction, num, (cctx->format_code) ? cctx->format_code : "(unset)");
if (ctx->duplex_mode) {
DECKLINK_BOOL duplex_supported = false;
if (ctx->attr->GetFlag(BMDDeckLinkSupportsDuplexModeConfiguration, &duplex_supported) != S_OK)
duplex_supported = false;
if (duplex_supported) {
res = ctx->cfg->SetInt(bmdDeckLinkConfigDuplexMode, ctx->duplex_mode == 2 ? bmdDuplexModeFull : bmdDuplexModeHalf);
if (res != S_OK)
av_log(avctx, AV_LOG_WARNING, "Setting duplex mode failed.\n");
else
av_log(avctx, AV_LOG_VERBOSE, "Successfully set duplex mode to %s duplex.\n", ctx->duplex_mode == 2 ? "full" : "half");
} else {
av_log(avctx, AV_LOG_WARNING, "Unable to set duplex mode, because it is not supported.\n");
}
}
if (direction == DIRECTION_IN) {
int ret;
ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
if (ret < 0)
return ret;
ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
if (ret < 0)
return ret;
res = ctx->dli->GetDisplayModeIterator (&itermode);
} else {
res = ctx->dlo->GetDisplayModeIterator (&itermode);
}
if (res!= S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
return AVERROR(EIO);
}
char format_buf[] = " ";
if (cctx->format_code)
memcpy(format_buf, cctx->format_code, FFMIN(strlen(cctx->format_code), sizeof(format_buf)));
BMDDisplayMode target_mode = (BMDDisplayMode)AV_RB32(format_buf);
AVRational target_tb = av_make_q(tb_num, tb_den);
ctx->bmd_mode = bmdModeUnknown;
while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
BMDTimeValue bmd_tb_num, bmd_tb_den;
int bmd_width = mode->GetWidth();
int bmd_height = mode->GetHeight();
BMDDisplayMode bmd_mode = mode->GetDisplayMode();
BMDFieldDominance bmd_field_dominance = mode->GetFieldDominance();
mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
AVRational mode_tb = av_make_q(bmd_tb_num, bmd_tb_den);
if ((bmd_width == width &&
bmd_height == height &&
!av_cmp_q(mode_tb, target_tb) &&
field_order_eq(field_order, bmd_field_dominance))
|| i == num
|| target_mode == bmd_mode) {
ctx->bmd_mode = bmd_mode;
ctx->bmd_width = bmd_width;
ctx->bmd_height = bmd_height;
ctx->bmd_tb_den = bmd_tb_den;
ctx->bmd_tb_num = bmd_tb_num;
ctx->bmd_field_dominance = bmd_field_dominance;
av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
bmd_width, bmd_height, 1/av_q2d(mode_tb),
(ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
}
mode->Release();
i++;
}
itermode->Release();
if (ctx->bmd_mode == bmdModeUnknown)
return -1;
if (direction == DIRECTION_IN) {
if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
bmdVideoOutputFlagDefault,
&support, NULL) != S_OK)
return -1;
} else {
if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
bmdVideoOutputFlagDefault,
&support, NULL) != S_OK)
return -1;
}
if (support == bmdDisplayModeSupported)
return 0;
return -1;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
SpectrumSynthContext *s = ctx->priv;
int width = ctx->inputs[0]->w;
int height = ctx->inputs[0]->h;
AVRational time_base = ctx->inputs[0]->time_base;
AVRational frame_rate = ctx->inputs[0]->frame_rate;
int i, ch, fft_bits;
float factor, overlap;
outlink->sample_rate = s->sample_rate;
outlink->time_base = (AVRational){1, s->sample_rate};
if (width != ctx->inputs[1]->w ||
height != ctx->inputs[1]->h) {
av_log(ctx, AV_LOG_ERROR,
"Magnitude and Phase sizes differ (%dx%d vs %dx%d).\n",
width, height,
ctx->inputs[1]->w, ctx->inputs[1]->h);
return AVERROR_INVALIDDATA;
} else if (av_cmp_q(time_base, ctx->inputs[1]->time_base) != 0) {
av_log(ctx, AV_LOG_ERROR,
"Magnitude and Phase time bases differ (%d/%d vs %d/%d).\n",
time_base.num, time_base.den,
ctx->inputs[1]->time_base.num,
ctx->inputs[1]->time_base.den);
return AVERROR_INVALIDDATA;
} else if (av_cmp_q(frame_rate, ctx->inputs[1]->frame_rate) != 0) {
av_log(ctx, AV_LOG_ERROR,
"Magnitude and Phase framerates differ (%d/%d vs %d/%d).\n",
frame_rate.num, frame_rate.den,
ctx->inputs[1]->frame_rate.num,
ctx->inputs[1]->frame_rate.den);
return AVERROR_INVALIDDATA;
}
s->size = s->orientation == VERTICAL ? height / s->channels : width / s->channels;
s->xend = s->orientation == VERTICAL ? width : height;
for (fft_bits = 1; 1 << fft_bits < 2 * s->size; fft_bits++);
s->win_size = 1 << fft_bits;
s->nb_freq = 1 << (fft_bits - 1);
s->fft = av_fft_init(fft_bits, 1);
if (!s->fft) {
av_log(ctx, AV_LOG_ERROR, "Unable to create FFT context. "
"The window size might be too high.\n");
return AVERROR(EINVAL);
}
s->fft_data = av_calloc(s->channels, sizeof(*s->fft_data));
if (!s->fft_data)
return AVERROR(ENOMEM);
for (ch = 0; ch < s->channels; ch++) {
s->fft_data[ch] = av_calloc(s->win_size, sizeof(**s->fft_data));
if (!s->fft_data[ch])
return AVERROR(ENOMEM);
}
s->buffer = ff_get_audio_buffer(outlink, s->win_size * 2);
if (!s->buffer)
return AVERROR(ENOMEM);
/* pre-calc windowing function */
s->window_func_lut = av_realloc_f(s->window_func_lut, s->win_size,
sizeof(*s->window_func_lut));
if (!s->window_func_lut)
return AVERROR(ENOMEM);
ff_generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
if (s->overlap == 1)
s->overlap = overlap;
s->hop_size = (1 - s->overlap) * s->win_size;
for (factor = 0, i = 0; i < s->win_size; i++) {
factor += s->window_func_lut[i] * s->window_func_lut[i];
}
s->factor = (factor / s->win_size) / FFMAX(1 / (1 - s->overlap) - 1, 1);
return 0;
}
static int config_out_props(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = outlink->src->inputs[0];
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
TInterlaceContext *tinterlace = ctx->priv;
int i;
tinterlace->vsub = desc->log2_chroma_h;
outlink->w = inlink->w;
outlink->h = tinterlace->mode == MODE_MERGE || tinterlace->mode == MODE_PAD ?
inlink->h*2 : inlink->h;
if (tinterlace->mode == MODE_MERGE || tinterlace->mode == MODE_PAD)
outlink->sample_aspect_ratio = av_mul_q(inlink->sample_aspect_ratio,
av_make_q(2, 1));
if (tinterlace->mode == MODE_PAD) {
uint8_t black[4] = { 16, 128, 128, 16 };
int i, ret;
if (ff_fmt_is_in(outlink->format, full_scale_yuvj_pix_fmts))
black[0] = black[3] = 0;
ret = av_image_alloc(tinterlace->black_data, tinterlace->black_linesize,
outlink->w, outlink->h, outlink->format, 1);
if (ret < 0)
return ret;
/* fill black picture with black */
for (i = 0; i < 4 && tinterlace->black_data[i]; i++) {
int h = i == 1 || i == 2 ? FF_CEIL_RSHIFT(outlink->h, desc->log2_chroma_h) : outlink->h;
memset(tinterlace->black_data[i], black[i],
tinterlace->black_linesize[i] * h);
}
}
if ((tinterlace->flags & TINTERLACE_FLAG_VLPF)
&& !(tinterlace->mode == MODE_INTERLEAVE_TOP
|| tinterlace->mode == MODE_INTERLEAVE_BOTTOM)) {
av_log(ctx, AV_LOG_WARNING, "low_pass_filter flag ignored with mode %d\n",
tinterlace->mode);
tinterlace->flags &= ~TINTERLACE_FLAG_VLPF;
}
tinterlace->preout_time_base = inlink->time_base;
if (tinterlace->mode == MODE_INTERLACEX2) {
tinterlace->preout_time_base.den *= 2;
outlink->frame_rate = av_mul_q(inlink->frame_rate, (AVRational){2,1});
outlink->time_base = av_mul_q(inlink->time_base , (AVRational){1,2});
} else if (tinterlace->mode != MODE_PAD) {
outlink->frame_rate = av_mul_q(inlink->frame_rate, (AVRational){1,2});
outlink->time_base = av_mul_q(inlink->time_base , (AVRational){2,1});
}
for (i = 0; i<FF_ARRAY_ELEMS(standard_tbs); i++){
if (!av_cmp_q(standard_tbs[i], outlink->time_base))
break;
}
if (i == FF_ARRAY_ELEMS(standard_tbs) ||
(tinterlace->flags & TINTERLACE_FLAG_EXACT_TB))
outlink->time_base = tinterlace->preout_time_base;
if (tinterlace->flags & TINTERLACE_FLAG_VLPF) {
tinterlace->lowpass_line = lowpass_line_c;
if (ARCH_X86)
ff_tinterlace_init_x86(tinterlace);
}
av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n",
tinterlace->mode, (tinterlace->flags & TINTERLACE_FLAG_VLPF) ? "on" : "off",
inlink->h, outlink->h);
return 0;
}
int main(void)
{
AVRational a,b,r;
for (a.num = -2; a.num <= 2; a.num++) {
for (a.den = -2; a.den <= 2; a.den++) {
for (b.num = -2; b.num <= 2; b.num++) {
for (b.den = -2; b.den <= 2; b.den++) {
int c = av_cmp_q(a,b);
double d = av_q2d(a) == av_q2d(b) ?
0 : (av_q2d(a) - av_q2d(b));
if (d > 0) d = 1;
else if (d < 0) d = -1;
else if (d != d) d = INT_MIN;
if (c != d)
av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num,
a.den, b.num, b.den, c,d);
r = av_sub_q(av_add_q(b,a), b);
if(b.den && (r.num*a.den != a.num*r.den || !r.num != !a.num || !r.den != !a.den))
av_log(NULL, AV_LOG_ERROR, "%d/%d ", r.num, r.den);
}
}
}
}
for (a.num = 1; a.num <= 10; a.num++) {
for (a.den = 1; a.den <= 10; a.den++) {
if (av_gcd(a.num, a.den) > 1)
continue;
for (b.num = 1; b.num <= 10; b.num++) {
for (b.den = 1; b.den <= 10; b.den++) {
int start;
if (av_gcd(b.num, b.den) > 1)
continue;
if (av_cmp_q(b, a) < 0)
continue;
for (start = 0; start < 10 ; start++) {
int acc= start;
int i;
for (i = 0; i<100; i++) {
int exact = start + av_rescale_q(i+1, b, a);
acc = av_add_stable(a, acc, b, 1);
if (FFABS(acc - exact) > 2) {
av_log(NULL, AV_LOG_ERROR, "%d/%d %d/%d, %d %d\n", a.num,
a.den, b.num, b.den, acc, exact);
return 1;
}
}
}
}
}
}
}
for (a.den = 1; a.den < 0x100000000U/3; a.den*=3) {
for (a.num = -1; a.num < (1<<27); a.num += 1 + a.num/100) {
float f = av_int2float(av_q2intfloat(a));
float f2 = av_q2d(a);
if (fabs(f - f2) > fabs(f)/5000000) {
av_log(NULL, AV_LOG_ERROR, "%d/%d %f %f\n", a.num,
a.den, f, f2);
return 1;
}
}
}
return 0;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
FramepackContext *s = outlink->src->priv;
int width = ctx->inputs[LEFT]->w;
int height = ctx->inputs[LEFT]->h;
AVRational time_base = ctx->inputs[LEFT]->time_base;
AVRational frame_rate = ctx->inputs[LEFT]->frame_rate;
// check size and fps match on the other input
if (width != ctx->inputs[RIGHT]->w ||
height != ctx->inputs[RIGHT]->h) {
av_log(ctx, AV_LOG_ERROR,
"Left and right sizes differ (%dx%d vs %dx%d).\n",
width, height,
ctx->inputs[RIGHT]->w, ctx->inputs[RIGHT]->h);
return AVERROR_INVALIDDATA;
} else if (av_cmp_q(time_base, ctx->inputs[RIGHT]->time_base) != 0) {
av_log(ctx, AV_LOG_ERROR,
"Left and right time bases differ (%d/%d vs %d/%d).\n",
time_base.num, time_base.den,
ctx->inputs[RIGHT]->time_base.num,
ctx->inputs[RIGHT]->time_base.den);
return AVERROR_INVALIDDATA;
} else if (av_cmp_q(frame_rate, ctx->inputs[RIGHT]->frame_rate) != 0) {
av_log(ctx, AV_LOG_ERROR,
"Left and right framerates differ (%d/%d vs %d/%d).\n",
frame_rate.num, frame_rate.den,
ctx->inputs[RIGHT]->frame_rate.num,
ctx->inputs[RIGHT]->frame_rate.den);
return AVERROR_INVALIDDATA;
}
s->pix_desc = av_pix_fmt_desc_get(outlink->format);
if (!s->pix_desc)
return AVERROR_BUG;
// modify output properties as needed
switch (s->format) {
case AV_STEREO3D_FRAMESEQUENCE:
time_base.den *= 2;
frame_rate.num *= 2;
s->double_pts = AV_NOPTS_VALUE;
break;
case AV_STEREO3D_COLUMNS:
case AV_STEREO3D_SIDEBYSIDE:
width *= 2;
break;
case AV_STEREO3D_LINES:
case AV_STEREO3D_TOPBOTTOM:
height *= 2;
break;
default:
av_log(ctx, AV_LOG_ERROR, "Unknown packing mode.");
return AVERROR_INVALIDDATA;
}
outlink->w = width;
outlink->h = height;
outlink->time_base = time_base;
outlink->frame_rate= frame_rate;
return 0;
}
static int init_muxer(AVFormatContext *s, AVDictionary **options)
{
int ret = 0, i;
AVStream *st;
AVDictionary *tmp = NULL;
AVCodecContext *codec = NULL;
AVOutputFormat *of = s->oformat;
const AVCodecDescriptor *desc;
if (options)
av_dict_copy(&tmp, *options, 0);
if ((ret = av_opt_set_dict(s, &tmp)) < 0)
goto fail;
#if FF_API_LAVF_BITEXACT
if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT)
s->flags |= AVFMT_FLAG_BITEXACT;
#endif
// some sanity checks
if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
av_log(s, AV_LOG_ERROR, "no streams\n");
ret = AVERROR(EINVAL);
goto fail;
}
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
codec = st->codec;
#if FF_API_LAVF_CODEC_TB
FF_DISABLE_DEPRECATION_WARNINGS
if (!st->time_base.num && codec->time_base.num) {
av_log(s, AV_LOG_WARNING, "Using AVStream.codec.time_base as a "
"timebase hint to the muxer is deprecated. Set "
"AVStream.time_base instead.\n");
avpriv_set_pts_info(st, 64, codec->time_base.num, codec->time_base.den);
}
FF_ENABLE_DEPRECATION_WARNINGS
#endif
if (!st->time_base.num) {
/* fall back on the default timebase values */
if (codec->codec_type == AVMEDIA_TYPE_AUDIO && codec->sample_rate)
avpriv_set_pts_info(st, 64, 1, codec->sample_rate);
else
avpriv_set_pts_info(st, 33, 1, 90000);
}
switch (codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
if (codec->sample_rate <= 0) {
av_log(s, AV_LOG_ERROR, "sample rate not set\n");
ret = AVERROR(EINVAL);
goto fail;
}
if (!codec->block_align)
codec->block_align = codec->channels *
av_get_bits_per_sample(codec->codec_id) >> 3;
break;
case AVMEDIA_TYPE_VIDEO:
if ((codec->width <= 0 || codec->height <= 0) &&
!(of->flags & AVFMT_NODIMENSIONS)) {
av_log(s, AV_LOG_ERROR, "dimensions not set\n");
ret = AVERROR(EINVAL);
goto fail;
}
if (av_cmp_q(st->sample_aspect_ratio,
codec->sample_aspect_ratio)) {
if (st->sample_aspect_ratio.num != 0 &&
st->sample_aspect_ratio.den != 0 &&
codec->sample_aspect_ratio.den != 0 &&
codec->sample_aspect_ratio.den != 0) {
av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
"(%d/%d) and encoder layer (%d/%d)\n",
st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
codec->sample_aspect_ratio.num,
codec->sample_aspect_ratio.den);
ret = AVERROR(EINVAL);
goto fail;
}
}
break;
}
desc = avcodec_descriptor_get(codec->codec_id);
if (desc && desc->props & AV_CODEC_PROP_REORDER)
st->internal->reorder = 1;
if (of->codec_tag) {
if (codec->codec_tag &&
codec->codec_id == AV_CODEC_ID_RAWVIDEO &&
!av_codec_get_tag(of->codec_tag, codec->codec_id) &&
!validate_codec_tag(s, st)) {
// the current rawvideo encoding system ends up setting
// the wrong codec_tag for avi, we override it here
codec->codec_tag = 0;
}
if (codec->codec_tag) {
if (!validate_codec_tag(s, st)) {
char tagbuf[32];
av_get_codec_tag_string(tagbuf, sizeof(tagbuf), codec->codec_tag);
av_log(s, AV_LOG_ERROR,
"Tag %s/0x%08x incompatible with output codec id '%d'\n",
tagbuf, codec->codec_tag, codec->codec_id);
ret = AVERROR_INVALIDDATA;
goto fail;
}
} else
codec->codec_tag = av_codec_get_tag(of->codec_tag, codec->codec_id);
}
if (of->flags & AVFMT_GLOBALHEADER &&
!(codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
av_log(s, AV_LOG_WARNING,
"Codec for stream %d does not use global headers "
"but container format requires global headers\n", i);
if (codec->codec_type != AVMEDIA_TYPE_ATTACHMENT)
s->internal->nb_interleaved_streams++;
}
if (!s->priv_data && of->priv_data_size > 0) {
s->priv_data = av_mallocz(of->priv_data_size);
if (!s->priv_data) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (of->priv_class) {
*(const AVClass **)s->priv_data = of->priv_class;
av_opt_set_defaults(s->priv_data);
if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
goto fail;
}
}
/* set muxer identification string */
if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
}
if (options) {
av_dict_free(options);
*options = tmp;
}
return 0;
fail:
av_dict_free(&tmp);
return ret;
}
int ff_decklink_set_format(AVFormatContext *avctx,
int width, int height,
int tb_num, int tb_den,
enum AVFieldOrder field_order,
decklink_direction_t direction, int num)
{
struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
BMDDisplayModeSupport support;
IDeckLinkDisplayModeIterator *itermode;
IDeckLinkDisplayMode *mode;
int i = 1;
HRESULT res;
av_log(avctx, AV_LOG_DEBUG, "Trying to find mode for frame size %dx%d, frame timing %d/%d, field order %d, direction %d, mode number %d, format code %s\n",
width, height, tb_num, tb_den, field_order, direction, num, (cctx->format_code) ? cctx->format_code : "(unset)");
if (direction == DIRECTION_IN) {
res = ctx->dli->GetDisplayModeIterator (&itermode);
} else {
res = ctx->dlo->GetDisplayModeIterator (&itermode);
}
if (res!= S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
return AVERROR(EIO);
}
char format_buf[] = " ";
if (cctx->format_code)
memcpy(format_buf, cctx->format_code, FFMIN(strlen(cctx->format_code), sizeof(format_buf)));
BMDDisplayMode target_mode = (BMDDisplayMode)AV_RB32(format_buf);
AVRational target_tb = av_make_q(tb_num, tb_den);
ctx->bmd_mode = bmdModeUnknown;
while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
BMDTimeValue bmd_tb_num, bmd_tb_den;
int bmd_width = mode->GetWidth();
int bmd_height = mode->GetHeight();
BMDDisplayMode bmd_mode = mode->GetDisplayMode();
BMDFieldDominance bmd_field_dominance = mode->GetFieldDominance();
mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
AVRational mode_tb = av_make_q(bmd_tb_num, bmd_tb_den);
if ((bmd_width == width &&
bmd_height == height &&
!av_cmp_q(mode_tb, target_tb) &&
field_order_eq(field_order, bmd_field_dominance))
|| i == num
|| target_mode == bmd_mode) {
ctx->bmd_mode = bmd_mode;
ctx->bmd_width = bmd_width;
ctx->bmd_height = bmd_height;
ctx->bmd_tb_den = bmd_tb_den;
ctx->bmd_tb_num = bmd_tb_num;
ctx->bmd_field_dominance = bmd_field_dominance;
av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
bmd_width, bmd_height, 1/av_q2d(mode_tb),
(ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
}
mode->Release();
i++;
}
itermode->Release();
if (ctx->bmd_mode == bmdModeUnknown)
return -1;
if (direction == DIRECTION_IN) {
if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, (BMDPixelFormat) cctx->raw_format,
bmdVideoOutputFlagDefault,
&support, NULL) != S_OK)
return -1;
} else {
if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
bmdVideoOutputFlagDefault,
&support, NULL) != S_OK)
return -1;
}
if (support == bmdDisplayModeSupported)
return 0;
return -1;
}