/* * Copyright (c) 2000-2003 Fabrice Bellard * * This file is part of FFmpeg. * * FFmpeg 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. * * FFmpeg 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 FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** * @file * multimedia converter based on the FFmpeg libraries */ #include "config.h" #include <errno.h>#include <limits.h>#include <stdatomic.h>#include <stdint.h>#include <stdlib.h>#include <string.h>#include <time.h> #if HAVE_IO_H#include <io.h>#endif#if HAVE_UNISTD_H#include <unistd.h>#endif #if HAVE_SYS_RESOURCE_H#include <sys/time.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_SETCONSOLECTRLHANDLER#include <windows.h>#endif #if HAVE_SYS_SELECT_H#include <sys/select.h>#endif #if HAVE_TERMIOS_H#include <fcntl.h>#include <sys/ioctl.h>#include <sys/time.h>#include <termios.h>#elif HAVE_KBHIT#include <conio.h>#endif #include "libavutil/bprint.h"#include "libavutil/dict.h"#include "libavutil/mem.h"#include "libavutil/time.h" #include "libavformat/avformat.h" #include "libavdevice/avdevice.h" #include "cmdutils.h"#include "ffmpeg.h"#include "ffmpeg_sched.h"#include "ffmpeg_utils.h" const char program_name[] = "ffmpeg";const int program_birth_year = 2000; FILE *vstats_file; typedef struct BenchmarkTimeStamps {    int64_t real_usec;    int64_t user_usec;    int64_t sys_usec;} BenchmarkTimeStamps; static BenchmarkTimeStamps get_benchmark_time_stamps(void);static int64_t getmaxrss(void); atomic_uint nb_output_dumped = 0; static BenchmarkTimeStamps current_time;AVIOContext *progress_avio = NULL; InputFile   **input_files   = NULL;int        nb_input_files   = 0; OutputFile   **output_files   = NULL;int         nb_output_files   = 0; FilterGraph **filtergraphs;int        nb_filtergraphs; Decoder     **decoders;int        nb_decoders; #if HAVE_TERMIOS_H /* init terminal so that we can grab keys */static struct termios oldtty;static int restore_tty;#endif static void term_exit_sigsafe(void){#if HAVE_TERMIOS_H    if(restore_tty)        tcsetattr (0, TCSANOW, &oldtty);#endif} void term_exit(void){    av_log(NULL, AV_LOG_QUIET, "%s", "");    term_exit_sigsafe();} static volatile int received_sigterm = 0;static volatile int received_nb_signals = 0;static atomic_int transcode_init_done = 0;static volatile int ffmpeg_exited = 0;static int64_t copy_ts_first_pts = AV_NOPTS_VALUE; static voidsigterm_handler(int sig){    int ret;    received_sigterm = sig;    received_nb_signals++;    term_exit_sigsafe();    if(received_nb_signals > 3) {        ret = write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",                    strlen("Received > 3 system signals, hard exiting\n"));        if (ret < 0) { /* Do nothing */ };        exit(123);    }} #if HAVE_SETCONSOLECTRLHANDLERstatic BOOL WINAPI CtrlHandler(DWORD fdwCtrlType){    av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);     switch (fdwCtrlType)    {    case CTRL_C_EVENT:    case CTRL_BREAK_EVENT:        sigterm_handler(SIGINT);        return TRUE;     case CTRL_CLOSE_EVENT:    case CTRL_LOGOFF_EVENT:    case CTRL_SHUTDOWN_EVENT:        sigterm_handler(SIGTERM);        /* Basically, with these 3 events, when we return from this method the           process is hard terminated, so stall as long as we need to           to try and let the main thread(s) clean up and gracefully terminate           (we have at most 5 seconds, but should be done far before that). */        while (!ffmpeg_exited) {            Sleep(0);        }        return TRUE;     default:        av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);        return FALSE;    }}#endif #ifdef __linux__#define SIGNAL(sig, func)               \    do {                                \        action.sa_handler = func;       \        sigaction(sig, &action, NULL);  \    } while (0)#else#define SIGNAL(sig, func) \    signal(sig, func)#endif void term_init(void){#if defined __linux__    struct sigaction action = {0};    action.sa_handler = sigterm_handler;     /* block other interrupts while processing this one */    sigfillset(&action.sa_mask);     /* restart interruptible functions (i.e. don't fail with EINTR)  */    action.sa_flags = SA_RESTART;#endif #if HAVE_TERMIOS_H    if (stdin_interaction) {        struct termios tty;        if (tcgetattr (0, &tty) == 0) {            oldtty = tty;            restore_tty = 1;             tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP                             |INLCR|IGNCR|ICRNL|IXON);            tty.c_oflag |= OPOST;            tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);            tty.c_cflag &= ~(CSIZE|PARENB);            tty.c_cflag |= CS8;            tty.c_cc[VMIN] = 1;            tty.c_cc[VTIME] = 0;             tcsetattr (0, TCSANOW, &tty);        }        SIGNAL(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */    }#endif     SIGNAL(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */    SIGNAL(SIGTERM, sigterm_handler); /* Termination (ANSI).  */#ifdef SIGXCPU    SIGNAL(SIGXCPU, sigterm_handler);#endif#ifdef SIGPIPE    signal(SIGPIPE, SIG_IGN); /* Broken pipe (POSIX). */#endif#if HAVE_SETCONSOLECTRLHANDLER    SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);#endif} /* read a key without blocking */static int read_key(void){    unsigned char ch;#if HAVE_TERMIOS_H    int n = 1;    struct timeval tv;    fd_set rfds;     FD_ZERO(&rfds);    FD_SET(0, &rfds);    tv.tv_sec = 0;    tv.tv_usec = 0;    n = select(1, &rfds, NULL, NULL, &tv);    if (n > 0) {        n = read(0, &ch, 1);        if (n == 1)            return ch;         return n;    }#elif HAVE_KBHIT#    if HAVE_PEEKNAMEDPIPE && HAVE_GETSTDHANDLE    static int is_pipe;    static HANDLE input_handle;    DWORD dw, nchars;    if(!input_handle){        input_handle = GetStdHandle(STD_INPUT_HANDLE);        is_pipe = !GetConsoleMode(input_handle, &dw);    }     if (is_pipe) {        /* When running under a GUI, you will end here. */        if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {            // input pipe may have been closed by the program that ran ffmpeg            return -1;        }        //Read it        if(nchars != 0) {            if (read(0, &ch, 1) == 1)                return ch;            return 0;        }else{            return -1;        }    }#    endif    if(kbhit())        return(getch());#endif    return -1;} static int decode_interrupt_cb(void *ctx){    return received_nb_signals > atomic_load(&transcode_init_done);} const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL }; static void ffmpeg_cleanup(int ret){    if (do_benchmark) {        int64_t maxrss = getmaxrss() / 1024;        av_log(NULL, AV_LOG_INFO, "bench: maxrss=%"PRId64"KiB\n", maxrss);    }     for (int i = 0; i < nb_filtergraphs; i++)        fg_free(&filtergraphs[i]);    av_freep(&filtergraphs);     for (int i = 0; i < nb_output_files; i++)        of_free(&output_files[i]);     for (int i = 0; i < nb_input_files; i++)        ifile_close(&input_files[i]);     for (int i = 0; i < nb_decoders; i++)        dec_free(&decoders[i]);    av_freep(&decoders);     if (vstats_file) {        if (fclose(vstats_file))            av_log(NULL, AV_LOG_ERROR,                   "Error closing vstats file, loss of information possible: %s\n",                   av_err2str(AVERROR(errno)));    }    av_freep(&vstats_filename);    of_enc_stats_close();     hw_device_free_all();     av_freep(&filter_nbthreads);     av_freep(&input_files);    av_freep(&output_files);     uninit_opts();     avformat_network_deinit();     if (received_sigterm) {        av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",               (int) received_sigterm);    } else if (ret && atomic_load(&transcode_init_done)) {        av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");    }    term_exit();    ffmpeg_exited = 1;} OutputStream *ost_iter(OutputStream *prev){    int of_idx  = prev ? prev->file->index : 0;    int ost_idx = prev ? prev->index + 1  : 0;     for (; of_idx < nb_output_files; of_idx++) {        OutputFile *of = output_files[of_idx];        if (ost_idx < of->nb_streams)            return of->streams[ost_idx];         ost_idx = 0;    }     return NULL;} InputStream *ist_iter(InputStream *prev){    int if_idx  = prev ? prev->file->index : 0;    int ist_idx = prev ? prev->index + 1  : 0;     for (; if_idx < nb_input_files; if_idx++) {        InputFile *f = input_files[if_idx];        if (ist_idx < f->nb_streams)            return f->streams[ist_idx];         ist_idx = 0;    }     return NULL;} static void frame_data_free(void *opaque, uint8_t *data){    FrameData *fd = (FrameData *)data;     avcodec_parameters_free(&fd->par_enc);     av_free(data);} static int frame_data_ensure(AVBufferRef **dst, int writable){    AVBufferRef *src = *dst;     if (!src || (writable && !av_buffer_is_writable(src))) {        FrameData *fd;         fd = av_mallocz(sizeof(*fd));        if (!fd)            return AVERROR(ENOMEM);         *dst = av_buffer_create((uint8_t *)fd, sizeof(*fd),                                frame_data_free, NULL, 0);        if (!*dst) {            av_buffer_unref(&src);            av_freep(&fd);            return AVERROR(ENOMEM);        }         if (src) {            const FrameData *fd_src = (const FrameData *)src->data;             memcpy(fd, fd_src, sizeof(*fd));            fd->par_enc = NULL;             if (fd_src->par_enc) {                int ret = 0;                 fd->par_enc = avcodec_parameters_alloc();                ret = fd->par_enc ?                      avcodec_parameters_copy(fd->par_enc, fd_src->par_enc) :                      AVERROR(ENOMEM);                if (ret < 0) {                    av_buffer_unref(dst);                    av_buffer_unref(&src);                    return ret;                }            }             av_buffer_unref(&src);        } else {            fd->dec.frame_num = UINT64_MAX;            fd->dec.pts       = AV_NOPTS_VALUE;             for (unsigned i = 0; i < FF_ARRAY_ELEMS(fd->wallclock); i++)                fd->wallclock[i] = INT64_MIN;        }    }     return 0;} FrameData *frame_data(AVFrame *frame){    int ret = frame_data_ensure(&frame->opaque_ref, 1);    return ret < 0 ? NULL : (FrameData*)frame->opaque_ref->data;} const FrameData *frame_data_c(AVFrame *frame){    int ret = frame_data_ensure(&frame->opaque_ref, 0);    return ret < 0 ? NULL : (const FrameData*)frame->opaque_ref->data;} FrameData *packet_data(AVPacket *pkt){    int ret = frame_data_ensure(&pkt->opaque_ref, 1);    return ret < 0 ? NULL : (FrameData*)pkt->opaque_ref->data;} const FrameData *packet_data_c(AVPacket *pkt){    int ret = frame_data_ensure(&pkt->opaque_ref, 0);    return ret < 0 ? NULL : (const FrameData*)pkt->opaque_ref->data;} int check_avoptions_used(const AVDictionary *opts, const AVDictionary *opts_used,                         void *logctx, int decode){    const AVClass  *class = avcodec_get_class();    const AVClass *fclass = avformat_get_class();     const int flag = decode ? AV_OPT_FLAG_DECODING_PARAM :                              AV_OPT_FLAG_ENCODING_PARAM;    const AVDictionaryEntry *e = NULL;     while ((e = av_dict_iterate(opts, e))) {        const AVOption *option, *foption;        char *optname, *p;         if (av_dict_get(opts_used, e->key, NULL, 0))            continue;         optname = av_strdup(e->key);        if (!optname)            return AVERROR(ENOMEM);         p = strchr(optname, ':');        if (p)            *p = 0;

Lines 1–500 of 1016. Load more