[deb_ffmpeg.git] / ffmpeg / tools / uncoded_frame.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libavutil/avassert.h"
#include "libavdevice/avdevice.h"
#include "libavfilter/avfilter.h"
#include "libavfilter/buffersink.h"
#include "libavformat/avformat.h"

typedef struct {
    AVFormatContext *mux;
    AVStream *stream;
    AVFilterContext *sink;
    AVFilterLink *link;
} Stream;

static int create_sink(Stream *st, AVFilterGraph *graph,
                       AVFilterContext *f, int idx)
{
    enum AVMediaType type = avfilter_pad_get_type(f->output_pads, idx);
    const char *sink_name;
    int ret;

    switch (type) {
    case AVMEDIA_TYPE_VIDEO: sink_name =  "buffersink"; break;
    case AVMEDIA_TYPE_AUDIO: sink_name = "abuffersink"; break;
    default:
        av_log(NULL, AV_LOG_ERROR, "Stream type not supported\n");
        return AVERROR(EINVAL);
    }
    ret = avfilter_graph_create_filter(&st->sink,
                                       avfilter_get_by_name(sink_name),
                                       NULL, NULL, NULL, graph);
    if (ret < 0)
        return ret;
    ret = avfilter_link(f, idx, st->sink, 0);
    if (ret < 0)
        return ret;
    st->link = st->sink->inputs[0];
    return 0;
}

int main(int argc, char **argv)
{
    char *in_graph_desc, **out_dev_name;
    int nb_out_dev = 0, nb_streams = 0;
    AVFilterGraph *in_graph = NULL;
    Stream *streams = NULL, *st;
    AVFrame *frame = NULL;
    int i, j, run = 1, ret;

    //av_log_set_level(AV_LOG_DEBUG);

    if (argc < 3) {
        av_log(NULL, AV_LOG_ERROR,
               "Usage: %s filter_graph dev:out [dev2:out2...]\n\n"
               "Examples:\n"
               "%s movie=file.nut:s=v+a xv:- alsa:default\n"
               "%s movie=file.nut:s=v+a uncodedframecrc:pipe:0\n",
               argv[0], argv[0], argv[0]);
        exit(1);
    }
    in_graph_desc = argv[1];
    out_dev_name = argv + 2;
    nb_out_dev = argc - 2;

    av_register_all();
    avdevice_register_all();
    avfilter_register_all();

    /* Create input graph */
    if (!(in_graph = avfilter_graph_alloc())) {
        ret = AVERROR(ENOMEM);
        av_log(NULL, AV_LOG_ERROR, "Unable to alloc graph graph: %s\n",
               av_err2str(ret));
        goto fail;
    }
    ret = avfilter_graph_parse_ptr(in_graph, in_graph_desc, NULL, NULL, NULL);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Unable to parse graph: %s\n",
               av_err2str(ret));
        goto fail;
    }
    nb_streams = 0;
    for (i = 0; i < in_graph->nb_filters; i++) {
        AVFilterContext *f = in_graph->filters[i];
        for (j = 0; j < f->nb_inputs; j++) {
            if (!f->inputs[j]) {
                av_log(NULL, AV_LOG_ERROR, "Graph has unconnected inputs\n");
                ret = AVERROR(EINVAL);
                goto fail;
            }
        }
        for (j = 0; j < f->nb_outputs; j++)
            if (!f->outputs[j])
                nb_streams++;
    }
    if (!nb_streams) {
        av_log(NULL, AV_LOG_ERROR, "Graph has no output stream\n");
        ret = AVERROR(EINVAL);
        goto fail;
    }
    if (nb_out_dev != 1 && nb_out_dev != nb_streams) {
        av_log(NULL, AV_LOG_ERROR,
               "Graph has %d output streams, %d devices given\n",
               nb_streams, nb_out_dev);
        ret = AVERROR(EINVAL);
        goto fail;
    }

    if (!(streams = av_calloc(nb_streams, sizeof(*streams)))) {
        ret = AVERROR(ENOMEM);
        av_log(NULL, AV_LOG_ERROR, "Could not allocate streams\n");
    }
    st = streams;
    for (i = 0; i < in_graph->nb_filters; i++) {
        AVFilterContext *f = in_graph->filters[i];
        for (j = 0; j < f->nb_outputs; j++) {
            if (!f->outputs[j]) {
                if ((ret = create_sink(st++, in_graph, f, j)) < 0)
                    goto fail;
            }
        }
    }
    av_assert0(st - streams == nb_streams);
    if ((ret = avfilter_graph_config(in_graph, NULL)) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Failed to configure graph\n");
        goto fail;
    }

    /* Create output devices */
    for (i = 0; i < nb_out_dev; i++) {
        char *fmt = NULL, *dev = out_dev_name[i];
        st = &streams[i];
        if ((dev = strchr(dev, ':'))) {
            *(dev++) = 0;
            fmt = out_dev_name[i];
        }
        ret = avformat_alloc_output_context2(&st->mux, NULL, fmt, dev);
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Failed to allocate output: %s\n",
                   av_err2str(ret));
            goto fail;
        }
        if (!(st->mux->oformat->flags & AVFMT_NOFILE)) {
            ret = avio_open2(&st->mux->pb, st->mux->filename, AVIO_FLAG_WRITE,
                             NULL, NULL);
            if (ret < 0) {
                av_log(st->mux, AV_LOG_ERROR, "Failed to init output: %s\n",
                       av_err2str(ret));
                goto fail;
            }
        }
    }
    for (; i < nb_streams; i++)
        streams[i].mux = streams[0].mux;

    /* Create output device streams */
    for (i = 0; i < nb_streams; i++) {
        st = &streams[i];
        if (!(st->stream = avformat_new_stream(st->mux, NULL))) {
            ret = AVERROR(ENOMEM);
            av_log(NULL, AV_LOG_ERROR, "Failed to create output stream\n");
            goto fail;
        }
        st->stream->codec->codec_type = st->link->type;
        st->stream->time_base = st->stream->codec->time_base =
            st->link->time_base;
        switch (st->link->type) {
        case AVMEDIA_TYPE_VIDEO:
            st->stream->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
            st->stream->avg_frame_rate =
            st->stream->  r_frame_rate = av_buffersink_get_frame_rate(st->sink);
            st->stream->codec->width               = st->link->w;
            st->stream->codec->height              = st->link->h;
            st->stream->codec->sample_aspect_ratio = st->link->sample_aspect_ratio;
            st->stream->codec->pix_fmt             = st->link->format;
            break;
        case AVMEDIA_TYPE_AUDIO:
            st->stream->codec->channel_layout = st->link->channel_layout;
            st->stream->codec->channels = avfilter_link_get_channels(st->link);
            st->stream->codec->sample_rate = st->link->sample_rate;
            st->stream->codec->sample_fmt = st->link->format;
            st->stream->codec->codec_id =
                av_get_pcm_codec(st->stream->codec->sample_fmt, -1);
            break;
        default:
            av_assert0(!"reached");
        }
    }

    /* Init output devices */
    for (i = 0; i < nb_out_dev; i++) {
        st = &streams[i];
        if ((ret = avformat_write_header(st->mux, NULL)) < 0) {
            av_log(st->mux, AV_LOG_ERROR, "Failed to init output: %s\n",
                   av_err2str(ret));
            goto fail;
        }
    }

    /* Check output devices */
    for (i = 0; i < nb_streams; i++) {
        st = &streams[i];
        ret = av_write_uncoded_frame_query(st->mux, st->stream->index);
        if (ret < 0) {
            av_log(st->mux, AV_LOG_ERROR,
                   "Uncoded frames not supported on stream #%d: %s\n",
                   i, av_err2str(ret));
            goto fail;
        }
    }

    while (run) {
        ret = avfilter_graph_request_oldest(in_graph);
        if (ret < 0) {
            if (ret == AVERROR_EOF) {
                run = 0;
            } else {
                av_log(NULL, AV_LOG_ERROR, "Error filtering: %s\n",
                       av_err2str(ret));
                break;
            }
        }
        for (i = 0; i < nb_streams; i++) {
            st = &streams[i];
            while (1) {
                if (!frame && !(frame = av_frame_alloc())) {
                    ret = AVERROR(ENOMEM);
                    av_log(NULL, AV_LOG_ERROR, "Could not allocate frame\n");
                    goto fail;
                }
                ret = av_buffersink_get_frame_flags(st->sink, frame,
                                                    AV_BUFFERSINK_FLAG_NO_REQUEST);
                if (ret < 0) {
                    if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
                        av_log(NULL, AV_LOG_WARNING, "Error in sink: %s\n",
                               av_err2str(ret));
                    break;
                }
                if (frame->pts != AV_NOPTS_VALUE)
                    frame->pts = av_rescale_q(frame->pts,
                                              st->link  ->time_base,
                                              st->stream->time_base);
                ret = av_interleaved_write_uncoded_frame(st->mux,
                                                         st->stream->index,
                                                         frame);
                frame = NULL;
                if (ret < 0) {
                    av_log(st->stream->codec, AV_LOG_ERROR,
                           "Error writing frame: %s\n", av_err2str(ret));
                    goto fail;
                }
            }
        }
    }
    ret = 0;

    for (i = 0; i < nb_out_dev; i++) {
        st = &streams[i];
        av_write_trailer(st->mux);
    }

fail:
    av_frame_free(&frame);
    avfilter_graph_free(&in_graph);
    if (streams) {
        for (i = 0; i < nb_out_dev; i++) {
            st = &streams[i];
            if (st->mux) {
                if (st->mux->pb)
                    avio_close(st->mux->pb);
                avformat_free_context(st->mux);
            }
        }
    }
    av_freep(&streams);
    return ret < 0;
}
Commit	Line	Data
2ba45a60 DM	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <string.h>
	4	#include "libavutil/avassert.h"
	5	#include "libavdevice/avdevice.h"
	6	#include "libavfilter/avfilter.h"
	7	#include "libavfilter/buffersink.h"
	8	#include "libavformat/avformat.h"
	9
	10	typedef struct {
	11	AVFormatContext *mux;
	12	AVStream *stream;
	13	AVFilterContext *sink;
	14	AVFilterLink *link;
	15	} Stream;
	16
	17	static int create_sink(Stream st, AVFilterGraph graph,
	18	AVFilterContext *f, int idx)
	19	{
	20	enum AVMediaType type = avfilter_pad_get_type(f->output_pads, idx);
	21	const char *sink_name;
	22	int ret;
	23
	24	switch (type) {
	25	case AVMEDIA_TYPE_VIDEO: sink_name = "buffersink"; break;
	26	case AVMEDIA_TYPE_AUDIO: sink_name = "abuffersink"; break;
	27	default:
	28	av_log(NULL, AV_LOG_ERROR, "Stream type not supported\n");
	29	return AVERROR(EINVAL);
	30	}
	31	ret = avfilter_graph_create_filter(&st->sink,
	32	avfilter_get_by_name(sink_name),
	33	NULL, NULL, NULL, graph);
	34	if (ret < 0)
	35	return ret;
	36	ret = avfilter_link(f, idx, st->sink, 0);
	37	if (ret < 0)
	38	return ret;
	39	st->link = st->sink->inputs[0];
	40	return 0;
	41	}
	42
	43	int main(int argc, char **argv)
	44	{
	45	char in_graph_desc, *out_dev_name;
	46	int nb_out_dev = 0, nb_streams = 0;
	47	AVFilterGraph *in_graph = NULL;
	48	Stream streams = NULL, st;
	49	AVFrame *frame = NULL;
	50	int i, j, run = 1, ret;
	51
	52	//av_log_set_level(AV_LOG_DEBUG);
	53
	54	if (argc < 3) {
	55	av_log(NULL, AV_LOG_ERROR,
	56	"Usage: %s filter_graph dev:out [dev2:out2...]\n\n"
	57	"Examples:\n"
	58	"%s movie=file.nut:s=v+a xv:- alsa:default\n"
	59	"%s movie=file.nut:s=v+a uncodedframecrc:pipe:0\n",
	60	argv[0], argv[0], argv[0]);
	61	exit(1);
	62	}
	63	in_graph_desc = argv[1];
	64	out_dev_name = argv + 2;
65	nb_out_dev = argc - 2;
66
67	av_register_all();
68	avdevice_register_all();
69	avfilter_register_all();
70
71	/* Create input graph */
72	if (!(in_graph = avfilter_graph_alloc())) {
73	ret = AVERROR(ENOMEM);
74	av_log(NULL, AV_LOG_ERROR, "Unable to alloc graph graph: %s\n",
75	av_err2str(ret));
76	goto fail;
77	}
78	ret = avfilter_graph_parse_ptr(in_graph, in_graph_desc, NULL, NULL, NULL);
79	if (ret < 0) {
80	av_log(NULL, AV_LOG_ERROR, "Unable to parse graph: %s\n",
81	av_err2str(ret));
82	goto fail;
83	}
84	nb_streams = 0;
85	for (i = 0; i < in_graph->nb_filters; i++) {
86	AVFilterContext *f = in_graph->filters[i];
87	for (j = 0; j < f->nb_inputs; j++) {
88	if (!f->inputs[j]) {
89	av_log(NULL, AV_LOG_ERROR, "Graph has unconnected inputs\n");
90	ret = AVERROR(EINVAL);
91	goto fail;
92	}
93	}
94	for (j = 0; j < f->nb_outputs; j++)
95	if (!f->outputs[j])
96	nb_streams++;
97	}
98	if (!nb_streams) {
99	av_log(NULL, AV_LOG_ERROR, "Graph has no output stream\n");
100	ret = AVERROR(EINVAL);
101	goto fail;
102	}
103	if (nb_out_dev != 1 && nb_out_dev != nb_streams) {
104	av_log(NULL, AV_LOG_ERROR,
105	"Graph has %d output streams, %d devices given\n",
106	nb_streams, nb_out_dev);
107	ret = AVERROR(EINVAL);
108	goto fail;
109	}
110
111	if (!(streams = av_calloc(nb_streams, sizeof(*streams)))) {
112	ret = AVERROR(ENOMEM);
113	av_log(NULL, AV_LOG_ERROR, "Could not allocate streams\n");
114	}
115	st = streams;
116	for (i = 0; i < in_graph->nb_filters; i++) {
117	AVFilterContext *f = in_graph->filters[i];
118	for (j = 0; j < f->nb_outputs; j++) {
119	if (!f->outputs[j]) {
120	if ((ret = create_sink(st++, in_graph, f, j)) < 0)
121	goto fail;
122	}
123	}
124	}
125	av_assert0(st - streams == nb_streams);
126	if ((ret = avfilter_graph_config(in_graph, NULL)) < 0) {
127	av_log(NULL, AV_LOG_ERROR, "Failed to configure graph\n");
128	goto fail;
129	}
130
131	/* Create output devices */
132	for (i = 0; i < nb_out_dev; i++) {
133	char fmt = NULL, dev = out_dev_name[i];
134	st = &streams[i];
135	if ((dev = strchr(dev, ':'))) {
136	*(dev++) = 0;
137	fmt = out_dev_name[i];
138	}
139	ret = avformat_alloc_output_context2(&st->mux, NULL, fmt, dev);
140	if (ret < 0) {
141	av_log(NULL, AV_LOG_ERROR, "Failed to allocate output: %s\n",
142	av_err2str(ret));
143	goto fail;
144	}
145	if (!(st->mux->oformat->flags & AVFMT_NOFILE)) {
146	ret = avio_open2(&st->mux->pb, st->mux->filename, AVIO_FLAG_WRITE,
147	NULL, NULL);
148	if (ret < 0) {
149	av_log(st->mux, AV_LOG_ERROR, "Failed to init output: %s\n",
150	av_err2str(ret));
151	goto fail;
152	}
153	}
154	}
155	for (; i < nb_streams; i++)
156	streams[i].mux = streams[0].mux;
157
158	/* Create output device streams */
159	for (i = 0; i < nb_streams; i++) {
160	st = &streams[i];
161	if (!(st->stream = avformat_new_stream(st->mux, NULL))) {
162	ret = AVERROR(ENOMEM);
163	av_log(NULL, AV_LOG_ERROR, "Failed to create output stream\n");
164	goto fail;
165	}
166	st->stream->codec->codec_type = st->link->type;
167	st->stream->time_base = st->stream->codec->time_base =
168	st->link->time_base;
169	switch (st->link->type) {
170	case AVMEDIA_TYPE_VIDEO:
171	st->stream->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
172	st->stream->avg_frame_rate =
173	st->stream-> r_frame_rate = av_buffersink_get_frame_rate(st->sink);
174	st->stream->codec->width = st->link->w;
175	st->stream->codec->height = st->link->h;
176	st->stream->codec->sample_aspect_ratio = st->link->sample_aspect_ratio;
177	st->stream->codec->pix_fmt = st->link->format;
178	break;
179	case AVMEDIA_TYPE_AUDIO:
180	st->stream->codec->channel_layout = st->link->channel_layout;
181	st->stream->codec->channels = avfilter_link_get_channels(st->link);
182	st->stream->codec->sample_rate = st->link->sample_rate;
183	st->stream->codec->sample_fmt = st->link->format;
184	st->stream->codec->codec_id =
185	av_get_pcm_codec(st->stream->codec->sample_fmt, -1);
186	break;
187	default:
188	av_assert0(!"reached");
189	}
190	}
191
192	/* Init output devices */
193	for (i = 0; i < nb_out_dev; i++) {
194	st = &streams[i];
195	if ((ret = avformat_write_header(st->mux, NULL)) < 0) {
196	av_log(st->mux, AV_LOG_ERROR, "Failed to init output: %s\n",
197	av_err2str(ret));
198	goto fail;
199	}
200	}
201
202	/* Check output devices */
203	for (i = 0; i < nb_streams; i++) {
204	st = &streams[i];
205	ret = av_write_uncoded_frame_query(st->mux, st->stream->index);
206	if (ret < 0) {
207	av_log(st->mux, AV_LOG_ERROR,
208	"Uncoded frames not supported on stream #%d: %s\n",
209	i, av_err2str(ret));
210	goto fail;
211	}
212	}
213
214	while (run) {
215	ret = avfilter_graph_request_oldest(in_graph);
216	if (ret < 0) {
217	if (ret == AVERROR_EOF) {
218	run = 0;
219	} else {
220	av_log(NULL, AV_LOG_ERROR, "Error filtering: %s\n",
221	av_err2str(ret));
222	break;
223	}
224	}
225	for (i = 0; i < nb_streams; i++) {
226	st = &streams[i];
227	while (1) {
228	if (!frame && !(frame = av_frame_alloc())) {
229	ret = AVERROR(ENOMEM);
230	av_log(NULL, AV_LOG_ERROR, "Could not allocate frame\n");
231	goto fail;
232	}
233	ret = av_buffersink_get_frame_flags(st->sink, frame,
234	AV_BUFFERSINK_FLAG_NO_REQUEST);
235	if (ret < 0) {
236	if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
237	av_log(NULL, AV_LOG_WARNING, "Error in sink: %s\n",
238	av_err2str(ret));
239	break;
240	}
241	if (frame->pts != AV_NOPTS_VALUE)
242	frame->pts = av_rescale_q(frame->pts,
243	st->link ->time_base,
244	st->stream->time_base);
245	ret = av_interleaved_write_uncoded_frame(st->mux,
246	st->stream->index,
247	frame);
248	frame = NULL;
249	if (ret < 0) {
250	av_log(st->stream->codec, AV_LOG_ERROR,
251	"Error writing frame: %s\n", av_err2str(ret));
252	goto fail;
253	}
254	}
255	}
256	}
257	ret = 0;
258
259	for (i = 0; i < nb_out_dev; i++) {
260	st = &streams[i];
261	av_write_trailer(st->mux);
262	}
263
264	fail:
265	av_frame_free(&frame);
266	avfilter_graph_free(&in_graph);
267	if (streams) {
268	for (i = 0; i < nb_out_dev; i++) {
269	st = &streams[i];
270	if (st->mux) {
271	if (st->mux->pb)
272	avio_close(st->mux->pb);
273	avformat_free_context(st->mux);
274	}
275	}
276	}
277	av_freep(&streams);
278	return ret < 0;
279	}