/* * Copyright (c) 2015 Matthieu Bouron <matthieu.bouron stupeflix.com> * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include <stdio.h>#include "libavformat/avformat.h"#include "libavutil/pixdesc.h"#include "libavcodec/internal.h"#include "libavutil/avassert.h"#include "libavutil/opt.h" static int try_decode_video_frame(AVCodecContext *codec_ctx, AVPacket *pkt, int decode){    int ret = 0;    int got_frame = 0;    AVFrame *frame = NULL;    int skip_frame = codec_ctx->skip_frame;     if (!avcodec_is_open(codec_ctx)) {        const AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id);         ret = avcodec_open2(codec_ctx, codec, NULL);        if (ret < 0) {            av_log(codec_ctx, AV_LOG_ERROR, "Failed to open codec\n");            goto end;        }    }     frame = av_frame_alloc();    if (!frame) {        av_log(NULL, AV_LOG_ERROR, "Failed to allocate frame\n");        goto end;    }     if (!decode && avpriv_codec_get_cap_skip_frame_fill_param(codec_ctx->codec)) {        codec_ctx->skip_frame = AVDISCARD_ALL;    }     do {        ret = avcodec_decode_video2(codec_ctx, frame, &got_frame, pkt);        av_assert0(decode || (!decode && !got_frame));        if (ret < 0)            break;        pkt->data += ret;        pkt->size -= ret;         if (got_frame) {            break;        }    } while (pkt->size > 0); end:    codec_ctx->skip_frame = skip_frame;     av_frame_free(&frame);    return ret;} static int find_video_stream_info(AVFormatContext *fmt_ctx, int decode){    int ret = 0;    int i, done = 0;    AVPacket pkt;     av_init_packet(&pkt);     while (!done) {        AVCodecContext *codec_ctx = NULL;        AVStream *st;         if ((ret = av_read_frame(fmt_ctx, &pkt)) < 0) {            av_log(fmt_ctx, AV_LOG_ERROR, "Failed to read frame\n");            goto end;        }         st = fmt_ctx->streams[pkt.stream_index];        codec_ctx = st->codec;         /* Writing to AVStream.codec_info_nb_frames must not be done by         * user applications. It is done here for testing purposing as         * find_video_stream_info tries to mimic avformat_find_stream_info         * which writes to this field.         * */        if (codec_ctx->codec_type != AVMEDIA_TYPE_VIDEO ||            st->codec_info_nb_frames++ > 0) {            av_packet_unref(&pkt);            continue;        }         ret = try_decode_video_frame(codec_ctx, &pkt, decode);        if (ret < 0) {            av_log(fmt_ctx, AV_LOG_ERROR, "Failed to decode video frame\n");            goto end;        }         av_packet_unref(&pkt);         /* check if all video streams have demuxed a packet */        done = 1;        for (i = 0; i < fmt_ctx->nb_streams; i++) {            st = fmt_ctx->streams[i];            codec_ctx = st->codec;             if (codec_ctx->codec_type != AVMEDIA_TYPE_VIDEO)                continue;             done &= st->codec_info_nb_frames > 0;        }    } end:    av_packet_unref(&pkt);     /* close all codecs opened in try_decode_video_frame */    for (i = 0; i < fmt_ctx->nb_streams; i++) {        AVStream *st = fmt_ctx->streams[i];        avcodec_close(st->codec);    }     return ret < 0;} static void dump_video_streams(const AVFormatContext *fmt_ctx, int decode){    int i;     for (i = 0; i < fmt_ctx->nb_streams; i++) {        const AVOption *opt = NULL;        const AVStream *st = fmt_ctx->streams[i];        AVCodecContext *codec_ctx = st->codec;         printf("stream=%d, decode=%d\n", i, decode);        while (opt = av_opt_next(codec_ctx, opt)) {            uint8_t *str;             if (opt->type == AV_OPT_TYPE_CONST)                continue;             if (!strcmp(opt->name, "frame_number"))                continue;             if (av_opt_get(codec_ctx, opt->name, 0, &str) >= 0) {                printf("    %s=%s\n", opt->name, str);                av_free(str);            }        }    }} static int open_and_probe_video_streams(AVFormatContext **fmt_ctx, const char *filename, int decode){    int ret = 0;     ret = avformat_open_input(fmt_ctx, filename, NULL, NULL);    if (ret < 0) {        av_log(NULL, AV_LOG_ERROR, "Failed to open input '%s'", filename);        goto end;    }     ret = find_video_stream_info(*fmt_ctx, decode);    if (ret < 0) {        goto end;    }     dump_video_streams(*fmt_ctx, decode); end:    return ret;} static int check_video_streams(const AVFormatContext *fmt_ctx1, const AVFormatContext *fmt_ctx2){    int i;    int ret = 0;     av_assert0(fmt_ctx1->nb_streams == fmt_ctx2->nb_streams);    for (i = 0; i < fmt_ctx1->nb_streams; i++) {        const AVOption *opt = NULL;        const AVStream *st1 = fmt_ctx1->streams[i];        const AVStream *st2 = fmt_ctx2->streams[i];        AVCodecContext *codec_ctx1 = st1->codec;        AVCodecContext *codec_ctx2 = st2->codec;         if (codec_ctx1->codec_type != AVMEDIA_TYPE_VIDEO)            continue;         while (opt = av_opt_next(codec_ctx1, opt)) {            uint8_t *str1 = NULL, *str2 = NULL;             if (opt->type == AV_OPT_TYPE_CONST)                continue;             if (!strcmp(opt->name, "frame_number"))                continue;             av_assert0(av_opt_get(codec_ctx1, opt->name, 0, &str1) >= 0);            av_assert0(av_opt_get(codec_ctx2, opt->name, 0, &str2) >= 0);            if (strcmp(str1, str2)) {                av_log(NULL, AV_LOG_ERROR, "Field %s differs: %s %s", opt->name, str1, str2);                ret = AVERROR(EINVAL);            }            av_free(str1);            av_free(str2);        }    }     return ret;} int main(int argc, char* argv[]){    int ret = 0;    AVFormatContext *fmt_ctx = NULL;    AVFormatContext *fmt_ctx_no_decode = NULL;     av_register_all();     if (argc < 2) {        av_log(NULL, AV_LOG_ERROR, "Usage: %s <input>\n", argv[0]);        return -1;    }     if ((ret = open_and_probe_video_streams(&fmt_ctx_no_decode, argv[1], 0)) < 0) {        av_log(NULL, AV_LOG_ERROR, "Failed to probe '%s' without frame decoding\n", argv[1]);        goto end;    }     if ((ret = open_and_probe_video_streams(&fmt_ctx, argv[1], 1)) < 0) {        av_log(NULL, AV_LOG_ERROR, "Failed to probe '%s' with frame decoding\n", argv[1]);        goto end;    }     ret = check_video_streams(fmt_ctx, fmt_ctx_no_decode); end:    avformat_close_input(&fmt_ctx);    avformat_close_input(&fmt_ctx_no_decode);     return ret;}