avconv.c 79.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
/*
 * avconv main
 * Copyright (c) 2000-2011 The libav developers.
 *
 * This file is part of Libav.
 *
 * Libav 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.
 *
 * Libav 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 Libav; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "config.h"
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <errno.h>
#include <signal.h>
#include <limits.h>
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
Justin Ruggles's avatar
Justin Ruggles committed
33
#include "libavresample/avresample.h"
34 35 36 37 38 39 40 41 42 43 44 45
#include "libavutil/opt.h"
#include "libavutil/audioconvert.h"
#include "libavutil/parseutils.h"
#include "libavutil/samplefmt.h"
#include "libavutil/colorspace.h"
#include "libavutil/fifo.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/dict.h"
#include "libavutil/mathematics.h"
#include "libavutil/pixdesc.h"
#include "libavutil/avstring.h"
#include "libavutil/libm.h"
46
#include "libavutil/imgutils.h"
47
#include "libavutil/time.h"
48 49 50 51
#include "libavformat/os_support.h"

# include "libavfilter/avfilter.h"
# include "libavfilter/avfiltergraph.h"
52
# include "libavfilter/buffersrc.h"
53
# include "libavfilter/buffersink.h"
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#if HAVE_SYS_RESOURCE_H
#include <sys/types.h>
#include <sys/resource.h>
#elif HAVE_GETPROCESSTIMES
#include <windows.h>
#endif
#if HAVE_GETPROCESSMEMORYINFO
#include <windows.h>
#include <psapi.h>
#endif

#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif

70 71 72 73
#if HAVE_PTHREADS
#include <pthread.h>
#endif

74 75
#include <time.h>

76
#include "avconv.h"
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
#include "cmdutils.h"

#include "libavutil/avassert.h"

const char program_name[] = "avconv";
const int program_birth_year = 2000;

static FILE *vstats_file;

static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;


93

94
#if HAVE_PTHREADS
95 96 97 98
/* signal to input threads that they should exit; set by the main thread */
static int transcoding_finished;
#endif

99 100
#define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"

101 102 103 104
InputStream **input_streams = NULL;
int        nb_input_streams = 0;
InputFile   **input_files   = NULL;
int        nb_input_files   = 0;
105

106 107 108 109
OutputStream **output_streams = NULL;
int         nb_output_streams = 0;
OutputFile   **output_files   = NULL;
int         nb_output_files   = 0;
110

111 112
FilterGraph **filtergraphs;
int        nb_filtergraphs;
113

114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
static void term_exit(void)
{
    av_log(NULL, AV_LOG_QUIET, "");
}

static volatile int received_sigterm = 0;
static volatile int received_nb_signals = 0;

static void
sigterm_handler(int sig)
{
    received_sigterm = sig;
    received_nb_signals++;
    term_exit();
}

static void term_init(void)
{
Aneesh Dogra's avatar
Aneesh Dogra committed
132
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
133 134 135 136 137 138
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
#ifdef SIGXCPU
    signal(SIGXCPU, sigterm_handler);
#endif
}

139
static int decode_interrupt_cb(void *ctx)
140 141 142 143
{
    return received_nb_signals > 1;
}

144
const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
145

146
void exit_program(int ret)
147
{
148 149 150 151
    int i, j;

    for (i = 0; i < nb_filtergraphs; i++) {
        avfilter_graph_free(&filtergraphs[i]->graph);
152 153
        for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
            av_freep(&filtergraphs[i]->inputs[j]->name);
154
            av_freep(&filtergraphs[i]->inputs[j]);
155
        }
156
        av_freep(&filtergraphs[i]->inputs);
157 158
        for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
            av_freep(&filtergraphs[i]->outputs[j]->name);
159
            av_freep(&filtergraphs[i]->outputs[j]);
160
        }
161 162 163 164
        av_freep(&filtergraphs[i]->outputs);
        av_freep(&filtergraphs[i]);
    }
    av_freep(&filtergraphs);
165 166

    /* close files */
Aneesh Dogra's avatar
Aneesh Dogra committed
167
    for (i = 0; i < nb_output_files; i++) {
168
        AVFormatContext *s = output_files[i]->ctx;
169 170 171
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
            avio_close(s->pb);
        avformat_free_context(s);
172 173
        av_dict_free(&output_files[i]->opts);
        av_freep(&output_files[i]);
174
    }
Janne Grunau's avatar
Janne Grunau committed
175
    for (i = 0; i < nb_output_streams; i++) {
176
        AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
Janne Grunau's avatar
Janne Grunau committed
177 178 179 180 181
        while (bsfc) {
            AVBitStreamFilterContext *next = bsfc->next;
            av_bitstream_filter_close(bsfc);
            bsfc = next;
        }
182
        output_streams[i]->bitstream_filters = NULL;
183

Anton Khirnov's avatar
Anton Khirnov committed
184
        av_freep(&output_streams[i]->forced_keyframes);
185
        av_freep(&output_streams[i]->avfilter);
186
        av_freep(&output_streams[i]->filtered_frame);
187
        av_freep(&output_streams[i]);
Janne Grunau's avatar
Janne Grunau committed
188
    }
Aneesh Dogra's avatar
Aneesh Dogra committed
189
    for (i = 0; i < nb_input_files; i++) {
190 191
        avformat_close_input(&input_files[i]->ctx);
        av_freep(&input_files[i]);
192
    }
193
    for (i = 0; i < nb_input_streams; i++) {
194 195
        av_freep(&input_streams[i]->decoded_frame);
        av_dict_free(&input_streams[i]->opts);
196
        free_buffer_pool(&input_streams[i]->buffer_pool);
197
        av_freep(&input_streams[i]->filters);
198
        av_freep(&input_streams[i]);
199
    }
200 201 202 203 204 205 206

    if (vstats_file)
        fclose(vstats_file);
    av_free(vstats_filename);

    av_freep(&input_streams);
    av_freep(&input_files);
207
    av_freep(&output_streams);
208
    av_freep(&output_files);
209 210 211 212

    uninit_opts();

    avfilter_uninit();
213
    avformat_network_deinit();
214 215

    if (received_sigterm) {
216 217
        av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
               (int) received_sigterm);
218 219 220
        exit (255);
    }

221
    exit(ret);
222 223
}

224
void assert_avoptions(AVDictionary *m)
225 226 227
{
    AVDictionaryEntry *t;
    if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
228
        av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
229 230 231 232 233 234 235 236 237 238
        exit_program(1);
    }
}

static void assert_codec_experimental(AVCodecContext *c, int encoder)
{
    const char *codec_string = encoder ? "encoder" : "decoder";
    AVCodec *codec;
    if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
        c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
239
        av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
240 241 242 243
                "results.\nAdd '-strict experimental' if you want to use it.\n",
                codec_string, c->codec->name);
        codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
244
            av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
                   codec_string, codec->name);
        exit_program(1);
    }
}

/**
 * Update the requested input sample format based on the output sample format.
 * This is currently only used to request float output from decoders which
 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
 * Ideally this will be removed in the future when decoders do not do format
 * conversion and only output in their native format.
 */
static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
                              AVCodecContext *enc)
{
    /* if sample formats match or a decoder sample format has already been
       requested, just return */
    if (enc->sample_fmt == dec->sample_fmt ||
        dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
        return;

    /* if decoder supports more than one output format */
    if (dec_codec && dec_codec->sample_fmts &&
        dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
        dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
        const enum AVSampleFormat *p;
        int min_dec = -1, min_inc = -1;

        /* find a matching sample format in the encoder */
        for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
            if (*p == enc->sample_fmt) {
                dec->request_sample_fmt = *p;
                return;
            } else if (*p > enc->sample_fmt) {
                min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
            } else
                min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
        }

        /* if none match, provide the one that matches quality closest */
        dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
                                  enc->sample_fmt - min_dec;
    }
}

290
static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
Aneesh Dogra's avatar
Aneesh Dogra committed
291
{
292 293
    AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
    AVCodecContext          *avctx = ost->st->codec;
294 295
    int ret;

296 297 298 299 300 301 302 303
    /*
     * Audio encoders may split the packets --  #frames in != #packets out.
     * But there is no reordering, so we can limit the number of output packets
     * by simply dropping them here.
     * Counting encoded video frames needs to be done separately because of
     * reordering, see do_video_out()
     */
    if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
304 305
        if (ost->frame_number >= ost->max_frames) {
            av_free_packet(pkt);
306
            return;
307
        }
308 309 310
        ost->frame_number++;
    }

Aneesh Dogra's avatar
Aneesh Dogra committed
311 312 313 314 315 316 317
    while (bsfc) {
        AVPacket new_pkt = *pkt;
        int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
                                           &new_pkt.data, &new_pkt.size,
                                           pkt->data, pkt->size,
                                           pkt->flags & AV_PKT_FLAG_KEY);
        if (a > 0) {
318
            av_free_packet(pkt);
Aneesh Dogra's avatar
Aneesh Dogra committed
319 320
            new_pkt.destruct = av_destruct_packet;
        } else if (a < 0) {
321 322 323
            av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
                   bsfc->filter->name, pkt->stream_index,
                   avctx->codec ? avctx->codec->name : "copy");
324 325 326 327
            print_error("", a);
            if (exit_on_error)
                exit_program(1);
        }
Aneesh Dogra's avatar
Aneesh Dogra committed
328
        *pkt = new_pkt;
329

Aneesh Dogra's avatar
Aneesh Dogra committed
330
        bsfc = bsfc->next;
331 332
    }

333
    pkt->stream_index = ost->index;
Aneesh Dogra's avatar
Aneesh Dogra committed
334 335
    ret = av_interleaved_write_frame(s, pkt);
    if (ret < 0) {
336 337 338 339 340
        print_error("av_interleaved_write_frame()", ret);
        exit_program(1);
    }
}

341 342
static int check_recording_time(OutputStream *ost)
{
343
    OutputFile *of = output_files[ost->file_index];
344 345 346 347 348 349 350 351 352 353

    if (of->recording_time != INT64_MAX &&
        av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
                      AV_TIME_BASE_Q) >= 0) {
        ost->is_past_recording_time = 1;
        return 0;
    }
    return 1;
}

354 355
static void do_audio_out(AVFormatContext *s, OutputStream *ost,
                         AVFrame *frame)
356 357 358
{
    AVCodecContext *enc = ost->st->codec;
    AVPacket pkt;
359
    int got_packet = 0;
360 361 362 363 364

    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;

365 366
    if (!check_recording_time(ost))
        return;
367

368
    if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
369
        frame->pts = ost->sync_opts;
370
    ost->sync_opts = frame->pts + frame->nb_samples;
371 372 373 374 375 376 377 378 379

    if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
        av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
        exit_program(1);
    }

    if (got_packet) {
        if (pkt.pts != AV_NOPTS_VALUE)
            pkt.pts      = av_rescale_q(pkt.pts,      enc->time_base, ost->st->time_base);
380 381
        if (pkt.dts != AV_NOPTS_VALUE)
            pkt.dts      = av_rescale_q(pkt.dts,      enc->time_base, ost->st->time_base);
382 383 384 385 386 387 388
        if (pkt.duration > 0)
            pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);

        write_frame(s, &pkt, ost);

        audio_size += pkt.size;
    }
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
}

static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
    uint8_t *buf = 0;

    dec = ist->st->codec;

    /* deinterlace : must be done before any resize */
    if (do_deinterlace) {
        int size;

        /* create temporary picture */
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
Aneesh Dogra's avatar
Aneesh Dogra committed
406
        buf  = av_malloc(size);
407 408 409 410 411 412
        if (!buf)
            return;

        picture2 = &picture_tmp;
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

Aneesh Dogra's avatar
Aneesh Dogra committed
413
        if (avpicture_deinterlace(picture2, picture,
414 415
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
            /* if error, do not deinterlace */
416
            av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
            av_free(buf);
            buf = NULL;
            picture2 = picture;
        }
    } else {
        picture2 = picture;
    }

    if (picture != picture2)
        *picture = *picture2;
    *bufp = buf;
}

static void do_subtitle_out(AVFormatContext *s,
                            OutputStream *ost,
                            InputStream *ist,
                            AVSubtitle *sub,
                            int64_t pts)
{
    static uint8_t *subtitle_out = NULL;
    int subtitle_out_max_size = 1024 * 1024;
    int subtitle_out_size, nb, i;
    AVCodecContext *enc;
    AVPacket pkt;

    if (pts == AV_NOPTS_VALUE) {
443
        av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
444 445 446 447 448 449 450 451 452 453 454 455 456 457
        if (exit_on_error)
            exit_program(1);
        return;
    }

    enc = ost->st->codec;

    if (!subtitle_out) {
        subtitle_out = av_malloc(subtitle_out_max_size);
    }

    /* Note: DVB subtitle need one packet to draw them and one other
       packet to clear them */
    /* XXX: signal it in the codec context ? */
458
    if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
459 460 461 462
        nb = 2;
    else
        nb = 1;

Aneesh Dogra's avatar
Aneesh Dogra committed
463
    for (i = 0; i < nb; i++) {
464 465 466 467
        ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
        if (!check_recording_time(ost))
            return;

468 469
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
        // start_display_time is required to be 0
Aneesh Dogra's avatar
Aneesh Dogra committed
470 471
        sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
        sub->end_display_time  -= sub->start_display_time;
472 473 474 475
        sub->start_display_time = 0;
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
                                                    subtitle_out_max_size, sub);
        if (subtitle_out_size < 0) {
476
            av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
477 478 479 480 481 482
            exit_program(1);
        }

        av_init_packet(&pkt);
        pkt.data = subtitle_out;
        pkt.size = subtitle_out_size;
Aneesh Dogra's avatar
Aneesh Dogra committed
483
        pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
484
        if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
485 486 487 488 489 490 491
            /* XXX: the pts correction is handled here. Maybe handling
               it in the codec would be better */
            if (i == 0)
                pkt.pts += 90 * sub->start_display_time;
            else
                pkt.pts += 90 * sub->end_display_time;
        }
492
        write_frame(s, &pkt, ost);
493 494 495
    }
}

496 497 498 499 500
static void do_video_out(AVFormatContext *s,
                         OutputStream *ost,
                         AVFrame *in_picture,
                         int *frame_size, float quality)
{
501 502 503
    int ret, format_video_sync;
    AVPacket pkt;
    AVCodecContext *enc = ost->st->codec;
504 505 506

    *frame_size = 0;

507
    format_video_sync = video_sync_method;
508 509 510
    if (format_video_sync == VSYNC_AUTO)
        format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
                            (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
511 512 513 514
    if (format_video_sync != VSYNC_PASSTHROUGH &&
        ost->frame_number &&
        in_picture->pts != AV_NOPTS_VALUE &&
        in_picture->pts < ost->sync_opts) {
Anton Khirnov's avatar
Anton Khirnov committed
515 516
        nb_frames_drop++;
        av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
517
        return;
Anton Khirnov's avatar
Anton Khirnov committed
518
    }
519

520 521 522 523 524
    if (in_picture->pts == AV_NOPTS_VALUE)
        in_picture->pts = ost->sync_opts;
    ost->sync_opts = in_picture->pts;


525
    if (!ost->frame_number)
526
        ost->first_pts = in_picture->pts;
527

Anton Khirnov's avatar
Anton Khirnov committed
528 529 530
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
531

Anton Khirnov's avatar
Anton Khirnov committed
532 533 534
    if (!check_recording_time(ost) ||
        ost->frame_number >= ost->max_frames)
        return;
535

Anton Khirnov's avatar
Anton Khirnov committed
536
    if (s->oformat->flags & AVFMT_RAWPICTURE &&
537
        enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
Anton Khirnov's avatar
Anton Khirnov committed
538 539 540 541 542 543 544 545 546
        /* raw pictures are written as AVPicture structure to
           avoid any copies. We support temporarily the older
           method. */
        enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
        enc->coded_frame->top_field_first  = in_picture->top_field_first;
        pkt.data   = (uint8_t *)in_picture;
        pkt.size   =  sizeof(AVPicture);
        pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
        pkt.flags |= AV_PKT_FLAG_KEY;
547

Anton Khirnov's avatar
Anton Khirnov committed
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
        write_frame(s, &pkt, ost);
    } else {
        int got_packet;
        AVFrame big_picture;

        big_picture = *in_picture;
        /* better than nothing: use input picture interlaced
           settings */
        big_picture.interlaced_frame = in_picture->interlaced_frame;
        if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
            if (ost->top_field_first == -1)
                big_picture.top_field_first = in_picture->top_field_first;
            else
                big_picture.top_field_first = !!ost->top_field_first;
        }
563

Anton Khirnov's avatar
Anton Khirnov committed
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
        /* handles same_quant here. This is not correct because it may
           not be a global option */
        big_picture.quality = quality;
        if (!enc->me_threshold)
            big_picture.pict_type = 0;
        if (ost->forced_kf_index < ost->forced_kf_count &&
            big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
            big_picture.pict_type = AV_PICTURE_TYPE_I;
            ost->forced_kf_index++;
        }
        ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
        if (ret < 0) {
            av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
            exit_program(1);
        }
579

Anton Khirnov's avatar
Anton Khirnov committed
580 581 582 583 584
        if (got_packet) {
            if (pkt.pts != AV_NOPTS_VALUE)
                pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
            if (pkt.dts != AV_NOPTS_VALUE)
                pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
585

Anton Khirnov's avatar
Anton Khirnov committed
586 587 588
            write_frame(s, &pkt, ost);
            *frame_size = pkt.size;
            video_size += pkt.size;
589

Anton Khirnov's avatar
Anton Khirnov committed
590 591 592
            /* if two pass, output log */
            if (ost->logfile && enc->stats_out) {
                fprintf(ost->logfile, "%s", enc->stats_out);
593 594
            }
        }
Anton Khirnov's avatar
Anton Khirnov committed
595 596 597 598 599 600 601 602
    }
    ost->sync_opts++;
    /*
     * For video, number of frames in == number of packets out.
     * But there may be reordering, so we can't throw away frames on encoder
     * flush, we need to limit them here, before they go into encoder.
     */
    ost->frame_number++;
603 604
}

Aneesh Dogra's avatar
Aneesh Dogra committed
605 606 607
static double psnr(double d)
{
    return -10.0 * log(d) / log(10.0);
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
}

static void do_video_stats(AVFormatContext *os, OutputStream *ost,
                           int frame_size)
{
    AVCodecContext *enc;
    int frame_number;
    double ti1, bitrate, avg_bitrate;

    /* this is executed just the first time do_video_stats is called */
    if (!vstats_file) {
        vstats_file = fopen(vstats_filename, "w");
        if (!vstats_file) {
            perror("fopen");
            exit_program(1);
        }
    }

    enc = ost->st->codec;
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
        frame_number = ost->frame_number;
Aneesh Dogra's avatar
Aneesh Dogra committed
629
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
630
        if (enc->flags&CODEC_FLAG_PSNR)
Aneesh Dogra's avatar
Aneesh Dogra committed
631
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
632 633 634 635 636 637 638

        fprintf(vstats_file,"f_size= %6d ", frame_size);
        /* compute pts value */
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
        if (ti1 < 0.01)
            ti1 = 0.01;

Aneesh Dogra's avatar
Aneesh Dogra committed
639
        bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
640 641
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
Aneesh Dogra's avatar
Aneesh Dogra committed
642
               (double)video_size / 1024, ti1, bitrate, avg_bitrate);
643 644 645 646
        fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
    }
}

647 648 649 650 651
/* check for new output on any of the filtergraphs */
static int poll_filters(void)
{
    AVFilterBufferRef *picref;
    AVFrame *filtered_frame = NULL;
652
    int i, frame_size;
653 654 655 656

    for (i = 0; i < nb_output_streams; i++) {
        OutputStream *ost = output_streams[i];
        OutputFile    *of = output_files[ost->file_index];
657
        int ret = 0;
658

659
        if (!ost->filter)
660 661 662 663 664 665 666 667
            continue;

        if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
            return AVERROR(ENOMEM);
        } else
            avcodec_get_frame_defaults(ost->filtered_frame);
        filtered_frame = ost->filtered_frame;

668
        while (ret >= 0 && !ost->is_past_recording_time) {
669 670 671 672 673 674 675
            if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
                !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
                ret = av_buffersink_read_samples(ost->filter->filter, &picref,
                                                 ost->st->codec->frame_size);
            else
                ret = av_buffersink_read(ost->filter->filter, &picref);

676
            if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
677
                break;
678 679
            else if (ret < 0)
                return ret;
680

681
            avfilter_copy_buf_props(filtered_frame, picref);
682
            if (picref->pts != AV_NOPTS_VALUE) {
683 684 685 686 687 688
                filtered_frame->pts = av_rescale_q(picref->pts,
                                                   ost->filter->filter->inputs[0]->time_base,
                                                   ost->st->codec->time_base) -
                                      av_rescale_q(of->start_time,
                                                   AV_TIME_BASE_Q,
                                                   ost->st->codec->time_base);
689

690 691 692 693
                if (of->start_time && filtered_frame->pts < 0) {
                    avfilter_unref_buffer(picref);
                    continue;
                }
694
            }
695 696 697 698 699 700 701 702 703 704 705 706

            switch (ost->filter->filter->inputs[0]->type) {
            case AVMEDIA_TYPE_VIDEO:
                if (!ost->frame_aspect_ratio)
                    ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;

                do_video_out(of->ctx, ost, filtered_frame, &frame_size,
                             same_quant ? ost->last_quality :
                                          ost->st->codec->global_quality);
                if (vstats_filename && frame_size)
                    do_video_stats(of->ctx, ost, frame_size);
                break;
707 708 709
            case AVMEDIA_TYPE_AUDIO:
                do_audio_out(of->ctx, ost, filtered_frame);
                break;
710
            default:
711
                // TODO support subtitle filters
712 713 714 715 716 717 718 719 720
                av_assert0(0);
            }

            avfilter_unref_buffer(picref);
        }
    }
    return 0;
}

721
static void print_report(int is_last_report, int64_t timer_start)
722 723 724 725 726 727 728 729 730 731 732
{
    char buf[1024];
    OutputStream *ost;
    AVFormatContext *oc;
    int64_t total_size;
    AVCodecContext *enc;
    int frame_number, vid, i;
    double bitrate, ti1, pts;
    static int64_t last_time = -1;
    static int qp_histogram[52];

733 734 735
    if (!print_stats && !is_last_report)
        return;

736 737 738 739 740 741 742 743 744 745 746 747 748 749
    if (!is_last_report) {
        int64_t cur_time;
        /* display the report every 0.5 seconds */
        cur_time = av_gettime();
        if (last_time == -1) {
            last_time = cur_time;
            return;
        }
        if ((cur_time - last_time) < 500000)
            return;
        last_time = cur_time;
    }


750
    oc = output_files[0]->ctx;
751 752

    total_size = avio_size(oc->pb);
Aneesh Dogra's avatar
Aneesh Dogra committed
753 754
    if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
        total_size = avio_tell(oc->pb);
755 756 757 758

    buf[0] = '\0';
    ti1 = 1e10;
    vid = 0;
759
    for (i = 0; i < nb_output_streams; i++) {
760
        float q = -1;
761
        ost = output_streams[i];
762
        enc = ost->st->codec;
763
        if (!ost->stream_copy && enc->coded_frame)
Aneesh Dogra's avatar
Aneesh Dogra committed
764
            q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
765 766 767 768
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
        }
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
Aneesh Dogra's avatar
Aneesh Dogra committed
769
            float t = (av_gettime() - timer_start) / 1000000.0;
770 771 772

            frame_number = ost->frame_number;
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
Aneesh Dogra's avatar
Aneesh Dogra committed
773 774
                     frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
            if (is_last_report)
775
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
Aneesh Dogra's avatar
Aneesh Dogra committed
776
            if (qp_hist) {
777 778
                int j;
                int qp = lrintf(q);
Aneesh Dogra's avatar
Aneesh Dogra committed
779
                if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
780
                    qp_histogram[qp]++;
Aneesh Dogra's avatar
Aneesh Dogra committed
781 782
                for (j = 0; j < 32; j++)
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
783
            }
Aneesh Dogra's avatar
Aneesh Dogra committed
784
            if (enc->flags&CODEC_FLAG_PSNR) {
785
                int j;
Aneesh Dogra's avatar
Aneesh Dogra committed
786 787 788
                double error, error_sum = 0;
                double scale, scale_sum = 0;
                char type[3] = { 'Y','U','V' };
789
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
Aneesh Dogra's avatar
Aneesh Dogra committed
790 791 792 793 794 795 796
                for (j = 0; j < 3; j++) {
                    if (is_last_report) {
                        error = enc->error[j];
                        scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
                    } else {
                        error = enc->coded_frame->error[j];
                        scale = enc->width * enc->height * 255.0 * 255.0;
797
                    }
Aneesh Dogra's avatar
Aneesh Dogra committed
798 799
                    if (j)
                        scale /= 4;
800 801
                    error_sum += error;
                    scale_sum += scale;
Aneesh Dogra's avatar
Aneesh Dogra committed
802
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
803
                }
Aneesh Dogra's avatar
Aneesh Dogra committed
804
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
805 806 807 808 809 810 811 812 813 814 815
            }
            vid = 1;
        }
        /* compute min output value */
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
        if ((pts < ti1) && (pts > 0))
            ti1 = pts;
    }
    if (ti1 < 0.01)
        ti1 = 0.01;

816
    bitrate = (double)(total_size * 8) / ti1 / 1000.0;
817

818
    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
819 820 821
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
            (double)total_size / 1024, ti1, bitrate);

822 823 824
    if (nb_frames_dup || nb_frames_drop)
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
                nb_frames_dup, nb_frames_drop);
825

826
    av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
827

828
    fflush(stderr);
829

830
    if (is_last_report) {
831
        int64_t raw= audio_size + video_size + extra_size;
832 833
        av_log(NULL, AV_LOG_INFO, "\n");
        av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
Aneesh Dogra's avatar
Aneesh Dogra committed
834 835 836 837
               video_size / 1024.0,
               audio_size / 1024.0,
               extra_size / 1024.0,
               100.0 * (total_size - raw) / raw
838 839 840 841
        );
    }
}

842
static void flush_encoders(void)
843 844 845
{
    int i, ret;

846
    for (i = 0; i < nb_output_streams; i++) {
847
        OutputStream   *ost = output_streams[i];
848
        AVCodecContext *enc = ost->st->codec;
849
        AVFormatContext *os = output_files[ost->file_index]->ctx;
850
        int stop_encoding = 0;
851

852
        if (!ost->encoding_needed)
853 854
            continue;

Aneesh Dogra's avatar
Aneesh Dogra committed
855
        if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
856
            continue;
857
        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
858 859
            continue;

Aneesh Dogra's avatar
Aneesh Dogra committed
860
        for (;;) {
861 862 863
            int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
            const char *desc;
            int64_t *size;
864 865 866

            switch (ost->st->codec->codec_type) {
            case AVMEDIA_TYPE_AUDIO:
867 868 869
                encode = avcodec_encode_audio2;
                desc   = "Audio";
                size   = &audio_size;
870 871
                break;
            case AVMEDIA_TYPE_VIDEO:
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
                encode = avcodec_encode_video2;
                desc   = "Video";
                size   = &video_size;
                break;
            default:
                stop_encoding = 1;
            }

            if (encode) {
                AVPacket pkt;
                int got_packet;
                av_init_packet(&pkt);
                pkt.data = NULL;
                pkt.size = 0;

                ret = encode(enc, &pkt, NULL, &got_packet);
888
                if (ret < 0) {
889
                    av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
890 891
                    exit_program(1);
                }
892
                *size += ret;
893 894 895
                if (ost->logfile && enc->stats_out) {
                    fprintf(ost->logfile, "%s", enc->stats_out);
                }
896
                if (!got_packet) {
897 898 899
                    stop_encoding = 1;
                    break;
                }
900 901 902 903
                if (pkt.pts != AV_NOPTS_VALUE)
                    pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
                if (pkt.dts != AV_NOPTS_VALUE)
                    pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
904
                write_frame(os, &pkt, ost);
905
            }
906

907
            if (stop_encoding)
908
                break;
909 910 911 912
        }
    }
}

913 914 915 916 917
/*
 * Check whether a packet from ist should be written into ost at this time
 */
static int check_output_constraints(InputStream *ist, OutputStream *ost)
{
918 919
    OutputFile *of = output_files[ost->file_index];
    int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
920 921 922 923

    if (ost->source_index != ist_index)
        return 0;

924
    if (of->start_time && ist->last_dts < of->start_time)
925 926 927 928 929 930 931
        return 0;

    return 1;
}

static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
{
932
    OutputFile *of = output_files[ost->file_index];
933 934 935 936 937 938 939 940 941
    int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
    AVPacket opkt;

    av_init_packet(&opkt);

    if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
        !ost->copy_initial_nonkeyframes)
        return;

942
    if (of->recording_time != INT64_MAX &&
943
        ist->last_dts >= of->recording_time + of->start_time) {
944 945 946 947
        ost->is_past_recording_time = 1;
        return;
    }

948 949 950 951 952 953 954 955 956 957 958 959 960 961
    /* force the input stream PTS */
    if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
        audio_size += pkt->size;
    else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
        video_size += pkt->size;
        ost->sync_opts++;
    }

    if (pkt->pts != AV_NOPTS_VALUE)
        opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
    else
        opkt.pts = AV_NOPTS_VALUE;

    if (pkt->dts == AV_NOPTS_VALUE)
962
        opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
963 964 965 966 967 968 969
    else
        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
    opkt.dts -= ost_tb_start_time;

    opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
    opkt.flags    = pkt->flags;

Aneesh Dogra's avatar
Aneesh Dogra committed
970
    // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
971 972 973 974
    if (  ost->st->codec->codec_id != AV_CODEC_ID_H264
       && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
       && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
       && ost->st->codec->codec_id != AV_CODEC_ID_VC1
975 976 977 978 979 980 981 982
       ) {
        if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
            opkt.destruct = av_destruct_packet;
    } else {
        opkt.data = pkt->data;
        opkt.size = pkt->size;
    }

983
    write_frame(of->ctx, &opkt, ost);
984 985 986 987
    ost->st->codec->frame_number++;
    av_free_packet(&opkt);
}

988 989
static void rate_emu_sleep(InputStream *ist)
{
990
    if (input_files[ist->file_index]->rate_emu) {
991
        int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
992 993
        int64_t now = av_gettime() - ist->start;
        if (pts > now)
994
            av_usleep(pts - now);
995 996 997
    }
}

998
int guess_input_channel_layout(InputStream *ist)
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
{
    AVCodecContext *dec = ist->st->codec;

    if (!dec->channel_layout) {
        char layout_name[256];

        dec->channel_layout = av_get_default_channel_layout(dec->channels);
        if (!dec->channel_layout)
            return 0;
        av_get_channel_layout_string(layout_name, sizeof(layout_name),
                                     dec->channels, dec->channel_layout);
        av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
               "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
    }
    return 1;
}

1016
static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1017
{
1018 1019
    AVFrame *decoded_frame;
    AVCodecContext *avctx = ist->st->codec;
1020
    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1021
    int i, ret, resample_changed;
1022

1023
    if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1024
        return AVERROR(ENOMEM);
1025 1026 1027
    else
        avcodec_get_frame_defaults(ist->decoded_frame);
    decoded_frame = ist->decoded_frame;
1028

1029 1030
    ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
    if (ret < 0) {
1031
        return ret;
1032
    }
1033 1034 1035

    if (!*got_output) {
        /* no audio frame */
1036 1037 1038
        if (!pkt->size)
            for (i = 0; i < ist->nb_filters; i++)
                av_buffersrc_buffer(ist->filters[i]->filter, NULL);
1039
        return ret;
1040 1041
    }

1042 1043